File Manager

Editing File: /usr/local/cpanel/ui/web-components/dist/custom-elements/index.js

import { HTMLElement, h, Host, createEvent, getRenderingRef, forceUpdate, getAssetPath, proxyCustomElement } from '@stencil/core/internal/client';
export { setAssetPath, setPlatformOptions } from '@stencil/core/internal/client';

/** Detect free variable `global` from Node.js. */
var freeGlobal$1 = typeof global == 'object' && global && global.Object === Object && global;

/** Detect free variable `self`. */
var freeSelf$1 = typeof self == 'object' && self && self.Object === Object && self;

/** Used as a reference to the global object. */
var root$1 = freeGlobal$1 || freeSelf$1 || Function('return this')();

/** Built-in value references. */
var Symbol$1 = root$1.Symbol;

/** Used for built-in method references. */
var objectProto$4 = Object.prototype;

/** Used to check objects for own properties. */
var hasOwnProperty$3 = objectProto$4.hasOwnProperty;

/**
 * Used to resolve the
 * [`toStringTag`](http://ecma-international.org/ecma-262/7.0/#sec-object.prototype.tostring)
 * of values.
 */
var nativeObjectToString$3 = objectProto$4.toString;

/** Built-in value references. */
var symToStringTag$3 = Symbol$1 ? Symbol$1.toStringTag : undefined;

/**
 * A specialized version of `baseGetTag` which ignores `Symbol.toStringTag` values.
 *
 * @private
 * @param {*} value The value to query.
 * @returns {string} Returns the raw `toStringTag`.
 */
function getRawTag$1(value) {
  var isOwn = hasOwnProperty$3.call(value, symToStringTag$3),
      tag = value[symToStringTag$3];

try {
    value[symToStringTag$3] = undefined;
    var unmasked = true;
  } catch (e) {}

/** Used for built-in method references. */
var objectProto$3 = Object.prototype;

/**
 * Used to resolve the
 * [`toStringTag`](http://ecma-international.org/ecma-262/7.0/#sec-object.prototype.tostring)
 * of values.
 */
var nativeObjectToString$2 = objectProto$3.toString;

/**
 * Converts `value` to a string using `Object.prototype.toString`.
 *
 * @private
 * @param {*} value The value to convert.
 * @returns {string} Returns the converted string.
 */
function objectToString$1(value) {
  return nativeObjectToString$2.call(value);
}

/** `Object#toString` result references. */
var nullTag$1 = '[object Null]',
    undefinedTag$1 = '[object Undefined]';

/** Built-in value references. */
var symToStringTag$2 = Symbol$1 ? Symbol$1.toStringTag : undefined;

/**
 * The base implementation of `getTag` without fallbacks for buggy environments.
 *
 * @private
 * @param {*} value The value to query.
 * @returns {string} Returns the `toStringTag`.
 */
function baseGetTag$1(value) {
  if (value == null) {
    return value === undefined ? undefinedTag$1 : nullTag$1;
  }
  return (symToStringTag$2 && symToStringTag$2 in Object(value))
    ? getRawTag$1(value)
    : objectToString$1(value);
}

/**
 * Checks if `value` is object-like. A value is object-like if it's not `null`
 * and has a `typeof` result of "object".
 *
 * @static
 * @memberOf _
 * @since 4.0.0
 * @category Lang
 * @param {*} value The value to check.
 * @returns {boolean} Returns `true` if `value` is object-like, else `false`.
 * @example
 *
 * _.isObjectLike({});
 * // => true
 *
 * _.isObjectLike([1, 2, 3]);
 * // => true
 *
 * _.isObjectLike(_.noop);
 * // => false
 *
 * _.isObjectLike(null);
 * // => false
 */
function isObjectLike$2(value) {
  return value != null && typeof value == 'object';
}

/** `Object#toString` result references. */
var symbolTag$1 = '[object Symbol]';

/**
 * Checks if `value` is classified as a `Symbol` primitive or object.
 *
 * @static
 * @memberOf _
 * @since 4.0.0
 * @category Lang
 * @param {*} value The value to check.
 * @returns {boolean} Returns `true` if `value` is a symbol, else `false`.
 * @example
 *
 * _.isSymbol(Symbol.iterator);
 * // => true
 *
 * _.isSymbol('abc');
 * // => false
 */
function isSymbol$1(value) {
  return typeof value == 'symbol' ||
    (isObjectLike$2(value) && baseGetTag$1(value) == symbolTag$1);
}

/**
 * A specialized version of `_.map` for arrays without support for iteratee
 * shorthands.
 *
 * @private
 * @param {Array} [array] The array to iterate over.
 * @param {Function} iteratee The function invoked per iteration.
 * @returns {Array} Returns the new mapped array.
 */
function arrayMap$1(array, iteratee) {
  var index = -1,
      length = array == null ? 0 : array.length,
      result = Array(length);

while (++index < length) {
 result[index] = iteratee(array[index], index, array);
 }
 return result;
}

/**
 * Checks if `value` is classified as an `Array` object.
 *
 * @static
 * @memberOf _
 * @since 0.1.0
 * @category Lang
 * @param {*} value The value to check.
 * @returns {boolean} Returns `true` if `value` is an array, else `false`.
 * @example
 *
 * _.isArray([1, 2, 3]);
 * // => true
 *
 * _.isArray(document.body.children);
 * // => false
 *
 * _.isArray('abc');
 * // => false
 *
 * _.isArray(_.noop);
 * // => false
 */
var isArray$2 = Array.isArray;

/** Used as references for various `Number` constants. */
var INFINITY$3 = 1 / 0;

/** Used to convert symbols to primitives and strings. */
var symbolProto$1 = Symbol$1 ? Symbol$1.prototype : undefined,
    symbolToString$1 = symbolProto$1 ? symbolProto$1.toString : undefined;

/**
 * The base implementation of `_.toString` which doesn't convert nullish
 * values to empty strings.
 *
 * @private
 * @param {*} value The value to process.
 * @returns {string} Returns the string.
 */
function baseToString$2(value) {
  // Exit early for strings to avoid a performance hit in some environments.
  if (typeof value == 'string') {
    return value;
  }
  if (isArray$2(value)) {
    // Recursively convert values (susceptible to call stack limits).
    return arrayMap$1(value, baseToString$2) + '';
  }
  if (isSymbol$1(value)) {
    return symbolToString$1 ? symbolToString$1.call(value) : '';
  }
  var result = (value + '');
  return (result == '0' && (1 / value) == -INFINITY$3) ? '-0' : result;
}

/** Used to match a single whitespace character. */
var reWhitespace$1 = /\s/;

/**
 * Used by `_.trim` and `_.trimEnd` to get the index of the last non-whitespace
 * character of `string`.
 *
 * @private
 * @param {string} string The string to inspect.
 * @returns {number} Returns the index of the last non-whitespace character.
 */
function trimmedEndIndex$1(string) {
  var index = string.length;

while (index-- && reWhitespace$1.test(string.charAt(index))) {}
  return index;
}

/** Used to match leading whitespace. */
var reTrimStart$1 = /^\s+/;

/**
 * The base implementation of `_.trim`.
 *
 * @private
 * @param {string} string The string to trim.
 * @returns {string} Returns the trimmed string.
 */
function baseTrim$1(string) {
  return string
    ? string.slice(0, trimmedEndIndex$1(string) + 1).replace(reTrimStart$1, '')
    : string;
}

/**
 * Checks if `value` is the
 * [language type](http://www.ecma-international.org/ecma-262/7.0/#sec-ecmascript-language-types)
 * of `Object`. (e.g. arrays, functions, objects, regexes, `new Number(0)`, and `new String('')`)
 *
 * @static
 * @memberOf _
 * @since 0.1.0
 * @category Lang
 * @param {*} value The value to check.
 * @returns {boolean} Returns `true` if `value` is an object, else `false`.
 * @example
 *
 * _.isObject({});
 * // => true
 *
 * _.isObject([1, 2, 3]);
 * // => true
 *
 * _.isObject(_.noop);
 * // => true
 *
 * _.isObject(null);
 * // => false
 */
function isObject$2(value) {
  var type = typeof value;
  return value != null && (type == 'object' || type == 'function');
}

/** Used as references for various `Number` constants. */
var NAN$1 = 0 / 0;

/** Used to detect bad signed hexadecimal string values. */
var reIsBadHex$1 = /^[-+]0x[0-9a-f]+$/i;

/** Used to detect binary string values. */
var reIsBinary$1 = /^0b[01]+$/i;

/** Used to detect octal string values. */
var reIsOctal$1 = /^0o[0-7]+$/i;

/** Built-in method references without a dependency on `root`. */
var freeParseInt$1 = parseInt;

/**
 * Converts `value` to a number.
 *
 * @static
 * @memberOf _
 * @since 4.0.0
 * @category Lang
 * @param {*} value The value to process.
 * @returns {number} Returns the number.
 * @example
 *
 * _.toNumber(3.2);
 * // => 3.2
 *
 * _.toNumber(Number.MIN_VALUE);
 * // => 5e-324
 *
 * _.toNumber(Infinity);
 * // => Infinity
 *
 * _.toNumber('3.2');
 * // => 3.2
 */
function toNumber$1(value) {
  if (typeof value == 'number') {
    return value;
  }
  if (isSymbol$1(value)) {
    return NAN$1;
  }
  if (isObject$2(value)) {
    var other = typeof value.valueOf == 'function' ? value.valueOf() : value;
    value = isObject$2(other) ? (other + '') : other;
  }
  if (typeof value != 'string') {
    return value === 0 ? value : +value;
  }
  value = baseTrim$1(value);
  var isBinary = reIsBinary$1.test(value);
  return (isBinary || reIsOctal$1.test(value))
    ? freeParseInt$1(value.slice(2), isBinary ? 2 : 8)
    : (reIsBadHex$1.test(value) ? NAN$1 : +value);
}

/**
 * Converts `value` to a string. An empty string is returned for `null`
 * and `undefined` values. The sign of `-0` is preserved.
 *
 * @static
 * @memberOf _
 * @since 4.0.0
 * @category Lang
 * @param {*} value The value to convert.
 * @returns {string} Returns the converted string.
 * @example
 *
 * _.toString(null);
 * // => ''
 *
 * _.toString(-0);
 * // => '-0'
 *
 * _.toString([1, 2, 3]);
 * // => '1,2,3'
 */
function toString$3(value) {
  return value == null ? '' : baseToString$2(value);
}

/**
 * The base implementation of `_.propertyOf` without support for deep paths.
 *
 * @private
 * @param {Object} object The object to query.
 * @returns {Function} Returns the new accessor function.
 */
function basePropertyOf$1(object) {
  return function(key) {
    return object == null ? undefined : object[key];
  };
}

/**
 * Gets the timestamp of the number of milliseconds that have elapsed since
 * the Unix epoch (1 January 1970 00:00:00 UTC).
 *
 * @static
 * @memberOf _
 * @since 2.4.0
 * @category Date
 * @returns {number} Returns the timestamp.
 * @example
 *
 * _.defer(function(stamp) {
 *   console.log(_.now() - stamp);
 * }, _.now());
 * // => Logs the number of milliseconds it took for the deferred invocation.
 */
var now = function() {
  return root$1.Date.now();
};

/** Error message constants. */
var FUNC_ERROR_TEXT = 'Expected a function';

/* Built-in method references for those with the same name as other `lodash` methods. */
var nativeMax = Math.max,
    nativeMin = Math.min;

/**
 * Creates a debounced function that delays invoking `func` until after `wait`
 * milliseconds have elapsed since the last time the debounced function was
 * invoked. The debounced function comes with a `cancel` method to cancel
 * delayed `func` invocations and a `flush` method to immediately invoke them.
 * Provide `options` to indicate whether `func` should be invoked on the
 * leading and/or trailing edge of the `wait` timeout. The `func` is invoked
 * with the last arguments provided to the debounced function. Subsequent
 * calls to the debounced function return the result of the last `func`
 * invocation.
 *
 * **Note:** If `leading` and `trailing` options are `true`, `func` is
 * invoked on the trailing edge of the timeout only if the debounced function
 * is invoked more than once during the `wait` timeout.
 *
 * If `wait` is `0` and `leading` is `false`, `func` invocation is deferred
 * until to the next tick, similar to `setTimeout` with a timeout of `0`.
 *
 * See [David Corbacho's article](https://css-tricks.com/debouncing-throttling-explained-examples/)
 * for details over the differences between `_.debounce` and `_.throttle`.
 *
 * @static
 * @memberOf _
 * @since 0.1.0
 * @category Function
 * @param {Function} func The function to debounce.
 * @param {number} [wait=0] The number of milliseconds to delay.
 * @param {Object} [options={}] The options object.
 * @param {boolean} [options.leading=false]
 *  Specify invoking on the leading edge of the timeout.
 * @param {number} [options.maxWait]
 *  The maximum time `func` is allowed to be delayed before it's invoked.
 * @param {boolean} [options.trailing=true]
 *  Specify invoking on the trailing edge of the timeout.
 * @returns {Function} Returns the new debounced function.
 * @example
 *
 * // Avoid costly calculations while the window size is in flux.
 * jQuery(window).on('resize', _.debounce(calculateLayout, 150));
 *
 * // Invoke `sendMail` when clicked, debouncing subsequent calls.
 * jQuery(element).on('click', _.debounce(sendMail, 300, {
 *   'leading': true,
 *   'trailing': false
 * }));
 *
 * // Ensure `batchLog` is invoked once after 1 second of debounced calls.
 * var debounced = _.debounce(batchLog, 250, { 'maxWait': 1000 });
 * var source = new EventSource('/stream');
 * jQuery(source).on('message', debounced);
 *
 * // Cancel the trailing debounced invocation.
 * jQuery(window).on('popstate', debounced.cancel);
 */
function debounce$1(func, wait, options) {
  var lastArgs,
      lastThis,
      maxWait,
      result,
      timerId,
      lastCallTime,
      lastInvokeTime = 0,
      leading = false,
      maxing = false,
      trailing = true;

if (typeof func != 'function') {
    throw new TypeError(FUNC_ERROR_TEXT);
  }
  wait = toNumber$1(wait) || 0;
  if (isObject$2(options)) {
    leading = !!options.leading;
    maxing = 'maxWait' in options;
    maxWait = maxing ? nativeMax(toNumber$1(options.maxWait) || 0, wait) : maxWait;
    trailing = 'trailing' in options ? !!options.trailing : trailing;
  }

function invokeFunc(time) {
    var args = lastArgs,
        thisArg = lastThis;

lastArgs = lastThis = undefined;
    lastInvokeTime = time;
    result = func.apply(thisArg, args);
    return result;
  }

function leadingEdge(time) {
    // Reset any `maxWait` timer.
    lastInvokeTime = time;
    // Start the timer for the trailing edge.
    timerId = setTimeout(timerExpired, wait);
    // Invoke the leading edge.
    return leading ? invokeFunc(time) : result;
  }

function remainingWait(time) {
    var timeSinceLastCall = time - lastCallTime,
        timeSinceLastInvoke = time - lastInvokeTime,
        timeWaiting = wait - timeSinceLastCall;

return maxing
      ? nativeMin(timeWaiting, maxWait - timeSinceLastInvoke)
      : timeWaiting;
  }

function shouldInvoke(time) {
    var timeSinceLastCall = time - lastCallTime,
        timeSinceLastInvoke = time - lastInvokeTime;

// Either this is the first call, activity has stopped and we're at the
 // trailing edge, the system time has gone backwards and we're treating
 // it as the trailing edge, or we've hit the `maxWait` limit.
 return (lastCallTime === undefined || (timeSinceLastCall >= wait) ||
 (timeSinceLastCall < 0) || (maxing && timeSinceLastInvoke >= maxWait));
 }

function timerExpired() {
    var time = now();
    if (shouldInvoke(time)) {
      return trailingEdge(time);
    }
    // Restart the timer.
    timerId = setTimeout(timerExpired, remainingWait(time));
  }

function trailingEdge(time) {
    timerId = undefined;

// Only invoke if we have `lastArgs` which means `func` has been
    // debounced at least once.
    if (trailing && lastArgs) {
      return invokeFunc(time);
    }
    lastArgs = lastThis = undefined;
    return result;
  }

function cancel() {
    if (timerId !== undefined) {
      clearTimeout(timerId);
    }
    lastInvokeTime = 0;
    lastArgs = lastCallTime = lastThis = timerId = undefined;
  }

function flush() {
    return timerId === undefined ? result : trailingEdge(now());
  }

function debounced() {
    var time = now(),
        isInvoking = shouldInvoke(time);

lastArgs = arguments;
    lastThis = this;
    lastCallTime = time;

if (isInvoking) {
      if (timerId === undefined) {
        return leadingEdge(lastCallTime);
      }
      if (maxing) {
        // Handle invocations in a tight loop.
        clearTimeout(timerId);
        timerId = setTimeout(timerExpired, wait);
        return invokeFunc(lastCallTime);
      }
    }
    if (timerId === undefined) {
      timerId = setTimeout(timerExpired, wait);
    }
    return result;
  }
  debounced.cancel = cancel;
  debounced.flush = flush;
  return debounced;
}

/** Used to map characters to HTML entities. */
var htmlEscapes = {
 '&': '&amp;',
 '<': '&lt;',
 '>': '&gt;',
 '"': '&quot;',
 "'": '&#39;'
};

/**
 * Used by `_.escape` to convert characters to HTML entities.
 *
 * @private
 * @param {string} chr The matched character to escape.
 * @returns {string} Returns the escaped character.
 */
var escapeHtmlChar = basePropertyOf$1(htmlEscapes);

/** Used to match HTML entities and HTML characters. */
var reUnescapedHtml = /[&<>"']/g,
 reHasUnescapedHtml = RegExp(reUnescapedHtml.source);

/**
 * Converts the characters "&", "<", ">", '"', and "'" in `string` to their
 * corresponding HTML entities.
 *
 * **Note:** No other characters are escaped. To escape additional
 * characters use a third-party library like [_he_](https://mths.be/he).
 *
 * Though the ">" character is escaped for symmetry, characters like
 * ">" and "/" don't need escaping in HTML and have no special meaning
 * unless they're part of a tag or unquoted attribute value. See
 * [Mathias Bynens's article](https://mathiasbynens.be/notes/ambiguous-ampersands)
 * (under "semi-related fun fact") for more details.
 *
 * When working with HTML you should always
 * [quote attribute values](http://wonko.com/post/html-escaping) to reduce
 * XSS vectors.
 *
 * @static
 * @since 0.1.0
 * @memberOf _
 * @category String
 * @param {string} [string=''] The string to escape.
 * @returns {string} Returns the escaped string.
 * @example
 *
 * _.escape('fred, barney, & pebbles');
 * // => 'fred, barney, &amp; pebbles'
 */
function escape(string) {
 string = toString$3(string);
 return (string && reHasUnescapedHtml.test(string))
 ? string.replace(reUnescapedHtml, escapeHtmlChar)
 : string;
}

/** Used to map HTML entities to characters. */
var htmlUnescapes = {
 '&amp;': '&',
 '&lt;': '<',
 '&gt;': '>',
 '&quot;': '"',
 '&#39;': "'"
};

/**
 * Used by `_.unescape` to convert HTML entities to characters.
 *
 * @private
 * @param {string} chr The matched character to unescape.
 * @returns {string} Returns the unescaped character.
 */
var unescapeHtmlChar = basePropertyOf$1(htmlUnescapes);

/** Used to match HTML entities and HTML characters. */
var reEscapedHtml = /&(?:amp|lt|gt|quot|#39);/g,
    reHasEscapedHtml = RegExp(reEscapedHtml.source);

/**
 * The inverse of `_.escape`; this method converts the HTML entities
 * `&amp;`, `&lt;`, `&gt;`, `&quot;`, and `&#39;` in `string` to
 * their corresponding characters.
 *
 * **Note:** No other HTML entities are unescaped. To unescape additional
 * HTML entities use a third-party library like [_he_](https://mths.be/he).
 *
 * @static
 * @memberOf _
 * @since 0.6.0
 * @category String
 * @param {string} [string=''] The string to unescape.
 * @returns {string} Returns the unescaped string.
 * @example
 *
 * _.unescape('fred, barney, &amp; pebbles');
 * // => 'fred, barney, & pebbles'
 */
function unescape(string) {
  string = toString$3(string);
  return (string && reHasEscapedHtml.test(string))
    ? string.replace(reEscapedHtml, unescapeHtmlChar)
    : string;
}

const cpAppCss = "";

var commonjsGlobal = typeof globalThis !== 'undefined' ? globalThis : typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {};

function createCommonjsModule(fn, basedir, module) {
	return module = {
		path: basedir,
		exports: {},
		require: function (path, base) {
			return commonjsRequire();
		}
	}, fn(module, module.exports), module.exports;
}

function commonjsRequire () {
	throw new Error('Dynamic requires are not currently supported by @rollup/plugin-commonjs');
}

var output_1 = createCommonjsModule(function (module, exports) {
Object.defineProperty(exports, "__esModule", { value: true });
exports.functions = exports.output = void 0;

/**
 * Output operator for bracket notation. Acts as "dispatch" function for the
 * output methods below.
 * @example
 * output({args:["chr",65]}) // => "A"
 * @param {string} func Name of the output function to process
 * @param {any[]} rest Any additional arguments to pass to the transform
 * @return {string} Processed output.
 */
function output({ args: [func, ...rest], }) {
 // Implementation of the chr() and amp() embeddable methods
 // [output,strong,cat amp() dog] => cat &amp; dog
 // [output,strong,cat chr(38) dog] => cat &amp; dog
 if (rest && typeof rest[0] === "string") {
 rest[0] = rest[0].replace(/chr$(\d+)$/g, function (template, p1) {
 return exports.functions.chr(Number(p1));
 });
 rest[0] = rest[0].replace(/amp/g, function (template) {
 return exports.functions.amp();
 });
 }
 if (typeof exports.functions[func] === "function") {
 return exports.functions[func](...rest);
 }
 else {
 throw new Error(`Locale output function '${func}' is not implemented.`);
 }
}
exports.output = output;
exports.functions = {
 /**
 * Output the HTML escaped version of an ampersand.
 * @example
 * amp() // => "&amp;"
 * @return {string} HTML safe value of &
 */
 amp() {
 return Html.htmlEscape("&");
 },
 /**
 * Output an HTML safe apostrophe
 * @example
 * apos() // => "&#39;"
 * @return {string} HTML safe apostrophe
 */
 apos() {
 return Html.htmlEscape("'");
 },
 /**
 * Output an HTML safe quote mark
 * @example
 * quot() // => "&quot;"
 * @return {string} HTML safe quote
 */
 quot() {
 return Html.htmlEscape('"');
 },
 /**
 * Output the string wrapped in a HTML tag
 * @example
 * underline("text") //=> text
 * @param {string} str
 * @return {string} string wrapped in HTML tag
 */
 underline(str) {
 return `${str}`;
 },
 /**
 * Output the string wrapped in a HTML tag
 * @example
 * strong("text") // => text
 * @param {string} str
 * @return {string} string wrapped in HTML tag
 */
 strong(str) {
 return `${str}`;
 },
 /**
 * Output the string wrapped in a HTML tag
 * @example
 * em("text") // => text
 * @param {string} str
 * @return {string} string wrapped in HTML tag
 */
 em(str) {
 return `${str}`;
 },
 /**
 * Output the string wrapped in a <abbr> HTML tag
 *
 * @example
 * abbr("WHO", "World Health Organization"); // => <abbr title="World Health Organization">WHO</abbr>
 * @param {string} abbr Abbreviation
 * @param {string} full Full version of the abbreviation
 * @return {string} string wrapped in <abbr> HTML tag
 */
 abbr(abbr, full) {
 return `<abbr title="${full}">${abbr}</abbr>`;
 },
 /**
 * Output the string wrapped in a <abbr> HTML tag with special markings
 * @example
 * acronym("WHO", "World Health Organization"); // => <abbr title="World Health Organization" class="initialism">WHO</abbr>
 * @param {string} abbr Acronym
 * @param {string} full Full version of the acronym
 * @return {string} string wrapped in <abbr>
 */
 acronym(abbr, full) {
 return `<abbr title="${full}" class="initialism">${abbr}</abbr>`;
 },
 /**
 * Output the string wrapped in a HTML tag with the provided classes
 * @example
 * class("text","text-bold","text-underline") // => text
 * @param {string} str String to embed in the span.
 * @param {...string} classes class names as arguments.
 * @return {string} span with classnames
 */
 class(str, ...classes) {
 const classNames = classes.join(" ");
 return `${str}`;
 },
 /**
 * Output the requested character encoded as an HTML character.
 * @example
 * chr(65) // => "A"
 * @param {number|string} num Character code to output.
 * @return {string} requested character encoded as an HTML character.
 */
 chr(num) {
 if (typeof num === "string") {
 num = Number(num);
 }
 if (typeof num !== "number" || isNaN(num)) {
 throw new Error("chr needs a number as argument");
 }
 return Html.htmlEscape(String.fromCharCode(num));
 },
 /**
 * Output HTML anchor link based on input provided.
 * Note: The special key/value _type,offsite can be used to make an offsite link.
 *
 * @example
 * url("https://somewhere.tld") // => <a href="https://somewhere.tld">https://somewhere.tld</a>
 * url("https://somewhere.tld", "Click Here") // => <a href="https://somewhere.tld">Click Here</a>
 * url("https://somewhere.tld", "Click Here", { "_type": "offsite" }) // => <a href="https://somewhere.tld" class="offsite" target="_blank">Click Here</a>
 * url("https://somewhere.tld", "Click Here", "class", "class1 class2"]) // => <a href="https://somewhere.tld" class="class1 class2">Click Here</a>
 * url("https://somewhere.tld", { html: "Click Here" }) // => <a href="https://somewhere.tld">Click Here</a>
 *
 * @param {string} dest href value.
 * @param {...any} [rest] additional parameters
 * @return {string} HTML anchor link
 */
 url(dest, ...rest) {
 let config, text;
 if (typeof rest[rest.length - 1] === "object") {
 // when config object is provided as parameter
 config = rest[rest.length - 1]; // config object is the last item in arguments
 if (rest.length === 2) {
 // addresses url( dest, text, { "class": "class1 class2" } )
 if (config.html) {
 throw new Error("Cannot provide both text and configuration with html attribute");
 }
 text = rest[0];
 }
 else if (config && config.html) {
 // addresses url( dest, { "html": "text", "class": "class1 class2" } )
 text = config.html;
 delete config.html;
 }
 else {
 // addresses url( dest, { "class": "class1 class2" } )
 text = dest;
 }
 }
 else if (rest.length % 2 === 0) {
 // when no object is provided. example: url(dest,"html", "Click Here")
 config = listToObject_1.listToObject(...rest);
 if (config && "html" in config && config.html !== "") {
 // url(dest,"html", "Click Here")
 text = config.html;
 delete config.html;
 }
 else {
 // url(dest,"class", "class1 class2")
 text = dest;
 }
 }
 else {
 // addresses url(dest, "Click Here", "class", "class1 class2")
 text = rest.shift();
 config = listToObject_1.listToObject(...rest);
 }
 // Special handle offsite links
 if ("_type" in config && config._type === "offsite") {
 config["class"] = "offsite";
 config.target = "_blank";
 delete config._type;
 }
 // Generates anchor tag
 let html = `<a href="${dest}"`;
 if (typeof config === "object") {
 for (const key in config) {
 if (Object.prototype.hasOwnProperty.call(config, key)) {
 html += ` ${key}="${config[key]}"`;
 }
 }
 }
 html += `>${text}</a>`;
 return html;
 },
};
//# sourceMappingURL=output.js.map
});

var asis_1 = createCommonjsModule(function (module, exports) {
Object.defineProperty(exports, "__esModule", { value: true });
exports.asis = void 0;

/**
 * Returns a string asis without any translation.
 * NOTE: asis function only takes one non translatable string
 * @example
 *      asis({args:["cPanel"]}); // => cPanel
 * @param {string} nonTranslatableString The string that should not be translated.
 * @returns {string} string that should not be translated.
 */
function asis({ args: [nonTranslatableString, ...rejectedArgs], }) {
    if (!nonTranslatableString ||
        rejectedArgs.length > 0 ||
        typeof nonTranslatableString !== "string") {
        throw new Error("asis function accepts one non translatable string.");
    }
    // Implementation of embeddable methods chr()
    // [asis,cat chr(38) dog] => cat &amp; dog
    nonTranslatableString = nonTranslatableString.replace(/chr$(\d+)$/g, function (template, p1) {
        return output_1.functions.chr(Number(p1));
    });
    // Implementation of embeddable method amp()
    // [asis,cat amp() dog] => cat &amp; dog
    nonTranslatableString = nonTranslatableString.replace(/amp/g, function (template) {
        return output_1.functions.amp();
    });
    return nonTranslatableString;
}
exports.asis = asis;
//# sourceMappingURL=asis.js.map
});

var quant_1 = createCommonjsModule(function (module, exports) {
Object.defineProperty(exports, "__esModule", { value: true });
exports.format_bytes = exports.numf = exports.quant = exports.numerate = void 0;

/**
 * This returns the given noun form which is appropriate for the quantity according to this language's conventions.
 * numerate is used internally by quant to quantify nouns.
 *
 * @example
 * numerate({cldr: cldr, args: [-1,"have one banana", "have many bananas", "owe you a banana"]}) // => owe you a banana
 * numerate({cldr: cldr, args: [1,"have one banana", "have many bananas", "owe you a banana"]}) // => I have one banana
 * numerate({cldr: cldr, args: [1,"have one banana", "have many bananas", "owe you a banana"]}) // => I have many bananas
 *
 * @param {CLDR} cldr CLDR data
 * @param {number} number quantity
 * @param {string[]} rest Singular, Plural and Negative string
 * @return {string} formatted string
 */
function numerate({ cldr: cldr$1, args: [num, ...rest], }) {
 if (!(cldr$1 instanceof cldr.CLDR)) {
 throw new Error("`numerate` function requires a valid CLDR instance for the `cldr` parameter.");
 }
 const pluralForms = cldr$1.getPluralForm(num, ...rest);
 const numerated = pluralForms ? pluralForms[0] : rest[rest.length - 1];
 return numerated;
}
exports.numerate = numerate;
/**
 * Used for quantifying a noun.
 * Provides a variant of the string based on the absolute value of the number provided.
 *
 * @example
 * quant({cldr: cldr, args:[10000, "test","tests"]}) // => "10,000 tests"
 * quant({cldr: cldr, args:[0, "singular","plural", "nothing"]}) // => "nothing"
 * quant({cldr: cldr, args:[[13.45789,2], "unit", "units"}) // => "13.46 units"
 * @param {CLDR} cldr cldr data
 * @param {number|number[]} num Quantity on which the output depends.
 * @param {string[]} rest singular, plural, zero string
 * @return {string} formatted string
 */
function quant({ cldr: cldr$1, args: [num, ...rest], }) {
 if (!(cldr$1 instanceof cldr.CLDR)) {
 throw new Error("`quant` function requires a valid CLDR instance for the `cldr` parameter.");
 }
 let quantity, decimalPlaces = 3;
 if (num instanceof Array) {
 decimalPlaces = num[1];
 quantity = num[0];
 }
 else {
 quantity = num;
 }
 const pluralForms = cldr$1.getPluralForm(quantity, ...rest);
 // If there's a mismatch between the actual number of forms
 // (singular, plural, etc.) and the real number, this can be
 // undefined, which can break code. We pick the rightmost, or
 // "most plural," form as a fallback.
 const numerated = pluralForms
 ? pluralForms[0]
 : rest[rest.length - 1];
 const isSpecialZero = pluralForms && pluralForms.length >= 2 ? pluralForms[1] : 0;
 if (isSpecialZero) {
 return numerated;
 }
 const formatted = numf({ cldr: cldr$1, args: [quantity, decimalPlaces] });
 if (numerated.indexOf("%s") !== -1) {
 return numerated.replace(/%s/g, formatted);
 }
 return cldr$1.isRtl()
 ? numerated + " " + formatted
 : formatted + " " + numerated;
}
exports.quant = quant;
/**
 * Gets CLDR Decimal Format information
 *
 * @param {CLDR} cldr cldr information
 */
function getCLDRDecimalFormatInfo(cldr) {
 const decimalFormatInfo = {};
 const formats = cldr.getFormats();
 if (Object.prototype.hasOwnProperty.call(formats, "decimal")) {
 decimalFormatInfo.decimalFormat = formats.decimal;
 }
 if (Object.prototype.hasOwnProperty.call(formats, "_decimal_format_group")) {
 decimalFormatInfo.decimalGroup = formats._decimal_format_group;
 }
 if (Object.prototype.hasOwnProperty.call(formats, "_decimal_format_decimal")) {
 decimalFormatInfo.decimalDecimal = formats._decimal_format_decimal;
 }
 return decimalFormatInfo;
}
/**
 * Returns the given number formatted nicely according to this language's conventions.
 * Does not localize exponential formats
 * @example
 * numf({cldr, args:[1000.0012,3]}) // => 1,000.001
 * numf({cldr, args:[6.022e23]}) // => "6.022e+23"
 *
 * @param {CLDR} cldr CLDR data
 * @param {number} num number to be formatted
 * @param {number} [decimalPlaces=6] decimal places
 * @return {string} formatted string
 */
function numf({ cldr: cldr$1, args: [num, decimalPlaces = 6], }) {
 if (!(cldr$1 instanceof cldr.CLDR)) {
 throw new Error("`numf` function requires a valid CLDR instance for the `cldr` parameter.");
 }
 // exponential -> don't know how to deal
 if (/e/.test(num.toString())) {
 return String(num);
 }
 const { decimalFormat, decimalGroup, decimalDecimal, } = getCLDRDecimalFormatInfo(cldr$1);
 if (!decimalFormat || !decimalGroup || !decimalDecimal) {
 throw new Error("CLDR Data is missing information related to formatting decimals.");
 }
 const isNegative = num < 0;
 num = Math.abs(num);
 // Trim the decimal part and round
 let whole = Math.floor(num);
 let fraction;
 if (/(?!')\.(?!')/.test(num.toString())) {
 // This weirdness is necessary to avoid floating-point
 // errors that can crop up with large-ish numbers.
 // Convert to a simple fraction.
 fraction = String(num).replace(/^[^.]+/, "0");
 // Now round to the desired precision.
 fraction = Number(fraction).toFixed(decimalPlaces);
 // e.g., 1.9999 when only 3 decimal places are desired.
 if (/^1/.test(fraction)) {
 whole++;
 num = whole;
 fraction = undefined;
 }
 else {
 // removes trailing 0's and returns fraction
 fraction = fraction.replace(/^.*\./, "").replace(/0+$/, "");
 }
 }
 let patternWithOutsideSymbols;
 // If language uses different formats for negative numbers than just adding "-" at the front,
 // you can put in two patterns, separated by a semicolon.
 // The first will be used for zero and positive values, while the second will be used for negative values.
 // http://cldr.unicode.org/translation/number-patterns
 if (/(?!');(?!')/.test(decimalFormat)) {
 patternWithOutsideSymbols = decimalFormat.split(/(?!');(?!')/)[isNegative ? 1 : 0];
 }
 else {
 patternWithOutsideSymbols = (isNegative ? "-" : "") + decimalFormat;
 }
 const innerPattern = patternWithOutsideSymbols.match(/[0#].*[0#]/)[0];
 // Applying the integer part of the pattern is much easier if it's
 // done with the strings reversed.
 const patternSplit = innerPattern.split(/(?!')\.(?!')/);
 const intPatternSplit = patternSplit[0]
 .split("")
 .reverse()
 .join("")
 .split(/(?!'),(?!')/);
 // If there is only one part of the int pattern, then set the "joiner"
 // to empty string. (http://unicode.org/cldr/trac/ticket/4094)
 let groupJoiner;
 if (intPatternSplit.length === 1) {
 groupJoiner = "";
 }
 else {
 // Most patterns look like #,##0.###, for which the leftmost # is
 // just a placeholder so we know where to put the group separator.
 intPatternSplit.pop();
 groupJoiner = decimalGroup;
 }
 const wholeReverse = String(whole).split("").reverse();
 const wholeAssembled = []; // reversed
 let pattern;
 const replacer = function (chr) {
 switch (chr) {
 case "#":
 return wholeReverse.shift() || "";
 case "0":
 return wholeReverse.shift() || "0";
 }
 };
 while (wholeReverse.length) {
 if (intPatternSplit.length) {
 pattern = intPatternSplit.shift();
 }
 // Since this is reversed, we can just replace a character
 // at a time, in regular forward order. Make sure we leave quoted
 // stuff alone while paying attention to stuff *by* quoted stuff.
 const assembleChunk = pattern
 .replace(/(?!')[0#]|[0#](?!')/g, replacer)
 .replace(/'([.,0#;¤%E])'$/, "")
 .replace(/'([.,0#;¤%E])'/, "$1");
 wholeAssembled.push(assembleChunk);
 }
 const formattedNumber = wholeAssembled.join(groupJoiner).split("").reverse().join("") +
 (fraction ? decimalDecimal + fraction : "");
 return patternWithOutsideSymbols.replace(/[0#].*[0#]/, formattedNumber);
}
exports.numf = numf;
/**
 * Formats bytes with the specific decimal places.
 * This depends on locale-specific overrides of base functionality
 * but should not itself need an override.
 *
 * @example
 * format_bytes({cldr, args: [22]}) // => 22 bytes
 * format_bytes({cldr, args: [1045, 2]}) // => 1.02 KB
 *
 * @param {number} bytes
 * @param {number} [decimalPlaces] Number of decimal places. Defaults to 2.
 * @return {string}
 */
function format_bytes({ cldr: cldr$1, args: [bytes, decimalPlaces = 2], }) {
 if (!(cldr$1 instanceof cldr.CLDR)) {
 throw new Error("`format_bytes` function requires a valid CLDR instance for the `cldr` parameter.");
 }
 // NOTE: There is no widely accepted consensus of exactly how to measure data
 // and which units to use for it. For example, some bodies define "B" to mean
 // bytes, while others don't. (NB: SI defines "B" to mean bels.) Some folks
 // use k for kilo; others use K. Some say kilo should be 1,024; others say
 // it's 1,000 (and "kibi" would be 1,024). What we do here is at least in
 // longstanding use at cPanel.
 const dataAbbreviations = [
 "KB",
 "MB",
 "GB",
 "TB",
 "PB",
 "EB",
 "ZB",
 "YB",
 ];
 const NBSP = "\u00a0";
 const exponent = bytes &&
 Math.min(Math.floor(Math.log(bytes) / Math.log(1024)), dataAbbreviations.length);
 if (!exponent) {
 return quant({ cldr: cldr$1, args: [bytes, "%s\u00a0byte", "%s\u00a0bytes"] }); // \u00a0 is a non breaking space
 }
 else {
 const quantity = bytes / Math.pow(1024, exponent);
 const formattedNumber = numf({
 cldr: cldr$1,
 args: [quantity, decimalPlaces],
 });
 return formattedNumber + NBSP + dataAbbreviations[exponent - 1];
 }
}
exports.format_bytes = format_bytes;
//# sourceMappingURL=quant.js.map
});

var datetime_1 = createCommonjsModule(function (module, exports) {
Object.defineProperty(exports, "__esModule", { value: true });
exports.local_datetime = exports.datetime = exports.dateToLocalDayNum = void 0;

/**
 * Given a date object, this function returns the index needed for days-of-the-week
 * lookups in CLDR arrays. CLDR arrays start with Monday, not Sunday.
 *
 * @param {Date} date The date to look up.
 * @return {number} The CLDR index corresponding to the date provided.
 */
const getCldrDayIndex = function (date) {
 // getUTCDay() starts from Sunday, but CLDR starts from Monday.
 const num = date.getUTCDay() - 1;
 return num < 0 ? 6 : num;
};
/**
 * This is a simple map from the return value of date.getUTCDay() to the standard
 * CLDR day of the week.
 *
 * UTC day numbers of the week start with Sunday and range 0-6.
 * CLDR day numbers of the week start with Monday and range from 1-7:
 *
 * Mon Tue Wed Thu Fri Sat Sun
 * 1 2 3 4 5 6 7
 */
const utcToCldrMap = [7, 1, 2, 3, 4, 5, 6];
/**
 * Given a date object and the first day of the locale's week, this function
 * will return the CLDR numerical day of the week for the date.
 *
 * When referring to days of the week, CLDR uses the numbers 1-7, with 1 being
 * the first day of the week and 7 being the last.
 *
 * @example
 * const tuesdayDate = new Date('Tue Dec 19 1995 00:00:00 UTC');
 *
 * // When Sunday is the first day of week => Sun, Mon, Tue (3)
 * dateToLocalDayNum( tuesdayDate, 7 ) // => 3
 *
 * // When Monday is the first day of week => Mon, Tue (2)
 * dateToLocalDayNum( tuesdayDate, 1 ) // => 2
 *
 * @example
 * const sundayDate = new Date('Sun Dec 17 1995 00:00:00 UTC');
 *
 * // When Sunday is the first day of week => Sun (1)
 * dateToLocalDayNum( sundayDate, 7 ) // => 1
 *
 * // When Monday is the first day of week => Mon, Tue, Wed, Thu, Fri, Sat, Sun (7)
 * dateToLocalDayNum( sundayDate, 1 ) // => 7
 *
 * @export
 * @param {Date} targetDate The date we want to process.
 * @param {number} firstDayOfWeek The locale's first day of the week, in CLDR's 1-7 notation (Mon = 1, Sun = 7).
 * @returns {number} The numerical day of the week for the date, in CLDR notation (1-7).
 */
function dateToLocalDayNum(targetDate, firstDayOfWeek) {
 // Convert the targetDate to the CLDR day number (1-7) to get it and firstDayOfWeek on the same scale.
 const targetDay = utcToCldrMap[targetDate.getUTCDay()];
 // Add a week to targetDay for simpler math. We normalize back down using the modulus.
 const offset = (targetDay + 7 - firstDayOfWeek) % 7;
 // We add 1 to the offset, because CLDR days of the week are numbered 1-7.
 return offset + 1;
}
exports.dateToLocalDayNum = dateToLocalDayNum;
/**
 * Given a string, this function will ensure that it reaches the specified length
 * with the specified filler character.
 *
 * @param {string} originalString String that needs padding
 * @param {number} len Required length of string
 * @param {string} fillerChar Filler character
 * @returns {string} padded string
 */
const padStart = function (originalString, len, fillerChar) {
 let fill = "", toFill = 0;
 len = len || 0;
 fillerChar = String(fillerChar === undefined ? " " : fillerChar);
 toFill = len - String(originalString).length;
 if (toFill > 0) {
 fill = [...Array(toFill)]
 .map(String.prototype.valueOf, fillerChar)
 .join("");
 }
 return fill + originalString;
};
/**
 * The maketext datetime operator implementation. This function takes in a date or
 * unix timestamp (as an integer) along with an optional format string and returns
 * the given date and/or the current time in the format specified. If no format is
 * provided, the default long format date for the locale is used.
 *
 * The format string can use various presets or provide a custom string that uses
 * patterns for replacement. You can find a list of patterns at the following link,
 * though not all of them are implemented:
 *
 * https://unicode.org/reports/tr35/tr35-dates.html#Date_Field_Symbol_Table
 *
 * Note: All times are in UTC. If you need localized time, use the local_datetime
 * function instead.
 *
 * @example
 * // Format the current date using the default date format
 * datetime({ cldr, args: [] })
 *
 * @example
 * // Format the given unix timestamp (December 1, 1995 00:00:00 UTC) using the datetime_format_short preset
 * datetime({ cldr, args: [817776000, 'datetime_format_short'] })
 *
 * @example
 * // Format the given Date instance (December 1, 1995 00:00:00 UTC) using a custom pattern
 * datetime({ cldr, args: [new Date(817776000 * 1000), 'MM/dd - HH:mm'] }) // => 12/1 - 00:00
 *
 * @param {CLDR} cldr The CLDR data to be used.
 * @param {any[]} args The array of args for the function.
 * @param {Date|number} args.[date] The date to be formatted. If using a number, it should be the unix timestamp in seconds.
 * @param {string} args.[formatString=date_format_long] The format preset or template to follow.
 * @param {string} [tzString] An optional time zone string, mainly used by local_datetime(). Defaults to 'UTC', since
 * all of the underlying JS time/date functions used by this method are the UTC variants.
 * @returns {string} The formatted datetime.
 */
function datetime({ cldr: cldr$1, args: [date = new Date(), formatString], tzString = "UTC", }) {
 // Accept unix timestamps as well (integers only)
 if (typeof date === "number" && /^-?\d+$/.test(date.toString())) {
 date = new Date(date * 1000);
 }
 if (!(date instanceof Date)) {
 throw new Error("The datetime function only accepts Date instances or integer values (unix timestamps) for the `date` parameter.");
 }
 if (!(cldr$1 instanceof cldr.CLDR)) {
 throw new Error("The datetime function requires a valid CLDR instance for the `cldr` parameter.");
 }
 const dateTimeInfo = cldr$1.getDateTimeInfo();
 // Make sure we don't just grab any random CLDR datetime key.
 if (typeof formatString === "string" &&
 /^(?:date|time|datetime|special)_format_/.test(formatString)) {
 formatString = dateTimeInfo[formatString];
 }
 // Use the default format if one wasn't provided or the preset didn't exist.
 if (!formatString) {
 formatString = dateTimeInfo.date_format_long;
 }
 return formatString.replace(/('[^']+')|(([a-zA-Z])\3*)/g, 
 /**
 * A replacement function that will replace quoted strings and pattern strings in the formatString.
 * Each match will have either a quotedString or patternString defined.
 *
 * @param {string} substring The substring of the main string that matched. Unused by this function.
 * @param {string} quotedString The value of the first capture group. This capture group checks for
 * strings enclosed in single quotes so they are passed through without
 * transformation via pattern substitution.
 * @param {string} patternString The value of the second capture group. This capture group checks for
 * alphabetic characters for replacement patterns.
 * @returns {string} The replacement string.
 */
 function (substring, quotedString, patternString) {
 if (quotedString) {
 return quoteSubstituter(quotedString);
 }
 else {
 return patternSubstituter(date, dateTimeInfo, patternString, tzString);
 }
 });
}
exports.datetime = datetime;
/**
 * This function strips quotation marks and returns the contained string as-is.
 * It is meant for ensuring that text within the quotes are not tested for pattern
 * substitutions.
 *
 * @param {string} quotedString The quoted string to be processed.
 * @returns {string} The contained string.
 */
function quoteSubstituter(quotedString) {
 return quotedString.substr(1, quotedString.length - 2);
}
/**
 * This function checks the matched patternString against all known patterns
 * and substitutes them for their datetime equivalents, following CLDR conventions.
 *
 * Pattern references:
 * https://unicode.org/reports/tr35/tr35-dates.html#Date_Field_Symbol_Table
 * https://metacpan.org/pod/DateTime#CLDR-Patterns
 *
 * @param {Date} date The date being processed.
 * @param {Object} dateTimeInfo The dateTimeInfo from the locale's CLDR data.
 * @param {string} patternString The pattern that has been matched.
 * @returns {string} Substitution string
 */
function patternSubstituter(date, dateTimeInfo, patternString, tzString) {
 switch (patternString) {
 case "yy":
 // 2 digit year
 return Math.abs(date.getUTCFullYear()).toString().slice(-2);
 case "y":
 case "yyy":
 case "yyyy":
 // Year
 return String(Math.abs(date.getUTCFullYear()));
 case "MMMMM":
 // Narrow month
 return dateTimeInfo.month_format_narrow[date.getUTCMonth()];
 case "LLLLL":
 // Narrow standalone month
 return dateTimeInfo.month_stand_alone_narrow[date.getUTCMonth()];
 case "MMMM":
 // Wide month
 return dateTimeInfo.month_format_wide[date.getUTCMonth()];
 case "LLLL":
 // Wide standalone month
 return dateTimeInfo.month_stand_alone_wide[date.getUTCMonth()];
 case "MMM":
 // Abbreviated month
 return dateTimeInfo.month_format_abbreviated[date.getUTCMonth()];
 case "LLL":
 // Abbreviated standalone month
 return dateTimeInfo.month_stand_alone_abbreviated[date.getUTCMonth()];
 case "MM":
 case "LL":
 // 2 digit, padded numeric month
 return padStart((date.getUTCMonth() + 1).toString(), 2, "0");
 case "M":
 case "L":
 // Unpadded numeric month
 return String(date.getUTCMonth() + 1);
 case "EEEE":
 // Wide day of the week
 return dateTimeInfo.day_format_wide[getCldrDayIndex(date)];
 case "EEE":
 case "EE":
 case "E":
 // Abbreviated day of the week
 return dateTimeInfo.day_format_abbreviated[getCldrDayIndex(date)];
 case "EEEEE":
 // Narrow day of the week
 return dateTimeInfo.day_format_narrow[getCldrDayIndex(date)];
 case "cccc":
 // Wide day of the week
 return dateTimeInfo.day_stand_alone_wide[getCldrDayIndex(date)];
 case "ccc":
 // Abbreviated day of the week
 return dateTimeInfo.day_stand_alone_abbreviated[getCldrDayIndex(date)];
 case "cc":
 case "c":
 // Numeric day of the week (1-7)
 return String(dateToLocalDayNum(date, Number(dateTimeInfo.first_day_of_week)));
 case "ccccc":
 // Narrow day of the week
 return dateTimeInfo.day_stand_alone_narrow[getCldrDayIndex(date)];
 case "dd":
 // 2 digit, padded numeric day of the month
 return padStart(date.getUTCDate().toString(), 2, "0");
 case "d":
 // Unpadded numeric day of the month
 return String(date.getUTCDate());
 case "h":
 case "hh": {
 // Padded and unpadded hours on the 12 hour clock
 let twelve_hours = date.getUTCHours();
 if (twelve_hours > 12) {
 twelve_hours -= 12;
 }
 // The midnight hour is represented as 12:XX in 12 hour format
 if (twelve_hours === 0) {
 twelve_hours = 12;
 }
 const result = patternString === "hh"
 ? padStart(twelve_hours.toString(), 2, "0")
 : twelve_hours;
 return String(result);
 }
 case "H":
 // Unpadded hours on the 24 hour clock
 return String(date.getUTCHours());
 case "HH":
 // 2 digit, padded hours on the 24 hour clock
 return padStart(date.getUTCHours().toString(), 2, "0");
 case "m":
 // Unpadded minutes
 return String(date.getUTCMinutes());
 case "mm":
 // 2 digit, padded minutes
 return padStart(date.getUTCMinutes().toString(), 2, "0");
 case "s":
 // Unpadded seconds
 return String(date.getUTCSeconds());
 case "ss":
 // 2 digit, padded seconds
 return padStart(date.getUTCSeconds().toString(), 2, "0");
 case "a": {
 // AM/PM
 const hours = date.getUTCHours();
 if (hours < 12) {
 return dateTimeInfo.am_pm_abbreviated[0];
 }
 else if (hours > 12) {
 return dateTimeInfo.am_pm_abbreviated[1];
 }
 // CLDR defines "noon", but CPAN DateTime::Locale doesn't have it, so we just use PM.
 return dateTimeInfo.am_pm_abbreviated[1];
 }
 case "z":
 case "zzzz":
 case "v":
 case "vvvv":
 // Time zone string. Defaults to UTC, unless you're coming through local_datetime.
 return tzString;
 case "G":
 case "GG":
 case "GGG":
 // Abbreviated era (AD/BC)
 return dateTimeInfo.era_abbreviated[date.getUTCFullYear() < 0 ? 0 : 1];
 case "GGGGG":
 // Narrow era
 return dateTimeInfo.era_narrow[date.getUTCFullYear() < 0 ? 0 : 1];
 case "GGGG":
 // Wide era
 return dateTimeInfo.era_wide[date.getUTCFullYear() < 0 ? 0 : 1];
 }
 return patternString;
}
/**
 * The maketext local_datetime operator implementation. This function mimics the
 * datetime operator, except that it also takes into account the local time zone.
 *
 * See datetime for more information on its usage.
 *
 * @example
 * // Format the given Date instance using a custom pattern in the local time zone.
 * // Fri Dec 1 1995 00:00:00 UTC => Thu Nov 30 1995 18:00:00 CST
 * datetime({ cldr, args: [new Date(817776000 * 1000), 'MM/dd - HH:mm'] }) // => 11/30 - 18:00
 *
 * @param {CLDR} cldr The CLDR data to be used.
 * @param {any[]} args The array of args for the function.
 * @param {Date|number} args.[date] The date to be formatted. If using a number, it should be the unix timestamp in seconds.
 * @param {string} args.[formatString] The format preset or template to follow.
 * @returns {string} The formatted datetime in the local time zone.
 */
function local_datetime({ cldr: cldr$1, args: [date = new Date(), formatString], }) {
 // Accept unix timestamps as well (integers only)
 if (typeof date === "number" && /^-?\d+$/.test(date.toString())) {
 date = new Date(date * 1000);
 }
 if (!(date instanceof Date)) {
 throw new Error("The datetime function only accepts Date instances or integer values (unix timestamps) for the `date` parameter.");
 }
 if (!(cldr$1 instanceof cldr.CLDR)) {
 throw new Error("The datetime function requires a valid CLDR instance for the `cldr` parameter.");
 }
 /**
 * Because all of the datetime substitutions rely on UTC time functions,
 * we need to manually adjust the base UTC time of the date object by the
 * local offset to get the final results in local time.
 *
 * (This has to happen on the passed-in object because of the tests’
 * use of spyOn().)
 */
 const tzOffset = date.getTimezoneOffset();
 // Now that we’ve grabbed the TZ offset, clone the date so that we
 // don’t affect the caller.
 date = new Date(date);
 date.setMinutes(date.getMinutes() - tzOffset);
 // Process the time zone string that datetime() will use in place of 'UTC'
 const offsetSign = tzOffset > 0 ? "-" : "+";
 const offsetHours = Math.floor(Math.abs(tzOffset) / 60);
 const offsetMinutes = Math.abs(tzOffset % 60);
 const tzString = "GMT" +
 offsetSign +
 padStart(offsetHours.toString(), 2, "0") +
 padStart(offsetMinutes.toString(), 2, "0");
 return datetime({
 cldr: cldr$1,
 args: [date, formatString],
 tzString,
 });
}
exports.local_datetime = local_datetime;
//# sourceMappingURL=datetime.js.map
});

var functions = createCommonjsModule(function (module, exports) {
Object.defineProperty(exports, "__esModule", { value: true });
exports.functions = void 0;

exports.functions = {
    asis: asis_1.asis,
    output: output_1.output,
    comment: comment_1.comment,
    boolean: boolean_1.boolean,
    numf: quant_1.numf,
    numerate: quant_1.numerate,
    quant: quant_1.quant,
    format_bytes: quant_1.format_bytes,
    datetime: datetime_1.datetime,
    local_datetime: datetime_1.local_datetime,
    list_and: list.list_and,
    list_or: list.list_or,
    list_or_quoted: list.list_or_quoted,
    list_and_quoted: list.list_and_quoted,
};
//# sourceMappingURL=index.js.map
});

var maketext_1 = createCommonjsModule(function (module, exports) {
Object.defineProperty(exports, "__esModule", { value: true });
exports.maketext = exports.functions = exports.config = void 0;

var locale$x = createCommonjsModule(function (module, exports) {
Object.defineProperty(exports, "__esModule", { value: true });
exports.Locale = void 0;

class Locale {
    /**
     * Create a new locale object based on some external environments.
     *
     * @param {RawCLDR}    rawCLDR locale specific CLDR functions and data
     * @param {Lexicon}    [lexicon]  Strings in the current locale for the application. Stored as a hash/object. Defaults to an empty hash/object.
     */
    constructor(rawCLDR, lexicon = {}) {
        this.lexicon = lexicon;
        this._cldr = new cldr.CLDR(rawCLDR);
    }
    /**
     * Generate a string using the template and the arguments in the current locale.
     *
     * @param {string} template maketext template
     * @param {any[]} params any additional arguments needed by maketext template
     * @returns {string} Generated string based on maketext template
     */
    maketext(template, ...params) {
        const localeData = {
            cldr: this._cldr,
            lexicon: this.lexicon,
            template: template,
            args: params,
        };
        return maketext_1.maketext(localeData);
    }
    /**
     * Localizes a date to the local timezone. Equivalent to (but cleaner than)
     * `maketext('[local_datetime,_1,my_fave_format]', date)`.
     *
     * @param {Date|number} [date=new Date()]            The date to be formatted. If using a number, it should be the unix timestamp in seconds.
     * @param {string}      [formatString=date_format_long]    The format preset (e.g., `datetime_format_medium`) or template to follow. Should be one of the string format options documented for Perl’s Locale::Maketext::Utils’s [datetime()](https://metacpan.org/dist/Locale-Maketext-Utils/view/lib/Locale/Maketext/Utils.pod#datetime%28%29) method.
     *
     * @returns {string} The localized date in the user’s timezone.
     */
    localDatetime(date, formatString) {
        return this._datetimeWrapper(datetime_1.local_datetime, date, formatString);
    }
    /**
     * **STOP!** Are you sure you don’t want `local_datetime`?
     *
     * Like `localDatetime()` but localizes a date to UTC rather than
     * the user’s timezone.
     *
     * If you use this function, be sure to tell the user that the
     * time displayed is UTC, not local time. Since most users will
     * expect local time, it’s generally better to use `local_datetime`
     * than to use this function. (Some users won’t know what UTC is!)
     *
     * @param {Date|number} [date=new Date()]            The date to be formatted. If using a number, it should be the unix timestamp in seconds.
     * @param {string}      [formatString=date_format_long]    The format preset (e.g., `datetime_format_medium`) or template to follow. See `localDatetime()` for more details.
     *
     * @returns {string} The localized date in UTC timezone.
     */
    datetime(date, formatString) {
        return this._datetimeWrapper(datetime_1.datetime, date, formatString);
    }
    _datetimeWrapper(datetimeFunc, date, formatString) {
        const localeData = {
            cldr: this._cldr,
            args: [date, formatString],
        };
        return datetimeFunc(localeData);
    }
    /**
     * Returns current locale
     *
     * @returns {string} Current locale
     */
    getCurrentLocale() {
        return this._cldr.getLocale();
    }
    /**
     * Returns true if the locale is right to left based. Returns false otherwise.
     */
    get isRtl() {
        return this._cldr.isRtl();
    }
    /**
     * Returns true if the locale is left to right based. Returns false otherwise.
     */
    get isLtr() {
        return this._cldr.isLtr();
    }
    /**
     * Returns the current cldr object for the locale.
     */
    get cldr() {
        return this._cldr;
    }
    /**
     * Returns the given number formatted nicely according to this language's conventions.
     * Does not localize exponential formats
     *  @example
     *      numf(1000.0012,3) // => 1,000.001
     *      numf(6.022e23) // => "6.022e+23"
     *
     * @param {number} num number to be formatted
     * @param {number} [decimalPlaces=6] decimal places
     * @return {string} formatted string
     */
    numf(num, decimalPlaces) {
        return this._formatNumber(quant_1.numf, num, decimalPlaces);
    }
    /**
     * Formats bytes with the specific decimal places.
     * This depends on locale-specific overrides of base functionality
     * but should not itself need an override.
     *
     * @example
     * format_bytes(22) // => 22 bytes
     * format_bytes(1045, 2) // => 1.02 KB
     *
     * @param {number} bytes
     * @param {number} [decimalPlaces] Number of decimal places. Defaults to 2.
     * @return {string}
     */
    format_bytes(num, decimalPlaces) {
        return this._formatNumber(quant_1.format_bytes, num, decimalPlaces);
    }
    _formatNumber(func, ...args) {
        return this._callCLDRFunc(func, args);
    }
    /**
     * Generates an and style string from the list.
     *
     * @example
     *  list_and("foo") // => "foo"
     *  list_and("foo", "bar") // => "foo and bar"
     *  list_and("foo", "bar", "baz") // => "foo, bar, and baz"
     *
     * @param {...string} list
     * @return {string} The localized output.
     */
    list_and(...args) {
        return this._callCLDRFunc(list.list_and, args);
    }
    /**
     * Like `list_and()` but quotes each list item.
     *
     * @param {...string} list
     * @return {string} The localized output.
     */
    list_and_quoted(...args) {
        return this._callCLDRFunc(list.list_and_quoted, args);
    }
    /**
     * Like `list_and()` but expresses an “or” instead of “and”.
     *
     * @param {...string} list
     * @return {string} The localized output.
     */
    list_or(...args) {
        return this._callCLDRFunc(list.list_or, args);
    }
    /**
     * Like `list_or()` but quotes each list item.
     *
     * @param {...string} list
     * @return {string} The localized output.
     */
    list_or_quoted(...args) {
        return this._callCLDRFunc(list.list_or_quoted, args);
    }
    _callCLDRFunc(func, args) {
        return func({
            cldr: this._cldr,
            args: args,
        });
    }
}
exports.Locale = Locale;
//# sourceMappingURL=locale.js.map
});

var dist = createCommonjsModule(function (module, exports) {
Object.defineProperty(exports, "__esModule", { value: true });
exports.Locale = void 0;

Object.defineProperty(exports, "Locale", { enumerable: true, get: function () { return locale$x.Locale; } });
//# sourceMappingURL=index.js.map
});

/**
# cpanel - ui/web-components/src/utils/locale.ts   Copyright 2022 cPanel, L.L.C.
#                                                           All rights reserved.
# copyright@cpanel.net                                         http://cpanel.net
# This code is subject to the cPanel license. Unauthorized copying is prohibited
 */
let localeInstance;
function getLocaleInstance() {
  if (typeof localeInstance !== "undefined") {
    return localeInstance;
  }
  const { LEXICON, CLDR } = window;
  if (!LEXICON || !CLDR) {
    throw new Error("The window object is missing keys required for localization!");
  }
  localeInstance = new dist.Locale(CLDR, LEXICON);
  return localeInstance;
}
/**
 * Ideally we might give the Locale object’s locale ID (e.g., `de`) to
 * .toLocaleLowerCase() in order to ensure parity between the browser’s
 * localization and our own. This is here so that, if we make that
 * change in the future, we’ll just have to update one place rather
 * than everywhere that we do this.
 */
function toLocaleLowerCase(input) {
  return input.toLocaleLowerCase();
}

/**
# cpanel - ui/web-components/src/utils/cp-tool-identifier.ts
#                                                  Copyright 2022 cPanel, L.L.C.
#                                                           All rights reserved.
# copyright@cpanel.net                                         http://cpanel.net
# This code is subject to the cPanel license. Unauthorized copying is prohibited
 */
class CpToolIdentifier {
  /**
   * Constructor for the CpToolIdentifer.
   *
   * @param group The category for the tool.
   * @param key The application key for the tool.
   */
  constructor(group, key) {
    this.group = group;
    this.key = key;
  }
  /**
   * Build a string representation fo the unique id.
   *
   * @returns The unique key for the tool.
   */
  toString() {
    return this.group + "$" + this.key;
  }
}

const cpFavoriteCss = ":host{display:block}.cp-app__compressed{align-items:center}.cp-app__compressed .cp-app__details-title{margin-bottom:0}.card{height:100%}.move{cursor:move}.remove-button{cursor:default}[dir=\"ltr\"] .remove-button{margin-left:auto}[dir=\"rtl\"] .remove-button{margin-right:auto}@media (max-width: 992px){.mobile-card-link{width:100%}}";

const cpFavoriteListCss = ":host{display:block}";

/**
# cpanel - ui/web-components/src/utils/cp-tool-select.ts
#                                                  Copyright 2022 cPanel, L.L.C.
#                                                           All rights reserved.
# copyright@cpanel.net                                         http://cpanel.net
# This code is subject to the cPanel license. Unauthorized copying is prohibited
 */
class CpToolSelect extends CpToolIdentifier {
  /**
   * Constructor for the CpToolSelect.
   *
   * @param group The category for the tool.
   * @param key The application key for the tool.
   * @param selected true if the tool is selected, false otherwise.
   */
  constructor(group, key, selected) {
    super(group, key);
    this.selected = selected;
  }
}

/**
# cpanel - ui/web-components/src/utils/app-name.ts Copyright 2022 cPanel, L.L.C.
#                                                           All rights reserved.
# copyright@cpanel.net                                         http://cpanel.net
# This code is subject to the cPanel license. Unauthorized copying is prohibited
 */
var AppName;
(function (AppName) {
  AppName["Cpanel"] = "cpanel";
  AppName["Whm"] = "whm";
  AppName["Webmail"] = "webmail";
})(AppName || (AppName = {}));

/**
 * Check if a possible element isConnected.
 * The property might not be there, so we check for it.
 *
 * We want it to return true if isConnected is not a property,
 * otherwise we would remove these elements and would not update.
 *
 * Better leak in Edge than to be useless.
 */
const isConnected = (maybeElement) => !('isConnected' in maybeElement) || maybeElement.isConnected;
const cleanupElements = debounce((map) => {
    for (let key of map.keys()) {
        map.set(key, map.get(key).filter(isConnected));
    }
}, 2000);
const stencilSubscription = () => {
    if (typeof getRenderingRef !== 'function') {
        // If we are not in a stencil project, we do nothing.
        // This function is not really exported by @stencil/core.
        return {};
    }
    const elmsToUpdate = new Map();
    return {
        dispose: () => elmsToUpdate.clear(),
        get: (propName) => {
            const elm = getRenderingRef();
            if (elm) {
                appendToMap(elmsToUpdate, propName, elm);
            }
        },
        set: (propName) => {
            const elements = elmsToUpdate.get(propName);
            if (elements) {
                elmsToUpdate.set(propName, elements.filter(forceUpdate));
            }
            cleanupElements(elmsToUpdate);
        },
        reset: () => {
            elmsToUpdate.forEach((elms) => elms.forEach(forceUpdate));
            cleanupElements(elmsToUpdate);
        },
    };
};

const createStore = (defaultState, shouldUpdate) => {
    const map = createObservableMap(defaultState, shouldUpdate);
    map.use(stencilSubscription());
    return map;
};

// MIT License
/**
 * Default argument serialization rules for each well known HTTP verb.
 */
class DefaultArgumentSerializationRules {
    /**
     * Construct the lookup table for well know verbs.
     */
    constructor() {
        this.map = {};
        // fallback rule if the verb is not defined.
        this.map["DEFAULT"] = {
            verb: "DEFAULT",
            dataInBody: true,
        };
        [HttpVerb.GET, HttpVerb.DELETE, HttpVerb.HEAD].forEach((verb) => {
            const label = HttpVerb[verb].toString();
            this.map[label] = {
                verb: label,
                dataInBody: false,
            };
        });
        [HttpVerb.POST, HttpVerb.PUT, HttpVerb.PATCH].forEach((verb) => {
            const label = HttpVerb[verb].toString();
            this.map[label] = {
                verb: label,
                dataInBody: true,
            };
        });
    }
    /**
     * Get a rule for serialization of arguments. This tells the generators where
     * argument data is packaged in a request. Arguments can be located in one of
     * the following:
     *
     *   Body,
     *   Url
     *
     * @param verb verb to lookup.
     */
    getRule(verb) {
        const name = typeof verb === "string" ? verb : HttpVerb[verb].toString();
        let rule = this.map[name];
        if (!rule) {
            rule = this.map["DEFAULT"];
        }
        return rule;
    }
}
/**
 * Singleton with the default argument serialization rules in it.
 */
const argumentSerializationRules = new DefaultArgumentSerializationRules();

// MIT License
/**
 * An name/value pair argument
 */
class Argument {
    /**
     * Build a new Argument.
     *
     * @param name Name of the argument
     * @param value Value of the argument.
     */
    constructor(name, value) {
        if (!name) {
            throw new Error("You must provide a name when creating a name/value argument");
        }
        this.name = name;
        this.value = value;
    }
}

// MIT License
/**
 * Abstract base class for all Request objects. Developers should
 * create a subclass of this that implements the generate() method.
 */
class Request$1 {
    /**
     * Create a new request.
     *
     * @param init   Optional request object used to initialize this object.
     */
    constructor(init) {
        /**
         * Namespace where the API call lives
         * @type {string}
         */
        this.namespace = "";
        /**
         * Method name of the API call.
         * @type {string}
         */
        this.method = "";
        /**
         * Optional list of arguments for the API call.
         * @type {IArgument[]}
         */
        this.arguments = [];
        /**
         * Optional list of sorting rules to pass to the API call.
         */
        this.sorts = [];
        /**
         * Optional list of filter rules to pass to the API call.
         */
        this.filters = [];
        /**
         * Optional list of columns to include with the response to the API call.
         */
        this.columns = [];
        /**
         * Optional pager rule to pass to the API.
         */
        this.pager = new Pager();
        /**
         * Optional custom headers collection
         */
        this.headers = new Headers();
        this._usePager = false;
        /**
         * Default configuration object.
         */
        this.defaultConfig = {
            analytics: false,
            json: false,
        };
        /**
         * Optional configuration information
         */
        this.config = this.defaultConfig;
        if (init) {
            this.method = init.method;
            if (init.namespace) {
                this.namespace = init.namespace;
            }
            if (init.arguments) {
                init.arguments.forEach((argument) => {
                    this.addArgument(argument);
                });
            }
            if (init.sorts) {
                init.sorts.forEach((sort) => {
                    this.addSort(sort);
                });
            }
            if (init.filters) {
                init.filters.forEach((filter) => {
                    this.addFilter(filter);
                });
            }
            if (init.columns) {
                init.columns.forEach((column) => this.addColumn(column));
            }
            if (init.pager) {
                this.paginate(init.pager);
            }
            if (init.config) {
                this.config = init.config;
            }
            else {
                this.config = this.defaultConfig;
            }
            if (init.headers) {
                init.headers.forEach((header) => {
                    this.addHeader(header);
                });
            }
        }
    }
    /**
     * Use the pager only if true.
     */
    get usePager() {
        return this._usePager;
    }
    /**
     * Add an argument to the request.
     *
     * @param argument
     * @return Updated Request object.
     */
    addArgument(argument) {
        if (argument instanceof Argument) {
            this.arguments.push(argument);
        }
        else {
            this.arguments.push(new Argument(argument.name, argument.value));
        }
        return this;
    }
    /**
     * Add sorting rule to the request.
     *
     * @param sort Sort object with sorting information.
     * @return Updated Request object.
     */
    addSort(sort) {
        if (sort instanceof Sort) {
            this.sorts.push(sort);
        }
        else {
            this.sorts.push(new Sort(sort.column, sort.direction, sort.type));
        }
        return this;
    }
    /**
     * Add a filter to the request.
     *
     * @param filter Filter object with filter information.
     * @return Updated Request object.
     */
    addFilter(filter) {
        if (filter instanceof Filter) {
            this.filters.push(filter);
        }
        else {
            this.filters.push(new Filter(filter.column, filter.operator, filter.value));
        }
        return this;
    }
    /**
     * Add a column to include in the request. If no columns are specified, all columns are retrieved.
     *
     * @param name Name of a column
     * @return Updated Request object.
     */
    addColumn(column) {
        this.columns.push(column);
        return this;
    }
    /**
     * Add a custom http header to the request
     *
     * @param name Name of a column
     * @return Updated Request object.
     */
    addHeader(header) {
        if (header instanceof CustomHeader) {
            this.headers.push(header);
        }
        else {
            this.headers.push(new CustomHeader(header));
        }
        return this;
    }
    /**
     * Set the pager setting for the request.
     *
     * @param pager Pager object with pagination information.
     * @return Updated Request object.
     */
    paginate(pager) {
        if (pager instanceof Pager) {
            this.pager = pager;
        }
        else {
            this.pager = new Pager(pager.page, pager.pageSize || 20);
        }
        this._usePager = true;
        return this;
    }
}

/**
 * Checks if `value` is `undefined`.
 *
 * @static
 * @since 0.1.0
 * @memberOf _
 * @category Lang
 * @param {*} value The value to check.
 * @returns {boolean} Returns `true` if `value` is `undefined`, else `false`.
 * @example
 *
 * _.isUndefined(void 0);
 * // => true
 *
 * _.isUndefined(null);
 * // => false
 */
function isUndefined(value) {
  return value === undefined;
}

var isUndefined_1 = isUndefined;

/**
 * Checks if `value` is `null`.
 *
 * @static
 * @memberOf _
 * @since 0.1.0
 * @category Lang
 * @param {*} value The value to check.
 * @returns {boolean} Returns `true` if `value` is `null`, else `false`.
 * @example
 *
 * _.isNull(null);
 * // => true
 *
 * _.isNull(void 0);
 * // => false
 */
function isNull(value) {
  return value === null;
}

var isNull_1 = isNull;

// MIT License
/**
 * Types of message that can be in a response.
 */
var MessageType;
(function (MessageType) {
    /**
     * Message is an error.
     */
    MessageType[MessageType["Error"] = 0] = "Error";
    /**
     * Message is a warning.
     */
    MessageType[MessageType["Warning"] = 1] = "Warning";
    /**
     * Message is informational.
     */
    MessageType[MessageType["Information"] = 2] = "Information";
    /**
     * The message type is unknown.
     */
    MessageType[MessageType["Unknown"] = 3] = "Unknown";
})(MessageType || (MessageType = {}));
const DefaultMetaData = {
    isPaged: false,
    isFiltered: false,
    record: 0,
    page: 0,
    pageSize: 0,
    totalRecords: 0,
    totalPages: 0,
    recordsBeforeFilter: 0,
    batch: false,
    properties: {},
};
/**
 * Deep cloning of a object to avoid reference overwritting.
 *
 * @param data Metadata object to be cloned.
 * @returns Cloned Metadata object.
 */
function clone(data) {
    return JSON.parse(JSON.stringify(data));
}
/**
 * Base class for all response. Must be sub-classed by a real implementation.
 */
class Response {
    /**
     * Build a new response object from the response. Note, this class should not be called
     * directly.
     * @param response Complete data passed from the server. Probably it's been parsed using JSON.parse().
     * @param options for how to handle the processing of the response data.
     */
    constructor(response, options) {
        /**
         * The status code returned by the API. Usually 1 for success, 0 for failure.
         */
        this.status = 0;
        /**
         * List of messages related to the response.
         */
        this.messages = [];
        /**
         * Additional data returned about the request. Paging, filtering, and maybe other custom properties.
         */
        this.meta = clone(DefaultMetaData);
        /**
         * Options about how to handle the response processing.
         */
        this.options = {
            keepUnprocessedResponse: false,
        };
        if (isUndefined_1(response) || isNull_1(response)) {
            throw new Error("The response was unexpectedly undefined or null");
        }
        if (options) {
            this.options = options;
        }
        if (this.options.keepUnprocessedResponse) {
            this.raw = JSON.parse(JSON.stringify(response)); // deep clone
        }
    }
    /**
     * Checks if the API was successful.
     *
     * @return true if successful, false if failure.
     */
    get success() {
        return this.status > 0;
    }
    /**
     * Checks if the api failed.
     *
     * @return true if the API reports failure, false otherwise.
     */
    get failed() {
        return this.status === 0;
    }
    /**
     * Get the list of messages based on the requested type.
     *
     * @param type Type of the message to look up.
     * @return List of messages that match the filter.
     */
    _getMessages(type) {
        return this.messages.filter((message) => message.type === type);
    }
    /**
     * Get the list of error messages.
     *
     * @return List of errors.
     */
    get errors() {
        return this._getMessages(MessageType.Error);
    }
    /**
     * Get the list of warning messages.
     *
     * @return List of warnings.
     */
    get warnings() {
        return this._getMessages(MessageType.Warning);
    }
    /**
     * Get the list of informational messages.
     *
     * @return List of informational messages.
     */
    get infoMessages() {
        return this._getMessages(MessageType.Information);
    }
    /**
     * Checks if there are any messages of a given type.
     * @param type Type of the message to check for.
     * @return true if there are messages of the requested type. false otherwise.
     */
    _hasMessages(type) {
        return this.messages.filter((message) => message.type === type).length > 0;
    }
    /**
     * Checks if there are any error messages in the response.
     *
     * @return true if there are error messages, false otherwise.
     */
    get hasErrors() {
        return this._hasMessages(MessageType.Error);
    }
    /**
     * Checks if there are any warnings in the response.
     *
     * @return true if there are warnings, false otherwise.
     */
    get hasWarnings() {
        return this._hasMessages(MessageType.Warning);
    }
    /**
     * Checks if there are any informational messages in the response.
     *
     * @return true if there are informational messages, false otherwise.
     */
    get hasInfoMessages() {
        return this._hasMessages(MessageType.Information);
    }
    /**
     * Check if the response was paginated by the backend.
     *
     * @return true if the backend returned a page of the total records.
     */
    get isPaged() {
        return this.meta.isPaged;
    }
    /**
     * Check if the response was filtered by the backend.
     *
     * @return true if the backend filtered the records.
     */
    get isFiltered() {
        return this.meta.isFiltered;
    }
}

/** Detect free variable `global` from Node.js. */
var freeGlobal = typeof commonjsGlobal == 'object' && commonjsGlobal && commonjsGlobal.Object === Object && commonjsGlobal;

var _freeGlobal = freeGlobal;

/** Detect free variable `self`. */
var freeSelf = typeof self == 'object' && self && self.Object === Object && self;

/** Used as a reference to the global object. */
var root = _freeGlobal || freeSelf || Function('return this')();

var _root = root;

/** Built-in value references. */
var Symbol = _root.Symbol;

var _Symbol = Symbol;

/** Used for built-in method references. */
var objectProto$2 = Object.prototype;

/** Used to check objects for own properties. */
var hasOwnProperty$2 = objectProto$2.hasOwnProperty;

/**
 * Used to resolve the
 * [`toStringTag`](http://ecma-international.org/ecma-262/7.0/#sec-object.prototype.tostring)
 * of values.
 */
var nativeObjectToString$1 = objectProto$2.toString;

/** Built-in value references. */
var symToStringTag$1 = _Symbol ? _Symbol.toStringTag : undefined;

/**
 * A specialized version of `baseGetTag` which ignores `Symbol.toStringTag` values.
 *
 * @private
 * @param {*} value The value to query.
 * @returns {string} Returns the raw `toStringTag`.
 */
function getRawTag(value) {
  var isOwn = hasOwnProperty$2.call(value, symToStringTag$1),
      tag = value[symToStringTag$1];

try {
    value[symToStringTag$1] = undefined;
    var unmasked = true;
  } catch (e) {}

var _getRawTag = getRawTag;

/** Used for built-in method references. */
var objectProto$1 = Object.prototype;

/**
 * Used to resolve the
 * [`toStringTag`](http://ecma-international.org/ecma-262/7.0/#sec-object.prototype.tostring)
 * of values.
 */
var nativeObjectToString = objectProto$1.toString;

/**
 * Converts `value` to a string using `Object.prototype.toString`.
 *
 * @private
 * @param {*} value The value to convert.
 * @returns {string} Returns the converted string.
 */
function objectToString(value) {
  return nativeObjectToString.call(value);
}

var _objectToString = objectToString;

/** `Object#toString` result references. */
var nullTag = '[object Null]',
    undefinedTag = '[object Undefined]';

/** Built-in value references. */
var symToStringTag = _Symbol ? _Symbol.toStringTag : undefined;

/**
 * The base implementation of `getTag` without fallbacks for buggy environments.
 *
 * @private
 * @param {*} value The value to query.
 * @returns {string} Returns the `toStringTag`.
 */
function baseGetTag(value) {
  if (value == null) {
    return value === undefined ? undefinedTag : nullTag;
  }
  return (symToStringTag && symToStringTag in Object(value))
    ? _getRawTag(value)
    : _objectToString(value);
}

var _baseGetTag = baseGetTag;

/**
 * Checks if `value` is object-like. A value is object-like if it's not `null`
 * and has a `typeof` result of "object".
 *
 * @static
 * @memberOf _
 * @since 4.0.0
 * @category Lang
 * @param {*} value The value to check.
 * @returns {boolean} Returns `true` if `value` is object-like, else `false`.
 * @example
 *
 * _.isObjectLike({});
 * // => true
 *
 * _.isObjectLike([1, 2, 3]);
 * // => true
 *
 * _.isObjectLike(_.noop);
 * // => false
 *
 * _.isObjectLike(null);
 * // => false
 */
function isObjectLike$1(value) {
  return value != null && typeof value == 'object';
}

var isObjectLike_1 = isObjectLike$1;

/** `Object#toString` result references. */
var boolTag = '[object Boolean]';

/**
 * Checks if `value` is classified as a boolean primitive or object.
 *
 * @static
 * @memberOf _
 * @since 0.1.0
 * @category Lang
 * @param {*} value The value to check.
 * @returns {boolean} Returns `true` if `value` is a boolean, else `false`.
 * @example
 *
 * _.isBoolean(false);
 * // => true
 *
 * _.isBoolean(null);
 * // => false
 */
function isBoolean$1(value) {
  return value === true || value === false ||
    (isObjectLike_1(value) && _baseGetTag(value) == boolTag);
}

var isBoolean_1 = isBoolean$1;

/** `Object#toString` result references. */
var numberTag = '[object Number]';

/**
 * Checks if `value` is classified as a `Number` primitive or object.
 *
 * **Note:** To exclude `Infinity`, `-Infinity`, and `NaN`, which are
 * classified as numbers, use the `_.isFinite` method.
 *
 * @static
 * @memberOf _
 * @since 0.1.0
 * @category Lang
 * @param {*} value The value to check.
 * @returns {boolean} Returns `true` if `value` is a number, else `false`.
 * @example
 *
 * _.isNumber(3);
 * // => true
 *
 * _.isNumber(Number.MIN_VALUE);
 * // => true
 *
 * _.isNumber(Infinity);
 * // => true
 *
 * _.isNumber('3');
 * // => false
 */
function isNumber$1(value) {
  return typeof value == 'number' ||
    (isObjectLike_1(value) && _baseGetTag(value) == numberTag);
}

var isNumber_1 = isNumber$1;

var isArray_1 = isArray$1;

/** `Object#toString` result references. */
var stringTag = '[object String]';

/**
 * Checks if `value` is classified as a `String` primitive or object.
 *
 * @static
 * @since 0.1.0
 * @memberOf _
 * @category Lang
 * @param {*} value The value to check.
 * @returns {boolean} Returns `true` if `value` is a string, else `false`.
 * @example
 *
 * _.isString('abc');
 * // => true
 *
 * _.isString(1);
 * // => false
 */
function isString$1(value) {
  return typeof value == 'string' ||
    (!isArray_1(value) && isObjectLike_1(value) && _baseGetTag(value) == stringTag);
}

var isString_1 = isString$1;

/**
 * Creates a unary function that invokes `func` with its argument transformed.
 *
 * @private
 * @param {Function} func The function to wrap.
 * @param {Function} transform The argument transform.
 * @returns {Function} Returns the new function.
 */
function overArg(func, transform) {
  return function(arg) {
    return func(transform(arg));
  };
}

var _overArg = overArg;

/** Built-in value references. */
var getPrototype = _overArg(Object.getPrototypeOf, Object);

var _getPrototype = getPrototype;

/** `Object#toString` result references. */
var objectTag = '[object Object]';

/** Used for built-in method references. */
var funcProto = Function.prototype,
    objectProto = Object.prototype;

/** Used to resolve the decompiled source of functions. */
var funcToString = funcProto.toString;

/** Used to check objects for own properties. */
var hasOwnProperty$1 = objectProto.hasOwnProperty;

/** Used to infer the `Object` constructor. */
var objectCtorString = funcToString.call(Object);

/**
 * Checks if `value` is a plain object, that is, an object created by the
 * `Object` constructor or one with a `[[Prototype]]` of `null`.
 *
 * @static
 * @memberOf _
 * @since 0.8.0
 * @category Lang
 * @param {*} value The value to check.
 * @returns {boolean} Returns `true` if `value` is a plain object, else `false`.
 * @example
 *
 * function Foo() {
 *   this.a = 1;
 * }
 *
 * _.isPlainObject(new Foo);
 * // => false
 *
 * _.isPlainObject([1, 2, 3]);
 * // => false
 *
 * _.isPlainObject({ 'x': 0, 'y': 0 });
 * // => true
 *
 * _.isPlainObject(Object.create(null));
 * // => true
 */
function isPlainObject(value) {
  if (!isObjectLike_1(value) || _baseGetTag(value) != objectTag) {
    return false;
  }
  var proto = _getPrototype(value);
  if (proto === null) {
    return true;
  }
  var Ctor = hasOwnProperty$1.call(proto, 'constructor') && proto.constructor;
  return typeof Ctor == 'function' && Ctor instanceof Ctor &&
    funcToString.call(Ctor) == objectCtorString;
}

var isPlainObject_1 = isPlainObject;

// MIT License
/**
 * Verify if the value can be serialized to JSON
 *
 * @param value Value to check.
 * @source https://stackoverflow.com/questions/30579940/reliable-way-to-check-if-objects-is-serializable-in-javascript#answer-30712764
 */
function isSerializable(value) {
    if (isUndefined_1(value) ||
        isNull_1(value) ||
        isBoolean_1(value) ||
        isNumber_1(value) ||
        isString_1(value)) {
        return true;
    }
    if (!isPlainObject_1(value) && !isArray_1(value)) {
        return false;
    }
    for (const key in value) {
        if (!isSerializable(value[key])) {
            return false;
        }
    }
    return true;
}

// MIT License
/**
 * Encode parameters using application/x-www-form-urlencoded
 */
class WwwFormUrlArgumentEncoder {
    constructor() {
        this.contentType = "application/x-www-form-urlencoded";
        this.separatorStart = "";
        this.separatorEnd = "";
        this.recordSeparator = "&";
    }
    /**
     * Encode a given value into the application/x-www-form-urlencoded.
     *
     * @param name Name of the field, may be empty string.
     * @param value Value to serialize
     * @param last True if this is the last argument being serialized.
     * @return Encoded version of the argument.
     */
    encode(name, value, last) {
        if (!name) {
            throw new Error("Name must have a non-empty value");
        }
        return (`${name}=${encodeURIComponent(value.toString())}` +
            (!last ? this.recordSeparator : ""));
    }
}
/**
 * Encode the parameter into JSON
 */
class JsonArgumentEncoder {
    constructor() {
        this.contentType = "application/json";
        this.separatorStart = "{";
        this.separatorEnd = "}";
        this.recordSeparator = ",";
    }
    /**
     * Encode a given value into the JSON application/json body.
     *
     * @param name Name of the field.
     * @param value Value to serialize
     * @param last True if this is the last argument being serialized.
     * @return {string}        Encoded version of the argument.
     */
    encode(name, value, last) {
        if (!name) {
            throw new Error("Name must have a non-empty value");
        }
        if (!isSerializable(value)) {
            throw new Error("The passed in value can not be serialized to JSON");
        }
        return (JSON.stringify(name) +
            ":" +
            JSON.stringify(value) +
            (!last ? this.recordSeparator : ""));
    }
}

// MIT License
//
// Copyright 2021 cPanel L.L.C.
//
// 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.
/**
 * Check if the protocol is https.
 * @param  protocol Protocol to test
 * @return true if its https: in any case, false otherwise.
 */
function isHttps(protocol) {
    return /^https:$/i.test(protocol);
}
/**
 * Check if the protocol is http.
 * @param  protocol Protocol to test
 * @return true if its http: in any case, false otherwise.
 */
function isHttp(protocol) {
    return /^http:$/i.test(protocol);
}
/**
 * Strip any trailing slashes from a string.
 *
 * @method stripTrailingSlash
 * @param  path The path string to process.
 * @return The path string without a trailing slash.
 */
function stripTrailingSlash(path) {
    return path && path.replace(/\/?$/, "");
}
// This will work in any context except a proxy URL to cPanel or Webmail
// that accesses a URL outside /frontend (cPanel) or /webmail (Webmail),
// but URLs like that are non-production by definition.
const PortToApplicationMap = {
    "80": "other",
    "443": "other",
    "2082": "cpanel",
    "2083": "cpanel",
    "2086": "whostmgr",
    "2087": "whostmgr",
    "2095": "webmail",
    "2096": "webmail",
    "9876": "unittest",
    "9877": "unittest",
    "9878": "unittest",
    "9879": "unittest",
    frontend: "cpanel",
    webmail: "webmail",
};
/**
 * Helper class used to calculate paths within cPanel applications.
 */
class ApplicationPath {
    /**
     * Create the PathHelper. This class is used to help generate paths
     * within an application. It has special knowledge about how paths are
     * constructed in the cPanel family of applications.
     *
     * @param location Abstraction for the window.location object to aid in unit testing this module.
     */
    constructor(location) {
        this.unprotectedPaths = ["/resetpass", "/invitation"];
        this.protocol = location.protocol;
        let port = location.port;
        if (!port) {
            // Since some browsers won't fill this in, we have to derive it from
            // the protocol if it's not provided in the window.location object.
            if (isHttps(this.protocol)) {
                port = "443";
            }
            else if (isHttp(this.protocol)) {
                port = "80";
            }
        }
        this.domain = location.hostname;
        this.port = parseInt(port, 10);
        this.path = location.pathname;
        const pathMatch = 
        // eslint-disable-next-line no-useless-escape -- regex, not a string
        this.path.match(/((?:\/cpsess\d+)?)(?:\/([^\/]+))?/) || [];
        // For proxy subdomains, we look at the first subdomain to identify the application.
        if (/^whm\./.test(this.domain)) {
            this.applicationName = PortToApplicationMap["2087"];
        }
        else if (/^cpanel\./.test(this.domain)) {
            this.applicationName = PortToApplicationMap["2083"];
        }
        else if (/^webmail\./.test(this.domain)) {
            this.applicationName = PortToApplicationMap["2095"];
        }
        else {
            this.applicationName =
                PortToApplicationMap[port.toString()] ||
                    PortToApplicationMap[pathMatch[2]] ||
                    "whostmgr";
        }
        this.securityToken = pathMatch[1] || "";
        this.applicationPath = this.securityToken
            ? this.path.replace(this.securityToken, "")
            : this.path;
        this.theme = "";
        if (!this.isUnprotected && (this.isCpanel || this.isWebmail)) {
            const folders = this.path.split("/");
            this.theme = folders[3];
        }
        this.themePath = "";
        let themePath = this.securityToken + "/";
        if (this.isUnprotected) {
            themePath = "/";
        }
        else if (this.isCpanel) {
            themePath += "frontend/" + this.theme + "/";
        }
        else if (this.isWebmail) {
            themePath += "webmail/" + this.theme + "/";
        }
        else if (this.isOther) {
            // For unrecognized applications, use the path passed in PAGE.THEME_PATH
            themePath = "/";
        }
        this.themePath = themePath;
        this.rootUrl = this.protocol + "//" + this.domain + ":" + this.port;
    }
    /**
     * Return whether we are running inside some other framework or application
     *
     * @return true if this is an unrecognized application or framework; false otherwise
     */
    get isOther() {
        return /other/i.test(this.applicationName);
    }
    /**
     * Return whether we are running inside an unprotected path
     *
     * @return true if this is unprotected; false otherwise
     */
    get isUnprotected() {
        return (!this.securityToken &&
            this.unprotectedPaths.indexOf(stripTrailingSlash(this.applicationPath)) !== -1);
    }
    /**
     * Return whether we are running inside cPanel or something else (e.g., WHM)
     *
     * @return true if this is cPanel; false otherwise
     */
    get isCpanel() {
        return /cpanel/i.test(this.applicationName);
    }
    /**
     * Return whether we are running inside WHM or something else (e.g., WHM)
     *
     * @return true if this is WHM; false otherwise
     */
    get isWhm() {
        return /whostmgr/i.test(this.applicationName);
    }
    /**
     * Return whether we are running inside WHM or something else (e.g., WHM)
     *
     * @return true if this is Webmail; false otherwise
     */
    get isWebmail() {
        return /webmail/i.test(this.applicationName);
    }
    /**
     * Get the domain relative path for the relative URL path.
     *
     * @param relative Relative path to the resource.
     * @return Domain relative URL path including theme, if applicable, for the application to the file.
     */
    buildPath(relative) {
        return this.themePath + relative;
    }
    /**
     * Get the full url path for the relative URL path.
     *
     * @param relative Relative path to the resource.
     * @return Full URL path including theme, if applicable, for the application to the file.
     */
    buildFullPath(relative) {
        return (this.protocol +
            "//" +
            this.domain +
            ":" +
            this.port +
            this.buildPath(relative));
    }
    /**
     * Build a path relative to the security token
     *
     * @param relative Relative path to the resource.
     * @return Full path to the token relative resource.
     */
    buildTokenPath(relative) {
        return (this.protocol +
            "//" +
            this.domain +
            ":" +
            this.port +
            this.securityToken +
            relative);
    }
}

/**
 * A specialized version of `_.reduce` for arrays without support for
 * iteratee shorthands.
 *
 * @private
 * @param {Array} [array] The array to iterate over.
 * @param {Function} iteratee The function invoked per iteration.
 * @param {*} [accumulator] The initial value.
 * @param {boolean} [initAccum] Specify using the first element of `array` as
 *  the initial value.
 * @returns {*} Returns the accumulated value.
 */
function arrayReduce(array, iteratee, accumulator, initAccum) {
  var index = -1,
      length = array == null ? 0 : array.length;

if (initAccum && length) {
 accumulator = array[++index];
 }
 while (++index < length) {
 accumulator = iteratee(accumulator, array[index], index, array);
 }
 return accumulator;
}

var _arrayReduce = arrayReduce;

/**
 * The base implementation of `_.propertyOf` without support for deep paths.
 *
 * @private
 * @param {Object} object The object to query.
 * @returns {Function} Returns the new accessor function.
 */
function basePropertyOf(object) {
  return function(key) {
    return object == null ? undefined : object[key];
  };
}

var _basePropertyOf = basePropertyOf;

/** Used to map Latin Unicode letters to basic Latin letters. */
var deburredLetters = {
  // Latin-1 Supplement block.
  '\xc0': 'A',  '\xc1': 'A', '\xc2': 'A', '\xc3': 'A', '\xc4': 'A', '\xc5': 'A',
  '\xe0': 'a',  '\xe1': 'a', '\xe2': 'a', '\xe3': 'a', '\xe4': 'a', '\xe5': 'a',
  '\xc7': 'C',  '\xe7': 'c',
  '\xd0': 'D',  '\xf0': 'd',
  '\xc8': 'E',  '\xc9': 'E', '\xca': 'E', '\xcb': 'E',
  '\xe8': 'e',  '\xe9': 'e', '\xea': 'e', '\xeb': 'e',
  '\xcc': 'I',  '\xcd': 'I', '\xce': 'I', '\xcf': 'I',
  '\xec': 'i',  '\xed': 'i', '\xee': 'i', '\xef': 'i',
  '\xd1': 'N',  '\xf1': 'n',
  '\xd2': 'O',  '\xd3': 'O', '\xd4': 'O', '\xd5': 'O', '\xd6': 'O', '\xd8': 'O',
  '\xf2': 'o',  '\xf3': 'o', '\xf4': 'o', '\xf5': 'o', '\xf6': 'o', '\xf8': 'o',
  '\xd9': 'U',  '\xda': 'U', '\xdb': 'U', '\xdc': 'U',
  '\xf9': 'u',  '\xfa': 'u', '\xfb': 'u', '\xfc': 'u',
  '\xdd': 'Y',  '\xfd': 'y', '\xff': 'y',
  '\xc6': 'Ae', '\xe6': 'ae',
  '\xde': 'Th', '\xfe': 'th',
  '\xdf': 'ss',
  // Latin Extended-A block.
  '\u0100': 'A',  '\u0102': 'A', '\u0104': 'A',
  '\u0101': 'a',  '\u0103': 'a', '\u0105': 'a',
  '\u0106': 'C',  '\u0108': 'C', '\u010a': 'C', '\u010c': 'C',
  '\u0107': 'c',  '\u0109': 'c', '\u010b': 'c', '\u010d': 'c',
  '\u010e': 'D',  '\u0110': 'D', '\u010f': 'd', '\u0111': 'd',
  '\u0112': 'E',  '\u0114': 'E', '\u0116': 'E', '\u0118': 'E', '\u011a': 'E',
  '\u0113': 'e',  '\u0115': 'e', '\u0117': 'e', '\u0119': 'e', '\u011b': 'e',
  '\u011c': 'G',  '\u011e': 'G', '\u0120': 'G', '\u0122': 'G',
  '\u011d': 'g',  '\u011f': 'g', '\u0121': 'g', '\u0123': 'g',
  '\u0124': 'H',  '\u0126': 'H', '\u0125': 'h', '\u0127': 'h',
  '\u0128': 'I',  '\u012a': 'I', '\u012c': 'I', '\u012e': 'I', '\u0130': 'I',
  '\u0129': 'i',  '\u012b': 'i', '\u012d': 'i', '\u012f': 'i', '\u0131': 'i',
  '\u0134': 'J',  '\u0135': 'j',
  '\u0136': 'K',  '\u0137': 'k', '\u0138': 'k',
  '\u0139': 'L',  '\u013b': 'L', '\u013d': 'L', '\u013f': 'L', '\u0141': 'L',
  '\u013a': 'l',  '\u013c': 'l', '\u013e': 'l', '\u0140': 'l', '\u0142': 'l',
  '\u0143': 'N',  '\u0145': 'N', '\u0147': 'N', '\u014a': 'N',
  '\u0144': 'n',  '\u0146': 'n', '\u0148': 'n', '\u014b': 'n',
  '\u014c': 'O',  '\u014e': 'O', '\u0150': 'O',
  '\u014d': 'o',  '\u014f': 'o', '\u0151': 'o',
  '\u0154': 'R',  '\u0156': 'R', '\u0158': 'R',
  '\u0155': 'r',  '\u0157': 'r', '\u0159': 'r',
  '\u015a': 'S',  '\u015c': 'S', '\u015e': 'S', '\u0160': 'S',
  '\u015b': 's',  '\u015d': 's', '\u015f': 's', '\u0161': 's',
  '\u0162': 'T',  '\u0164': 'T', '\u0166': 'T',
  '\u0163': 't',  '\u0165': 't', '\u0167': 't',
  '\u0168': 'U',  '\u016a': 'U', '\u016c': 'U', '\u016e': 'U', '\u0170': 'U', '\u0172': 'U',
  '\u0169': 'u',  '\u016b': 'u', '\u016d': 'u', '\u016f': 'u', '\u0171': 'u', '\u0173': 'u',
  '\u0174': 'W',  '\u0175': 'w',
  '\u0176': 'Y',  '\u0177': 'y', '\u0178': 'Y',
  '\u0179': 'Z',  '\u017b': 'Z', '\u017d': 'Z',
  '\u017a': 'z',  '\u017c': 'z', '\u017e': 'z',
  '\u0132': 'IJ', '\u0133': 'ij',
  '\u0152': 'Oe', '\u0153': 'oe',
  '\u0149': "'n", '\u017f': 's'
};

/**
 * Used by `_.deburr` to convert Latin-1 Supplement and Latin Extended-A
 * letters to basic Latin letters.
 *
 * @private
 * @param {string} letter The matched letter to deburr.
 * @returns {string} Returns the deburred letter.
 */
var deburrLetter = _basePropertyOf(deburredLetters);

var _deburrLetter = deburrLetter;

/**
 * A specialized version of `_.map` for arrays without support for iteratee
 * shorthands.
 *
 * @private
 * @param {Array} [array] The array to iterate over.
 * @param {Function} iteratee The function invoked per iteration.
 * @returns {Array} Returns the new mapped array.
 */
function arrayMap(array, iteratee) {
  var index = -1,
      length = array == null ? 0 : array.length,
      result = Array(length);

while (++index < length) {
 result[index] = iteratee(array[index], index, array);
 }
 return result;
}

var _arrayMap = arrayMap;

/** `Object#toString` result references. */
var symbolTag = '[object Symbol]';

/**
 * Checks if `value` is classified as a `Symbol` primitive or object.
 *
 * @static
 * @memberOf _
 * @since 4.0.0
 * @category Lang
 * @param {*} value The value to check.
 * @returns {boolean} Returns `true` if `value` is a symbol, else `false`.
 * @example
 *
 * _.isSymbol(Symbol.iterator);
 * // => true
 *
 * _.isSymbol('abc');
 * // => false
 */
function isSymbol(value) {
  return typeof value == 'symbol' ||
    (isObjectLike_1(value) && _baseGetTag(value) == symbolTag);
}

var isSymbol_1 = isSymbol;

/** Used as references for various `Number` constants. */
var INFINITY$2 = 1 / 0;

/** Used to convert symbols to primitives and strings. */
var symbolProto = _Symbol ? _Symbol.prototype : undefined,
    symbolToString = symbolProto ? symbolProto.toString : undefined;

/**
 * The base implementation of `_.toString` which doesn't convert nullish
 * values to empty strings.
 *
 * @private
 * @param {*} value The value to process.
 * @returns {string} Returns the string.
 */
function baseToString$1(value) {
  // Exit early for strings to avoid a performance hit in some environments.
  if (typeof value == 'string') {
    return value;
  }
  if (isArray_1(value)) {
    // Recursively convert values (susceptible to call stack limits).
    return _arrayMap(value, baseToString$1) + '';
  }
  if (isSymbol_1(value)) {
    return symbolToString ? symbolToString.call(value) : '';
  }
  var result = (value + '');
  return (result == '0' && (1 / value) == -INFINITY$2) ? '-0' : result;
}

var _baseToString = baseToString$1;

/**
 * Converts `value` to a string. An empty string is returned for `null`
 * and `undefined` values. The sign of `-0` is preserved.
 *
 * @static
 * @memberOf _
 * @since 4.0.0
 * @category Lang
 * @param {*} value The value to convert.
 * @returns {string} Returns the converted string.
 * @example
 *
 * _.toString(null);
 * // => ''
 *
 * _.toString(-0);
 * // => '-0'
 *
 * _.toString([1, 2, 3]);
 * // => '1,2,3'
 */
function toString$2(value) {
  return value == null ? '' : _baseToString(value);
}

var toString_1 = toString$2;

/** Used to match Latin Unicode letters (excluding mathematical operators). */
var reLatin = /[\xc0-\xd6\xd8-\xf6\xf8-\xff\u0100-\u017f]/g;

/** Used to compose unicode character classes. */
var rsComboMarksRange$4 = '\\u0300-\\u036f',
    reComboHalfMarksRange$4 = '\\ufe20-\\ufe2f',
    rsComboSymbolsRange$4 = '\\u20d0-\\u20ff',
    rsComboRange$4 = rsComboMarksRange$4 + reComboHalfMarksRange$4 + rsComboSymbolsRange$4;

/** Used to compose unicode capture groups. */
var rsCombo$3 = '[' + rsComboRange$4 + ']';

/**
 * Used to match [combining diacritical marks](https://en.wikipedia.org/wiki/Combining_Diacritical_Marks) and
 * [combining diacritical marks for symbols](https://en.wikipedia.org/wiki/Combining_Diacritical_Marks_for_Symbols).
 */
var reComboMark = RegExp(rsCombo$3, 'g');

/**
 * Deburrs `string` by converting
 * [Latin-1 Supplement](https://en.wikipedia.org/wiki/Latin-1_Supplement_(Unicode_block)#Character_table)
 * and [Latin Extended-A](https://en.wikipedia.org/wiki/Latin_Extended-A)
 * letters to basic Latin letters and removing
 * [combining diacritical marks](https://en.wikipedia.org/wiki/Combining_Diacritical_Marks).
 *
 * @static
 * @memberOf _
 * @since 3.0.0
 * @category String
 * @param {string} [string=''] The string to deburr.
 * @returns {string} Returns the deburred string.
 * @example
 *
 * _.deburr('déjà vu');
 * // => 'deja vu'
 */
function deburr(string) {
  string = toString_1(string);
  return string && string.replace(reLatin, _deburrLetter).replace(reComboMark, '');
}

var deburr_1 = deburr;

/** Used to match words composed of alphanumeric characters. */
var reAsciiWord = /[^\x00-\x2f\x3a-\x40\x5b-\x60\x7b-\x7f]+/g;

/**
 * Splits an ASCII `string` into an array of its words.
 *
 * @private
 * @param {string} The string to inspect.
 * @returns {Array} Returns the words of `string`.
 */
function asciiWords(string) {
  return string.match(reAsciiWord) || [];
}

var _asciiWords = asciiWords;

/** Used to detect strings that need a more robust regexp to match words. */
var reHasUnicodeWord = /[a-z][A-Z]|[A-Z]{2}[a-z]|[0-9][a-zA-Z]|[a-zA-Z][0-9]|[^a-zA-Z0-9 ]/;

/**
 * Checks if `string` contains a word composed of Unicode symbols.
 *
 * @private
 * @param {string} string The string to inspect.
 * @returns {boolean} Returns `true` if a word is found, else `false`.
 */
function hasUnicodeWord(string) {
  return reHasUnicodeWord.test(string);
}

var _hasUnicodeWord = hasUnicodeWord;

/** Used to compose unicode character classes. */
var rsAstralRange$3 = '\\ud800-\\udfff',
    rsComboMarksRange$3 = '\\u0300-\\u036f',
    reComboHalfMarksRange$3 = '\\ufe20-\\ufe2f',
    rsComboSymbolsRange$3 = '\\u20d0-\\u20ff',
    rsComboRange$3 = rsComboMarksRange$3 + reComboHalfMarksRange$3 + rsComboSymbolsRange$3,
    rsDingbatRange = '\\u2700-\\u27bf',
    rsLowerRange = 'a-z\\xdf-\\xf6\\xf8-\\xff',
    rsMathOpRange = '\\xac\\xb1\\xd7\\xf7',
    rsNonCharRange = '\\x00-\\x2f\\x3a-\\x40\\x5b-\\x60\\x7b-\\xbf',
    rsPunctuationRange = '\\u2000-\\u206f',
    rsSpaceRange = ' \\t\\x0b\\f\\xa0\\ufeff\\n\\r\\u2028\\u2029\\u1680\\u180e\\u2000\\u2001\\u2002\\u2003\\u2004\\u2005\\u2006\\u2007\\u2008\\u2009\\u200a\\u202f\\u205f\\u3000',
    rsUpperRange = 'A-Z\\xc0-\\xd6\\xd8-\\xde',
    rsVarRange$3 = '\\ufe0e\\ufe0f',
    rsBreakRange = rsMathOpRange + rsNonCharRange + rsPunctuationRange + rsSpaceRange;

/** Used to compose unicode capture groups. */
var rsApos$1 = "['\u2019]",
    rsBreak = '[' + rsBreakRange + ']',
    rsCombo$2 = '[' + rsComboRange$3 + ']',
    rsDigits = '\\d+',
    rsDingbat = '[' + rsDingbatRange + ']',
    rsLower = '[' + rsLowerRange + ']',
    rsMisc = '[^' + rsAstralRange$3 + rsBreakRange + rsDigits + rsDingbatRange + rsLowerRange + rsUpperRange + ']',
    rsFitz$2 = '\\ud83c[\\udffb-\\udfff]',
    rsModifier$2 = '(?:' + rsCombo$2 + '|' + rsFitz$2 + ')',
    rsNonAstral$2 = '[^' + rsAstralRange$3 + ']',
    rsRegional$2 = '(?:\\ud83c[\\udde6-\\uddff]){2}',
    rsSurrPair$2 = '[\\ud800-\\udbff][\\udc00-\\udfff]',
    rsUpper = '[' + rsUpperRange + ']',
    rsZWJ$3 = '\\u200d';

/** Used to compose unicode regexes. */
var rsMiscLower = '(?:' + rsLower + '|' + rsMisc + ')',
    rsMiscUpper = '(?:' + rsUpper + '|' + rsMisc + ')',
    rsOptContrLower = '(?:' + rsApos$1 + '(?:d|ll|m|re|s|t|ve))?',
    rsOptContrUpper = '(?:' + rsApos$1 + '(?:D|LL|M|RE|S|T|VE))?',
    reOptMod$2 = rsModifier$2 + '?',
    rsOptVar$2 = '[' + rsVarRange$3 + ']?',
    rsOptJoin$2 = '(?:' + rsZWJ$3 + '(?:' + [rsNonAstral$2, rsRegional$2, rsSurrPair$2].join('|') + ')' + rsOptVar$2 + reOptMod$2 + ')*',
    rsOrdLower = '\\d*(?:1st|2nd|3rd|(?![123])\\dth)(?=\\b|[A-Z_])',
    rsOrdUpper = '\\d*(?:1ST|2ND|3RD|(?![123])\\dTH)(?=\\b|[a-z_])',
    rsSeq$2 = rsOptVar$2 + reOptMod$2 + rsOptJoin$2,
    rsEmoji = '(?:' + [rsDingbat, rsRegional$2, rsSurrPair$2].join('|') + ')' + rsSeq$2;

/** Used to match complex or compound words. */
var reUnicodeWord = RegExp([
  rsUpper + '?' + rsLower + '+' + rsOptContrLower + '(?=' + [rsBreak, rsUpper, '$'].join('|') + ')',
  rsMiscUpper + '+' + rsOptContrUpper + '(?=' + [rsBreak, rsUpper + rsMiscLower, '$'].join('|') + ')',
  rsUpper + '?' + rsMiscLower + '+' + rsOptContrLower,
  rsUpper + '+' + rsOptContrUpper,
  rsOrdUpper,
  rsOrdLower,
  rsDigits,
  rsEmoji
].join('|'), 'g');

/**
 * Splits a Unicode `string` into an array of its words.
 *
 * @private
 * @param {string} The string to inspect.
 * @returns {Array} Returns the words of `string`.
 */
function unicodeWords(string) {
  return string.match(reUnicodeWord) || [];
}

var _unicodeWords = unicodeWords;

/**
 * Splits `string` into an array of its words.
 *
 * @static
 * @memberOf _
 * @since 3.0.0
 * @category String
 * @param {string} [string=''] The string to inspect.
 * @param {RegExp|string} [pattern] The pattern to match words.
 * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`.
 * @returns {Array} Returns the words of `string`.
 * @example
 *
 * _.words('fred, barney, & pebbles');
 * // => ['fred', 'barney', 'pebbles']
 *
 * _.words('fred, barney, & pebbles', /[^, ]+/g);
 * // => ['fred', 'barney', '&', 'pebbles']
 */
function words(string, pattern, guard) {
  string = toString_1(string);
  pattern = guard ? undefined : pattern;

if (pattern === undefined) {
    return _hasUnicodeWord(string) ? _unicodeWords(string) : _asciiWords(string);
  }
  return string.match(pattern) || [];
}

var words_1 = words;

/** Used to compose unicode capture groups. */
var rsApos = "['\u2019]";

/** Used to match apostrophes. */
var reApos = RegExp(rsApos, 'g');

/**
 * Creates a function like `_.camelCase`.
 *
 * @private
 * @param {Function} callback The function to combine each word.
 * @returns {Function} Returns the new compounder function.
 */
function createCompounder(callback) {
  return function(string) {
    return _arrayReduce(words_1(deburr_1(string).replace(reApos, '')), callback, '');
  };
}

var _createCompounder = createCompounder;

/**
 * Converts `string` to
 * [snake case](https://en.wikipedia.org/wiki/Snake_case).
 *
 * @static
 * @memberOf _
 * @since 3.0.0
 * @category String
 * @param {string} [string=''] The string to convert.
 * @returns {string} Returns the snake cased string.
 * @example
 *
 * _.snakeCase('Foo Bar');
 * // => 'foo_bar'
 *
 * _.snakeCase('fooBar');
 * // => 'foo_bar'
 *
 * _.snakeCase('--FOO-BAR--');
 * // => 'foo_bar'
 */
var snakeCase = _createCompounder(function(result, word, index) {
  return result + (index ? '_' : '') + word.toLowerCase();
});

var snakeCase_1 = snakeCase;

// MIT License
class UapiRequest extends Request$1 {
    /**
     * Add a custom HTTP header to the request
     *
     * @param name Name of a column
     * @return Updated Request object.
     */
    addHeader(header) {
        if (header instanceof WhmApiTokenHeader) {
            throw new WhmApiTokenMismatchError("A WhmApiTokenHeader cannot be used on a CpanelApiRequest");
        }
        super.addHeader(header);
        return this;
    }
    /**
     * Build a fragment of the parameter list based on the list of name/value pairs.
     *
     * @param params  Parameters to serialize.
     * @param encoder Encoder to use to serialize the each parameter.
     * @return Fragment with the serialized parameters
     */
    _build(params, encoder) {
        let fragment = "";
        params.forEach((arg, index, array) => {
            const isLast = index === array.length - 1;
            fragment += encoder.encode(arg.name, arg.value, isLast);
        });
        return encoder.separatorStart + fragment + encoder.separatorEnd;
    }
    /**
     * Generates the arguments for the request.
     *
     * @param params List of parameters to adjust based on the sort rules in the Request.
     */
    _generateArguments(params) {
        this.arguments.forEach((argument) => params.push(argument));
    }
    /**
     * Generates the sort parameters for the request.
     *
     * @param params List of parameters to adjust based on the sort rules in the Request.
     */
    _generateSorts(params) {
        this.sorts.forEach((sort, index) => {
            if (index === 0) {
                params.push({ name: "api.sort", value: fromBoolean(true) });
            }
            params.push({ name: "api.sort_column_" + index, value: sort.column });
            params.push({
                name: "api.sort_reverse_" + index,
                value: fromBoolean(sort.direction !== SortDirection.Ascending),
            });
            params.push({
                name: "api.sort_method_" + index,
                value: snakeCase_1(SortType[sort.type]),
            });
        });
    }
    /**
     * Look up the correct name for the filter operator
     *
     * @param operator Type of filter operator to use to filter the items
     * @returns The string counter part for the filter operator.
     * @throws Will throw an error if an unrecognized FilterOperator is provided.
     */
    _lookupFilterOperator(operator) {
        switch (operator) {
            case FilterOperator.GreaterThanUnlimited:
                return "gt_handle_unlimited";
            case FilterOperator.GreaterThan:
                return "gt";
            case FilterOperator.LessThanUnlimited:
                return "lt_handle_unlimited";
            case FilterOperator.LessThan:
                return "lt";
            case FilterOperator.NotEqual:
                return "ne";
            case FilterOperator.Equal:
                return "eq";
            case FilterOperator.Defined:
                return "defined";
            case FilterOperator.Undefined:
                return "undefined";
            case FilterOperator.Matches:
                return "matches";
            case FilterOperator.Ends:
                return "ends";
            case FilterOperator.Begins:
                return "begins";
            case FilterOperator.Contains:
                return "contains";
            default:
                // eslint-disable-next-line no-case-declarations -- just used for readability
                const key = FilterOperator[operator];
                throw new Error(`Unrecognized FilterOperator ${key} for UAPI`);
        }
    }
    /**
     * Generate the filter parameters if any.
     *
     * @param params List of parameters to adjust based on the filter rules provided.
     */
    _generateFilters(params) {
        this.filters.forEach((filter, index) => {
            params.push({ name: "api.filter_column_" + index, value: filter.column });
            params.push({
                name: "api.filter_type_" + index,
                value: this._lookupFilterOperator(filter.operator),
            });
            params.push({ name: "api.filter_term_" + index, value: filter.value });
        });
    }
    /**
     * In UAPI, we request the starting record, not the starting page. This translates
     * the page and page size into the correct starting record.
     */
    _traslatePageToStart(pager) {
        return (pager.page - 1) * pager.pageSize + 1;
    }
    /**
     * Generate the pager request parameters, if any.
     *
     * @param params List of parameters to adjust based on the pagination rules.
     */
    _generatePagination(params) {
        if (!this.usePager) {
            return;
        }
        const allPages = this.pager.all();
        params.push({
            name: "api.paginate",
            value: fromBoolean(true),
        });
        params.push({
            name: "api.paginate_start",
            value: allPages ? -1 : this._traslatePageToStart(this.pager),
        });
        if (!allPages) {
            params.push({
                name: "api.paginate_size",
                value: this.pager.pageSize,
            });
        }
    }
    /**
     * Generate any additional parameters from the configuration data.
     *
     * @param params List of parameters to adjust based on the configuration.
     */
    _generateConfiguration(params) {
        if (this.config && this.config["analytics"]) {
            params.push({
                name: "api.analytics",
                value: fromBoolean(this.config.analytics),
            });
        }
    }
    /**
     * Create a new uapi request.
     *
     * @param init  Optional request objects used to initialize this object.
     */
    constructor(init) {
        super(init);
    }
    /**
     * Generate the interchange object that has the pre-encoded
     * request using UAPI formatting.
     *
     * @param rule Optional parameter to specify a specific Rule we want the Request to be generated for.
     * @return Request information ready to be used by a remoting layer
     */
    generate(rule) {
        // Needed for pure JS clients, since they don't get the compiler checks
        if (!this.namespace) {
            throw new Error("You must define a namespace for the UAPI call before you generate a request");
        }
        if (!this.method) {
            throw new Error("You must define a method for the UAPI call before you generate a request");
        }
        if (!rule) {
            rule = {
                verb: HttpVerb.POST,
                encoder: this.config.json
                    ? new JsonArgumentEncoder()
                    : new WwwFormUrlArgumentEncoder(),
            };
        }
        if (!rule.encoder) {
            rule.encoder = this.config.json
                ? new JsonArgumentEncoder()
                : new WwwFormUrlArgumentEncoder();
        }
        const argumentRule = argumentSerializationRules.getRule(rule.verb);
        const info = {
            headers: new Headers([
                {
                    name: "Content-Type",
                    value: rule.encoder.contentType,
                },
            ]),
            url: ["", "execute", this.namespace, this.method]
                .map(encodeURIComponent)
                .join("/"),
            body: "",
        };
        const params = [];
        this._generateArguments(params);
        this._generateSorts(params);
        this._generateFilters(params);
        this._generatePagination(params);
        this._generateConfiguration(params);
        const encoded = this._build(params, rule.encoder);
        if (argumentRule.dataInBody) {
            info["body"] = encoded;
        }
        else {
            if (rule.verb === HttpVerb.GET) {
                info["url"] += `?${encoded}`;
            }
            else {
                info["url"] += encoded;
            }
        }
        this.headers.forEach((header) => {
            info.headers.push({
                name: header.name,
                value: header.value,
            });
        });
        return info;
    }
}

// MIT License
/**
 * This class will extract the available metadata from the UAPI format into a standard format for JavaScript developers.
 */
class UapiMetaData {
    /**
     * Build a new MetaData object from the metadata response from the server.
     *
     * @param meta UAPI metadata object.
     */
    constructor(meta) {
        /**
         * Indicates if the data is paged.
         */
        this.isPaged = false;
        /**
         * The record number of the first record of a page.
         */
        this.record = 0;
        /**
         * The current page.
         */
        this.page = 0;
        /**
         * The page size of the returned set.
         */
        this.pageSize = 0;
        /**
         * The total number of records available on the backend.
         */
        this.totalRecords = 0;
        /**
         * The total number of pages of records on the backend.
         */
        this.totalPages = 0;
        /**
         * Indicates if the data set if filtered.
         */
        this.isFiltered = false;
        /**
         * Number of records available before the filter was processed.
         */
        this.recordsBeforeFilter = 0;
        /**
         * Indicates the response was the result of a batch API.
         */
        this.batch = false;
        /**
         * A collection of the other less common or custom UAPI metadata properties.
         */
        this.properties = {};
        // Handle pagination
        if (meta.paginate) {
            this.isPaged = true;
            this.record = parseInt(meta.paginate.start_result, 10) || 0;
            this.page = parseInt(meta.paginate.current_page, 10) || 0;
            this.pageSize = parseInt(meta.paginate.results_per_page, 10) || 0;
            this.totalPages = parseInt(meta.paginate.total_pages, 10) || 0;
            this.totalRecords = parseInt(meta.paginate.total_results, 10) || 0;
        }
        // Handle filtering
        if (meta.filter) {
            this.isFiltered = true;
            this.recordsBeforeFilter =
                parseInt(meta.filter.records_before_filter, 10) || 0;
        }
        // Get any other custom metadata properties off the object
        const builtinSet = new Set(["paginate", "filter"]);
        Object.keys(meta)
            .filter((key) => !builtinSet.has(key))
            .forEach((key) => {
            this.properties[key] = meta[key];
        });
    }
}
/**
 * Parser that will convert a UAPI wire-formated object into a standard response object for JavaScript developers.
 */
class UapiResponse extends Response {
    /**
     * Parse out the status from the response.
     *
     * @param  response Raw response object from the backend. Already passed through JSON.parse().
     * @return Number indicating success or failure. > 1 success, 0 failure.
     */
    _parseStatus(response) {
        this.status = 0; // Assume it failed.
        if (typeof response.status === "undefined") {
            throw new Error("The response should have a numeric status property indicating the API succeeded (>0) or failed (=0)");
        }
        this.status = parseInt(response.status, 10);
    }
    /**
     * Parse out the messages from the response.
     *
     * @param response The response object sent by the API method.
     */
    _parseMessages(response) {
        if ("errors" in response) {
            const errors = response.errors;
            if (errors && errors.length) {
                errors.forEach((error) => {
                    this.messages.push({
                        type: MessageType.Error,
                        message: error,
                    });
                });
            }
        }
        if ("messages" in response) {
            const messages = response.messages;
            if (messages) {
                messages.forEach((message) => {
                    this.messages.push({
                        type: MessageType.Information,
                        message: message,
                    });
                });
            }
        }
    }
    /**
     * Parse out the status, data and metadata from a UAPI response into the abstract Response and IMetaData structures.
     *
     * @param response  Raw response from the server. It's just been JSON.parse() at this point.
     * @param Options on how to handle parsing of the response.
     */
    constructor(response, options) {
        super(response, options);
        this._parseStatus(response);
        this._parseMessages(response);
        if (!response || !Object.prototype.hasOwnProperty.call(response, "data")) {
            throw new Error("Expected response to contain a data property, but it is missing");
        }
        // TODO: Add parsing by specific types to take care of renames and type coercion.
        this.data = response.data;
        if (response.metadata) {
            this.meta = new UapiMetaData(response.metadata);
        }
    }
}

/** Used as references for various `Number` constants. */
var MAX_SAFE_INTEGER = 9007199254740991;

/* Built-in method references for those with the same name as other `lodash` methods. */
var nativeFloor = Math.floor;

/**
 * The base implementation of `_.repeat` which doesn't coerce arguments.
 *
 * @private
 * @param {string} string The string to repeat.
 * @param {number} n The number of times to repeat the string.
 * @returns {string} Returns the repeated string.
 */
function baseRepeat(string, n) {
 var result = '';
 if (!string || n < 1 || n > MAX_SAFE_INTEGER) {
 return result;
 }
 // Leverage the exponentiation by squaring algorithm for a faster repeat.
 // See https://en.wikipedia.org/wiki/Exponentiation_by_squaring for more details.
 do {
 if (n % 2) {
 result += string;
 }
 n = nativeFloor(n / 2);
 if (n) {
 string += string;
 }
 } while (n);

return result;
}

var _baseRepeat = baseRepeat;

/**
 * The base implementation of `_.slice` without an iteratee call guard.
 *
 * @private
 * @param {Array} array The array to slice.
 * @param {number} [start=0] The start position.
 * @param {number} [end=array.length] The end position.
 * @returns {Array} Returns the slice of `array`.
 */
function baseSlice(array, start, end) {
  var index = -1,
      length = array.length;

if (start < 0) {
 start = -start > length ? 0 : (length + start);
 }
 end = end > length ? length : end;
 if (end < 0) {
 end += length;
 }
 length = start > end ? 0 : ((end - start) >>> 0);
 start >>>= 0;

var result = Array(length);
 while (++index < length) {
 result[index] = array[index + start];
 }
 return result;
}

var _baseSlice = baseSlice;

/**
 * Casts `array` to a slice if it's needed.
 *
 * @private
 * @param {Array} array The array to inspect.
 * @param {number} start The start position.
 * @param {number} [end=array.length] The end position.
 * @returns {Array} Returns the cast slice.
 */
function castSlice(array, start, end) {
  var length = array.length;
  end = end === undefined ? length : end;
  return (!start && end >= length) ? array : _baseSlice(array, start, end);
}

var _castSlice = castSlice;

/** Used to compose unicode character classes. */
var rsAstralRange$2 = '\\ud800-\\udfff',
    rsComboMarksRange$2 = '\\u0300-\\u036f',
    reComboHalfMarksRange$2 = '\\ufe20-\\ufe2f',
    rsComboSymbolsRange$2 = '\\u20d0-\\u20ff',
    rsComboRange$2 = rsComboMarksRange$2 + reComboHalfMarksRange$2 + rsComboSymbolsRange$2,
    rsVarRange$2 = '\\ufe0e\\ufe0f';

/** Used to compose unicode capture groups. */
var rsZWJ$2 = '\\u200d';

/** Used to detect strings with [zero-width joiners or code points from the astral planes](http://eev.ee/blog/2015/09/12/dark-corners-of-unicode/). */
var reHasUnicode = RegExp('[' + rsZWJ$2 + rsAstralRange$2  + rsComboRange$2 + rsVarRange$2 + ']');

/**
 * Checks if `string` contains Unicode symbols.
 *
 * @private
 * @param {string} string The string to inspect.
 * @returns {boolean} Returns `true` if a symbol is found, else `false`.
 */
function hasUnicode(string) {
  return reHasUnicode.test(string);
}

var _hasUnicode = hasUnicode;

/**
 * The base implementation of `_.property` without support for deep paths.
 *
 * @private
 * @param {string} key The key of the property to get.
 * @returns {Function} Returns the new accessor function.
 */
function baseProperty(key) {
  return function(object) {
    return object == null ? undefined : object[key];
  };
}

var _baseProperty = baseProperty;

/**
 * Gets the size of an ASCII `string`.
 *
 * @private
 * @param {string} string The string inspect.
 * @returns {number} Returns the string size.
 */
var asciiSize = _baseProperty('length');

var _asciiSize = asciiSize;

/** Used to compose unicode character classes. */
var rsAstralRange$1 = '\\ud800-\\udfff',
    rsComboMarksRange$1 = '\\u0300-\\u036f',
    reComboHalfMarksRange$1 = '\\ufe20-\\ufe2f',
    rsComboSymbolsRange$1 = '\\u20d0-\\u20ff',
    rsComboRange$1 = rsComboMarksRange$1 + reComboHalfMarksRange$1 + rsComboSymbolsRange$1,
    rsVarRange$1 = '\\ufe0e\\ufe0f';

/** Used to compose unicode capture groups. */
var rsAstral$1 = '[' + rsAstralRange$1 + ']',
    rsCombo$1 = '[' + rsComboRange$1 + ']',
    rsFitz$1 = '\\ud83c[\\udffb-\\udfff]',
    rsModifier$1 = '(?:' + rsCombo$1 + '|' + rsFitz$1 + ')',
    rsNonAstral$1 = '[^' + rsAstralRange$1 + ']',
    rsRegional$1 = '(?:\\ud83c[\\udde6-\\uddff]){2}',
    rsSurrPair$1 = '[\\ud800-\\udbff][\\udc00-\\udfff]',
    rsZWJ$1 = '\\u200d';

/** Used to compose unicode regexes. */
var reOptMod$1 = rsModifier$1 + '?',
    rsOptVar$1 = '[' + rsVarRange$1 + ']?',
    rsOptJoin$1 = '(?:' + rsZWJ$1 + '(?:' + [rsNonAstral$1, rsRegional$1, rsSurrPair$1].join('|') + ')' + rsOptVar$1 + reOptMod$1 + ')*',
    rsSeq$1 = rsOptVar$1 + reOptMod$1 + rsOptJoin$1,
    rsSymbol$1 = '(?:' + [rsNonAstral$1 + rsCombo$1 + '?', rsCombo$1, rsRegional$1, rsSurrPair$1, rsAstral$1].join('|') + ')';

/** Used to match [string symbols](https://mathiasbynens.be/notes/javascript-unicode). */
var reUnicode$1 = RegExp(rsFitz$1 + '(?=' + rsFitz$1 + ')|' + rsSymbol$1 + rsSeq$1, 'g');

/**
 * Gets the size of a Unicode `string`.
 *
 * @private
 * @param {string} string The string inspect.
 * @returns {number} Returns the string size.
 */
function unicodeSize(string) {
  var result = reUnicode$1.lastIndex = 0;
  while (reUnicode$1.test(string)) {
    ++result;
  }
  return result;
}

var _unicodeSize = unicodeSize;

/**
 * Gets the number of symbols in `string`.
 *
 * @private
 * @param {string} string The string to inspect.
 * @returns {number} Returns the string size.
 */
function stringSize(string) {
  return _hasUnicode(string)
    ? _unicodeSize(string)
    : _asciiSize(string);
}

var _stringSize = stringSize;

/**
 * Converts an ASCII `string` to an array.
 *
 * @private
 * @param {string} string The string to convert.
 * @returns {Array} Returns the converted array.
 */
function asciiToArray(string) {
  return string.split('');
}

var _asciiToArray = asciiToArray;

/** Used to compose unicode character classes. */
var rsAstralRange = '\\ud800-\\udfff',
    rsComboMarksRange = '\\u0300-\\u036f',
    reComboHalfMarksRange = '\\ufe20-\\ufe2f',
    rsComboSymbolsRange = '\\u20d0-\\u20ff',
    rsComboRange = rsComboMarksRange + reComboHalfMarksRange + rsComboSymbolsRange,
    rsVarRange = '\\ufe0e\\ufe0f';

/** Used to compose unicode capture groups. */
var rsAstral = '[' + rsAstralRange + ']',
    rsCombo = '[' + rsComboRange + ']',
    rsFitz = '\\ud83c[\\udffb-\\udfff]',
    rsModifier = '(?:' + rsCombo + '|' + rsFitz + ')',
    rsNonAstral = '[^' + rsAstralRange + ']',
    rsRegional = '(?:\\ud83c[\\udde6-\\uddff]){2}',
    rsSurrPair = '[\\ud800-\\udbff][\\udc00-\\udfff]',
    rsZWJ = '\\u200d';

/** Used to compose unicode regexes. */
var reOptMod = rsModifier + '?',
    rsOptVar = '[' + rsVarRange + ']?',
    rsOptJoin = '(?:' + rsZWJ + '(?:' + [rsNonAstral, rsRegional, rsSurrPair].join('|') + ')' + rsOptVar + reOptMod + ')*',
    rsSeq = rsOptVar + reOptMod + rsOptJoin,
    rsSymbol = '(?:' + [rsNonAstral + rsCombo + '?', rsCombo, rsRegional, rsSurrPair, rsAstral].join('|') + ')';

/** Used to match [string symbols](https://mathiasbynens.be/notes/javascript-unicode). */
var reUnicode = RegExp(rsFitz + '(?=' + rsFitz + ')|' + rsSymbol + rsSeq, 'g');

/**
 * Converts a Unicode `string` to an array.
 *
 * @private
 * @param {string} string The string to convert.
 * @returns {Array} Returns the converted array.
 */
function unicodeToArray(string) {
  return string.match(reUnicode) || [];
}

var _unicodeToArray = unicodeToArray;

/**
 * Converts `string` to an array.
 *
 * @private
 * @param {string} string The string to convert.
 * @returns {Array} Returns the converted array.
 */
function stringToArray(string) {
  return _hasUnicode(string)
    ? _unicodeToArray(string)
    : _asciiToArray(string);
}

var _stringToArray = stringToArray;

/* Built-in method references for those with the same name as other `lodash` methods. */
var nativeCeil = Math.ceil;

/**
 * Creates the padding for `string` based on `length`. The `chars` string
 * is truncated if the number of characters exceeds `length`.
 *
 * @private
 * @param {number} length The padding length.
 * @param {string} [chars=' '] The string used as padding.
 * @returns {string} Returns the padding for `string`.
 */
function createPadding(length, chars) {
  chars = chars === undefined ? ' ' : _baseToString(chars);

var charsLength = chars.length;
 if (charsLength < 2) {
 return charsLength ? _baseRepeat(chars, length) : chars;
 }
 var result = _baseRepeat(chars, nativeCeil(length / _stringSize(chars)));
 return _hasUnicode(chars)
 ? _castSlice(_stringToArray(result), 0, length).join('')
 : result.slice(0, length);
}

var _createPadding = createPadding;

/** Used to match a single whitespace character. */
var reWhitespace = /\s/;

while (index-- && reWhitespace.test(string.charAt(index))) {}
  return index;
}

var _trimmedEndIndex = trimmedEndIndex;

/** Used to match leading whitespace. */
var reTrimStart = /^\s+/;

/**
 * The base implementation of `_.trim`.
 *
 * @private
 * @param {string} string The string to trim.
 * @returns {string} Returns the trimmed string.
 */
function baseTrim(string) {
  return string
    ? string.slice(0, _trimmedEndIndex(string) + 1).replace(reTrimStart, '')
    : string;
}

var _baseTrim = baseTrim;

/**
 * Checks if `value` is the
 * [language type](http://www.ecma-international.org/ecma-262/7.0/#sec-ecmascript-language-types)
 * of `Object`. (e.g. arrays, functions, objects, regexes, `new Number(0)`, and `new String('')`)
 *
 * @static
 * @memberOf _
 * @since 0.1.0
 * @category Lang
 * @param {*} value The value to check.
 * @returns {boolean} Returns `true` if `value` is an object, else `false`.
 * @example
 *
 * _.isObject({});
 * // => true
 *
 * _.isObject([1, 2, 3]);
 * // => true
 *
 * _.isObject(_.noop);
 * // => true
 *
 * _.isObject(null);
 * // => false
 */
function isObject$1(value) {
  var type = typeof value;
  return value != null && (type == 'object' || type == 'function');
}

var isObject_1 = isObject$1;

/** Used as references for various `Number` constants. */
var NAN = 0 / 0;

/** Used to detect bad signed hexadecimal string values. */
var reIsBadHex = /^[-+]0x[0-9a-f]+$/i;

/** Used to detect binary string values. */
var reIsBinary = /^0b[01]+$/i;

/** Used to detect octal string values. */
var reIsOctal = /^0o[0-7]+$/i;

/** Built-in method references without a dependency on `root`. */
var freeParseInt = parseInt;

/**
 * Converts `value` to a number.
 *
 * @static
 * @memberOf _
 * @since 4.0.0
 * @category Lang
 * @param {*} value The value to process.
 * @returns {number} Returns the number.
 * @example
 *
 * _.toNumber(3.2);
 * // => 3.2
 *
 * _.toNumber(Number.MIN_VALUE);
 * // => 5e-324
 *
 * _.toNumber(Infinity);
 * // => Infinity
 *
 * _.toNumber('3.2');
 * // => 3.2
 */
function toNumber(value) {
  if (typeof value == 'number') {
    return value;
  }
  if (isSymbol_1(value)) {
    return NAN;
  }
  if (isObject_1(value)) {
    var other = typeof value.valueOf == 'function' ? value.valueOf() : value;
    value = isObject_1(other) ? (other + '') : other;
  }
  if (typeof value != 'string') {
    return value === 0 ? value : +value;
  }
  value = _baseTrim(value);
  var isBinary = reIsBinary.test(value);
  return (isBinary || reIsOctal.test(value))
    ? freeParseInt(value.slice(2), isBinary ? 2 : 8)
    : (reIsBadHex.test(value) ? NAN : +value);
}

var toNumber_1 = toNumber;

/** Used as references for various `Number` constants. */
var INFINITY$1 = 1 / 0,
    MAX_INTEGER = 1.7976931348623157e+308;

/**
 * Converts `value` to a finite number.
 *
 * @static
 * @memberOf _
 * @since 4.12.0
 * @category Lang
 * @param {*} value The value to convert.
 * @returns {number} Returns the converted number.
 * @example
 *
 * _.toFinite(3.2);
 * // => 3.2
 *
 * _.toFinite(Number.MIN_VALUE);
 * // => 5e-324
 *
 * _.toFinite(Infinity);
 * // => 1.7976931348623157e+308
 *
 * _.toFinite('3.2');
 * // => 3.2
 */
function toFinite(value) {
 if (!value) {
 return value === 0 ? value : 0;
 }
 value = toNumber_1(value);
 if (value === INFINITY$1 || value === -INFINITY$1) {
 var sign = (value < 0 ? -1 : 1);
 return sign * MAX_INTEGER;
 }
 return value === value ? value : 0;
}

var toFinite_1 = toFinite;

/**
 * Converts `value` to an integer.
 *
 * **Note:** This method is loosely based on
 * [`ToInteger`](http://www.ecma-international.org/ecma-262/7.0/#sec-tointeger).
 *
 * @static
 * @memberOf _
 * @since 4.0.0
 * @category Lang
 * @param {*} value The value to convert.
 * @returns {number} Returns the converted integer.
 * @example
 *
 * _.toInteger(3.2);
 * // => 3
 *
 * _.toInteger(Number.MIN_VALUE);
 * // => 0
 *
 * _.toInteger(Infinity);
 * // => 1.7976931348623157e+308
 *
 * _.toInteger('3.2');
 * // => 3
 */
function toInteger(value) {
  var result = toFinite_1(value),
      remainder = result % 1;

return result === result ? (remainder ? result - remainder : result) : 0;
}

var toInteger_1 = toInteger;

/**
 * Pads `string` on the left side if it's shorter than `length`. Padding
 * characters are truncated if they exceed `length`.
 *
 * @static
 * @memberOf _
 * @since 4.0.0
 * @category String
 * @param {string} [string=''] The string to pad.
 * @param {number} [length=0] The padding length.
 * @param {string} [chars=' '] The string used as padding.
 * @returns {string} Returns the padded string.
 * @example
 *
 * _.padStart('abc', 6);
 * // => '   abc'
 *
 * _.padStart('abc', 6, '_-');
 * // => '_-_abc'
 *
 * _.padStart('abc', 3);
 * // => 'abc'
 */
function padStart(string, length, chars) {
  string = toString_1(string);
  length = toInteger_1(length);

var strLength = length ? _stringSize(string) : 0;
 return (length && strLength < length)
 ? (_createPadding(length - strLength, chars) + string)
 : string;
}

var padStart_1 = padStart;

// MIT License
/**
 * Type of response format for WHM API 1. The data can be requested to be sent back
 * either in JSON format or XML format.
 */
var WhmApiType;
(function (WhmApiType) {
    /**
     * Json-Api request
     */
    WhmApiType["JsonApi"] = "json-api";
    /**
     * Xml-Api request
     */
    WhmApiType["XmlApi"] = "xml-api";
})(WhmApiType || (WhmApiType = {}));
class WhmApiRequest extends Request$1 {
    /**
     * Create a new UAPI request.
     *
     * @param init Optional request object used to initialize this object.
     */
    constructor(apiType, init) {
        super(init);
        /**
         * The API output format the request should be generated for.
         */
        this.apiType = WhmApiType.JsonApi;
        // Needed for or pure js clients since they don't get the compiler checks
        if (apiType != WhmApiType.JsonApi && apiType != WhmApiType.XmlApi) {
            throw new Error("You must define the API type for the whmapi call before you generate a request.");
        }
        else {
            this.apiType = apiType;
        }
        if (!this.method) {
            throw new Error("You must define a method for the WHM API call before you generate a request");
        }
    }
    /**
     * Add a custom HTTP header to the request
     *
     * @param name Name of a column
     * @return Updated Request object.
     */
    addHeader(header) {
        if (header instanceof CpanelApiTokenHeader) {
            throw new CpanelApiTokenMismatchError("A CpanelApiTokenHeader cannot be used on a WhmApiRequest");
        }
        super.addHeader(header);
        return this;
    }
    /**
     * Build a fragment of the parameter list based on the list of name/value pairs.
     *
     * @param params  Parameters to serialize.
     * @param encoder Encoder to use to serialize the each parameter.
     * @return Fragment with the serialized parameters
     */
    _build(params, encoder) {
        let fragment = "";
        params.forEach((arg, index, array) => {
            const isLast = index === array.length - 1;
            fragment += encoder.encode(arg.name, arg.value, isLast);
        });
        return encoder.separatorStart + fragment + encoder.separatorEnd;
    }
    /**
     * Convert from a number into a string that WHM API 1 will sort
     * in the same order as the numbers; e.g.: 26=>"za", 52=>"zza", ...
     * @method  _make_whm_api_fieldspec_from_number
     * @private
     * @param num Index of sort item
     * @return letter combination for the index of the sort item.
     */
    _make_whm_api_fieldspec_from_number(num) {
        const left = padStart_1("", Math.floor(num / 26), "z");
        return left + "abcdefghijklmnopqrstuvwxyz".charAt(num % 26);
    }
    /**
     * Generates the arguments for the request.
     *
     * @param params List of parameters to adjust based on the sort rules in the Request.
     */
    _generateArguments(params) {
        // For any WHM API call, the API version must be specified as an argument. It is required.
        // Adding it first before everything.
        const apiVersionParam = { name: "api.version", value: 1 };
        params.push(apiVersionParam);
        this.arguments.forEach((argument) => params.push(argument));
    }
    /**
     * Generates the sort parameters for the request.
     *
     * @param params List of parameters to adjust based on the sort rules in the Request.
     */
    _generateSorts(params) {
        this.sorts.forEach((sort, index) => {
            if (index === 0) {
                params.push({ name: "api.sort.enable", value: fromBoolean(true) });
            }
            const sortPrefix = `api.sort.${this._make_whm_api_fieldspec_from_number(index)}`;
            params.push({ name: `${sortPrefix}.field`, value: sort.column });
            params.push({
                name: `${sortPrefix}.reverse`,
                value: fromBoolean(sort.direction !== SortDirection.Ascending),
            });
            params.push({
                name: `${sortPrefix}.method`,
                value: snakeCase_1(SortType[sort.type]),
            });
        });
    }
    /**
     * Look up the correct name for the filter operator
     *
     * @param operator Type of filter operator to use to filter the items
     * @returns The string counter part for the filter operator.
     * @throws Will throw an error if an unrecognized FilterOperator is provided.
     */
    _lookupFilterOperator(operator) {
        switch (operator) {
            case FilterOperator.GreaterThanUnlimited:
                return "gt_handle_unlimited";
            case FilterOperator.GreaterThan:
                return "gt";
            case FilterOperator.LessThanUnlimited:
                return "lt_handle_unlimited";
            case FilterOperator.LessThan:
                return "lt";
            case FilterOperator.Equal:
                return "eq";
            case FilterOperator.Begins:
                return "begins";
            case FilterOperator.Contains:
                return "contains";
            default:
                // eslint-disable-next-line no-case-declarations -- improves readability
                const key = FilterOperator[operator];
                throw new Error(`Unrecoginzed FilterOperator ${key} for WHM API 1`);
        }
    }
    /**
     * Generate the filter parameters, if any.
     *
     * @param params List of parameters to adjust based on the filter rules provided.
     */
    _generateFilters(params) {
        this.filters.forEach((filter, index) => {
            if (index === 0) {
                params.push({
                    name: "api.filter.enable",
                    value: fromBoolean(true),
                });
                params.push({
                    name: "api.filter.verbose",
                    value: fromBoolean(true),
                });
            }
            const filterPrefix = `api.filter.${this._make_whm_api_fieldspec_from_number(index)}`;
            params.push({ name: `${filterPrefix}.field`, value: filter.column });
            params.push({
                name: `${filterPrefix}.type`,
                value: this._lookupFilterOperator(filter.operator),
            });
            params.push({ name: `${filterPrefix}.arg0`, value: filter.value });
        });
    }
    /**
     * In UAPI, we request the starting record, not the starting page. This translates
     * the page and page size into the correct starting record.
     *
     * @param pager Object containing pager settings.
     */
    _translatePageToStart(pager) {
        return (pager.page - 1) * pager.pageSize + 1;
    }
    /**
     * Generate the pager request parameters, if any.
     *
     * @param params List of parameters to adjust based on the pagination rules.
     */
    _generatePagination(params) {
        if (!this.usePager) {
            return;
        }
        const allPages = this.pager.all();
        params.push({ name: "api.chunk.enable", value: fromBoolean(true) });
        params.push({ name: "api.chunk.verbose", value: fromBoolean(true) });
        params.push({
            name: "api.chunk.start",
            value: allPages ? -1 : this._translatePageToStart(this.pager),
        });
        if (!allPages) {
            params.push({
                name: "api.chunk.size",
                value: this.pager.pageSize,
            });
        }
    }
    /**
     * Generate the interchange object that has the pre-encoded
     * request using UAPI formatting.
     *
     * @param rule Optional parameter to specify a specific Rule we want the Request to be generated for.
     * @return {RequestInfo} Request information ready to be used by a remoting layer
     */
    generate(rule) {
        if (!rule) {
            rule = {
                verb: HttpVerb.POST,
                encoder: this.config.json
                    ? new JsonArgumentEncoder()
                    : new WwwFormUrlArgumentEncoder(),
            };
        }
        if (!rule.encoder) {
            rule.encoder = this.config.json
                ? new JsonArgumentEncoder()
                : new WwwFormUrlArgumentEncoder();
        }
        const argumentRule = argumentSerializationRules.getRule(rule.verb);
        const info = {
            headers: new Headers([
                {
                    name: "Content-Type",
                    value: rule.encoder.contentType,
                },
            ]),
            url: ["", this.apiType, this.method].map(encodeURIComponent).join("/"),
            body: "",
        };
        const params = [];
        this._generateArguments(params);
        this._generateSorts(params);
        this._generateFilters(params);
        this._generatePagination(params);
        const encoded = this._build(params, rule.encoder);
        if (argumentRule.dataInBody) {
            info["body"] = encoded;
        }
        else {
            if (rule.verb === HttpVerb.GET) {
                info["url"] += `?${encoded}`;
            }
            else {
                info["url"] += encoded;
            }
        }
        this.headers.forEach((header) => {
            info.headers.push({
                name: header.name,
                value: header.value,
            });
        });
        return info;
    }
}

/**
# cpanel - ui/web-components/src/components/header/cp-header-search/account-access-tweak-setting.enum.ts
#                                                  Copyright 2022 cPanel, L.L.C.
#                                                           All rights reserved.
# copyright@cpanel.net                                         http://cpanel.net
# This code is subject to the cPanel license. Unauthorized copying is prohibited
 */
var AccountAccessTweakSetting;
(function (AccountAccessTweakSetting) {
  AccountAccessTweakSetting["OWNER_ROOT"] = "owner_root";
  AccountAccessTweakSetting["OWNER_ONLY"] = "owner";
  AccountAccessTweakSetting["USER"] = "user";
  // This is here just as a dummy value to set in cPanel,
  // which doesn’t actually need the account-access check logic.
  AccountAccessTweakSetting["NONE"] = "";
})(AccountAccessTweakSetting || (AccountAccessTweakSetting = {}));

/**
# cpanel - ui/web-components/src/components/shared/interfaces/permissions.ts
#                                                  Copyright 2022 cPanel, L.L.C.
#                                                           All rights reserved.
# copyright@cpanel.net                                         http://cpanel.net
# This code is subject to the cPanel license. Unauthorized copying is prohibited
 */
class Permissions {
  constructor(permissions) {
    this.basicWHMFunctions = (permissions === null || permissions === void 0 ? void 0 : permissions.basicWHMFunctions) ? toBoolean(permissions.basicWHMFunctions) : false;
    this.listAccounts = (permissions === null || permissions === void 0 ? void 0 : permissions.listAccounts) ? toBoolean(permissions.listAccounts) : false;
    this.modifyAccount = (permissions === null || permissions === void 0 ? void 0 : permissions.modifyAccount) ? toBoolean(permissions.modifyAccount) : false;
    this.all = (permissions === null || permissions === void 0 ? void 0 : permissions.all) ? toBoolean(permissions.all) : false;
    this.impersonateAccountTweakSettingValue = (permissions === null || permissions === void 0 ? void 0 : permissions.impersonateAccountTweakSettingValue)
      ? permissions.impersonateAccountTweakSettingValue
      : AccountAccessTweakSetting.NONE;
  }
}

/**
# cpanel - ui/web-components/src/components/header/ui-overlay.ts
#                                                  Copyright 2022 cPanel, L.L.C.
#                                                           All rights reserved.
# copyright@cpanel.net                                         http://cpanel.net
# This code is subject to the cPanel license. Unauthorized copying is prohibited
 */
// This is the class that marks the overlay as “shown”.
const CP_OVERLAY_ACTIVE_CLASS = "cp-overlay--cover-content-area";
/**
 * @class
 *
 * This class manages a document overlay element for multiple components.
 * Having a class that manages the overlay prevents one component from
 * “stepping on” another component’s use of the overlay; consider:
 *
 * - Component A shows overlay
 * - Component B shows overlay (no visible change)
 * - Component A hides overlay
 *
 * At this time the overlay is hidden, despite that component B still
 * wants it shown.
 *
 * This module implements logic whereby the overlay is shown if and only
 * if at least 1 caller has “claimed” the overlay.
 */
class UIOverlay {
  /**
   * @constructor
   * @param {overlayEl} - The overlay element
   */
  constructor(overlayEl) {
    this.element = overlayEl;
    this.claims = {};
  }
  /**
   * “Claims” the overlay for the `name`d component. The overlay will
   * be shown if it’s not already.
   *
   * **IMPORTANT:** Nothing prevents two components from giving the
   * same `name`. The integrity of this, though, depends on each
   * caller/component giving a _different_ name.
   */
  claim(name) {
    this.claims[name] = true;
    this.element.classList.add(CP_OVERLAY_ACTIVE_CLASS);
  }
  /**
   * Releases the `name`d component’s “claim” on the overlay.
   * If no “claims” are left, then this hides the overlay.
   */
  release(name) {
    delete this.claims[name];
    if (!Object.keys(this.claims).length) {
      this.element.classList.remove(CP_OVERLAY_ACTIVE_CLASS);
    }
  }
}

/**
# cpanel - ui/web-components/src/utils/store.ts    Copyright 2022 cPanel, L.L.C.
#                                                           All rights reserved.
# copyright@cpanel.net                                         http://cpanel.net
# This code is subject to the cPanel license. Unauthorized copying is prohibited
 */
const { state, dispose } = createStore({
  // directory prefix for cpanel code base
  directoryPrefix: "",
  // cpanel and whm application list
  appList: [],
  mainMenuLinks: [],
  // if the app is cpanel, whm or webmail
  appName: "",
  categoryList: [],
  hostName: "",
  serverEnvironment: "",
  user: "",
  favorites: [],
  /**
   * Display friendly cpanel version.
   */
  version: "",
  /**
   * The full version of cPanel.
   */
  cpanelFullVersion: "",
  plugins: [],
  whmNotifications: [],
  licenseType: "",
  // cPanel users primary domain
  primaryDomain: "",
  permissions: new Permissions(),
  appSearchResultsLimit: 0,
  /**
   * A dummy object, to be replaced at DOMContentLoaded time.
   */
  uiOverlay: new UIOverlay(document.documentElement),
  initialNavUrl: "",
  /**
   * The logo name (cf. Whostmgr::UI::Logos) and its URL path.
   * (MagicRevision is applied.)
   */
  whmLogos: {},
  /**
   * The company id as provided by the cPanel license.
   */
  companyId: "",
  /**
   * The application key
   */
  cpanelAppKey: "",
});

//                                      Copyright 2025 WebPros International, LLC
const locale$v = getLocaleInstance();
class SharedUtilsService {
  /**
   * Constructs a url that can be used by the users of the cPanel interface to give feedback.
   * Returns the url including it's associated data.
   */
  getFeedbackLinkDataForCpanel(cpanelFullVersion, companyId, cpanelAppKey) {
    const url = "https://surveys.webpros.com/to/efKeF6N7", source = "cpanel-feedback";
    return {
      url: `${url}?utm_source=${source}&cpanel_productversion=${cpanelFullVersion}&companyid=${companyId}&cpanel_appkey=${cpanelAppKey}`,
      target: source,
      title: locale$v.maketext("Give Feedback"),
    };
  }
}
const sharedUtils = new SharedUtilsService();

/**
# cpanel - ui/web-components/src/components/footer/footer-links.ts
#                                                  Copyright 2022 cPanel, L.L.C.
#                                                           All rights reserved.
# copyright@cpanel.net                                         http://cpanel.net
# This code is subject to the cPanel license. Unauthorized copying is prohibited
 */
const locale$u = getLocaleInstance();
function getFooterLinks(appName, directoryPrefix, docLink, helpLink) {
  return appName === AppName.Cpanel
    ? getcPanelLinks(directoryPrefix, docLink, helpLink)
    : getWHMLinks(directoryPrefix);
}
function getLogoTitle(appName) {
  return appName === AppName.Cpanel ? locale$u.maketext("cPanel") : locale$u.maketext("WHM");
}
const COMMON_LINKS = [
  {
    id: "lnkFooterPrivacy",
    href: "https://go.cpanel.net/privacy",
    target: "privacyPolicy",
    title: locale$u.maketext("Privacy Policy"),
  },
];
function getcPanelLinks(prefix, docLink, helpLink) {
  const feedbackLinkData = sharedUtils.getFeedbackLinkDataForCpanel(state.cpanelFullVersion, state.companyId, state.cpanelAppKey);
  let links = [
    {
      id: "lnkFooterHome",
      href: prefix + "index.html",
      title: locale$u.maketext("Home"),
      target: "_self",
    },
    {
      id: "lnkFooterTrademark",
      href: prefix + "trademarks.html",
      title: locale$u.maketext("Trademarks"),
      target: "_self",
    },
    ...COMMON_LINKS,
    {
      id: "lnkFooterDocs",
      href: docLink || "https://go.cpanel.net/cpaneldocsHome",
      target: "docs",
      title: locale$u.maketext("Documentation"),
    },
    {
      id: "lnkFooterFeedback",
      href: feedbackLinkData.url,
      target: feedbackLinkData.target,
      title: feedbackLinkData.title,
    },
  ];
  if (helpLink) {
    links.push({
      id: "lnkFooterHelp",
      href: helpLink,
      target: "help",
      title: locale$u.maketext("Help"),
    });
  }
  return links;
}
function getWHMLinks(prefix) {
  return [
    {
      id: "lnkFooterHome",
      href: prefix,
      title: locale$u.maketext("Home"),
      target: "_self",
    },
    {
      id: "lnkFooterTrademark",
      href: `${prefix}/scripts10/trademarks`,
      title: locale$u.maketext("Trademarks"),
      target: "_self",
    },
    ...COMMON_LINKS,
    {
      id: "lnkFooterDocs",
      href: "https://go.cpanel.net/whmdocs",
      target: "docs",
      title: locale$u.maketext("Documentation"),
    },
    {
      id: "lnkFooterFaq",
      href: "https://go.cpanel.net/allfaq",
      target: "support_faq",
      title: locale$u.maketext("[asis,cPanel amp() WHM] FAQ[comment,footer link text]"),
    },
    {
      id: "lnkFooterSupport",
      href: "https://go.cpanel.net/cpforum",
      target: "support_forums",
      title: locale$u.maketext("Support Forums"),
    },
    {
      id: "lnkFootercPUniversity",
      href: "https://university.cpanel.net/",
      target: "cp_university",
      title: locale$u.maketext("[asis,cPanel] University"),
    },
  ];
}

var IconMode;
(function (IconMode) {
  IconMode[IconMode["Inline"] = 0] = "Inline";
  IconMode[IconMode["Centered"] = 1] = "Centered";
})(IconMode || (IconMode = {}));

var IconSize;
(function (IconSize) {
  IconSize["xs"] = "ri-xs";
  IconSize["sm"] = "ri-sm";
  IconSize["lg"] = "ri-lg";
  IconSize["xl"] = "ri-xl";
})(IconSize || (IconSize = {}));

/*
# cpanel - ui/web-components/src/utils/dns-only.ts Copyright 2022 cPanel, L.L.C.
#                                                           All rights reserved.
# copyright@cpanel.net                                         http://cpanel.net
# This code is subject to the cPanel license. Unauthorized copying is prohibited
*/
/**
 * Returns true if it is a DNS only cPanel installation and the app being accessed is WHM.
 */
function isDnsOnly() {
  var _a;
  return ((_a = window["COMMON"]) === null || _a === void 0 ? void 0 : _a.isDnsOnly) && state.appName === AppName.Whm;
}

/**
 * Get the current notification count for the logged in user.
 * @returns A promise that resolves with the number of notifications for the logged in user.
 */
async function fetchNotificationCount() {
  const request = new UapiRequest({
    namespace: "Notifications",
    method: "get_notifications_count",
  }).generate();
  const pathBuilder = new ApplicationPath(new LocationService());
  const fullRequestUrl = pathBuilder.buildTokenPath(request.url);
  return fetch(fullRequestUrl)
    .then(response => response.json())
    .then(response => {
    const resp = new UapiResponse(response);
    if (!resp.status) {
      throw resp.messages.map(message => message.message);
    }
    return resp.data;
  })
    .catch(errors => {
    if (!Array.isArray(errors)) {
      errors = [errors];
    }
    errors.forEach(message => console.warn(`Error loading notifications: ${message}`));
  });
}

const cpHeaderNotificationsControlCss = ":host{display:block}a{border:1px solid var(--cp-primary-color);text-decoration:none;cursor:pointer;color:inherit;background:transparent;height:100%;width:100%;padding:var(--cp-spacer-2);display:flex;align-items:center;justify-content:center;box-sizing:border-box;border-radius:50%}";

/**
 * Fuse.js v6.6.2 - Lightweight fuzzy-search (http://fusejs.io)
 *
 * Copyright (c) 2022 Kiro Risk (http://kiro.me)
 * All Rights Reserved. Apache Software License 2.0
 *
 * http://www.apache.org/licenses/LICENSE-2.0
 */

function isArray(value) {
  return !Array.isArray
    ? getTag(value) === '[object Array]'
    : Array.isArray(value)
}

// Adapted from: https://github.com/lodash/lodash/blob/master/.internal/baseToString.js
const INFINITY = 1 / 0;
function baseToString(value) {
  // Exit early for strings to avoid a performance hit in some environments.
  if (typeof value == 'string') {
    return value
  }
  let result = value + '';
  return result == '0' && 1 / value == -INFINITY ? '-0' : result
}

function toString$1(value) {
  return value == null ? '' : baseToString(value)
}

function isString(value) {
  return typeof value === 'string'
}

function isNumber(value) {
  return typeof value === 'number'
}

// Adapted from: https://github.com/lodash/lodash/blob/master/isBoolean.js
function isBoolean(value) {
  return (
    value === true ||
    value === false ||
    (isObjectLike(value) && getTag(value) == '[object Boolean]')
  )
}

function isObject(value) {
  return typeof value === 'object'
}

// Checks if `value` is object-like.
function isObjectLike(value) {
  return isObject(value) && value !== null
}

function isDefined(value) {
  return value !== undefined && value !== null
}

function isBlank(value) {
  return !value.trim().length
}

// Gets the `toStringTag` of `value`.
// Adapted from: https://github.com/lodash/lodash/blob/master/.internal/getTag.js
function getTag(value) {
  return value == null
    ? value === undefined
      ? '[object Undefined]'
      : '[object Null]'
    : Object.prototype.toString.call(value)
}

const EXTENDED_SEARCH_UNAVAILABLE = 'Extended search is not available';

const INCORRECT_INDEX_TYPE = "Incorrect 'index' type";

const LOGICAL_SEARCH_INVALID_QUERY_FOR_KEY = (key) =>
  `Invalid value for key ${key}`;

const PATTERN_LENGTH_TOO_LARGE = (max) =>
  `Pattern length exceeds max of ${max}.`;

const MISSING_KEY_PROPERTY = (name) => `Missing ${name} property in key`;

const INVALID_KEY_WEIGHT_VALUE = (key) =>
  `Property 'weight' in key '${key}' must be a positive integer`;

const hasOwn = Object.prototype.hasOwnProperty;

class KeyStore {
  constructor(keys) {
    this._keys = [];
    this._keyMap = {};

let totalWeight = 0;

keys.forEach((key) => {
      let obj = createKey(key);

totalWeight += obj.weight;

this._keys.push(obj);
      this._keyMap[obj.id] = obj;

totalWeight += obj.weight;
    });

// Normalize weights so that their sum is equal to 1
    this._keys.forEach((key) => {
      key.weight /= totalWeight;
    });
  }
  get(keyId) {
    return this._keyMap[keyId]
  }
  keys() {
    return this._keys
  }
  toJSON() {
    return JSON.stringify(this._keys)
  }
}

function createKey(key) {
  let path = null;
  let id = null;
  let src = null;
  let weight = 1;
  let getFn = null;

if (isString(key) || isArray(key)) {
    src = key;
    path = createKeyPath(key);
    id = createKeyId(key);
  } else {
    if (!hasOwn.call(key, 'name')) {
      throw new Error(MISSING_KEY_PROPERTY('name'))
    }

const name = key.name;
    src = name;

if (hasOwn.call(key, 'weight')) {
      weight = key.weight;

if (weight <= 0) {
 throw new Error(INVALID_KEY_WEIGHT_VALUE(name))
 }
 }

path = createKeyPath(name);
    id = createKeyId(name);
    getFn = key.getFn;
  }

return { path, id, weight, src, getFn }
}

function createKeyPath(key) {
  return isArray(key) ? key : key.split('.')
}

function createKeyId(key) {
  return isArray(key) ? key.join('.') : key
}

function get$1(obj, path) {
  let list = [];
  let arr = false;

const deepGet = (obj, path, index) => {
    if (!isDefined(obj)) {
      return
    }
    if (!path[index]) {
      // If there's no path left, we've arrived at the object we care about.
      list.push(obj);
    } else {
      let key = path[index];

const value = obj[key];

if (!isDefined(value)) {
        return
      }

// If we're at the last value in the path, and if it's a string/number/bool,
 // add it to the list
 if (
 index === path.length - 1 &&
 (isString(value) || isNumber(value) || isBoolean(value))
 ) {
 list.push(toString$1(value));
 } else if (isArray(value)) {
 arr = true;
 // Search each item in the array.
 for (let i = 0, len = value.length; i < len; i += 1) {
 deepGet(value[i], path, index + 1);
 }
 } else if (path.length) {
 // An object. Recurse further.
 deepGet(value, path, index + 1);
 }
 }
 };

// Backwards compatibility (since path used to be a string)
  deepGet(obj, isString(path) ? path.split('.') : path, 0);

return arr ? list : list[0]
}

const MatchOptions = {
  // Whether the matches should be included in the result set. When `true`, each record in the result
  // set will include the indices of the matched characters.
  // These can consequently be used for highlighting purposes.
  includeMatches: false,
  // When `true`, the matching function will continue to the end of a search pattern even if
  // a perfect match has already been located in the string.
  findAllMatches: false,
  // Minimum number of characters that must be matched before a result is considered a match
  minMatchCharLength: 1
};

const BasicOptions = {
 // When `true`, the algorithm continues searching to the end of the input even if a perfect
 // match is found before the end of the same input.
 isCaseSensitive: false,
 // When true, the matching function will continue to the end of a search pattern even if
 includeScore: false,
 // List of properties that will be searched. This also supports nested properties.
 keys: [],
 // Whether to sort the result list, by score
 shouldSort: true,
 // Default sort function: sort by ascending score, ascending index
 sortFn: (a, b) =>
 a.score === b.score ? (a.idx < b.idx ? -1 : 1) : a.score < b.score ? -1 : 1
};

const FuzzyOptions = {
  // Approximately where in the text is the pattern expected to be found?
  location: 0,
  // At what point does the match algorithm give up. A threshold of '0.0' requires a perfect match
  // (of both letters and location), a threshold of '1.0' would match anything.
  threshold: 0.6,
  // Determines how close the match must be to the fuzzy location (specified above).
  // An exact letter match which is 'distance' characters away from the fuzzy location
  // would score as a complete mismatch. A distance of '0' requires the match be at
  // the exact location specified, a threshold of '1000' would require a perfect match
  // to be within 800 characters of the fuzzy location to be found using a 0.8 threshold.
  distance: 100
};

const AdvancedOptions = {
  // When `true`, it enables the use of unix-like search commands
  useExtendedSearch: false,
  // The get function to use when fetching an object's properties.
  // The default will search nested paths *ie foo.bar.baz*
  getFn: get$1,
  // When `true`, search will ignore `location` and `distance`, so it won't matter
  // where in the string the pattern appears.
  // More info: https://fusejs.io/concepts/scoring-theory.html#fuzziness-score
  ignoreLocation: false,
  // When `true`, the calculation for the relevance score (used for sorting) will
  // ignore the field-length norm.
  // More info: https://fusejs.io/concepts/scoring-theory.html#field-length-norm
  ignoreFieldNorm: false,
  // The weight to determine how much field length norm effects scoring.
  fieldNormWeight: 1
};

var Config$1 = {
  ...BasicOptions,
  ...MatchOptions,
  ...FuzzyOptions,
  ...AdvancedOptions
};

const SPACE = /[^ ]+/g;

// Field-length norm: the shorter the field, the higher the weight.
// Set to 3 decimals to reduce index size.
function norm(weight = 1, mantissa = 3) {
  const cache = new Map();
  const m = Math.pow(10, mantissa);

return {
    get(value) {
      const numTokens = value.match(SPACE).length;

if (cache.has(numTokens)) {
        return cache.get(numTokens)
      }

// Default function is 1/sqrt(x), weight makes that variable
      const norm = 1 / Math.pow(numTokens, 0.5 * weight);

// In place of `toFixed(mantissa)`, for faster computation
      const n = parseFloat(Math.round(norm * m) / m);

cache.set(numTokens, n);

return n
    },
    clear() {
      cache.clear();
    }
  }
}

class FuseIndex {
  constructor({
    getFn = Config$1.getFn,
    fieldNormWeight = Config$1.fieldNormWeight
  } = {}) {
    this.norm = norm(fieldNormWeight, 3);
    this.getFn = getFn;
    this.isCreated = false;

this.setIndexRecords();
  }
  setSources(docs = []) {
    this.docs = docs;
  }
  setIndexRecords(records = []) {
    this.records = records;
  }
  setKeys(keys = []) {
    this.keys = keys;
    this._keysMap = {};
    keys.forEach((key, idx) => {
      this._keysMap[key.id] = idx;
    });
  }
  create() {
    if (this.isCreated || !this.docs.length) {
      return
    }

this.isCreated = true;

// List is Array<String>
 if (isString(this.docs[0])) {
 this.docs.forEach((doc, docIndex) => {
 this._addString(doc, docIndex);
 });
 } else {
 // List is Array<Object>
 this.docs.forEach((doc, docIndex) => {
 this._addObject(doc, docIndex);
 });
 }

this.norm.clear();
  }
  // Adds a doc to the end of the index
  add(doc) {
    const idx = this.size();

if (isString(doc)) {
      this._addString(doc, idx);
    } else {
      this._addObject(doc, idx);
    }
  }
  // Removes the doc at the specified index of the index
  removeAt(idx) {
    this.records.splice(idx, 1);

// Change ref index of every subsquent doc
 for (let i = idx, len = this.size(); i < len; i += 1) {
 this.records[i].i -= 1;
 }
 }
 getValueForItemAtKeyId(item, keyId) {
 return item[this._keysMap[keyId]]
 }
 size() {
 return this.records.length
 }
 _addString(doc, docIndex) {
 if (!isDefined(doc) || isBlank(doc)) {
 return
 }

let record = {
      v: doc,
      i: docIndex,
      n: this.norm.get(doc)
    };

this.records.push(record);
  }
  _addObject(doc, docIndex) {
    let record = { i: docIndex, $: {} };

// Iterate over every key (i.e, path), and fetch the value at that key
    this.keys.forEach((key, keyIndex) => {
      let value = key.getFn ? key.getFn(doc) : this.getFn(doc, key.path);

if (!isDefined(value)) {
        return
      }

if (isArray(value)) {
        let subRecords = [];
        const stack = [{ nestedArrIndex: -1, value }];

while (stack.length) {
          const { nestedArrIndex, value } = stack.pop();

if (!isDefined(value)) {
            continue
          }

if (isString(value) && !isBlank(value)) {
            let subRecord = {
              v: value,
              i: nestedArrIndex,
              n: this.norm.get(value)
            };

subRecords.push(subRecord);
          } else if (isArray(value)) {
            value.forEach((item, k) => {
              stack.push({
                nestedArrIndex: k,
                value: item
              });
            });
          } else ;
        }
        record.$[keyIndex] = subRecords;
      } else if (isString(value) && !isBlank(value)) {
        let subRecord = {
          v: value,
          n: this.norm.get(value)
        };

record.$[keyIndex] = subRecord;
      }
    });

this.records.push(record);
  }
  toJSON() {
    return {
      keys: this.keys,
      records: this.records
    }
  }
}

function computeScore$1(
  pattern,
  {
    errors = 0,
    currentLocation = 0,
    expectedLocation = 0,
    distance = Config$1.distance,
    ignoreLocation = Config$1.ignoreLocation
  } = {}
) {
  const accuracy = errors / pattern.length;

if (ignoreLocation) {
    return accuracy
  }

const proximity = Math.abs(expectedLocation - currentLocation);

if (!distance) {
    // Dodge divide by zero error.
    return proximity ? 1.0 : accuracy
  }

return accuracy + proximity / distance
}

function convertMaskToIndices(
  matchmask = [],
  minMatchCharLength = Config$1.minMatchCharLength
) {
  let indices = [];
  let start = -1;
  let end = -1;
  let i = 0;

for (let len = matchmask.length; i < len; i += 1) {
 let match = matchmask[i];
 if (match && start === -1) {
 start = i;
 } else if (!match && start !== -1) {
 end = i - 1;
 if (end - start + 1 >= minMatchCharLength) {
 indices.push([start, end]);
 }
 start = -1;
 }
 }

// (i-1 - start) + 1 => i - start
  if (matchmask[i - 1] && i - start >= minMatchCharLength) {
    indices.push([start, i - 1]);
  }

return indices
}

// Machine word size
const MAX_BITS = 32;

function search(
  text,
  pattern,
  patternAlphabet,
  {
    location = Config$1.location,
    distance = Config$1.distance,
    threshold = Config$1.threshold,
    findAllMatches = Config$1.findAllMatches,
    minMatchCharLength = Config$1.minMatchCharLength,
    includeMatches = Config$1.includeMatches,
    ignoreLocation = Config$1.ignoreLocation
  } = {}
) {
  if (pattern.length > MAX_BITS) {
    throw new Error(PATTERN_LENGTH_TOO_LARGE(MAX_BITS))
  }

const patternLen = pattern.length;
  // Set starting location at beginning text and initialize the alphabet.
  const textLen = text.length;
  // Handle the case when location > text.length
  const expectedLocation = Math.max(0, Math.min(location, textLen));
  // Highest score beyond which we give up.
  let currentThreshold = threshold;
  // Is there a nearby exact match? (speedup)
  let bestLocation = expectedLocation;

// Performance: only computer matches when the minMatchCharLength > 1
  // OR if `includeMatches` is true.
  const computeMatches = minMatchCharLength > 1 || includeMatches;
  // A mask of the matches, used for building the indices
  const matchMask = computeMatches ? Array(textLen) : [];

let index;

// Get all exact matches, here for speed up
  while ((index = text.indexOf(pattern, bestLocation)) > -1) {
    let score = computeScore$1(pattern, {
      currentLocation: index,
      expectedLocation,
      distance,
      ignoreLocation
    });

currentThreshold = Math.min(score, currentThreshold);
    bestLocation = index + patternLen;

if (computeMatches) {
 let i = 0;
 while (i < patternLen) {
 matchMask[index + i] = 1;
 i += 1;
 }
 }
 }

// Reset the best location
  bestLocation = -1;

let lastBitArr = [];
  let finalScore = 1;
  let binMax = patternLen + textLen;

const mask = 1 << (patternLen - 1);

for (let i = 0; i < patternLen; i += 1) {
 // Scan for the best match; each iteration allows for one more error.
 // Run a binary search to determine how far from the match location we can stray
 // at this error level.
 let binMin = 0;
 let binMid = binMax;

while (binMin < binMid) {
 const score = computeScore$1(pattern, {
 errors: i,
 currentLocation: expectedLocation + binMid,
 expectedLocation,
 distance,
 ignoreLocation
 });

if (score <= currentThreshold) {
 binMin = binMid;
 } else {
 binMax = binMid;
 }

binMid = Math.floor((binMax - binMin) / 2 + binMin);
    }

// Use the result from this iteration as the maximum for the next.
    binMax = binMid;

let start = Math.max(1, expectedLocation - binMid + 1);
    let finish = findAllMatches
      ? textLen
      : Math.min(expectedLocation + binMid, textLen) + patternLen;

// Initialize the bit array
    let bitArr = Array(finish + 2);

bitArr[finish + 1] = (1 << i) - 1;

for (let j = finish; j >= start; j -= 1) {
      let currentLocation = j - 1;
      let charMatch = patternAlphabet[text.charAt(currentLocation)];

if (computeMatches) {
        // Speed up: quick bool to int conversion (i.e, `charMatch ? 1 : 0`)
        matchMask[currentLocation] = +!!charMatch;
      }

// First pass: exact match
 bitArr[j] = ((bitArr[j + 1] << 1) | 1) & charMatch;

// Subsequent passes: fuzzy match
 if (i) {
 bitArr[j] |=
 ((lastBitArr[j + 1] | lastBitArr[j]) << 1) | 1 | lastBitArr[j + 1];
 }

if (bitArr[j] & mask) {
        finalScore = computeScore$1(pattern, {
          errors: i,
          currentLocation,
          expectedLocation,
          distance,
          ignoreLocation
        });

// This match will almost certainly be better than any existing match.
 // But check anyway.
 if (finalScore <= currentThreshold) {
 // Indeed it is
 currentThreshold = finalScore;
 bestLocation = currentLocation;

// Already passed `loc`, downhill from here on in.
 if (bestLocation <= expectedLocation) {
 break
 }

// When passing `bestLocation`, don't exceed our current distance from `expectedLocation`.
          start = Math.max(1, 2 * expectedLocation - bestLocation);
        }
      }
    }

// No hope for a (better) match at greater error levels.
    const score = computeScore$1(pattern, {
      errors: i + 1,
      currentLocation: expectedLocation,
      expectedLocation,
      distance,
      ignoreLocation
    });

if (score > currentThreshold) {
      break
    }

lastBitArr = bitArr;
  }

const result = {
    isMatch: bestLocation >= 0,
    // Count exact matches (those with a score of 0) to be "almost" exact
    score: Math.max(0.001, finalScore)
  };

if (computeMatches) {
    const indices = convertMaskToIndices(matchMask, minMatchCharLength);
    if (!indices.length) {
      result.isMatch = false;
    } else if (includeMatches) {
      result.indices = indices;
    }
  }

return result
}

function createPatternAlphabet(pattern) {
  let mask = {};

for (let i = 0, len = pattern.length; i < len; i += 1) {
 const char = pattern.charAt(i);
 mask[char] = (mask[char] || 0) | (1 << (len - i - 1));
 }

return mask
}

class BitapSearch {
  constructor(
    pattern,
    {
      location = Config$1.location,
      threshold = Config$1.threshold,
      distance = Config$1.distance,
      includeMatches = Config$1.includeMatches,
      findAllMatches = Config$1.findAllMatches,
      minMatchCharLength = Config$1.minMatchCharLength,
      isCaseSensitive = Config$1.isCaseSensitive,
      ignoreLocation = Config$1.ignoreLocation
    } = {}
  ) {
    this.options = {
      location,
      threshold,
      distance,
      includeMatches,
      findAllMatches,
      minMatchCharLength,
      isCaseSensitive,
      ignoreLocation
    };

this.pattern = isCaseSensitive ? pattern : pattern.toLowerCase();

this.chunks = [];

if (!this.pattern.length) {
      return
    }

const addChunk = (pattern, startIndex) => {
      this.chunks.push({
        pattern,
        alphabet: createPatternAlphabet(pattern),
        startIndex
      });
    };

const len = this.pattern.length;

if (len > MAX_BITS) {
      let i = 0;
      const remainder = len % MAX_BITS;
      const end = len - remainder;

while (i < end) {
 addChunk(this.pattern.substr(i, MAX_BITS), i);
 i += MAX_BITS;
 }

if (remainder) {
        const startIndex = len - MAX_BITS;
        addChunk(this.pattern.substr(startIndex), startIndex);
      }
    } else {
      addChunk(this.pattern, 0);
    }
  }

searchIn(text) {
    const { isCaseSensitive, includeMatches } = this.options;

if (!isCaseSensitive) {
      text = text.toLowerCase();
    }

// Exact match
    if (this.pattern === text) {
      let result = {
        isMatch: true,
        score: 0
      };

if (includeMatches) {
        result.indices = [[0, text.length - 1]];
      }

return result
    }

// Otherwise, use Bitap algorithm
    const {
      location,
      distance,
      threshold,
      findAllMatches,
      minMatchCharLength,
      ignoreLocation
    } = this.options;

let allIndices = [];
    let totalScore = 0;
    let hasMatches = false;

this.chunks.forEach(({ pattern, alphabet, startIndex }) => {
      const { isMatch, score, indices } = search(text, pattern, alphabet, {
        location: location + startIndex,
        distance,
        threshold,
        findAllMatches,
        minMatchCharLength,
        includeMatches,
        ignoreLocation
      });

if (isMatch) {
        hasMatches = true;
      }

totalScore += score;

if (isMatch && indices) {
        allIndices = [...allIndices, ...indices];
      }
    });

let result = {
      isMatch: hasMatches,
      score: hasMatches ? totalScore / this.chunks.length : 1
    };

if (hasMatches && includeMatches) {
      result.indices = allIndices;
    }

return result
  }
}

class BaseMatch {
  constructor(pattern) {
    this.pattern = pattern;
  }
  static isMultiMatch(pattern) {
    return getMatch(pattern, this.multiRegex)
  }
  static isSingleMatch(pattern) {
    return getMatch(pattern, this.singleRegex)
  }
  search(/*text*/) {}
}

function getMatch(pattern, exp) {
  const matches = pattern.match(exp);
  return matches ? matches[1] : null
}

// Token: 'file

class ExactMatch extends BaseMatch {
  constructor(pattern) {
    super(pattern);
  }
  static get type() {
    return 'exact'
  }
  static get multiRegex() {
    return /^="(.*)"$/
  }
  static get singleRegex() {
    return /^=(.*)$/
  }
  search(text) {
    const isMatch = text === this.pattern;

return {
      isMatch,
      score: isMatch ? 0 : 1,
      indices: [0, this.pattern.length - 1]
    }
  }
}

// Token: !fire

class InverseExactMatch extends BaseMatch {
  constructor(pattern) {
    super(pattern);
  }
  static get type() {
    return 'inverse-exact'
  }
  static get multiRegex() {
    return /^!"(.*)"$/
  }
  static get singleRegex() {
    return /^!(.*)$/
  }
  search(text) {
    const index = text.indexOf(this.pattern);
    const isMatch = index === -1;

return {
      isMatch,
      score: isMatch ? 0 : 1,
      indices: [0, text.length - 1]
    }
  }
}

// Token: ^file

class PrefixExactMatch extends BaseMatch {
  constructor(pattern) {
    super(pattern);
  }
  static get type() {
    return 'prefix-exact'
  }
  static get multiRegex() {
    return /^\^"(.*)"$/
  }
  static get singleRegex() {
    return /^\^(.*)$/
  }
  search(text) {
    const isMatch = text.startsWith(this.pattern);

return {
      isMatch,
      score: isMatch ? 0 : 1,
      indices: [0, this.pattern.length - 1]
    }
  }
}

// Token: !^fire

class InversePrefixExactMatch extends BaseMatch {
  constructor(pattern) {
    super(pattern);
  }
  static get type() {
    return 'inverse-prefix-exact'
  }
  static get multiRegex() {
    return /^!\^"(.*)"$/
  }
  static get singleRegex() {
    return /^!\^(.*)$/
  }
  search(text) {
    const isMatch = !text.startsWith(this.pattern);

return {
      isMatch,
      score: isMatch ? 0 : 1,
      indices: [0, text.length - 1]
    }
  }
}

// Token: .file$

class SuffixExactMatch extends BaseMatch {
  constructor(pattern) {
    super(pattern);
  }
  static get type() {
    return 'suffix-exact'
  }
  static get multiRegex() {
    return /^"(.*)"\$$/
  }
  static get singleRegex() {
    return /^(.*)\$$/
  }
  search(text) {
    const isMatch = text.endsWith(this.pattern);

return {
      isMatch,
      score: isMatch ? 0 : 1,
      indices: [text.length - this.pattern.length, text.length - 1]
    }
  }
}

// Token: !.file$

class InverseSuffixExactMatch extends BaseMatch {
  constructor(pattern) {
    super(pattern);
  }
  static get type() {
    return 'inverse-suffix-exact'
  }
  static get multiRegex() {
    return /^!"(.*)"\$$/
  }
  static get singleRegex() {
    return /^!(.*)\$$/
  }
  search(text) {
    const isMatch = !text.endsWith(this.pattern);
    return {
      isMatch,
      score: isMatch ? 0 : 1,
      indices: [0, text.length - 1]
    }
  }
}

class FuzzyMatch extends BaseMatch {
  constructor(
    pattern,
    {
      location = Config$1.location,
      threshold = Config$1.threshold,
      distance = Config$1.distance,
      includeMatches = Config$1.includeMatches,
      findAllMatches = Config$1.findAllMatches,
      minMatchCharLength = Config$1.minMatchCharLength,
      isCaseSensitive = Config$1.isCaseSensitive,
      ignoreLocation = Config$1.ignoreLocation
    } = {}
  ) {
    super(pattern);
    this._bitapSearch = new BitapSearch(pattern, {
      location,
      threshold,
      distance,
      includeMatches,
      findAllMatches,
      minMatchCharLength,
      isCaseSensitive,
      ignoreLocation
    });
  }
  static get type() {
    return 'fuzzy'
  }
  static get multiRegex() {
    return /^"(.*)"$/
  }
  static get singleRegex() {
    return /^(.*)$/
  }
  search(text) {
    return this._bitapSearch.searchIn(text)
  }
}

// Token: 'file

class IncludeMatch extends BaseMatch {
  constructor(pattern) {
    super(pattern);
  }
  static get type() {
    return 'include'
  }
  static get multiRegex() {
    return /^'"(.*)"$/
  }
  static get singleRegex() {
    return /^'(.*)$/
  }
  search(text) {
    let location = 0;
    let index;

const indices = [];
    const patternLen = this.pattern.length;

// Get all exact matches
    while ((index = text.indexOf(this.pattern, location)) > -1) {
      location = index + patternLen;
      indices.push([index, location - 1]);
    }

const isMatch = !!indices.length;

return {
      isMatch,
      score: isMatch ? 0 : 1,
      indices
    }
  }
}

// ❗Order is important. DO NOT CHANGE.
const searchers = [
  ExactMatch,
  IncludeMatch,
  PrefixExactMatch,
  InversePrefixExactMatch,
  InverseSuffixExactMatch,
  SuffixExactMatch,
  InverseExactMatch,
  FuzzyMatch
];

const searchersLen = searchers.length;

// Regex to split by spaces, but keep anything in quotes together
const SPACE_RE = / +(?=(?:[^\"]*\"[^\"]*\")*[^\"]*$)/;
const OR_TOKEN = '|';

// Return a 2D array representation of the query, for simpler parsing.
// Example:
// "^core go$ | rb$ | py$ xy$" => [["^core", "go$"], ["rb$"], ["py$", "xy$"]]
function parseQuery(pattern, options = {}) {
  return pattern.split(OR_TOKEN).map((item) => {
    let query = item
      .trim()
      .split(SPACE_RE)
      .filter((item) => item && !!item.trim());

let results = [];
 for (let i = 0, len = query.length; i < len; i += 1) {
 const queryItem = query[i];

// 1. Handle multiple query match (i.e, once that are quoted, like `"hello world"`)
 let found = false;
 let idx = -1;
 while (!found && ++idx < searchersLen) {
 const searcher = searchers[idx];
 let token = searcher.isMultiMatch(queryItem);
 if (token) {
 results.push(new searcher(token, options));
 found = true;
 }
 }

if (found) {
        continue
      }

// 2. Handle single query matches (i.e, once that are *not* quoted)
 idx = -1;
 while (++idx < searchersLen) {
 const searcher = searchers[idx];
 let token = searcher.isSingleMatch(queryItem);
 if (token) {
 results.push(new searcher(token, options));
 break
 }
 }
 }

return results
  })
}

// These extended matchers can return an array of matches, as opposed
// to a singl match
const MultiMatchSet = new Set([FuzzyMatch.type, IncludeMatch.type]);

/**
 * Command-like searching
 * ======================
 *
 * Given multiple search terms delimited by spaces.e.g. `^jscript .python$ ruby !java`,
 * search in a given text.
 *
 * Search syntax:
 *
 * | Token       | Match type                 | Description                            |
 * | ----------- | -------------------------- | -------------------------------------- |
 * | `jscript`   | fuzzy-match                | Items that fuzzy match `jscript`       |
 * | `=scheme`   | exact-match                | Items that are `scheme`                |
 * | `'python`   | include-match              | Items that include `python`            |
 * | `!ruby`     | inverse-exact-match        | Items that do not include `ruby`       |
 * | `^java`     | prefix-exact-match         | Items that start with `java`           |
 * | `!^earlang` | inverse-prefix-exact-match | Items that do not start with `earlang` |
 * | `.js$`      | suffix-exact-match         | Items that end with `.js`              |
 * | `!.go$`     | inverse-suffix-exact-match | Items that do not end with `.go`       |
 *
 * A single pipe character acts as an OR operator. For example, the following
 * query matches entries that start with `core` and end with either`go`, `rb`,
 * or`py`.
 *
 * ```
 * ^core go$ | rb$ | py$
 * ```
 */
class ExtendedSearch {
  constructor(
    pattern,
    {
      isCaseSensitive = Config$1.isCaseSensitive,
      includeMatches = Config$1.includeMatches,
      minMatchCharLength = Config$1.minMatchCharLength,
      ignoreLocation = Config$1.ignoreLocation,
      findAllMatches = Config$1.findAllMatches,
      location = Config$1.location,
      threshold = Config$1.threshold,
      distance = Config$1.distance
    } = {}
  ) {
    this.query = null;
    this.options = {
      isCaseSensitive,
      includeMatches,
      minMatchCharLength,
      findAllMatches,
      ignoreLocation,
      location,
      threshold,
      distance
    };

this.pattern = isCaseSensitive ? pattern : pattern.toLowerCase();
    this.query = parseQuery(this.pattern, this.options);
  }

static condition(_, options) {
    return options.useExtendedSearch
  }

searchIn(text) {
    const query = this.query;

if (!query) {
      return {
        isMatch: false,
        score: 1
      }
    }

const { includeMatches, isCaseSensitive } = this.options;

text = isCaseSensitive ? text : text.toLowerCase();

let numMatches = 0;
    let allIndices = [];
    let totalScore = 0;

// ORs
 for (let i = 0, qLen = query.length; i < qLen; i += 1) {
 const searchers = query[i];

// Reset indices
      allIndices.length = 0;
      numMatches = 0;

// ANDs
 for (let j = 0, pLen = searchers.length; j < pLen; j += 1) {
 const searcher = searchers[j];
 const { isMatch, indices, score } = searcher.search(text);

if (isMatch) {
          numMatches += 1;
          totalScore += score;
          if (includeMatches) {
            const type = searcher.constructor.type;
            if (MultiMatchSet.has(type)) {
              allIndices = [...allIndices, ...indices];
            } else {
              allIndices.push(indices);
            }
          }
        } else {
          totalScore = 0;
          numMatches = 0;
          allIndices.length = 0;
          break
        }
      }

// OR condition, so if TRUE, return
      if (numMatches) {
        let result = {
          isMatch: true,
          score: totalScore / numMatches
        };

if (includeMatches) {
          result.indices = allIndices;
        }

return result
      }
    }

// Nothing was matched
    return {
      isMatch: false,
      score: 1
    }
  }
}

const registeredSearchers = [];

function register(...args) {
  registeredSearchers.push(...args);
}

function createSearcher(pattern, options) {
 for (let i = 0, len = registeredSearchers.length; i < len; i += 1) {
 let searcherClass = registeredSearchers[i];
 if (searcherClass.condition(pattern, options)) {
 return new searcherClass(pattern, options)
 }
 }

return new BitapSearch(pattern, options)
}

const LogicalOperator = {
  AND: '$and',
  OR: '$or'
};

const KeyType = {
  PATH: '$path',
  PATTERN: '$val'
};

const isExpression = (query) =>
  !!(query[LogicalOperator.AND] || query[LogicalOperator.OR]);

const isPath = (query) => !!query[KeyType.PATH];

const isLeaf = (query) =>
  !isArray(query) && isObject(query) && !isExpression(query);

const convertToExplicit = (query) => ({
  [LogicalOperator.AND]: Object.keys(query).map((key) => ({
    [key]: query[key]
  }))
});

// When `auto` is `true`, the parse function will infer and initialize and add
// the appropriate `Searcher` instance
function parse(query, options, { auto = true } = {}) {
  const next = (query) => {
    let keys = Object.keys(query);

const isQueryPath = isPath(query);

if (!isQueryPath && keys.length > 1 && !isExpression(query)) {
      return next(convertToExplicit(query))
    }

if (isLeaf(query)) {
      const key = isQueryPath ? query[KeyType.PATH] : keys[0];

const pattern = isQueryPath ? query[KeyType.PATTERN] : query[key];

if (!isString(pattern)) {
        throw new Error(LOGICAL_SEARCH_INVALID_QUERY_FOR_KEY(key))
      }

const obj = {
        keyId: createKeyId(key),
        pattern
      };

if (auto) {
        obj.searcher = createSearcher(pattern, options);
      }

return obj
    }

let node = {
      children: [],
      operator: keys[0]
    };

keys.forEach((key) => {
      const value = query[key];

if (isArray(value)) {
        value.forEach((item) => {
          node.children.push(next(item));
        });
      }
    });

return node
  };

if (!isExpression(query)) {
    query = convertToExplicit(query);
  }

return next(query)
}

// Practical scoring function
function computeScore(
  results,
  { ignoreFieldNorm = Config$1.ignoreFieldNorm }
) {
  results.forEach((result) => {
    let totalScore = 1;

result.matches.forEach(({ key, norm, score }) => {
      const weight = key ? key.weight : null;

totalScore *= Math.pow(
        score === 0 && weight ? Number.EPSILON : score,
        (weight || 1) * (ignoreFieldNorm ? 1 : norm)
      );
    });

result.score = totalScore;
  });
}

function transformMatches(result, data) {
  const matches = result.matches;
  data.matches = [];

if (!isDefined(matches)) {
    return
  }

matches.forEach((match) => {
    if (!isDefined(match.indices) || !match.indices.length) {
      return
    }

const { indices, value } = match;

let obj = {
      indices,
      value
    };

if (match.key) {
      obj.key = match.key.src;
    }

if (match.idx > -1) {
      obj.refIndex = match.idx;
    }

data.matches.push(obj);
  });
}

function transformScore(result, data) {
  data.score = result.score;
}

function format(
  results,
  docs,
  {
    includeMatches = Config$1.includeMatches,
    includeScore = Config$1.includeScore
  } = {}
) {
  const transformers = [];

if (includeMatches) transformers.push(transformMatches);
  if (includeScore) transformers.push(transformScore);

return results.map((result) => {
    const { idx } = result;

const data = {
      item: docs[idx],
      refIndex: idx
    };

if (transformers.length) {
      transformers.forEach((transformer) => {
        transformer(result, data);
      });
    }

return data
  })
}

class Fuse {
  constructor(docs, options = {}, index) {
    this.options = { ...Config$1, ...options };

if (
      this.options.useExtendedSearch &&
      !true
    ) {
      throw new Error(EXTENDED_SEARCH_UNAVAILABLE)
    }

this._keyStore = new KeyStore(this.options.keys);

this.setCollection(docs, index);
  }

setCollection(docs, index) {
    this._docs = docs;

if (index && !(index instanceof FuseIndex)) {
      throw new Error(INCORRECT_INDEX_TYPE)
    }

this._myIndex =
      index ||
      createIndex(this.options.keys, this._docs, {
        getFn: this.options.getFn,
        fieldNormWeight: this.options.fieldNormWeight
      });
  }

add(doc) {
    if (!isDefined(doc)) {
      return
    }

this._docs.push(doc);
    this._myIndex.add(doc);
  }

remove(predicate = (/* doc, idx */) => false) {
    const results = [];

for (let i = 0, len = this._docs.length; i < len; i += 1) {
 const doc = this._docs[i];
 if (predicate(doc, i)) {
 this.removeAt(i);
 i -= 1;
 len -= 1;

results.push(doc);
      }
    }

return results
  }

removeAt(idx) {
    this._docs.splice(idx, 1);
    this._myIndex.removeAt(idx);
  }

getIndex() {
    return this._myIndex
  }

search(query, { limit = -1 } = {}) {
    const {
      includeMatches,
      includeScore,
      shouldSort,
      sortFn,
      ignoreFieldNorm
    } = this.options;

let results = isString(query)
      ? isString(this._docs[0])
        ? this._searchStringList(query)
        : this._searchObjectList(query)
      : this._searchLogical(query);

computeScore(results, { ignoreFieldNorm });

if (shouldSort) {
      results.sort(sortFn);
    }

if (isNumber(limit) && limit > -1) {
      results = results.slice(0, limit);
    }

return format(results, this._docs, {
      includeMatches,
      includeScore
    })
  }

_searchStringList(query) {
    const searcher = createSearcher(query, this.options);
    const { records } = this._myIndex;
    const results = [];

// Iterate over every string in the index
    records.forEach(({ v: text, i: idx, n: norm }) => {
      if (!isDefined(text)) {
        return
      }

const { isMatch, score, indices } = searcher.searchIn(text);

if (isMatch) {
        results.push({
          item: text,
          idx,
          matches: [{ score, value: text, norm, indices }]
        });
      }
    });

return results
  }

_searchLogical(query) {

const expression = parse(query, this.options);

const evaluate = (node, item, idx) => {
      if (!node.children) {
        const { keyId, searcher } = node;

const matches = this._findMatches({
          key: this._keyStore.get(keyId),
          value: this._myIndex.getValueForItemAtKeyId(item, keyId),
          searcher
        });

if (matches && matches.length) {
          return [
            {
              idx,
              item,
              matches
            }
          ]
        }

return []
      }

const records = this._myIndex.records;
    const resultMap = {};
    const results = [];

records.forEach(({ $: item, i: idx }) => {
      if (isDefined(item)) {
        let expResults = evaluate(expression, item, idx);

if (expResults.length) {
          // Dedupe when adding
          if (!resultMap[idx]) {
            resultMap[idx] = { idx, item, matches: [] };
            results.push(resultMap[idx]);
          }
          expResults.forEach(({ matches }) => {
            resultMap[idx].matches.push(...matches);
          });
        }
      }
    });

return results
  }

_searchObjectList(query) {
    const searcher = createSearcher(query, this.options);
    const { keys, records } = this._myIndex;
    const results = [];

// List is Array<Object>
 records.forEach(({ $: item, i: idx }) => {
 if (!isDefined(item)) {
 return
 }

let matches = [];

// Iterate over every key (i.e, path), and fetch the value at that key
      keys.forEach((key, keyIndex) => {
        matches.push(
          ...this._findMatches({
            key,
            value: item[keyIndex],
            searcher
          })
        );
      });

if (matches.length) {
        results.push({
          idx,
          item,
          matches
        });
      }
    });

return results
  }
  _findMatches({ key, value, searcher }) {
    if (!isDefined(value)) {
      return []
    }

let matches = [];

if (isArray(value)) {
      value.forEach(({ v: text, i: idx, n: norm }) => {
        if (!isDefined(text)) {
          return
        }

const { isMatch, score, indices } = searcher.searchIn(text);

if (isMatch) {
          matches.push({
            score,
            key,
            value: text,
            idx,
            norm,
            indices
          });
        }
      });
    } else {
      const { v: text, n: norm } = value;

const { isMatch, score, indices } = searcher.searchIn(text);

if (isMatch) {
        matches.push({ score, key, value: text, norm, indices });
      }
    }

return matches
  }
}

Fuse.version = '6.6.2';
Fuse.createIndex = createIndex;
Fuse.parseIndex = parseIndex;
Fuse.config = Config$1;

{
  Fuse.parseQuery = parse;
}

{
  register(ExtendedSearch);
}

/* NOTE: tabindex attribute is required for Safari otherwise
    the links do not work and clicking one dismisses the dropdown. */
const toolSearchResult = (appEntry, index, directoryPrefix) => (h("li", null,
  h("a", { role: "row", class: "list-group-item list-group-item-action tool-result__container", href: appEntry.url_is_absolute ? appEntry.url : directoryPrefix + appEntry.url, target: appEntry.target, tabindex: "-1" },
    h("div", { id: "app-result" + index + "x0", role: "gridcell", class: "tool-result__main" },
      h("span", { class: "tool-result__heading", innerHTML: appEntry.name }),
      h("p", { class: "tool-result__description" }, appEntry.description)),
    h("p", { class: "tool-result__category" },
      h("span", { id: "app-result" + index + "x1", role: "gridcell" }, appEntry.category)))));

/* NOTE: tabindex attribute is required for Safari otherwise
the links do not work and clicking one dismisses the dropdown. */
const accountSearchResult = (account, cpSecurityToken, permissions, whmUser) => {
  let canWhmUserAccessAccount = false;
  if (whmUser) {
    if ((permissions === null || permissions === void 0 ? void 0 : permissions.impersonateAccountTweakSettingValue) === "owner_root" &&
      (whmUser === "root" || whmUser === account.owner)) {
      canWhmUserAccessAccount = true;
    }
    else if ((permissions === null || permissions === void 0 ? void 0 : permissions.impersonateAccountTweakSettingValue) === "owner" && whmUser === account.owner) {
      canWhmUserAccessAccount = true;
    }
  }
  return (h("li", { role: "row", class: "list-group-item account-result__container" },
    h("div", { class: "account-result__main_section" },
      h("p", { class: "account-result__username" }, account.user),
      h("a", { tabindex: "0", class: "account-result__domain", target: "_blank", href: "https://" + account.domain }, account.domain)),
    h("div", { class: "account-result__action-section" },
      (permissions === null || permissions === void 0 ? void 0 : permissions.modifyAccount) && (h("form", { tabindex: "-1", class: "text-center", method: "GET", action: cpSecurityToken + "/scripts/edituser" },
        h("input", { type: "hidden", name: "user", value: account.user }),
        h("input", { type: "hidden", name: "domain", value: account.domain }),
        h("button", { tabindex: "0", id: "account-result__modify-" + account.user, class: "button--rounded", role: "gridcell" },
          h("cp-icon", { class: "button__pencil-icon", name: "pencil-fill", size: IconSize.xl, mode: IconMode.Centered })))),
      canWhmUserAccessAccount && (h("form", { tabindex: "-1", class: "text-center", method: "POST", target: "_blank", action: "/xfercpanel" },
        h("input", { type: "hidden", name: "token", value: cpSecurityToken.replace(/\/+$/, "") }),
        h("input", { type: "hidden", name: "user", value: account.user }),
        h("button", { tabindex: "0", id: "account-result__impersonate" + account.user, type: "submit", class: "button--rounded button__image-container", role: "gridcell" },
          h("img", { class: "button__image", src: getAssetPath("./assets/cp-logo.svg"), alt: "cpanel logo" })))))));
};

/**
# cpanel - ui/web-components/src/components/header/cp-header-search/fuzzy-search.config.ts
#                                                  Copyright 2022 cPanel, L.L.C.
#                                                           All rights reserved.
# copyright@cpanel.net                                         http://cpanel.net
# This code is subject to the cPanel license. Unauthorized copying is prohibited
 */
const SEARCH_OPTIONS = {
  keys: [
    {
      name: "name",
      weight: 3,
    },
    {
      name: "searchText",
      weight: 3,
    },
    {
      name: "category",
      weight: 1,
    },
    {
      name: "description",
      weight: 1,
    },
  ],
  includeMatches: true,
};
const WHM_MAIN_MENU_SEARCH_OPTIONS = Object.assign(Object.assign({}, SEARCH_OPTIONS), { 
  // Reduce threshold to tighten up the search relevance. This helps in reducing the number of
  // non-relevant matches.
  threshold: 0.3 });

/**
# cpanel - ui/web-components/src/components/shared/services/whm/list-accounts.service.ts
#                                                  Copyright 2022 cPanel, L.L.C.
#                                                           All rights reserved.
# copyright@cpanel.net                                         http://cpanel.net
# This code is subject to the cPanel license. Unauthorized copying is prohibited
 */
const LIST_ACCOUNTS_FN = "listaccts";
const DEFAULT_MAX_RESULTS = 5;
const SEARCH_ARGUMENT_NAME = "search";
const LIST_ACCOUNTS_PATH = "scripts4/listaccts";
const WANT_ARGUMENT = new Argument("want", "user,domain,owner");
const SEARCH_TYPE_ARGUMENT = new Argument("searchtype", "domain_and_user");
/**
 * Can be used to fetch Account data and generate a path to the list account page.
 */
const ListAccountsService = {
  /**
   * Fetches the accounts for the search value provided.
   */
  getAccounts(searchValue, resultsToDisplayCount = DEFAULT_MAX_RESULTS) {
    const pager = new Pager(1, resultsToDisplayCount);
    const request = new WhmApiRequest(WhmApiType.JsonApi, {
      method: LIST_ACCOUNTS_FN,
      arguments: [SEARCH_TYPE_ARGUMENT, WANT_ARGUMENT, new Argument(SEARCH_ARGUMENT_NAME, searchValue)],
      pager,
    });
    const requestInfo = request.generate({
      verb: HttpVerb.GET,
      encoder: new WwwFormUrlArgumentEncoder(),
    });
    const pathBuilder = new ApplicationPath(new LocationService());
    const requestUrl = pathBuilder.buildTokenPath(requestInfo.url);
    let resultP = fetch(requestUrl)
      .then(response => response.json())
      .then(data => {
      var _a, _b, _c;
      if (!data.metadata.result) {
        throw data.metadata.reason;
      }
      let accounts = (_a = data === null || data === void 0 ? void 0 : data.data) === null || _a === void 0 ? void 0 : _a.acct.map(a => {
        return Object.assign(Object.assign({}, a), { name: a.user });
      });
      return {
        accounts: accounts || [],
        records: (_c = (_b = data === null || data === void 0 ? void 0 : data.metadata) === null || _b === void 0 ? void 0 : _b.chunk) === null || _c === void 0 ? void 0 : _c.records,
      };
    });
    resultP.catch(console.error);
    return resultP;
  },
  /**
   * The link to the list accounts page with the user's query preselected.
   */
  getRelativePathToListAccountsPage(searchValue) {
    const pathBuilder = new ApplicationPath(new LocationService());
    const searchParams = new URLSearchParams({
      [SEARCH_ARGUMENT_NAME]: searchValue,
      [SEARCH_TYPE_ARGUMENT.name]: SEARCH_TYPE_ARGUMENT.value,
    }).toString();
    return `${pathBuilder.securityToken}/${LIST_ACCOUNTS_PATH}?${searchParams}`;
  },
};

/**
# cpanel - ui/web-components/src/components/shared/classes/combobox.ts
#                                                  Copyright 2022 cPanel, L.L.C.
#                                                           All rights reserved.
# copyright@cpanel.net                                         http://cpanel.net
# This code is subject to the cPanel license. Unauthorized copying is prohibited
 */
class Combobox {
  constructor(el) {
    this.el = el;
  }
  get elements() {
    return Array.from(this.el.querySelectorAll("[role=row], [role=gridcell]"));
  }
  get activeElementId() {
    return this.el.getAttribute("aria-activedecendant");
  }
  get currentIndex() {
    return this.elements.findIndex(el => el.id == this.activeElementId);
  }
  get currentRow() {
    if (!this.currentGridcell) {
      return;
    }
    return this.previous(is_row);
  }
  render() {
    var _a, _b;
    (_a = this.currentGridcell) === null || _a === void 0 ? void 0 : _a.classList.add("active");
    (_b = this.currentRow) === null || _b === void 0 ? void 0 : _b.classList.add("active");
  }
  clearActive() {
    var _a, _b;
    (_a = this.currentGridcell) === null || _a === void 0 ? void 0 : _a.classList.remove("active");
    (_b = this.currentRow) === null || _b === void 0 ? void 0 : _b.classList.remove("active");
  }
  /**
   * Sets the element as the focused element for the grid popup
   * and updates the DOM to reflect the changes. If the element has
   * a role of row, it will search for the first gridcell and set that
   * as the focused element.
   * @param element HTMLElement
   */
  goTo(element) {
    this.clearActive();
    if (!element) {
      this.el.removeAttribute("aria-activedecendant");
    }
    if (is_row(element)) {
      const gridcell = element.querySelector("[role=gridcell]");
      this.el.setAttribute("aria-activedecendant", gridcell.id);
    }
    if (is_gridcell(element)) {
      this.el.setAttribute("aria-activedecendant", element.id);
    }
    this.render();
  }
  /**
   * returns the currently focused gridcell
   * or undefined if you havent specified a row or gridcell
   * with the goTo function
   * @returns HTMLElement | undefined
   */
  get currentGridcell() {
    return this.elements.find(el => el.id == this.activeElementId);
  }
  next(predicate) {
    const element = this.elements.slice(this.currentIndex + 1).find(predicate);
    if (element) {
      return element;
    }
    return this.elements.find(predicate);
  }
  previous(predicate) {
    const element = this.elements.slice(0, this.currentIndex).reverse().find(predicate);
    if (element) {
      return element;
    }
    return this.elements.reverse().find(predicate);
  }
  /**
   * return the next gridcell element of the grid popup
   * based on the currently focused gridcell.
   * If the currenlty focused gridcell is the last one, it then
   * returns the first one.
   * @returns HTMLElement
   */
  get nextGridcell() {
    return this.next(is_gridcell);
  }
  /**
   * return the previous gridcell element of the grid popup
   * based on the currently focused gridcell.
   * If the currenlty focused gridcell is the first one, it then
   * returns the last one.
   * @returns HTMLElement
   */
  get previousGridcell() {
    return this.previous(is_gridcell);
  }
  /**
   * return the next row element of the grid popup
   * based on the currently focused gridcell.
   * If the currenlty focused row is the first one, it then
   * returns the last one.
   * @returns HTMLElement
   */
  get nextRow() {
    return this.next(is_row);
  }
  /**
   * return the previous row element of the grid popup
   * based on the currently focused gridcell.
   * If the currenlty focused row is the last one, it then
   * returns the first one.
   * @returns HTMLElement
   */
  get previousRow() {
    return this.previous(e => is_row(e) && this.currentRow != e);
  }
  /**
   * return the first element of the grid popup, usually
   * an element with a role of 'row'
   * @returns HTMLElement
   */
  get firstElement() {
    return this.elements[0];
  }
}
/**
 * Checks whether the element passed contains the
 * attribute role set to 'row'
 * @param element HTMLElement
 * @returns boolean
 */
function is_row(element) {
  return (element === null || element === void 0 ? void 0 : element.getAttribute("role")) == "row";
}
/**
 * Checks whether the element passed contains the
 * attribute role set to 'gridcell'
 * @param element HTMLElement
 * @returns boolean
 */
function is_gridcell(element) {
  return (element === null || element === void 0 ? void 0 : element.getAttribute("role")) == "gridcell";
}

/**
# cpanel - ui/web-components/src/utils/dom-utils.ts
#                                                  Copyright 2022 cPanel, L.L.C.
#                                                           All rights reserved.
# copyright@cpanel.net                                         http://cpanel.net
# This code is subject to the cPanel license. Unauthorized copying is prohibited
 */
/**
 * A recursive funtion that will return the internal element that has focus, even if it's inside a shadow root.
 *
 * Note: Due to how active element is retargeted in shadow DOM, it becomes difficult to access the actual element that is focussed at any instant.
 * So we had to use the recursive function to traverse through the element DOM to find the right one.
 * Reference URL: https://www.abeautifulsite.net/posts/finding-the-active-element-in-a-shadow-root/
 */
function getActiveElement(root = document) {
  const activeEl = root.activeElement;
  if (!activeEl) {
    return null;
  }
  if (activeEl.shadowRoot) {
    return getActiveElement(activeEl.shadowRoot);
  }
  else {
    return activeEl;
  }
}

// Copyright 2022 cPanel, L.L.C. - All rights reserved.
// copyright@cpanel.net
// https://cpanel.net
// This code is subject to the cPanel license. Unauthorized copying is prohibited
/**
 * Viewport sizes as defined by Bootstrap
 */
var ViewportSize;
(function (ViewportSize) {
  ViewportSize["xs"] = "xs";
  ViewportSize["sm"] = "sm";
  ViewportSize["md"] = "md";
  ViewportSize["lg"] = "lg";
  ViewportSize["xl"] = "xl";
})(ViewportSize || (ViewportSize = {}));

/**
# cpanel - ui/web-components/src/utils/base-api.ts Copyright 2022 cPanel, L.L.C.
#                                                           All rights reserved.
# copyright@cpanel.net                                         http://cpanel.net
# This code is subject to the cPanel license. Unauthorized copying is prohibited
 */
/**
 * *DO NOT USE THIS* unless for some reason @cpanel/api doesn’t work for you.
 *
 * Returns the base-url for a cPanel API call.
 */
function buildRequestURL(securityToken, api) {
  return `${securityToken}/json-api/${api}`;
}

/**
# cpanel - ui/web-components/src/components/shared/models/load-average.model.ts
#                                                  Copyright 2022 cPanel, L.L.C.
#                                                           All rights reserved.
# copyright@cpanel.net                                         http://cpanel.net
# This code is subject to the cPanel license. Unauthorized copying is prohibited
 */
/**
 * A single load average data point.
 */
class LoadAverages {
  /**
   * Type safe class for the load average data.
   *
   * @param data - The load average data to plug into the class.
   */
  constructor(data) {
    this.fifteen = +data.fifteen;
    this.five = +data.five;
    this.one = +data.one;
  }
}

/**
# cpanel - ui/web-components/src/components/shared/services/whm/load-average.service.ts
#                                                  Copyright 2022 cPanel, L.L.C.
#                                                           All rights reserved.
# copyright@cpanel.net                                         http://cpanel.net
# This code is subject to the cPanel license. Unauthorized copying is prohibited
 */
let abortController;
function abort() {
  if (abortController) {
    abortController.abort();
    abortController = undefined;
  }
}
/**
 * Fetches a sample of the one, five, and fifteen minute server load averages.
 *
 * @param securityToken The current session token.
 * @returns The latest linux load average sample via an api call back to the server.
 */
function get(securityToken) {
  const url = buildRequestURL(securityToken, "loadavg");
  abortController = new AbortController();
  return fetch(url, {
    method: "GET",
    cache: "no-cache",
    signal: abortController.signal,
  })
    .then(resp => {
    return resp.json();
  })
    .then(data => {
    if (data.cpanelresult && data.cpanelresult.error) {
      throw data.cpanelresult.error;
    }
    return new LoadAverages(data);
  });
}

var Config = {
    DEBUG: false,
    LIB_VERSION: '2.49.0'
};

// since es6 imports are static and we run unit tests from the console, window won't be defined when importing this file
var window$1;
if (typeof(window) === 'undefined') {
    var loc = {
        hostname: ''
    };
    window$1 = {
        navigator: { userAgent: '' },
        document: {
            location: loc,
            referrer: ''
        },
        screen: { width: 0, height: 0 },
        location: loc
    };
} else {
    window$1 = window;
}

/*
 * Saved references to long variable names, so that closure compiler can
 * minimize file size.
 */

// Console override
var console$1 = {
    /** @type {function(...*)} */
    log: function() {
        if (Config.DEBUG && !_.isUndefined(windowConsole) && windowConsole) {
            try {
                windowConsole.log.apply(windowConsole, arguments);
            } catch (err) {
                _.each(arguments, function(arg) {
                    windowConsole.log(arg);
                });
            }
        }
    },
    /** @type {function(...*)} */
    warn: function() {
        if (Config.DEBUG && !_.isUndefined(windowConsole) && windowConsole) {
            var args = ['Mixpanel warning:'].concat(_.toArray(arguments));
            try {
                windowConsole.warn.apply(windowConsole, args);
            } catch (err) {
                _.each(args, function(arg) {
                    windowConsole.warn(arg);
                });
            }
        }
    },
    /** @type {function(...*)} */
    error: function() {
        if (Config.DEBUG && !_.isUndefined(windowConsole) && windowConsole) {
            var args = ['Mixpanel error:'].concat(_.toArray(arguments));
            try {
                windowConsole.error.apply(windowConsole, args);
            } catch (err) {
                _.each(args, function(arg) {
                    windowConsole.error(arg);
                });
            }
        }
    },
    /** @type {function(...*)} */
    critical: function() {
        if (!_.isUndefined(windowConsole) && windowConsole) {
            var args = ['Mixpanel error:'].concat(_.toArray(arguments));
            try {
                windowConsole.error.apply(windowConsole, args);
            } catch (err) {
                _.each(args, function(arg) {
                    windowConsole.error(arg);
                });
            }
        }
    }
};

// UNDERSCORE
// Embed part of the Underscore Library
_.bind = function(func, context) {
    var args, bound;
    if (nativeBind && func.bind === nativeBind) {
        return nativeBind.apply(func, slice.call(arguments, 1));
    }
    if (!_.isFunction(func)) {
        throw new TypeError();
    }
    args = slice.call(arguments, 2);
    bound = function() {
        if (!(this instanceof bound)) {
            return func.apply(context, args.concat(slice.call(arguments)));
        }
        var ctor = {};
        ctor.prototype = func.prototype;
        var self = new ctor();
        ctor.prototype = null;
        var result = func.apply(self, args.concat(slice.call(arguments)));
        if (Object(result) === result) {
            return result;
        }
        return self;
    };
    return bound;
};

/**
 * @param {*=} obj
 * @param {function(...*)=} iterator
 * @param {Object=} context
 */
_.each = function(obj, iterator, context) {
 if (obj === null || obj === undefined) {
 return;
 }
 if (nativeForEach && obj.forEach === nativeForEach) {
 obj.forEach(iterator, context);
 } else if (obj.length === +obj.length) {
 for (var i = 0, l = obj.length; i < l; i++) {
 if (i in obj && iterator.call(context, obj[i], i, obj) === breaker) {
 return;
 }
 }
 } else {
 for (var key in obj) {
 if (hasOwnProperty.call(obj, key)) {
 if (iterator.call(context, obj[key], key, obj) === breaker) {
 return;
 }
 }
 }
 }
};

_.extend = function(obj) {
    _.each(slice.call(arguments, 1), function(source) {
        for (var prop in source) {
            if (source[prop] !== void 0) {
                obj[prop] = source[prop];
            }
        }
    });
    return obj;
};

_.isArray = nativeIsArray || function(obj) {
    return toString.call(obj) === '[object Array]';
};

// from a comment on http://dbj.org/dbj/?p=286
// fails on only one very rare and deliberate custom object:
// var bomb = { toString : undefined, valueOf: function(o) { return "function BOMBA!"; }};
_.isFunction = function(f) {
    try {
        return /^\s*\bfunction\b/.test(f);
    } catch (x) {
        return false;
    }
};

_.isArguments = function(obj) {
    return !!(obj && hasOwnProperty.call(obj, 'callee'));
};

_.toArray = function(iterable) {
    if (!iterable) {
        return [];
    }
    if (iterable.toArray) {
        return iterable.toArray();
    }
    if (_.isArray(iterable)) {
        return slice.call(iterable);
    }
    if (_.isArguments(iterable)) {
        return slice.call(iterable);
    }
    return _.values(iterable);
};

_.map = function(arr, callback, context) {
    if (nativeMap && arr.map === nativeMap) {
        return arr.map(callback, context);
    } else {
        var results = [];
        _.each(arr, function(item) {
            results.push(callback.call(context, item));
        });
        return results;
    }
};

_.keys = function(obj) {
    var results = [];
    if (obj === null) {
        return results;
    }
    _.each(obj, function(value, key) {
        results[results.length] = key;
    });
    return results;
};

_.values = function(obj) {
    var results = [];
    if (obj === null) {
        return results;
    }
    _.each(obj, function(value) {
        results[results.length] = value;
    });
    return results;
};

_.include = function(obj, target) {
    var found = false;
    if (obj === null) {
        return found;
    }
    if (nativeIndexOf && obj.indexOf === nativeIndexOf) {
        return obj.indexOf(target) != -1;
    }
    _.each(obj, function(value) {
        if (found || (found = (value === target))) {
            return breaker;
        }
    });
    return found;
};

_.includes = function(str, needle) {
    return str.indexOf(needle) !== -1;
};

// Underscore Addons
_.inherit = function(subclass, superclass) {
    subclass.prototype = new superclass();
    subclass.prototype.constructor = subclass;
    subclass.superclass = superclass.prototype;
    return subclass;
};

_.isObject = function(obj) {
    return (obj === Object(obj) && !_.isArray(obj));
};

_.isEmptyObject = function(obj) {
    if (_.isObject(obj)) {
        for (var key in obj) {
            if (hasOwnProperty.call(obj, key)) {
                return false;
            }
        }
        return true;
    }
    return false;
};

_.isUndefined = function(obj) {
    return obj === void 0;
};

_.isString = function(obj) {
    return toString.call(obj) == '[object String]';
};

_.isDate = function(obj) {
    return toString.call(obj) == '[object Date]';
};

_.isNumber = function(obj) {
    return toString.call(obj) == '[object Number]';
};

_.isElement = function(obj) {
    return !!(obj && obj.nodeType === 1);
};

_.encodeDates = function(obj) {
    _.each(obj, function(v, k) {
        if (_.isDate(v)) {
            obj[k] = _.formatDate(v);
        } else if (_.isObject(v)) {
            obj[k] = _.encodeDates(v); // recurse
        }
    });
    return obj;
};

_.timestamp = function() {
    Date.now = Date.now || function() {
        return +new Date;
    };
    return Date.now();
};

_.formatDate = function(d) {
 // YYYY-MM-DDTHH:MM:SS in UTC
 function pad(n) {
 return n < 10 ? '0' + n : n;
 }
 return d.getUTCFullYear() + '-' +
 pad(d.getUTCMonth() + 1) + '-' +
 pad(d.getUTCDate()) + 'T' +
 pad(d.getUTCHours()) + ':' +
 pad(d.getUTCMinutes()) + ':' +
 pad(d.getUTCSeconds());
};

_.strip_empty_properties = function(p) {
    var ret = {};
    _.each(p, function(v, k) {
        if (_.isString(v) && v.length > 0) {
            ret[k] = v;
        }
    });
    return ret;
};

/*
 * this function returns a copy of object after truncating it.  If
 * passed an Array or Object it will iterate through obj and
 * truncate all the values recursively.
 */
_.truncate = function(obj, length) {
    var ret;

if (typeof(obj) === 'string') {
        ret = obj.slice(0, length);
    } else if (_.isArray(obj)) {
        ret = [];
        _.each(obj, function(val) {
            ret.push(_.truncate(val, length));
        });
    } else if (_.isObject(obj)) {
        ret = {};
        _.each(obj, function(val, key) {
            ret[key] = _.truncate(val, length);
        });
    } else {
        ret = obj;
    }

return ret;
};

_.JSONEncode = (function() {
    return function(mixed_val) {
        var value = mixed_val;
        var quote = function(string) {
            var escapable = /[\\"\x00-\x1f\x7f-\x9f\u00ad\u0600-\u0604\u070f\u17b4\u17b5\u200c-\u200f\u2028-\u202f\u2060-\u206f\ufeff\ufff0-\uffff]/g; // eslint-disable-line no-control-regex
            var meta = { // table of character substitutions
                '\b': '\\b',
                '\t': '\\t',
                '\n': '\\n',
                '\f': '\\f',
                '\r': '\\r',
                '"': '\\"',
                '\\': '\\\\'
            };

escapable.lastIndex = 0;
            return escapable.test(string) ?
                '"' + string.replace(escapable, function(a) {
                    var c = meta[a];
                    return typeof c === 'string' ? c :
                        '\\u' + ('0000' + a.charCodeAt(0).toString(16)).slice(-4);
                }) + '"' :
                '"' + string + '"';
        };

var str = function(key, holder) {
            var gap = '';
            var indent = '    ';
            var i = 0; // The loop counter.
            var k = ''; // The member key.
            var v = ''; // The member value.
            var length = 0;
            var mind = gap;
            var partial = [];
            var value = holder[key];

// If the value has a toJSON method, call it to obtain a replacement value.
            if (value && typeof value === 'object' &&
                typeof value.toJSON === 'function') {
                value = value.toJSON(key);
            }

// What happens next depends on the value's type.
            switch (typeof value) {
                case 'string':
                    return quote(value);

case 'number':
                    // JSON numbers must be finite. Encode non-finite numbers as null.
                    return isFinite(value) ? String(value) : 'null';

case 'boolean':
                case 'null':
                    // If the value is a boolean or null, convert it to a string. Note:
                    // typeof null does not produce 'null'. The case is included here in
                    // the remote chance that this gets fixed someday.

return String(value);

case 'object':
                    // If the type is 'object', we might be dealing with an object or an array or
                    // null.
                    // Due to a specification blunder in ECMAScript, typeof null is 'object',
                    // so watch out for that case.
                    if (!value) {
                        return 'null';
                    }

// Make an array to hold the partial results of stringifying this object value.
                    gap += indent;
                    partial = [];

// Is the value an array?
                    if (toString.apply(value) === '[object Array]') {
                        // The value is an array. Stringify every element. Use null as a placeholder
                        // for non-JSON values.

length = value.length;
 for (i = 0; i < length; i += 1) {
 partial[i] = str(i, value) || 'null';
 }

// Join all of the elements together, separated with commas, and wrap them in
                        // brackets.
                        v = partial.length === 0 ? '[]' :
                            gap ? '[\n' + gap +
                            partial.join(',\n' + gap) + '\n' +
                            mind + ']' :
                                '[' + partial.join(',') + ']';
                        gap = mind;
                        return v;
                    }

// Iterate through all of the keys in the object.
                    for (k in value) {
                        if (hasOwnProperty.call(value, k)) {
                            v = str(k, value);
                            if (v) {
                                partial.push(quote(k) + (gap ? ': ' : ':') + v);
                            }
                        }
                    }

// Join all of the member texts together, separated with commas,
                    // and wrap them in braces.
                    v = partial.length === 0 ? '{}' :
                        gap ? '{' + partial.join(',') + '' +
                        mind + '}' : '{' + partial.join(',') + '}';
                    gap = mind;
                    return v;
            }
        };

// Make a fake root object containing our value under the key of ''.
        // Return the result of stringifying the value.
        return str('', {
            '': value
        });
    };
})();

/**
 * From https://github.com/douglascrockford/JSON-js/blob/master/json_parse.js
 * Slightly modified to throw a real Error rather than a POJO
 */
_.JSONDecode = (function() {
    var at, // The index of the current character
        ch, // The current character
        escapee = {
            '"': '"',
            '\\': '\\',
            '/': '/',
            'b': '\b',
            'f': '\f',
            'n': '\n',
            'r': '\r',
            't': '\t'
        },
        text,
        error = function(m) {
            var e = new SyntaxError(m);
            e.at = at;
            e.text = text;
            throw e;
        },
        next = function(c) {
            // If a c parameter is provided, verify that it matches the current character.
            if (c && c !== ch) {
                error('Expected \'' + c + '\' instead of \'' + ch + '\'');
            }
            // Get the next character. When there are no more characters,
            // return the empty string.
            ch = text.charAt(at);
            at += 1;
            return ch;
        },
        number = function() {
            // Parse a number value.
            var number,
                string = '';

if (ch === '-') {
 string = '-';
 next('-');
 }
 while (ch >= '0' && ch <= '9') {
 string += ch;
 next();
 }
 if (ch === '.') {
 string += '.';
 while (next() && ch >= '0' && ch <= '9') {
 string += ch;
 }
 }
 if (ch === 'e' || ch === 'E') {
 string += ch;
 next();
 if (ch === '-' || ch === '+') {
 string += ch;
 next();
 }
 while (ch >= '0' && ch <= '9') {
 string += ch;
 next();
 }
 }
 number = +string;
 if (!isFinite(number)) {
 error('Bad number');
 } else {
 return number;
 }
 },

string = function() {
 // Parse a string value.
 var hex,
 i,
 string = '',
 uffff;
 // When parsing for string values, we must look for " and \ characters.
 if (ch === '"') {
 while (next()) {
 if (ch === '"') {
 next();
 return string;
 }
 if (ch === '\\') {
 next();
 if (ch === 'u') {
 uffff = 0;
 for (i = 0; i < 4; i += 1) {
 hex = parseInt(next(), 16);
 if (!isFinite(hex)) {
 break;
 }
 uffff = uffff * 16 + hex;
 }
 string += String.fromCharCode(uffff);
 } else if (typeof escapee[ch] === 'string') {
 string += escapee[ch];
 } else {
 break;
 }
 } else {
 string += ch;
 }
 }
 }
 error('Bad string');
 },
 white = function() {
 // Skip whitespace.
 while (ch && ch <= ' ') {
 next();
 }
 },
 word = function() {
 // true, false, or null.
 switch (ch) {
 case 't':
 next('t');
 next('r');
 next('u');
 next('e');
 return true;
 case 'f':
 next('f');
 next('a');
 next('l');
 next('s');
 next('e');
 return false;
 case 'n':
 next('n');
 next('u');
 next('l');
 next('l');
 return null;
 }
 error('Unexpected "' + ch + '"');
 },
 value, // Placeholder for the value function.
 array = function() {
 // Parse an array value.
 var array = [];

if (ch === '[') {
                next('[');
                white();
                if (ch === ']') {
                    next(']');
                    return array; // empty array
                }
                while (ch) {
                    array.push(value());
                    white();
                    if (ch === ']') {
                        next(']');
                        return array;
                    }
                    next(',');
                    white();
                }
            }
            error('Bad array');
        },
        object = function() {
            // Parse an object value.
            var key,
                object = {};

if (ch === '{') {
                next('{');
                white();
                if (ch === '}') {
                    next('}');
                    return object; // empty object
                }
                while (ch) {
                    key = string();
                    white();
                    next(':');
                    if (Object.hasOwnProperty.call(object, key)) {
                        error('Duplicate key "' + key + '"');
                    }
                    object[key] = value();
                    white();
                    if (ch === '}') {
                        next('}');
                        return object;
                    }
                    next(',');
                    white();
                }
            }
            error('Bad object');
        };

value = function() {
 // Parse a JSON value. It could be an object, an array, a string,
 // a number, or a word.
 white();
 switch (ch) {
 case '{':
 return object();
 case '[':
 return array();
 case '"':
 return string();
 case '-':
 return number();
 default:
 return ch >= '0' && ch <= '9' ? number() : word();
 }
 };

// Return the json_parse function. It will have access to all of the
    // above functions and variables.
    return function(source) {
        var result;

text = source;
        at = 0;
        ch = ' ';
        result = value();
        white();
        if (ch) {
            error('Syntax error');
        }

return result;
    };
})();

_.base64Encode = function(data) {
    var b64 = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=';
    var o1, o2, o3, h1, h2, h3, h4, bits, i = 0,
        ac = 0,
        enc = '',
        tmp_arr = [];

if (!data) {
        return data;
    }

data = _.utf8Encode(data);

do { // pack three octets into four hexets
        o1 = data.charCodeAt(i++);
        o2 = data.charCodeAt(i++);
        o3 = data.charCodeAt(i++);

bits = o1 << 16 | o2 << 8 | o3;

h1 = bits >> 18 & 0x3f;
        h2 = bits >> 12 & 0x3f;
        h3 = bits >> 6 & 0x3f;
        h4 = bits & 0x3f;

// use hexets to index into b64, and append result to encoded string
 tmp_arr[ac++] = b64.charAt(h1) + b64.charAt(h2) + b64.charAt(h3) + b64.charAt(h4);
 } while (i < data.length);

enc = tmp_arr.join('');

switch (data.length % 3) {
        case 1:
            enc = enc.slice(0, -2) + '==';
            break;
        case 2:
            enc = enc.slice(0, -1) + '=';
            break;
    }

return enc;
};

_.utf8Encode = function(string) {
    string = (string + '').replace(/\r\n/g, '\n').replace(/\r/g, '\n');

var utftext = '',
        start,
        end;
    var stringl = 0,
        n;

start = end = 0;
    stringl = string.length;

for (n = 0; n < stringl; n++) {
 var c1 = string.charCodeAt(n);
 var enc = null;

if (c1 < 128) {
 end++;
 } else if ((c1 > 127) && (c1 < 2048)) {
 enc = String.fromCharCode((c1 >> 6) | 192, (c1 & 63) | 128);
 } else {
 enc = String.fromCharCode((c1 >> 12) | 224, ((c1 >> 6) & 63) | 128, (c1 & 63) | 128);
 }
 if (enc !== null) {
 if (end > start) {
 utftext += string.substring(start, end);
 }
 utftext += enc;
 start = end = n + 1;
 }
 }

if (end > start) {
        utftext += string.substring(start, string.length);
    }

return utftext;
};

_.UUID = (function() {

// Time-based entropy
    var T = function() {
        var time = 1 * new Date(); // cross-browser version of Date.now()
        var ticks;
        if (window$1.performance && window$1.performance.now) {
            ticks = window$1.performance.now();
        } else {
            // fall back to busy loop
            ticks = 0;

// this while loop figures how many browser ticks go by
            // before 1*new Date() returns a new number, ie the amount
            // of ticks that go by per millisecond
            while (time == 1 * new Date()) {
                ticks++;
            }
        }
        return time.toString(16) + Math.floor(ticks).toString(16);
    };

// Math.Random entropy
    var R = function() {
        return Math.random().toString(16).replace('.', '');
    };

// User agent entropy
    // This function takes the user agent string, and then xors
    // together each sequence of 8 bytes.  This produces a final
    // sequence of 8 bytes which it returns as hex.
    var UA = function() {
        var ua = userAgent,
            i, ch, buffer = [],
            ret = 0;

function xor(result, byte_array) {
 var j, tmp = 0;
 for (j = 0; j < byte_array.length; j++) {
 tmp |= (buffer[j] << j * 8);
 }
 return result ^ tmp;
 }

for (i = 0; i < ua.length; i++) {
 ch = ua.charCodeAt(i);
 buffer.unshift(ch & 0xFF);
 if (buffer.length >= 4) {
 ret = xor(ret, buffer);
 buffer = [];
 }
 }

if (buffer.length > 0) {
            ret = xor(ret, buffer);
        }

return ret.toString(16);
    };

return function() {
        var se = (screen.height * screen.width).toString(16);
        return (T() + '-' + R() + '-' + UA() + '-' + se + '-' + T());
    };
})();

// _.isBlockedUA()
// This is to block various web spiders from executing our JS and
// sending false tracking data
var BLOCKED_UA_STRS = [
    'ahrefsbot',
    'ahrefssiteaudit',
    'baiduspider',
    'bingbot',
    'bingpreview',
    'chrome-lighthouse',
    'facebookexternal',
    'petalbot',
    'pinterest',
    'screaming frog',
    'yahoo! slurp',
    'yandexbot',

// a whole bunch of goog-specific crawlers
 // https://developers.google.com/search/docs/advanced/crawling/overview-google-crawlers
 'adsbot-google',
 'apis-google',
 'duplexweb-google',
 'feedfetcher-google',
 'google favicon',
 'google web preview',
 'google-read-aloud',
 'googlebot',
 'googleweblight',
 'mediapartners-google',
 'storebot-google'
];
_.isBlockedUA = function(ua) {
 var i;
 ua = ua.toLowerCase();
 for (i = 0; i < BLOCKED_UA_STRS.length; i++) {
 if (ua.indexOf(BLOCKED_UA_STRS[i]) !== -1) {
 return true;
 }
 }
 return false;
};

/**
 * @param {Object=} formdata
 * @param {string=} arg_separator
 */
_.HTTPBuildQuery = function(formdata, arg_separator) {
    var use_val, use_key, tmp_arr = [];

if (_.isUndefined(arg_separator)) {
        arg_separator = '&';
    }

_.each(formdata, function(val, key) {
        use_val = encodeURIComponent(val.toString());
        use_key = encodeURIComponent(key);
        tmp_arr[tmp_arr.length] = use_key + '=' + use_val;
    });

return tmp_arr.join(arg_separator);
};

_.getQueryParam = function(url, param) {
    // Expects a raw URL

param = param.replace(/[[]/, '\\[').replace(/[\]]/, '\\]');
    var regexS = '[\\?&]' + param + '=([^&#]*)',
        regex = new RegExp(regexS),
        results = regex.exec(url);
    if (results === null || (results && typeof(results[1]) !== 'string' && results[1].length)) {
        return '';
    } else {
        var result = results[1];
        try {
            result = decodeURIComponent(result);
        } catch(err) {
            console$1.error('Skipping decoding for malformed query param: ' + result);
        }
        return result.replace(/\+/g, ' ');
    }
};

// _.cookie
// Methods partially borrowed from quirksmode.org/js/cookies.html
_.cookie = {
 get: function(name) {
 var nameEQ = name + '=';
 var ca = document$1.cookie.split(';');
 for (var i = 0; i < ca.length; i++) {
 var c = ca[i];
 while (c.charAt(0) == ' ') {
 c = c.substring(1, c.length);
 }
 if (c.indexOf(nameEQ) === 0) {
 return decodeURIComponent(c.substring(nameEQ.length, c.length));
 }
 }
 return null;
 },

parse: function(name) {
        var cookie;
        try {
            cookie = _.JSONDecode(_.cookie.get(name)) || {};
        } catch (err) {
            // noop
        }
        return cookie;
    },

set_seconds: function(name, value, seconds, is_cross_subdomain, is_secure, is_cross_site, domain_override) {
        var cdomain = '',
            expires = '',
            secure = '';

if (domain_override) {
            cdomain = '; domain=' + domain_override;
        } else if (is_cross_subdomain) {
            var domain = extract_domain(document$1.location.hostname);
            cdomain = domain ? '; domain=.' + domain : '';
        }

if (seconds) {
            var date = new Date();
            date.setTime(date.getTime() + (seconds * 1000));
            expires = '; expires=' + date.toGMTString();
        }

if (is_cross_site) {
            is_secure = true;
            secure = '; SameSite=None';
        }
        if (is_secure) {
            secure += '; secure';
        }

document$1.cookie = name + '=' + encodeURIComponent(value) + expires + '; path=/' + cdomain + secure;
    },

set: function(name, value, days, is_cross_subdomain, is_secure, is_cross_site, domain_override) {
        var cdomain = '', expires = '', secure = '';

if (days) {
            var date = new Date();
            date.setTime(date.getTime() + (days * 24 * 60 * 60 * 1000));
            expires = '; expires=' + date.toGMTString();
        }

if (is_cross_site) {
            is_secure = true;
            secure = '; SameSite=None';
        }
        if (is_secure) {
            secure += '; secure';
        }

var new_cookie_val = name + '=' + encodeURIComponent(value) + expires + '; path=/' + cdomain + secure;
        document$1.cookie = new_cookie_val;
        return new_cookie_val;
    },

remove: function(name, is_cross_subdomain, domain_override) {
        _.cookie.set(name, '', -1, is_cross_subdomain, false, false, domain_override);
    }
};

var _localStorageSupported = null;
var localStorageSupported = function(storage, forceCheck) {
    if (_localStorageSupported !== null && !forceCheck) {
        return _localStorageSupported;
    }

_localStorageSupported = supported;
    return supported;
};

// _.localStorage
_.localStorage = {
    is_supported: function(force_check) {
        var supported = localStorageSupported(null, force_check);
        if (!supported) {
            console$1.error('localStorage unsupported; falling back to cookie store');
        }
        return supported;
    },

error: function(msg) {
        console$1.error('localStorage error: ' + msg);
    },

get: function(name) {
        try {
            return window.localStorage.getItem(name);
        } catch (err) {
            _.localStorage.error(err);
        }
        return null;
    },

parse: function(name) {
        try {
            return _.JSONDecode(_.localStorage.get(name)) || {};
        } catch (err) {
            // noop
        }
        return null;
    },

set: function(name, value) {
        try {
            window.localStorage.setItem(name, value);
        } catch (err) {
            _.localStorage.error(err);
        }
    },

remove: function(name) {
        try {
            window.localStorage.removeItem(name);
        } catch (err) {
            _.localStorage.error(err);
        }
    }
};

_.register_event = (function() {
    // written by Dean Edwards, 2005
    // with input from Tino Zijdel - crisp@xs4all.nl
    // with input from Carl Sverre - mail@carlsverre.com
    // with input from Mixpanel
    // http://dean.edwards.name/weblog/2005/10/add-event/
    // https://gist.github.com/1930440

/**
     * @param {Object} element
     * @param {string} type
     * @param {function(...*)} handler
     * @param {boolean=} oldSchool
     * @param {boolean=} useCapture
     */
    var register_event = function(element, type, handler, oldSchool, useCapture) {
        if (!element) {
            console$1.error('No valid element provided to register_event');
            return;
        }

if (element.addEventListener && !oldSchool) {
            element.addEventListener(type, handler, !!useCapture);
        } else {
            var ontype = 'on' + type;
            var old_handler = element[ontype]; // can be undefined
            element[ontype] = makeHandler(element, handler, old_handler);
        }
    };

function makeHandler(element, new_handler, old_handlers) {
        var handler = function(event) {
            event = event || fixEvent(window.event);

// this basically happens in firefox whenever another script
            // overwrites the onload callback and doesn't pass the event
            // object to previously defined callbacks.  All the browsers
            // that don't define window.event implement addEventListener
            // so the dom_loaded handler will still be fired as usual.
            if (!event) {
                return undefined;
            }

var ret = true;
            var old_result, new_result;

if (_.isFunction(old_handlers)) {
                old_result = old_handlers(event);
            }
            new_result = new_handler.call(element, event);

if ((false === old_result) || (false === new_result)) {
                ret = false;
            }

return ret;
        };

return handler;
    }

return register_event;
})();

var TOKEN_MATCH_REGEX = new RegExp('^(\\w*)\\[(\\w+)([=~\\|\\^\\$\\*]?)=?"?([^\\]"]*)"?\\]$');

_.dom_query = (function() {
    /* document.getElementsBySelector(selector)
    - returns an array of element objects from the current document
    matching the CSS selector. Selectors can contain element names,
    class names and ids and can be nested. For example:

elements = document.getElementsBySelector('div#main p a.external')

Will return an array of all 'a' elements with 'external' in their
    class attribute that are contained inside 'p' elements that are
    contained inside the 'div' element which has id="main"

New in version 0.4: Support for CSS2 and CSS3 attribute selectors:
    See http://www.w3.org/TR/css3-selectors/#attribute-selectors

Version 0.4 - Simon Willison, March 25th 2003
    -- Works in Phoenix 0.5, Mozilla 1.3, Opera 7, Internet Explorer 6, Internet Explorer 5 on Windows
    -- Opera 7 fails

Version 0.5 - Carl Sverre, Jan 7th 2013
    -- Now uses jQuery-esque `hasClass` for testing class name
    equality.  This fixes a bug related to '-' characters being
    considered not part of a 'word' in regex.
    */

function getAllChildren(e) {
        // Returns all children of element. Workaround required for IE5/Windows. Ugh.
        return e.all ? e.all : e.getElementsByTagName('*');
    }

var bad_whitespace = /[\t\r\n]/g;

function hasClass(elem, selector) {
        var className = ' ' + selector + ' ';
        return ((' ' + elem.className + ' ').replace(bad_whitespace, ' ').indexOf(className) >= 0);
    }

return function(query) {
        if (_.isElement(query)) {
            return [query];
        } else if (_.isObject(query) && !_.isUndefined(query.length)) {
            return query;
        } else {
            return getElementsBySelector.call(this, query);
        }
    };
})();

var CAMPAIGN_KEYWORDS = ['utm_source', 'utm_medium', 'utm_campaign', 'utm_content', 'utm_term'];
var CLICK_IDS = ['dclid', 'fbclid', 'gclid', 'ko_click_id', 'li_fat_id', 'msclkid', 'ttclid', 'twclid', 'wbraid'];

_.info = {
    campaignParams: function(default_value) {
        var kw = '',
            params = {};
        _.each(CAMPAIGN_KEYWORDS, function(kwkey) {
            kw = _.getQueryParam(document$1.URL, kwkey);
            if (kw.length) {
                params[kwkey] = kw;
            } else if (default_value !== undefined) {
                params[kwkey] = default_value;
            }
        });

return params;
    },

clickParams: function() {
        var id = '',
            params = {};
        _.each(CLICK_IDS, function(idkey) {
            id = _.getQueryParam(document$1.URL, idkey);
            if (id.length) {
                params[idkey] = id;
            }
        });

return params;
    },

marketingParams: function() {
        return _.extend(_.info.campaignParams(), _.info.clickParams());
    },

searchEngine: function(referrer) {
        if (referrer.search('https?://(.*)google.([^/?]*)') === 0) {
            return 'google';
        } else if (referrer.search('https?://(.*)bing.com') === 0) {
            return 'bing';
        } else if (referrer.search('https?://(.*)yahoo.com') === 0) {
            return 'yahoo';
        } else if (referrer.search('https?://(.*)duckduckgo.com') === 0) {
            return 'duckduckgo';
        } else {
            return null;
        }
    },

searchInfo: function(referrer) {
        var search = _.info.searchEngine(referrer),
            param = (search != 'yahoo') ? 'q' : 'p',
            ret = {};

if (search !== null) {
            ret['$search_engine'] = search;

var keyword = _.getQueryParam(referrer, param);
            if (keyword.length) {
                ret['mp_keyword'] = keyword;
            }
        }

return ret;
    },

/**
     * This function detects which browser is running this script.
     * The order of the checks are important since many user agents
     * include key words used in later checks.
     */
    browser: function(user_agent, vendor, opera) {
        vendor = vendor || ''; // vendor is undefined for at least IE9
        if (opera || _.includes(user_agent, ' OPR/')) {
            if (_.includes(user_agent, 'Mini')) {
                return 'Opera Mini';
            }
            return 'Opera';
        } else if (/(BlackBerry|PlayBook|BB10)/i.test(user_agent)) {
            return 'BlackBerry';
        } else if (_.includes(user_agent, 'IEMobile') || _.includes(user_agent, 'WPDesktop')) {
            return 'Internet Explorer Mobile';
        } else if (_.includes(user_agent, 'SamsungBrowser/')) {
            // https://developer.samsung.com/internet/user-agent-string-format
            return 'Samsung Internet';
        } else if (_.includes(user_agent, 'Edge') || _.includes(user_agent, 'Edg/')) {
            return 'Microsoft Edge';
        } else if (_.includes(user_agent, 'FBIOS')) {
            return 'Facebook Mobile';
        } else if (_.includes(user_agent, 'Chrome')) {
            return 'Chrome';
        } else if (_.includes(user_agent, 'CriOS')) {
            return 'Chrome iOS';
        } else if (_.includes(user_agent, 'UCWEB') || _.includes(user_agent, 'UCBrowser')) {
            return 'UC Browser';
        } else if (_.includes(user_agent, 'FxiOS')) {
            return 'Firefox iOS';
        } else if (_.includes(vendor, 'Apple')) {
            if (_.includes(user_agent, 'Mobile')) {
                return 'Mobile Safari';
            }
            return 'Safari';
        } else if (_.includes(user_agent, 'Android')) {
            return 'Android Mobile';
        } else if (_.includes(user_agent, 'Konqueror')) {
            return 'Konqueror';
        } else if (_.includes(user_agent, 'Firefox')) {
            return 'Firefox';
        } else if (_.includes(user_agent, 'MSIE') || _.includes(user_agent, 'Trident/')) {
            return 'Internet Explorer';
        } else if (_.includes(user_agent, 'Gecko')) {
            return 'Mozilla';
        } else {
            return '';
        }
    },

/**
     * This function detects which browser version is running this script,
     * parsing major and minor version (e.g., 42.1). User agent strings from:
     * http://www.useragentstring.com/pages/useragentstring.php
     */
    browserVersion: function(userAgent, vendor, opera) {
        var browser = _.info.browser(userAgent, vendor, opera);
        var versionRegexs = {
            'Internet Explorer Mobile': /rv:(\d+(\.\d+)?)/,
            'Microsoft Edge': /Edge?\/(\d+(\.\d+)?)/,
            'Chrome': /Chrome\/(\d+(\.\d+)?)/,
            'Chrome iOS': /CriOS\/(\d+(\.\d+)?)/,
            'UC Browser' : /(UCBrowser|UCWEB)\/(\d+(\.\d+)?)/,
            'Safari': /Version\/(\d+(\.\d+)?)/,
            'Mobile Safari': /Version\/(\d+(\.\d+)?)/,
            'Opera': /(Opera|OPR)\/(\d+(\.\d+)?)/,
            'Firefox': /Firefox\/(\d+(\.\d+)?)/,
            'Firefox iOS': /FxiOS\/(\d+(\.\d+)?)/,
            'Konqueror': /Konqueror:(\d+(\.\d+)?)/,
            'BlackBerry': /BlackBerry (\d+(\.\d+)?)/,
            'Android Mobile': /android\s(\d+(\.\d+)?)/,
            'Samsung Internet': /SamsungBrowser\/(\d+(\.\d+)?)/,
            'Internet Explorer': /(rv:|MSIE )(\d+(\.\d+)?)/,
            'Mozilla': /rv:(\d+(\.\d+)?)/
        };
        var regex = versionRegexs[browser];
        if (regex === undefined) {
            return null;
        }
        var matches = userAgent.match(regex);
        if (!matches) {
            return null;
        }
        return parseFloat(matches[matches.length - 2]);
    },

os: function() {
        var a = userAgent;
        if (/Windows/i.test(a)) {
            if (/Phone/.test(a) || /WPDesktop/.test(a)) {
                return 'Windows Phone';
            }
            return 'Windows';
        } else if (/(iPhone|iPad|iPod)/.test(a)) {
            return 'iOS';
        } else if (/Android/.test(a)) {
            return 'Android';
        } else if (/(BlackBerry|PlayBook|BB10)/i.test(a)) {
            return 'BlackBerry';
        } else if (/Mac/i.test(a)) {
            return 'Mac OS X';
        } else if (/Linux/.test(a)) {
            return 'Linux';
        } else if (/CrOS/.test(a)) {
            return 'Chrome OS';
        } else {
            return '';
        }
    },

device: function(user_agent) {
        if (/Windows Phone/i.test(user_agent) || /WPDesktop/.test(user_agent)) {
            return 'Windows Phone';
        } else if (/iPad/.test(user_agent)) {
            return 'iPad';
        } else if (/iPod/.test(user_agent)) {
            return 'iPod Touch';
        } else if (/iPhone/.test(user_agent)) {
            return 'iPhone';
        } else if (/(BlackBerry|PlayBook|BB10)/i.test(user_agent)) {
            return 'BlackBerry';
        } else if (/Android/.test(user_agent)) {
            return 'Android';
        } else {
            return '';
        }
    },

referringDomain: function(referrer) {
        var split = referrer.split('/');
        if (split.length >= 3) {
            return split[2];
        }
        return '';
    },

currentUrl: function() {
        return window$1.location.href;
    },

properties: function(extra_props) {
        if (typeof extra_props !== 'object') {
            extra_props = {};
        }
        return _.extend(_.strip_empty_properties({
            '$os': _.info.os(),
            '$browser': _.info.browser(userAgent, navigator.vendor, windowOpera),
            '$referrer': document$1.referrer,
            '$referring_domain': _.info.referringDomain(document$1.referrer),
            '$device': _.info.device(userAgent)
        }), {
            '$current_url': _.info.currentUrl(),
            '$browser_version': _.info.browserVersion(userAgent, navigator.vendor, windowOpera),
            '$screen_height': screen.height,
            '$screen_width': screen.width,
            'mp_lib': 'web',
            '$lib_version': Config.LIB_VERSION,
            '$insert_id': cheap_guid(),
            'time': _.timestamp() / 1000 // epoch time in seconds
        }, _.strip_empty_properties(extra_props));
    },

people_properties: function() {
        return _.extend(_.strip_empty_properties({
            '$os': _.info.os(),
            '$browser': _.info.browser(userAgent, navigator.vendor, windowOpera)
        }), {
            '$browser_version': _.info.browserVersion(userAgent, navigator.vendor, windowOpera)
        });
    },

mpPageViewProperties: function() {
        return _.strip_empty_properties({
            'current_page_title': document$1.title,
            'current_domain': window$1.location.hostname,
            'current_url_path': window$1.location.pathname,
            'current_url_protocol': window$1.location.protocol,
            'current_url_search': window$1.location.search
        });
    }
};

var cheap_guid = function(maxlen) {
    var guid = Math.random().toString(36).substring(2, 10) + Math.random().toString(36).substring(2, 10);
    return maxlen ? guid.substring(0, maxlen) : guid;
};

// naive way to extract domain name (example.com) from full hostname (my.sub.example.com)
var SIMPLE_DOMAIN_MATCH_REGEX = /[a-z0-9][a-z0-9-]*\.[a-z]+$/i;
// this next one attempts to account for some ccSLDs, e.g. extracting oxford.ac.uk from www.oxford.ac.uk
var DOMAIN_MATCH_REGEX = /[a-z0-9][a-z0-9-]+\.[a-z.]{2,6}$/i;
/**
 * Attempts to extract main domain name from full hostname, using a few blunt heuristics. For
 * common TLDs like .com/.org that always have a simple SLD.TLD structure (example.com), we
 * simply extract the last two .-separated parts of the hostname (SIMPLE_DOMAIN_MATCH_REGEX).
 * For others, we attempt to account for short ccSLD+TLD combos (.ac.uk) with the legacy
 * DOMAIN_MATCH_REGEX (kept to maintain backwards compatibility with existing Mixpanel
 * integrations). The only _reliable_ way to extract domain from hostname is with an up-to-date
 * list like at https://publicsuffix.org/ so for cases that this helper fails at, the SDK
 * offers the 'cookie_domain' config option to set it explicitly.
 * @example
 * extract_domain('my.sub.example.com')
 * // 'example.com'
 */
var extract_domain = function(hostname) {
    var domain_regex = DOMAIN_MATCH_REGEX;
    var parts = hostname.split('.');
    var tld = parts[parts.length - 1];
    if (tld.length > 4 || tld === 'com' || tld === 'org') {
        domain_regex = SIMPLE_DOMAIN_MATCH_REGEX;
    }
    var matches = hostname.match(domain_regex);
    return matches ? matches[0] : '';
};

var JSONStringify = null;
var JSONParse = null;
if (typeof JSON !== 'undefined') {
    JSONStringify = JSON.stringify;
    JSONParse = JSON.parse;
}
JSONStringify = JSONStringify || _.JSONEncode;
JSONParse = JSONParse || _.JSONDecode;

// EXPORTS (for closure compiler)
_['toArray']                = _.toArray;
_['isObject']               = _.isObject;
_['JSONEncode']             = _.JSONEncode;
_['JSONDecode']             = _.JSONDecode;
_['isBlockedUA']            = _.isBlockedUA;
_['isEmptyObject']          = _.isEmptyObject;
_['info']                   = _.info;
_['info']['device']         = _.info.device;
_['info']['browser']        = _.info.browser;
_['info']['browserVersion'] = _.info.browserVersion;
_['info']['properties']     = _.info.properties;

/**
 * DomTracker Object
 * @constructor
 */
var DomTracker = function() {};

// interface
DomTracker.prototype.create_properties = function() {};
DomTracker.prototype.event_handler = function() {};
DomTracker.prototype.after_track_handler = function() {};

DomTracker.prototype.init = function(mixpanel_instance) {
    this.mp = mixpanel_instance;
    return this;
};

/**
 * @param {Object|string} query
 * @param {string} event_name
 * @param {Object=} properties
 * @param {function=} user_callback
 */
DomTracker.prototype.track = function(query, event_name, properties, user_callback) {
    var that = this;
    var elements = _.dom_query(query);

if (elements.length === 0) {
        console$1.error('The DOM query (' + query + ') returned 0 elements');
        return;
    }

_.each(elements, function(element) {
        _.register_event(element, this.override_event, function(e) {
            var options = {};
            var props = that.create_properties(properties, this);
            var timeout = that.mp.get_config('track_links_timeout');

that.event_handler(e, this, options);

// in case the mixpanel servers don't get back to us in time
            window.setTimeout(that.track_callback(user_callback, props, options, true), timeout);

// fire the tracking event
            that.mp.track(event_name, props, that.track_callback(user_callback, props, options));
        });
    }, this);

return true;
};

/**
 * @param {function} user_callback
 * @param {Object} props
 * @param {boolean=} timeout_occured
 */
DomTracker.prototype.track_callback = function(user_callback, props, options, timeout_occured) {
    timeout_occured = timeout_occured || false;
    var that = this;

return function() {
        // options is referenced from both callbacks, so we can have
        // a 'lock' of sorts to ensure only one fires
        if (options.callback_fired) { return; }
        options.callback_fired = true;

if (user_callback && user_callback(timeout_occured, props) === false) {
            // user can prevent the default functionality by
            // returning false from their callback
            return;
        }

that.after_track_handler(props, options, timeout_occured);
    };
};

DomTracker.prototype.create_properties = function(properties, element) {
    var props;

if (typeof(properties) === 'function') {
        props = properties(element);
    } else {
        props = _.extend({}, properties);
    }

return props;
};

/**
 * LinkTracker Object
 * @constructor
 * @extends DomTracker
 */
var LinkTracker = function() {
    this.override_event = 'click';
};
_.inherit(LinkTracker, DomTracker);

LinkTracker.prototype.create_properties = function(properties, element) {
    var props = LinkTracker.superclass.create_properties.apply(this, arguments);

if (element.href) { props['url'] = element.href; }

return props;
};

LinkTracker.prototype.event_handler = function(evt, element, options) {
    options.new_tab = (
        evt.which === 2 ||
        evt.metaKey ||
        evt.ctrlKey ||
        element.target === '_blank'
    );
    options.href = element.href;

if (!options.new_tab) {
        evt.preventDefault();
    }
};

LinkTracker.prototype.after_track_handler = function(props, options) {
    if (options.new_tab) { return; }

setTimeout(function() {
        window.location = options.href;
    }, 0);
};

/**
 * FormTracker Object
 * @constructor
 * @extends DomTracker
 */
var FormTracker = function() {
    this.override_event = 'submit';
};
_.inherit(FormTracker, DomTracker);

FormTracker.prototype.event_handler = function(evt, element, options) {
    options.element = element;
    evt.preventDefault();
};

FormTracker.prototype.after_track_handler = function(props, options) {
    setTimeout(function() {
        options.element.submit();
    }, 0);
};

// eslint-disable-line camelcase

var logger$2 = console_with_prefix('lock');

/**
 * SharedLock: a mutex built on HTML5 localStorage, to ensure that only one browser
 * window/tab at a time will be able to access shared resources.
 *
 * Based on the Alur and Taubenfeld fast lock
 * (http://www.cs.rochester.edu/research/synchronization/pseudocode/fastlock.html)
 * with an added timeout to ensure there will be eventual progress in the event
 * that a window is closed in the middle of the callback.
 *
 * Implementation based on the original version by David Wolever (https://github.com/wolever)
 * at https://gist.github.com/wolever/5fd7573d1ef6166e8f8c4af286a69432.
 *
 * @example
 * const myLock = new SharedLock('some-key');
 * myLock.withLock(function() {
 *   console.log('I hold the mutex!');
 * });
 *
 * @constructor
 */
var SharedLock = function(key, options) {
    options = options || {};

this.storageKey = key;
    this.storage = options.storage || window.localStorage;
    this.pollIntervalMS = options.pollIntervalMS || 100;
    this.timeoutMS = options.timeoutMS || 2000;
};

// pass in a specific pid to test contention scenarios; otherwise
// it is chosen randomly for each acquisition attempt
SharedLock.prototype.withLock = function(lockedCB, errorCB, pid) {
    if (!pid && typeof errorCB !== 'function') {
        pid = errorCB;
        errorCB = null;
    }

var i = pid || (new Date().getTime() + '|' + Math.random());
    var startTime = new Date().getTime();

var key = this.storageKey;
    var pollIntervalMS = this.pollIntervalMS;
    var timeoutMS = this.timeoutMS;
    var storage = this.storage;

var keyX = key + ':X';
    var keyY = key + ':Y';
    var keyZ = key + ':Z';

var reportError = function(err) {
        errorCB && errorCB(err);
    };

var loop = function() {
        storage.setItem(keyX, i);

waitFor(getSetY, function() {
            if (storage.getItem(keyX) === i) {
                criticalSection();
                return;
            }

delay(function() {
                if (storage.getItem(keyY) !== i) {
                    loop();
                    return;
                }
                waitFor(function() {
                    return !storage.getItem(keyZ);
                }, criticalSection);
            });
        });
    };

try {
        if (localStorageSupported(storage, true)) {
            loop();
        } else {
            throw new Error('localStorage support check failed');
        }
    } catch(err) {
        reportError(err);
    }
};

// eslint-disable-line camelcase

var logger$1 = console_with_prefix('batch');

/**
 * RequestQueue: queue for batching API requests with localStorage backup for retries.
 * Maintains an in-memory queue which represents the source of truth for the current
 * page, but also writes all items out to a copy in the browser's localStorage, which
 * can be read on subsequent pageloads and retried. For batchability, all the request
 * items in the queue should be of the same type (events, people updates, group updates)
 * so they can be sent in a single request to the same API endpoint.
 *
 * LocalStorage keying and locking: In order for reloads and subsequent pageloads of
 * the same site to access the same persisted data, they must share the same localStorage
 * key (for instance based on project token and queue type). Therefore access to the
 * localStorage entry is guarded by an asynchronous mutex (SharedLock) to prevent
 * simultaneously open windows/tabs from overwriting each other's data (which would lead
 * to data loss in some situations).
 * @constructor
 */
var RequestQueue = function(storageKey, options) {
    options = options || {};
    this.storageKey = storageKey;
    this.storage = options.storage || window.localStorage;
    this.reportError = options.errorReporter || _.bind(logger$1.error, logger$1);
    this.lock = new SharedLock(storageKey, {storage: this.storage});

this.pid = options.pid || null; // pass pid to test out storage lock contention scenarios

this.memQueue = [];
};

/**
 * Add one item to queues (memory and localStorage). The queued entry includes
 * the given item along with an auto-generated ID and a "flush-after" timestamp.
 * It is expected that the item will be sent over the network and dequeued
 * before the flush-after time; if this doesn't happen it is considered orphaned
 * (e.g., the original tab where it was enqueued got closed before it could be
 * sent) and the item can be sent by any tab that finds it in localStorage.
 *
 * The final callback param is called with a param indicating success or
 * failure of the enqueue operation; it is asynchronous because the localStorage
 * lock is asynchronous.
 */
RequestQueue.prototype.enqueue = function(item, flushInterval, cb) {
    var queueEntry = {
        'id': cheap_guid(),
        'flushAfter': new Date().getTime() + flushInterval * 2,
        'payload': item
    };

this.lock.withLock(_.bind(function lockAcquired() {
        var succeeded;
        try {
            var storedQueue = this.readFromStorage();
            storedQueue.push(queueEntry);
            succeeded = this.saveToStorage(storedQueue);
            if (succeeded) {
                // only add to in-memory queue when storage succeeds
                this.memQueue.push(queueEntry);
            }
        } catch(err) {
            this.reportError('Error enqueueing item', item);
            succeeded = false;
        }
        if (cb) {
            cb(succeeded);
        }
    }, this), _.bind(function lockFailure(err) {
        this.reportError('Error acquiring storage lock', err);
        if (cb) {
            cb(false);
        }
    }, this), this.pid);
};

/**
 * Read out the given number of queue entries. If this.memQueue
 * has fewer than batchSize items, then look for "orphaned" items
 * in the persisted queue (items where the 'flushAfter' time has
 * already passed).
 */
RequestQueue.prototype.fillBatch = function(batchSize) {
 var batch = this.memQueue.slice(0, batchSize);
 if (batch.length < batchSize) {
 // don't need lock just to read events; localStorage is thread-safe
 // and the worst that could happen is a duplicate send of some
 // orphaned events, which will be deduplicated on the server side
 var storedQueue = this.readFromStorage();
 if (storedQueue.length) {
 // item IDs already in batch; don't duplicate out of storage
 var idsInBatch = {}; // poor man's Set
 _.each(batch, function(item) { idsInBatch[item['id']] = true; });

for (var i = 0; i < storedQueue.length; i++) {
 var item = storedQueue[i];
 if (new Date().getTime() > item['flushAfter'] && !idsInBatch[item['id']]) {
 item.orphaned = true;
 batch.push(item);
 if (batch.length >= batchSize) {
 break;
 }
 }
 }
 }
 }
 return batch;
};

/**
 * Remove items with matching 'id' from array (immutably)
 * also remove any item without a valid id (e.g., malformed
 * storage entries).
 */
var filterOutIDsAndInvalid = function(items, idSet) {
    var filteredItems = [];
    _.each(items, function(item) {
        if (item['id'] && !idSet[item['id']]) {
            filteredItems.push(item);
        }
    });
    return filteredItems;
};

/**
 * Remove items with matching IDs from both in-memory queue
 * and persisted queue
 */
RequestQueue.prototype.removeItemsByID = function(ids, cb) {
    var idSet = {}; // poor man's Set
    _.each(ids, function(id) { idSet[id] = true; });

this.memQueue = filterOutIDsAndInvalid(this.memQueue, idSet);

var removeFromStorage = _.bind(function() {
        var succeeded;
        try {
            var storedQueue = this.readFromStorage();
            storedQueue = filterOutIDsAndInvalid(storedQueue, idSet);
            succeeded = this.saveToStorage(storedQueue);

// an extra check: did storage report success but somehow
 // the items are still there?
 if (succeeded) {
 storedQueue = this.readFromStorage();
 for (var i = 0; i < storedQueue.length; i++) {
 var item = storedQueue[i];
 if (item['id'] && !!idSet[item['id']]) {
 this.reportError('Item not removed from storage');
 return false;
 }
 }
 }
 } catch(err) {
 this.reportError('Error removing items', ids);
 succeeded = false;
 }
 return succeeded;
 }, this);

this.lock.withLock(function lockAcquired() {
        var succeeded = removeFromStorage();
        if (cb) {
            cb(succeeded);
        }
    }, _.bind(function lockFailure(err) {
        var succeeded = false;
        this.reportError('Error acquiring storage lock', err);
        if (!localStorageSupported(this.storage, true)) {
            // Looks like localStorage writes have stopped working sometime after
            // initialization (probably full), and so nobody can acquire locks
            // anymore. Consider it temporarily safe to remove items without the
            // lock, since nobody's writing successfully anyway.
            succeeded = removeFromStorage();
            if (!succeeded) {
                // OK, we couldn't even write out the smaller queue. Try clearing it
                // entirely.
                try {
                    this.storage.removeItem(this.storageKey);
                } catch(err) {
                    this.reportError('Error clearing queue', err);
                }
            }
        }
        if (cb) {
            cb(succeeded);
        }
    }, this), this.pid);
};

// internal helper for RequestQueue.updatePayloads
var updatePayloads = function(existingItems, itemsToUpdate) {
    var newItems = [];
    _.each(existingItems, function(item) {
        var id = item['id'];
        if (id in itemsToUpdate) {
            var newPayload = itemsToUpdate[id];
            if (newPayload !== null) {
                item['payload'] = newPayload;
                newItems.push(item);
            }
        } else {
            // no update
            newItems.push(item);
        }
    });
    return newItems;
};

/**
 * Update payloads of given items in both in-memory queue and
 * persisted queue. Items set to null are removed from queues.
 */
RequestQueue.prototype.updatePayloads = function(itemsToUpdate, cb) {
    this.memQueue = updatePayloads(this.memQueue, itemsToUpdate);
    this.lock.withLock(_.bind(function lockAcquired() {
        var succeeded;
        try {
            var storedQueue = this.readFromStorage();
            storedQueue = updatePayloads(storedQueue, itemsToUpdate);
            succeeded = this.saveToStorage(storedQueue);
        } catch(err) {
            this.reportError('Error updating items', itemsToUpdate);
            succeeded = false;
        }
        if (cb) {
            cb(succeeded);
        }
    }, this), _.bind(function lockFailure(err) {
        this.reportError('Error acquiring storage lock', err);
        if (cb) {
            cb(false);
        }
    }, this), this.pid);
};

/**
 * Read and parse items array from localStorage entry, handling
 * malformed/missing data if necessary.
 */
RequestQueue.prototype.readFromStorage = function() {
    var storageEntry;
    try {
        storageEntry = this.storage.getItem(this.storageKey);
        if (storageEntry) {
            storageEntry = JSONParse(storageEntry);
            if (!_.isArray(storageEntry)) {
                this.reportError('Invalid storage entry:', storageEntry);
                storageEntry = null;
            }
        }
    } catch (err) {
        this.reportError('Error retrieving queue', err);
        storageEntry = null;
    }
    return storageEntry || [];
};

/**
 * Serialize the given items array to localStorage.
 */
RequestQueue.prototype.saveToStorage = function(queue) {
    try {
        this.storage.setItem(this.storageKey, JSONStringify(queue));
        return true;
    } catch (err) {
        this.reportError('Error saving queue', err);
        return false;
    }
};

/**
 * Clear out queues (memory and localStorage).
 */
RequestQueue.prototype.clear = function() {
    this.memQueue = [];
    this.storage.removeItem(this.storageKey);
};

// eslint-disable-line camelcase

// maximum interval between request retries after exponential backoff
var MAX_RETRY_INTERVAL_MS = 10 * 60 * 1000; // 10 minutes

var logger = console_with_prefix('batch');

/**
 * RequestBatcher: manages the queueing, flushing, retry etc of requests of one
 * type (events, people, groups).
 * Uses RequestQueue to manage the backing store.
 * @constructor
 */
var RequestBatcher = function(storageKey, options) {
    this.errorReporter = options.errorReporter;
    this.queue = new RequestQueue(storageKey, {
        errorReporter: _.bind(this.reportError, this),
        storage: options.storage
    });

this.libConfig = options.libConfig;
    this.sendRequest = options.sendRequestFunc;
    this.beforeSendHook = options.beforeSendHook;
    this.stopAllBatching = options.stopAllBatchingFunc;

// seed variable batch size + flush interval with configured values
    this.batchSize = this.libConfig['batch_size'];
    this.flushInterval = this.libConfig['batch_flush_interval_ms'];

this.stopped = !this.libConfig['batch_autostart'];
    this.consecutiveRemovalFailures = 0;

// extra client-side dedupe
    this.itemIdsSentSuccessfully = {};
};

/**
 * Add one item to queue.
 */
RequestBatcher.prototype.enqueue = function(item, cb) {
    this.queue.enqueue(item, this.flushInterval, cb);
};

/**
 * Start flushing batches at the configured time interval. Must call
 * this method upon SDK init in order to send anything over the network.
 */
RequestBatcher.prototype.start = function() {
    this.stopped = false;
    this.consecutiveRemovalFailures = 0;
    this.flush();
};

/**
 * Stop flushing batches. Can be restarted by calling start().
 */
RequestBatcher.prototype.stop = function() {
    this.stopped = true;
    if (this.timeoutID) {
        clearTimeout(this.timeoutID);
        this.timeoutID = null;
    }
};

/**
 * Clear out queue.
 */
RequestBatcher.prototype.clear = function() {
    this.queue.clear();
};

/**
 * Restore batch size configuration to whatever is set in the main SDK.
 */
RequestBatcher.prototype.resetBatchSize = function() {
    this.batchSize = this.libConfig['batch_size'];
};

/**
 * Restore flush interval time configuration to whatever is set in the main SDK.
 */
RequestBatcher.prototype.resetFlush = function() {
    this.scheduleFlush(this.libConfig['batch_flush_interval_ms']);
};

/**
 * Schedule the next flush in the given number of milliseconds.
 */
RequestBatcher.prototype.scheduleFlush = function(flushMS) {
    this.flushInterval = flushMS;
    if (!this.stopped) { // don't schedule anymore if batching has been stopped
        this.timeoutID = setTimeout(_.bind(this.flush, this), this.flushInterval);
    }
};

/**
 * Flush one batch to network. Depending on success/failure modes, it will either
 * remove the batch from the queue or leave it in for retry, and schedule the next
 * flush. In cases of most network or API failures, it will back off exponentially
 * when retrying.
 * @param {Object} [options]
 * @param {boolean} [options.sendBeacon] - whether to send batch with
 * navigator.sendBeacon (only useful for sending batches before page unloads, as
 * sendBeacon offers no callbacks or status indications)
 */
RequestBatcher.prototype.flush = function(options) {
    try {

if (this.requestInProgress) {
            logger.log('Flush: Request already in progress');
            return;
        }

options = options || {};
        var timeoutMS = this.libConfig['batch_request_timeout_ms'];
        var startTime = new Date().getTime();
        var currentBatchSize = this.batchSize;
        var batch = this.queue.fillBatch(currentBatchSize);
        var dataForRequest = [];
        var transformedItems = {};
        _.each(batch, function(item) {
            var payload = item['payload'];
            if (this.beforeSendHook && !item.orphaned) {
                payload = this.beforeSendHook(payload);
            }
            if (payload) {
                // mp_sent_by_lib_version prop captures which lib version actually
                // sends each event (regardless of which version originally queued
                // it for sending)
                if (payload['event'] && payload['properties']) {
                    payload['properties'] = _.extend(
                        {},
                        payload['properties'],
                        {'mp_sent_by_lib_version': Config.LIB_VERSION}
                    );
                }
                var addPayload = true;
                var itemId = item['id'];
                if (itemId) {
                    if ((this.itemIdsSentSuccessfully[itemId] || 0) > 5) {
                        this.reportError('[dupe] item ID sent too many times, not sending', {
                            item: item,
                            batchSize: batch.length,
                            timesSent: this.itemIdsSentSuccessfully[itemId]
                        });
                        addPayload = false;
                    }
                } else {
                    this.reportError('[dupe] found item with no ID', {item: item});
                }

if (addPayload) {
 dataForRequest.push(payload);
 }
 }
 transformedItems[item['id']] = payload;
 }, this);
 if (dataForRequest.length < 1) {
 this.resetFlush();
 return; // nothing to do
 }

this.requestInProgress = true;

var batchSendCallback = _.bind(function(res) {
            this.requestInProgress = false;

try {

// handle API response in a try-catch to make sure we can reset the
                // flush operation if something goes wrong

if (removeItemsFromQueue) {
                    this.queue.removeItemsByID(
                        _.map(batch, function(item) { return item['id']; }),
                        _.bind(function(succeeded) {
                            if (succeeded) {
                                this.consecutiveRemovalFailures = 0;
                                this.flush(); // handle next batch if the queue isn't empty
                            } else {
                                this.reportError('Failed to remove items from queue');
                                if (++this.consecutiveRemovalFailures > 5) {
                                    this.reportError('Too many queue failures; disabling batching system.');
                                    this.stopAllBatching();
                                } else {
                                    this.resetFlush();
                                }
                            }
                        }, this)
                    );

// client-side dedupe
                    _.each(batch, _.bind(function(item) {
                        var itemId = item['id'];
                        if (itemId) {
                            this.itemIdsSentSuccessfully[itemId] = this.itemIdsSentSuccessfully[itemId] || 0;
                            this.itemIdsSentSuccessfully[itemId]++;
                            if (this.itemIdsSentSuccessfully[itemId] > 5) {
                                this.reportError('[dupe] item ID sent too many times', {
                                    item: item,
                                    batchSize: batch.length,
                                    timesSent: this.itemIdsSentSuccessfully[itemId]
                                });
                            }
                        } else {
                            this.reportError('[dupe] found item with no ID while removing', {item: item});
                        }
                    }, this));
                }

} catch(err) {
                this.reportError('Error handling API response', err);
                this.resetFlush();
            }
        }, this);
        var requestOptions = {
            method: 'POST',
            verbose: true,
            ignore_json_errors: true, // eslint-disable-line camelcase
            timeout_ms: timeoutMS // eslint-disable-line camelcase
        };
        if (options.unloading) {
            requestOptions.transport = 'sendBeacon';
        }
        logger.log('MIXPANEL REQUEST:', dataForRequest);
        this.sendRequest(dataForRequest, requestOptions, batchSendCallback);

} catch(err) {
        this.reportError('Error flushing request queue', err);
        this.resetFlush();
    }
};

/**
 * Log error to global logger and optional user-defined logger.
 */
RequestBatcher.prototype.reportError = function(msg, err) {
    logger.error.apply(logger.error, arguments);
    if (this.errorReporter) {
        try {
            if (!(err instanceof Error)) {
                err = new Error(msg);
            }
            this.errorReporter(msg, err);
        } catch(err) {
            logger.error(err);
        }
    }
};

/**
 * A function used to track a Mixpanel event (e.g. MixpanelLib.track)
 * @callback trackFunction
 * @param {String} event_name The name of the event. This can be anything the user does - 'Button Click', 'Sign Up', 'Item Purchased', etc.
 * @param {Object} [properties] A set of properties to include with the event you're sending. These describe the user who did the event or details about the event itself.
 * @param {Function} [callback] If provided, the callback function will be called after tracking the event.
 */

/** Public **/

var GDPR_DEFAULT_PERSISTENCE_PREFIX = '__mp_opt_in_out_';

/**
 * Opt the user in to data tracking and cookies/localstorage for the given token
 * @param {string} token - Mixpanel project tracking token
 * @param {Object} [options]
 * @param {trackFunction} [options.track] - function used for tracking a Mixpanel event to record the opt-in action
 * @param {string} [options.trackEventName] - event name to be used for tracking the opt-in action
 * @param {Object} [options.trackProperties] - set of properties to be tracked along with the opt-in action
 * @param {string} [options.persistenceType] Persistence mechanism used - cookie or localStorage
 * @param {string} [options.persistencePrefix=__mp_opt_in_out] - custom prefix to be used in the cookie/localstorage name
 * @param {Number} [options.cookieExpiration] - number of days until the opt-in cookie expires
 * @param {string} [options.cookieDomain] - custom cookie domain
 * @param {boolean} [options.crossSiteCookie] - whether the opt-in cookie is set as cross-site-enabled
 * @param {boolean} [options.crossSubdomainCookie] - whether the opt-in cookie is set as cross-subdomain or not
 * @param {boolean} [options.secureCookie] - whether the opt-in cookie is set as secure or not
 */
function optIn(token, options) {
    _optInOut(true, token, options);
}

/**
 * Opt the user out of data tracking and cookies/localstorage for the given token
 * @param {string} token - Mixpanel project tracking token
 * @param {Object} [options]
 * @param {string} [options.persistenceType] Persistence mechanism used - cookie or localStorage
 * @param {string} [options.persistencePrefix=__mp_opt_in_out] - custom prefix to be used in the cookie/localstorage name
 * @param {Number} [options.cookieExpiration] - number of days until the opt-out cookie expires
 * @param {string} [options.cookieDomain] - custom cookie domain
 * @param {boolean} [options.crossSiteCookie] - whether the opt-in cookie is set as cross-site-enabled
 * @param {boolean} [options.crossSubdomainCookie] - whether the opt-out cookie is set as cross-subdomain or not
 * @param {boolean} [options.secureCookie] - whether the opt-out cookie is set as secure or not
 */
function optOut(token, options) {
    _optInOut(false, token, options);
}

/**
 * Check whether the user has opted in to data tracking and cookies/localstorage for the given token
 * @param {string} token - Mixpanel project tracking token
 * @param {Object} [options]
 * @param {string} [options.persistenceType] Persistence mechanism used - cookie or localStorage
 * @param {string} [options.persistencePrefix=__mp_opt_in_out] - custom prefix to be used in the cookie/localstorage name
 * @returns {boolean} whether the user has opted in to the given opt type
 */
function hasOptedIn(token, options) {
    return _getStorageValue(token, options) === '1';
}

/**
 * Check whether the user has opted out of data tracking and cookies/localstorage for the given token
 * @param {string} token - Mixpanel project tracking token
 * @param {Object} [options]
 * @param {string} [options.persistenceType] Persistence mechanism used - cookie or localStorage
 * @param {string} [options.persistencePrefix=__mp_opt_in_out] - custom prefix to be used in the cookie/localstorage name
 * @param {boolean} [options.ignoreDnt] - flag to ignore browser DNT settings and always return false
 * @returns {boolean} whether the user has opted out of the given opt type
 */
function hasOptedOut(token, options) {
    if (_hasDoNotTrackFlagOn(options)) {
        console$1.warn('This browser has "Do Not Track" enabled. This will prevent the Mixpanel SDK from sending any data. To ignore the "Do Not Track" browser setting, initialize the Mixpanel instance with the config "ignore_dnt: true"');
        return true;
    }
    var optedOut = _getStorageValue(token, options) === '0';
    if (optedOut) {
        console$1.warn('You are opted out of Mixpanel tracking. This will prevent the Mixpanel SDK from sending any data.');
    }
    return optedOut;
}

/**
 * Wrap a MixpanelLib method with a check for whether the user is opted out of data tracking and cookies/localstorage for the given token
 * If the user has opted out, return early instead of executing the method.
 * If a callback argument was provided, execute it passing the 0 error code.
 * @param {function} method - wrapped method to be executed if the user has not opted out
 * @returns {*} the result of executing method OR undefined if the user has opted out
 */
function addOptOutCheckMixpanelLib(method) {
    return _addOptOutCheck(method, function(name) {
        return this.get_config(name);
    });
}

/**
 * Wrap a MixpanelPeople method with a check for whether the user is opted out of data tracking and cookies/localstorage for the given token
 * If the user has opted out, return early instead of executing the method.
 * If a callback argument was provided, execute it passing the 0 error code.
 * @param {function} method - wrapped method to be executed if the user has not opted out
 * @returns {*} the result of executing method OR undefined if the user has opted out
 */
function addOptOutCheckMixpanelPeople(method) {
    return _addOptOutCheck(method, function(name) {
        return this._get_config(name);
    });
}

/**
 * Wrap a MixpanelGroup method with a check for whether the user is opted out of data tracking and cookies/localstorage for the given token
 * If the user has opted out, return early instead of executing the method.
 * If a callback argument was provided, execute it passing the 0 error code.
 * @param {function} method - wrapped method to be executed if the user has not opted out
 * @returns {*} the result of executing method OR undefined if the user has opted out
 */
function addOptOutCheckMixpanelGroup(method) {
    return _addOptOutCheck(method, function(name) {
        return this._get_config(name);
    });
}

/**
 * Clear the user's opt in/out status of data tracking and cookies/localstorage for the given token
 * @param {string} token - Mixpanel project tracking token
 * @param {Object} [options]
 * @param {string} [options.persistenceType] Persistence mechanism used - cookie or localStorage
 * @param {string} [options.persistencePrefix=__mp_opt_in_out] - custom prefix to be used in the cookie/localstorage name
 * @param {Number} [options.cookieExpiration] - number of days until the opt-in cookie expires
 * @param {string} [options.cookieDomain] - custom cookie domain
 * @param {boolean} [options.crossSiteCookie] - whether the opt-in cookie is set as cross-site-enabled
 * @param {boolean} [options.crossSubdomainCookie] - whether the opt-in cookie is set as cross-subdomain or not
 * @param {boolean} [options.secureCookie] - whether the opt-in cookie is set as secure or not
 */
function clearOptInOut(token, options) {
    options = options || {};
    _getStorage(options).remove(
        _getStorageKey(token, options), !!options.crossSubdomainCookie, options.cookieDomain
    );
}

/** Private **/

/**
 * Get storage util
 * @param {Object} [options]
 * @param {string} [options.persistenceType]
 * @returns {object} either _.cookie or _.localstorage
 */
function _getStorage(options) {
    options = options || {};
    return options.persistenceType === 'localStorage' ? _.localStorage : _.cookie;
}

/**
 * Get the name of the cookie that is used for the given opt type (tracking, cookie, etc.)
 * @param {string} token - Mixpanel project tracking token
 * @param {Object} [options]
 * @param {string} [options.persistencePrefix=__mp_opt_in_out] - custom prefix to be used in the cookie/localstorage name
 * @returns {string} the name of the cookie for the given opt type
 */
function _getStorageKey(token, options) {
    options = options || {};
    return (options.persistencePrefix || GDPR_DEFAULT_PERSISTENCE_PREFIX) + token;
}

/**
 * Get the value of the cookie that is used for the given opt type (tracking, cookie, etc.)
 * @param {string} token - Mixpanel project tracking token
 * @param {Object} [options]
 * @param {string} [options.persistencePrefix=__mp_opt_in_out] - custom prefix to be used in the cookie/localstorage name
 * @returns {string} the value of the cookie for the given opt type
 */
function _getStorageValue(token, options) {
    return _getStorage(options).get(_getStorageKey(token, options));
}

/**
 * Check whether the user has set the DNT/doNotTrack setting to true in their browser
 * @param {Object} [options]
 * @param {string} [options.window] - alternate window object to check; used to force various DNT settings in browser tests
 * @param {boolean} [options.ignoreDnt] - flag to ignore browser DNT settings and always return false
 * @returns {boolean} whether the DNT setting is true
 */
function _hasDoNotTrackFlagOn(options) {
    if (options && options.ignoreDnt) {
        return false;
    }
    var win = (options && options.window) || window$1;
    var nav = win['navigator'] || {};
    var hasDntOn = false;

_.each([
        nav['doNotTrack'], // standard
        nav['msDoNotTrack'],
        win['doNotTrack']
    ], function(dntValue) {
        if (_.includes([true, 1, '1', 'yes'], dntValue)) {
            hasDntOn = true;
        }
    });

return hasDntOn;
}

/**
 * Set cookie/localstorage for the user indicating that they are opted in or out for the given opt type
 * @param {boolean} optValue - whether to opt the user in or out for the given opt type
 * @param {string} token - Mixpanel project tracking token
 * @param {Object} [options]
 * @param {trackFunction} [options.track] - function used for tracking a Mixpanel event to record the opt-in action
 * @param {string} [options.trackEventName] - event name to be used for tracking the opt-in action
 * @param {Object} [options.trackProperties] - set of properties to be tracked along with the opt-in action
 * @param {string} [options.persistencePrefix=__mp_opt_in_out] - custom prefix to be used in the cookie/localstorage name
 * @param {Number} [options.cookieExpiration] - number of days until the opt-in cookie expires
 * @param {string} [options.cookieDomain] - custom cookie domain
 * @param {boolean} [options.crossSiteCookie] - whether the opt-in cookie is set as cross-site-enabled
 * @param {boolean} [options.crossSubdomainCookie] - whether the opt-in cookie is set as cross-subdomain or not
 * @param {boolean} [options.secureCookie] - whether the opt-in cookie is set as secure or not
 */
function _optInOut(optValue, token, options) {
    if (!_.isString(token) || !token.length) {
        console$1.error('gdpr.' + (optValue ? 'optIn' : 'optOut') + ' called with an invalid token');
        return;
    }

options = options || {};

_getStorage(options).set(
        _getStorageKey(token, options),
        optValue ? 1 : 0,
        _.isNumber(options.cookieExpiration) ? options.cookieExpiration : null,
        !!options.crossSubdomainCookie,
        !!options.secureCookie,
        !!options.crossSiteCookie,
        options.cookieDomain
    );

if (options.track && optValue) { // only track event if opting in (optValue=true)
        options.track(options.trackEventName || '$opt_in', options.trackProperties, {
            'send_immediately': true
        });
    }
}

/**
 * Wrap a method with a check for whether the user is opted out of data tracking and cookies/localstorage for the given token
 * If the user has opted out, return early instead of executing the method.
 * If a callback argument was provided, execute it passing the 0 error code.
 * @param {function} method - wrapped method to be executed if the user has not opted out
 * @param {function} getConfigValue - getter function for the Mixpanel API token and other options to be used with opt-out check
 * @returns {*} the result of executing method OR undefined if the user has opted out
 */
function _addOptOutCheck(method, getConfigValue) {
    return function() {
        var optedOut = false;

try {
            var token = getConfigValue.call(this, 'token');
            var ignoreDnt = getConfigValue.call(this, 'ignore_dnt');
            var persistenceType = getConfigValue.call(this, 'opt_out_tracking_persistence_type');
            var persistencePrefix = getConfigValue.call(this, 'opt_out_tracking_cookie_prefix');
            var win = getConfigValue.call(this, 'window'); // used to override window during browser tests

if (token) { // if there was an issue getting the token, continue method execution as normal
                optedOut = hasOptedOut(token, {
                    ignoreDnt: ignoreDnt,
                    persistenceType: persistenceType,
                    persistencePrefix: persistencePrefix,
                    window: win
                });
            }
        } catch(err) {
            console$1.error('Unexpected error when checking tracking opt-out status: ' + err);
        }

if (!optedOut) {
            return method.apply(this, arguments);
        }

var callback = arguments[arguments.length - 1];
        if (typeof(callback) === 'function') {
            callback(0);
        }

return;
    };
}

/** @const */ var SET_ACTION      = '$set';
/** @const */ var SET_ONCE_ACTION = '$set_once';
/** @const */ var UNSET_ACTION    = '$unset';
/** @const */ var ADD_ACTION      = '$add';
/** @const */ var APPEND_ACTION   = '$append';
/** @const */ var UNION_ACTION    = '$union';
/** @const */ var REMOVE_ACTION   = '$remove';
/** @const */ var DELETE_ACTION   = '$delete';

// Common internal methods for mixpanel.people and mixpanel.group APIs.
// These methods shouldn't involve network I/O.
var apiActions = {
    set_action: function(prop, to) {
        var data = {};
        var $set = {};
        if (_.isObject(prop)) {
            _.each(prop, function(v, k) {
                if (!this._is_reserved_property(k)) {
                    $set[k] = v;
                }
            }, this);
        } else {
            $set[prop] = to;
        }

data[SET_ACTION] = $set;
        return data;
    },

unset_action: function(prop) {
        var data = {};
        var $unset = [];
        if (!_.isArray(prop)) {
            prop = [prop];
        }

_.each(prop, function(k) {
            if (!this._is_reserved_property(k)) {
                $unset.push(k);
            }
        }, this);

data[UNSET_ACTION] = $unset;
        return data;
    },

set_once_action: function(prop, to) {
        var data = {};
        var $set_once = {};
        if (_.isObject(prop)) {
            _.each(prop, function(v, k) {
                if (!this._is_reserved_property(k)) {
                    $set_once[k] = v;
                }
            }, this);
        } else {
            $set_once[prop] = to;
        }
        data[SET_ONCE_ACTION] = $set_once;
        return data;
    },

union_action: function(list_name, values) {
        var data = {};
        var $union = {};
        if (_.isObject(list_name)) {
            _.each(list_name, function(v, k) {
                if (!this._is_reserved_property(k)) {
                    $union[k] = _.isArray(v) ? v : [v];
                }
            }, this);
        } else {
            $union[list_name] = _.isArray(values) ? values : [values];
        }
        data[UNION_ACTION] = $union;
        return data;
    },

append_action: function(list_name, value) {
        var data = {};
        var $append = {};
        if (_.isObject(list_name)) {
            _.each(list_name, function(v, k) {
                if (!this._is_reserved_property(k)) {
                    $append[k] = v;
                }
            }, this);
        } else {
            $append[list_name] = value;
        }
        data[APPEND_ACTION] = $append;
        return data;
    },

remove_action: function(list_name, value) {
        var data = {};
        var $remove = {};
        if (_.isObject(list_name)) {
            _.each(list_name, function(v, k) {
                if (!this._is_reserved_property(k)) {
                    $remove[k] = v;
                }
            }, this);
        } else {
            $remove[list_name] = value;
        }
        data[REMOVE_ACTION] = $remove;
        return data;
    },

delete_action: function() {
        var data = {};
        data[DELETE_ACTION] = '';
        return data;
    }
};

/**
 * Mixpanel Group Object
 * @constructor
 */
var MixpanelGroup = function() {};

_.extend(MixpanelGroup.prototype, apiActions);

MixpanelGroup.prototype._init = function(mixpanel_instance, group_key, group_id) {
    this._mixpanel = mixpanel_instance;
    this._group_key = group_key;
    this._group_id = group_id;
};

/**
 * Set properties on a group.
 *
 * ### Usage:
 *
 *     mixpanel.get_group('company', 'mixpanel').set('Location', '405 Howard');
 *
 *     // or set multiple properties at once
 *     mixpanel.get_group('company', 'mixpanel').set({
 *          'Location': '405 Howard',
 *          'Founded' : 2009,
 *     });
 *     // properties can be strings, integers, dates, or lists
 *
 * @param {Object|String} prop If a string, this is the name of the property. If an object, this is an associative array of names and values.
 * @param {*} [to] A value to set on the given property name
 * @param {Function} [callback] If provided, the callback will be called after the tracking event
 */
MixpanelGroup.prototype.set = addOptOutCheckMixpanelGroup(function(prop, to, callback) {
    var data = this.set_action(prop, to);
    if (_.isObject(prop)) {
        callback = to;
    }
    return this._send_request(data, callback);
});

/**
 * Set properties on a group, only if they do not yet exist.
 * This will not overwrite previous group property values, unlike
 * group.set().
 *
 * ### Usage:
 *
 *     mixpanel.get_group('company', 'mixpanel').set_once('Location', '405 Howard');
 *
 *     // or set multiple properties at once
 *     mixpanel.get_group('company', 'mixpanel').set_once({
 *          'Location': '405 Howard',
 *          'Founded' : 2009,
 *     });
 *     // properties can be strings, integers, lists or dates
 *
 * @param {Object|String} prop If a string, this is the name of the property. If an object, this is an associative array of names and values.
 * @param {*} [to] A value to set on the given property name
 * @param {Function} [callback] If provided, the callback will be called after the tracking event
 */
MixpanelGroup.prototype.set_once = addOptOutCheckMixpanelGroup(function(prop, to, callback) {
    var data = this.set_once_action(prop, to);
    if (_.isObject(prop)) {
        callback = to;
    }
    return this._send_request(data, callback);
});

/**
 * Unset properties on a group permanently.
 *
 * ### Usage:
 *
 *     mixpanel.get_group('company', 'mixpanel').unset('Founded');
 *
 * @param {String} prop The name of the property.
 * @param {Function} [callback] If provided, the callback will be called after the tracking event
 */
MixpanelGroup.prototype.unset = addOptOutCheckMixpanelGroup(function(prop, callback) {
    var data = this.unset_action(prop);
    return this._send_request(data, callback);
});

/**
 * Merge a given list with a list-valued group property, excluding duplicate values.
 *
 * ### Usage:
 *
 *     // merge a value to a list, creating it if needed
 *     mixpanel.get_group('company', 'mixpanel').union('Location', ['San Francisco', 'London']);
 *
 * @param {String} list_name Name of the property.
 * @param {Array} values Values to merge with the given property
 * @param {Function} [callback] If provided, the callback will be called after the tracking event
 */
MixpanelGroup.prototype.union = addOptOutCheckMixpanelGroup(function(list_name, values, callback) {
    if (_.isObject(list_name)) {
        callback = values;
    }
    var data = this.union_action(list_name, values);
    return this._send_request(data, callback);
});

/**
 * Permanently delete a group.
 *
 * ### Usage:
 *
 *     mixpanel.get_group('company', 'mixpanel').delete();
 *
 * @param {Function} [callback] If provided, the callback will be called after the tracking event
 */
MixpanelGroup.prototype['delete'] = addOptOutCheckMixpanelGroup(function(callback) {
    // bracket notation above prevents a minification error related to reserved words
    var data = this.delete_action();
    return this._send_request(data, callback);
});

/**
 * Remove a property from a group. The value will be ignored if doesn't exist.
 *
 * ### Usage:
 *
 *     mixpanel.get_group('company', 'mixpanel').remove('Location', 'London');
 *
 * @param {String} list_name Name of the property.
 * @param {Object} value Value to remove from the given group property
 * @param {Function} [callback] If provided, the callback will be called after the tracking event
 */
MixpanelGroup.prototype.remove = addOptOutCheckMixpanelGroup(function(list_name, value, callback) {
    var data = this.remove_action(list_name, value);
    return this._send_request(data, callback);
});

MixpanelGroup.prototype._send_request = function(data, callback) {
    data['$group_key'] = this._group_key;
    data['$group_id'] = this._group_id;
    data['$token'] = this._get_config('token');

var date_encoded_data = _.encodeDates(data);
    return this._mixpanel._track_or_batch({
        type: 'groups',
        data: date_encoded_data,
        endpoint: this._get_config('api_host') + '/' +  this._get_config('api_routes')['groups'],
        batcher: this._mixpanel.request_batchers.groups
    }, callback);
};

MixpanelGroup.prototype._is_reserved_property = function(prop) {
    return prop === '$group_key' || prop === '$group_id';
};

MixpanelGroup.prototype._get_config = function(conf) {
    return this._mixpanel.get_config(conf);
};

MixpanelGroup.prototype.toString = function() {
    return this._mixpanel.toString() + '.group.' + this._group_key + '.' + this._group_id;
};

// MixpanelGroup Exports
MixpanelGroup.prototype['remove']   = MixpanelGroup.prototype.remove;
MixpanelGroup.prototype['set']      = MixpanelGroup.prototype.set;
MixpanelGroup.prototype['set_once'] = MixpanelGroup.prototype.set_once;
MixpanelGroup.prototype['union']    = MixpanelGroup.prototype.union;
MixpanelGroup.prototype['unset']    = MixpanelGroup.prototype.unset;
MixpanelGroup.prototype['toString'] = MixpanelGroup.prototype.toString;

/**
 * Mixpanel People Object
 * @constructor
 */
var MixpanelPeople = function() {};

_.extend(MixpanelPeople.prototype, apiActions);

MixpanelPeople.prototype._init = function(mixpanel_instance) {
    this._mixpanel = mixpanel_instance;
};

/*
* Set properties on a user record.
*
* ### Usage:
*
*     mixpanel.people.set('gender', 'm');
*
*     // or set multiple properties at once
*     mixpanel.people.set({
*         'Company': 'Acme',
*         'Plan': 'Premium',
*         'Upgrade date': new Date()
*     });
*     // properties can be strings, integers, dates, or lists
*
* @param {Object|String} prop If a string, this is the name of the property. If an object, this is an associative array of names and values.
* @param {*} [to] A value to set on the given property name
* @param {Function} [callback] If provided, the callback will be called after tracking the event.
*/
MixpanelPeople.prototype.set = addOptOutCheckMixpanelPeople(function(prop, to, callback) {
    var data = this.set_action(prop, to);
    if (_.isObject(prop)) {
        callback = to;
    }
    // make sure that the referrer info has been updated and saved
    if (this._get_config('save_referrer')) {
        this._mixpanel['persistence'].update_referrer_info(document.referrer);
    }

// update $set object with default people properties
    data[SET_ACTION] = _.extend(
        {},
        _.info.people_properties(),
        data[SET_ACTION]
    );
    return this._send_request(data, callback);
});

/*
* Set properties on a user record, only if they do not yet exist.
* This will not overwrite previous people property values, unlike
* people.set().
*
* ### Usage:
*
*     mixpanel.people.set_once('First Login Date', new Date());
*
*     // or set multiple properties at once
*     mixpanel.people.set_once({
*         'First Login Date': new Date(),
*         'Starting Plan': 'Premium'
*     });
*
*     // properties can be strings, integers or dates
*
* @param {Object|String} prop If a string, this is the name of the property. If an object, this is an associative array of names and values.
* @param {*} [to] A value to set on the given property name
* @param {Function} [callback] If provided, the callback will be called after tracking the event.
*/
MixpanelPeople.prototype.set_once = addOptOutCheckMixpanelPeople(function(prop, to, callback) {
    var data = this.set_once_action(prop, to);
    if (_.isObject(prop)) {
        callback = to;
    }
    return this._send_request(data, callback);
});

/*
* Unset properties on a user record (permanently removes the properties and their values from a profile).
*
* ### Usage:
*
*     mixpanel.people.unset('gender');
*
*     // or unset multiple properties at once
*     mixpanel.people.unset(['gender', 'Company']);
*
* @param {Array|String} prop If a string, this is the name of the property. If an array, this is a list of property names.
* @param {Function} [callback] If provided, the callback will be called after tracking the event.
*/
MixpanelPeople.prototype.unset = addOptOutCheckMixpanelPeople(function(prop, callback) {
    var data = this.unset_action(prop);
    return this._send_request(data, callback);
});

/*
* Increment/decrement numeric people analytics properties.
*
* ### Usage:
*
*     mixpanel.people.increment('page_views', 1);
*
*     // or, for convenience, if you're just incrementing a counter by
*     // 1, you can simply do
*     mixpanel.people.increment('page_views');
*
*     // to decrement a counter, pass a negative number
*     mixpanel.people.increment('credits_left', -1);
*
*     // like mixpanel.people.set(), you can increment multiple
*     // properties at once:
*     mixpanel.people.increment({
*         counter1: 1,
*         counter2: 6
*     });
*
* @param {Object|String} prop If a string, this is the name of the property. If an object, this is an associative array of names and numeric values.
* @param {Number} [by] An amount to increment the given property
* @param {Function} [callback] If provided, the callback will be called after tracking the event.
*/
MixpanelPeople.prototype.increment = addOptOutCheckMixpanelPeople(function(prop, by, callback) {
    var data = {};
    var $add = {};
    if (_.isObject(prop)) {
        _.each(prop, function(v, k) {
            if (!this._is_reserved_property(k)) {
                if (isNaN(parseFloat(v))) {
                    console$1.error('Invalid increment value passed to mixpanel.people.increment - must be a number');
                    return;
                } else {
                    $add[k] = v;
                }
            }
        }, this);
        callback = by;
    } else {
        // convenience: mixpanel.people.increment('property'); will
        // increment 'property' by 1
        if (_.isUndefined(by)) {
            by = 1;
        }
        $add[prop] = by;
    }
    data[ADD_ACTION] = $add;

return this._send_request(data, callback);
});

/*
* Append a value to a list-valued people analytics property.
*
* ### Usage:
*
*     // append a value to a list, creating it if needed
*     mixpanel.people.append('pages_visited', 'homepage');
*
*     // like mixpanel.people.set(), you can append multiple
*     // properties at once:
*     mixpanel.people.append({
*         list1: 'bob',
*         list2: 123
*     });
*
* @param {Object|String} list_name If a string, this is the name of the property. If an object, this is an associative array of names and values.
* @param {*} [value] value An item to append to the list
* @param {Function} [callback] If provided, the callback will be called after tracking the event.
*/
MixpanelPeople.prototype.append = addOptOutCheckMixpanelPeople(function(list_name, value, callback) {
    if (_.isObject(list_name)) {
        callback = value;
    }
    var data = this.append_action(list_name, value);
    return this._send_request(data, callback);
});

/*
* Remove a value from a list-valued people analytics property.
*
* ### Usage:
*
*     mixpanel.people.remove('School', 'UCB');
*
* @param {Object|String} list_name If a string, this is the name of the property. If an object, this is an associative array of names and values.
* @param {*} [value] value Item to remove from the list
* @param {Function} [callback] If provided, the callback will be called after tracking the event.
*/
MixpanelPeople.prototype.remove = addOptOutCheckMixpanelPeople(function(list_name, value, callback) {
    if (_.isObject(list_name)) {
        callback = value;
    }
    var data = this.remove_action(list_name, value);
    return this._send_request(data, callback);
});

/*
* Merge a given list with a list-valued people analytics property,
* excluding duplicate values.
*
* ### Usage:
*
*     // merge a value to a list, creating it if needed
*     mixpanel.people.union('pages_visited', 'homepage');
*
*     // like mixpanel.people.set(), you can append multiple
*     // properties at once:
*     mixpanel.people.union({
*         list1: 'bob',
*         list2: 123
*     });
*
*     // like mixpanel.people.append(), you can append multiple
*     // values to the same list:
*     mixpanel.people.union({
*         list1: ['bob', 'billy']
*     });
*
* @param {Object|String} list_name If a string, this is the name of the property. If an object, this is an associative array of names and values.
* @param {*} [value] Value / values to merge with the given property
* @param {Function} [callback] If provided, the callback will be called after tracking the event.
*/
MixpanelPeople.prototype.union = addOptOutCheckMixpanelPeople(function(list_name, values, callback) {
    if (_.isObject(list_name)) {
        callback = values;
    }
    var data = this.union_action(list_name, values);
    return this._send_request(data, callback);
});

/*
 * Record that you have charged the current user a certain amount
 * of money. Charges recorded with track_charge() will appear in the
 * Mixpanel revenue report.
 *
 * ### Usage:
 *
 *     // charge a user $50
 *     mixpanel.people.track_charge(50);
 *
 *     // charge a user $30.50 on the 2nd of january
 *     mixpanel.people.track_charge(30.50, {
 *         '$time': new Date('jan 1 2012')
 *     });
 *
 * @param {Number} amount The amount of money charged to the current user
 * @param {Object} [properties] An associative array of properties associated with the charge
 * @param {Function} [callback] If provided, the callback will be called when the server responds
 * @deprecated
 */
MixpanelPeople.prototype.track_charge = addOptOutCheckMixpanelPeople(function(amount, properties, callback) {
    if (!_.isNumber(amount)) {
        amount = parseFloat(amount);
        if (isNaN(amount)) {
            console$1.error('Invalid value passed to mixpanel.people.track_charge - must be a number');
            return;
        }
    }

return this.append('$transactions', _.extend({
        '$amount': amount
    }, properties), callback);
});

/*
 * Permanently clear all revenue report transactions from the
 * current user's people analytics profile.
 *
 * ### Usage:
 *
 *     mixpanel.people.clear_charges();
 *
 * @param {Function} [callback] If provided, the callback will be called after tracking the event.
 * @deprecated
 */
MixpanelPeople.prototype.clear_charges = function(callback) {
    return this.set('$transactions', [], callback);
};

/*
* Permanently deletes the current people analytics profile from
* Mixpanel (using the current distinct_id).
*
* ### Usage:
*
*     // remove the all data you have stored about the current user
*     mixpanel.people.delete_user();
*
*/
MixpanelPeople.prototype.delete_user = function() {
    if (!this._identify_called()) {
        console$1.error('mixpanel.people.delete_user() requires you to call identify() first');
        return;
    }
    var data = {'$delete': this._mixpanel.get_distinct_id()};
    return this._send_request(data);
};

MixpanelPeople.prototype.toString = function() {
    return this._mixpanel.toString() + '.people';
};

MixpanelPeople.prototype._send_request = function(data, callback) {
    data['$token'] = this._get_config('token');
    data['$distinct_id'] = this._mixpanel.get_distinct_id();
    var device_id = this._mixpanel.get_property('$device_id');
    var user_id = this._mixpanel.get_property('$user_id');
    var had_persisted_distinct_id = this._mixpanel.get_property('$had_persisted_distinct_id');
    if (device_id) {
        data['$device_id'] = device_id;
    }
    if (user_id) {
        data['$user_id'] = user_id;
    }
    if (had_persisted_distinct_id) {
        data['$had_persisted_distinct_id'] = had_persisted_distinct_id;
    }

var date_encoded_data = _.encodeDates(data);

if (!this._identify_called()) {
        this._enqueue(data);
        if (!_.isUndefined(callback)) {
            if (this._get_config('verbose')) {
                callback({status: -1, error: null});
            } else {
                callback(-1);
            }
        }
        return _.truncate(date_encoded_data, 255);
    }

return this._mixpanel._track_or_batch({
        type: 'people',
        data: date_encoded_data,
        endpoint: this._get_config('api_host') + '/' +  this._get_config('api_routes')['engage'],
        batcher: this._mixpanel.request_batchers.people
    }, callback);
};

MixpanelPeople.prototype._get_config = function(conf_var) {
    return this._mixpanel.get_config(conf_var);
};

MixpanelPeople.prototype._identify_called = function() {
    return this._mixpanel._flags.identify_called === true;
};

// Queue up engage operations if identify hasn't been called yet.
MixpanelPeople.prototype._enqueue = function(data) {
    if (SET_ACTION in data) {
        this._mixpanel['persistence']._add_to_people_queue(SET_ACTION, data);
    } else if (SET_ONCE_ACTION in data) {
        this._mixpanel['persistence']._add_to_people_queue(SET_ONCE_ACTION, data);
    } else if (UNSET_ACTION in data) {
        this._mixpanel['persistence']._add_to_people_queue(UNSET_ACTION, data);
    } else if (ADD_ACTION in data) {
        this._mixpanel['persistence']._add_to_people_queue(ADD_ACTION, data);
    } else if (APPEND_ACTION in data) {
        this._mixpanel['persistence']._add_to_people_queue(APPEND_ACTION, data);
    } else if (REMOVE_ACTION in data) {
        this._mixpanel['persistence']._add_to_people_queue(REMOVE_ACTION, data);
    } else if (UNION_ACTION in data) {
        this._mixpanel['persistence']._add_to_people_queue(UNION_ACTION, data);
    } else {
        console$1.error('Invalid call to _enqueue():', data);
    }
};

MixpanelPeople.prototype._flush_one_queue = function(action, action_method, callback, queue_to_params_fn) {
    var _this = this;
    var queued_data = _.extend({}, this._mixpanel['persistence'].load_queue(action));
    var action_params = queued_data;

if (!_.isUndefined(queued_data) && _.isObject(queued_data) && !_.isEmptyObject(queued_data)) {
        _this._mixpanel['persistence']._pop_from_people_queue(action, queued_data);
        _this._mixpanel['persistence'].save();
        if (queue_to_params_fn) {
            action_params = queue_to_params_fn(queued_data);
        }
        action_method.call(_this, action_params, function(response, data) {
            // on bad response, we want to add it back to the queue
            if (response === 0) {
                _this._mixpanel['persistence']._add_to_people_queue(action, queued_data);
            }
            if (!_.isUndefined(callback)) {
                callback(response, data);
            }
        });
    }
};

// Flush queued engage operations - order does not matter,
// and there are network level race conditions anyway
MixpanelPeople.prototype._flush = function(
    _set_callback, _add_callback, _append_callback, _set_once_callback, _union_callback, _unset_callback, _remove_callback
) {
    var _this = this;

this._flush_one_queue(SET_ACTION, this.set, _set_callback);
    this._flush_one_queue(SET_ONCE_ACTION, this.set_once, _set_once_callback);
    this._flush_one_queue(UNSET_ACTION, this.unset, _unset_callback, function(queue) { return _.keys(queue); });
    this._flush_one_queue(ADD_ACTION, this.increment, _add_callback);
    this._flush_one_queue(UNION_ACTION, this.union, _union_callback);

// we have to fire off each $append individually since there is
    // no concat method server side
    var $append_queue = this._mixpanel['persistence'].load_queue(APPEND_ACTION);
    if (!_.isUndefined($append_queue) && _.isArray($append_queue) && $append_queue.length) {
        var $append_item;
        var append_callback = function(response, data) {
            if (response === 0) {
                _this._mixpanel['persistence']._add_to_people_queue(APPEND_ACTION, $append_item);
            }
            if (!_.isUndefined(_append_callback)) {
                _append_callback(response, data);
            }
        };
        for (var i = $append_queue.length - 1; i >= 0; i--) {
            $append_queue = this._mixpanel['persistence'].load_queue(APPEND_ACTION);
            $append_item = $append_queue.pop();
            _this._mixpanel['persistence'].save();
            if (!_.isEmptyObject($append_item)) {
                _this.append($append_item, append_callback);
            }
        }
    }

// same for $remove
    var $remove_queue = this._mixpanel['persistence'].load_queue(REMOVE_ACTION);
    if (!_.isUndefined($remove_queue) && _.isArray($remove_queue) && $remove_queue.length) {
        var $remove_item;
        var remove_callback = function(response, data) {
            if (response === 0) {
                _this._mixpanel['persistence']._add_to_people_queue(REMOVE_ACTION, $remove_item);
            }
            if (!_.isUndefined(_remove_callback)) {
                _remove_callback(response, data);
            }
        };
        for (var j = $remove_queue.length - 1; j >= 0; j--) {
            $remove_queue = this._mixpanel['persistence'].load_queue(REMOVE_ACTION);
            $remove_item = $remove_queue.pop();
            _this._mixpanel['persistence'].save();
            if (!_.isEmptyObject($remove_item)) {
                _this.remove($remove_item, remove_callback);
            }
        }
    }
};

MixpanelPeople.prototype._is_reserved_property = function(prop) {
    return prop === '$distinct_id' || prop === '$token' || prop === '$device_id' || prop === '$user_id' || prop === '$had_persisted_distinct_id';
};

// MixpanelPeople Exports
MixpanelPeople.prototype['set']           = MixpanelPeople.prototype.set;
MixpanelPeople.prototype['set_once']      = MixpanelPeople.prototype.set_once;
MixpanelPeople.prototype['unset']         = MixpanelPeople.prototype.unset;
MixpanelPeople.prototype['increment']     = MixpanelPeople.prototype.increment;
MixpanelPeople.prototype['append']        = MixpanelPeople.prototype.append;
MixpanelPeople.prototype['remove']        = MixpanelPeople.prototype.remove;
MixpanelPeople.prototype['union']         = MixpanelPeople.prototype.union;
MixpanelPeople.prototype['track_charge']  = MixpanelPeople.prototype.track_charge;
MixpanelPeople.prototype['clear_charges'] = MixpanelPeople.prototype.clear_charges;
MixpanelPeople.prototype['delete_user']   = MixpanelPeople.prototype.delete_user;
MixpanelPeople.prototype['toString']      = MixpanelPeople.prototype.toString;

/*
 * Constants
 */
/** @const */ var SET_QUEUE_KEY          = '__mps';
/** @const */ var SET_ONCE_QUEUE_KEY     = '__mpso';
/** @const */ var UNSET_QUEUE_KEY        = '__mpus';
/** @const */ var ADD_QUEUE_KEY          = '__mpa';
/** @const */ var APPEND_QUEUE_KEY       = '__mpap';
/** @const */ var REMOVE_QUEUE_KEY       = '__mpr';
/** @const */ var UNION_QUEUE_KEY        = '__mpu';
// This key is deprecated, but we want to check for it to see whether aliasing is allowed.
/** @const */ var PEOPLE_DISTINCT_ID_KEY = '$people_distinct_id';
/** @const */ var ALIAS_ID_KEY           = '__alias';
/** @const */ var EVENT_TIMERS_KEY       = '__timers';
/** @const */ var RESERVED_PROPERTIES = [
    SET_QUEUE_KEY,
    SET_ONCE_QUEUE_KEY,
    UNSET_QUEUE_KEY,
    ADD_QUEUE_KEY,
    APPEND_QUEUE_KEY,
    REMOVE_QUEUE_KEY,
    UNION_QUEUE_KEY,
    PEOPLE_DISTINCT_ID_KEY,
    ALIAS_ID_KEY,
    EVENT_TIMERS_KEY
];

/**
 * Mixpanel Persistence Object
 * @constructor
 */
var MixpanelPersistence = function(config) {
    this['props'] = {};
    this.campaign_params_saved = false;

if (config['persistence_name']) {
        this.name = 'mp_' + config['persistence_name'];
    } else {
        this.name = 'mp_' + config['token'] + '_mixpanel';
    }

var storage_type = config['persistence'];
    if (storage_type !== 'cookie' && storage_type !== 'localStorage') {
        console$1.critical('Unknown persistence type ' + storage_type + '; falling back to cookie');
        storage_type = config['persistence'] = 'cookie';
    }

if (storage_type === 'localStorage' && _.localStorage.is_supported()) {
        this.storage = _.localStorage;
    } else {
        this.storage = _.cookie;
    }

this.load();
    this.update_config(config);
    this.upgrade(config);
    this.save();
};

MixpanelPersistence.prototype.properties = function() {
    var p = {};

this.load();

// Filter out reserved properties
    _.each(this['props'], function(v, k) {
        if (!_.include(RESERVED_PROPERTIES, k)) {
            p[k] = v;
        }
    });
    return p;
};

MixpanelPersistence.prototype.load = function() {
    if (this.disabled) { return; }

var entry = this.storage.parse(this.name);

if (entry) {
        this['props'] = _.extend({}, entry);
    }
};

MixpanelPersistence.prototype.upgrade = function(config) {
    var upgrade_from_old_lib = config['upgrade'],
        old_cookie_name,
        old_cookie;

if (upgrade_from_old_lib) {
        old_cookie_name = 'mp_super_properties';
        // Case where they had a custom cookie name before.
        if (typeof(upgrade_from_old_lib) === 'string') {
            old_cookie_name = upgrade_from_old_lib;
        }

old_cookie = this.storage.parse(old_cookie_name);

// remove the cookie
        this.storage.remove(old_cookie_name);
        this.storage.remove(old_cookie_name, true);

if (old_cookie) {
            this['props'] = _.extend(
                this['props'],
                old_cookie['all'],
                old_cookie['events']
            );
        }
    }

if (!config['cookie_name'] && config['name'] !== 'mixpanel') {
        // special case to handle people with cookies of the form
        // mp_TOKEN_INSTANCENAME from the first release of this library
        old_cookie_name = 'mp_' + config['token'] + '_' + config['name'];
        old_cookie = this.storage.parse(old_cookie_name);

if (old_cookie) {
            this.storage.remove(old_cookie_name);
            this.storage.remove(old_cookie_name, true);

// Save the prop values that were in the cookie from before -
            // this should only happen once as we delete the old one.
            this.register_once(old_cookie);
        }
    }

if (this.storage === _.localStorage) {
        old_cookie = _.cookie.parse(this.name);

_.cookie.remove(this.name);
        _.cookie.remove(this.name, true);

if (old_cookie) {
            this.register_once(old_cookie);
        }
    }
};

MixpanelPersistence.prototype.save = function() {
    if (this.disabled) { return; }

this.storage.set(
        this.name,
        _.JSONEncode(this['props']),
        this.expire_days,
        this.cross_subdomain,
        this.secure,
        this.cross_site,
        this.cookie_domain
    );
};

MixpanelPersistence.prototype.load_prop = function(key) {
    this.load();
    return this['props'][key];
};

MixpanelPersistence.prototype.remove = function() {
    // remove both domain and subdomain cookies
    this.storage.remove(this.name, false, this.cookie_domain);
    this.storage.remove(this.name, true, this.cookie_domain);
};

// removes the storage entry and deletes all loaded data
// forced name for tests
MixpanelPersistence.prototype.clear = function() {
    this.remove();
    this['props'] = {};
};

/**
* @param {Object} props
* @param {*=} default_value
* @param {number=} days
*/
MixpanelPersistence.prototype.register_once = function(props, default_value, days) {
    if (_.isObject(props)) {
        if (typeof(default_value) === 'undefined') { default_value = 'None'; }
        this.expire_days = (typeof(days) === 'undefined') ? this.default_expiry : days;

this.load();

_.each(props, function(val, prop) {
            if (!this['props'].hasOwnProperty(prop) || this['props'][prop] === default_value) {
                this['props'][prop] = val;
            }
        }, this);

this.save();

return true;
    }
    return false;
};

/**
* @param {Object} props
* @param {number=} days
*/
MixpanelPersistence.prototype.register = function(props, days) {
    if (_.isObject(props)) {
        this.expire_days = (typeof(days) === 'undefined') ? this.default_expiry : days;

this.load();
        _.extend(this['props'], props);
        this.save();

return true;
    }
    return false;
};

MixpanelPersistence.prototype.unregister = function(prop) {
    this.load();
    if (prop in this['props']) {
        delete this['props'][prop];
        this.save();
    }
};

MixpanelPersistence.prototype.update_search_keyword = function(referrer) {
    this.register(_.info.searchInfo(referrer));
};

// EXPORTED METHOD, we test this directly.
MixpanelPersistence.prototype.update_referrer_info = function(referrer) {
    // If referrer doesn't exist, we want to note the fact that it was type-in traffic.
    this.register_once({
        '$initial_referrer': referrer || '$direct',
        '$initial_referring_domain': _.info.referringDomain(referrer) || '$direct'
    }, '');
};

MixpanelPersistence.prototype.get_referrer_info = function() {
    return _.strip_empty_properties({
        '$initial_referrer': this['props']['$initial_referrer'],
        '$initial_referring_domain': this['props']['$initial_referring_domain']
    });
};

MixpanelPersistence.prototype.update_config = function(config) {
    this.default_expiry = this.expire_days = config['cookie_expiration'];
    this.set_disabled(config['disable_persistence']);
    this.set_cookie_domain(config['cookie_domain']);
    this.set_cross_site(config['cross_site_cookie']);
    this.set_cross_subdomain(config['cross_subdomain_cookie']);
    this.set_secure(config['secure_cookie']);
};

MixpanelPersistence.prototype.set_disabled = function(disabled) {
    this.disabled = disabled;
    if (this.disabled) {
        this.remove();
    } else {
        this.save();
    }
};

MixpanelPersistence.prototype.set_cookie_domain = function(cookie_domain) {
    if (cookie_domain !== this.cookie_domain) {
        this.remove();
        this.cookie_domain = cookie_domain;
        this.save();
    }
};

MixpanelPersistence.prototype.set_cross_site = function(cross_site) {
    if (cross_site !== this.cross_site) {
        this.cross_site = cross_site;
        this.remove();
        this.save();
    }
};

MixpanelPersistence.prototype.set_cross_subdomain = function(cross_subdomain) {
    if (cross_subdomain !== this.cross_subdomain) {
        this.cross_subdomain = cross_subdomain;
        this.remove();
        this.save();
    }
};

MixpanelPersistence.prototype.get_cross_subdomain = function() {
    return this.cross_subdomain;
};

MixpanelPersistence.prototype.set_secure = function(secure) {
    if (secure !== this.secure) {
        this.secure = secure ? true : false;
        this.remove();
        this.save();
    }
};

MixpanelPersistence.prototype._add_to_people_queue = function(queue, data) {
    var q_key = this._get_queue_key(queue),
        q_data = data[queue],
        set_q = this._get_or_create_queue(SET_ACTION),
        set_once_q = this._get_or_create_queue(SET_ONCE_ACTION),
        unset_q = this._get_or_create_queue(UNSET_ACTION),
        add_q = this._get_or_create_queue(ADD_ACTION),
        union_q = this._get_or_create_queue(UNION_ACTION),
        remove_q = this._get_or_create_queue(REMOVE_ACTION, []),
        append_q = this._get_or_create_queue(APPEND_ACTION, []);

if (q_key === SET_QUEUE_KEY) {
        // Update the set queue - we can override any existing values
        _.extend(set_q, q_data);
        // if there was a pending increment, override it
        // with the set.
        this._pop_from_people_queue(ADD_ACTION, q_data);
        // if there was a pending union, override it
        // with the set.
        this._pop_from_people_queue(UNION_ACTION, q_data);
        this._pop_from_people_queue(UNSET_ACTION, q_data);
    } else if (q_key === SET_ONCE_QUEUE_KEY) {
        // only queue the data if there is not already a set_once call for it.
        _.each(q_data, function(v, k) {
            if (!(k in set_once_q)) {
                set_once_q[k] = v;
            }
        });
        this._pop_from_people_queue(UNSET_ACTION, q_data);
    } else if (q_key === UNSET_QUEUE_KEY) {
        _.each(q_data, function(prop) {

// undo previously-queued actions on this key
            _.each([set_q, set_once_q, add_q, union_q], function(enqueued_obj) {
                if (prop in enqueued_obj) {
                    delete enqueued_obj[prop];
                }
            });
            _.each(append_q, function(append_obj) {
                if (prop in append_obj) {
                    delete append_obj[prop];
                }
            });

unset_q[prop] = true;

});
    } else if (q_key === ADD_QUEUE_KEY) {
        _.each(q_data, function(v, k) {
            // If it exists in the set queue, increment
            // the value
            if (k in set_q) {
                set_q[k] += v;
            } else {
                // If it doesn't exist, update the add
                // queue
                if (!(k in add_q)) {
                    add_q[k] = 0;
                }
                add_q[k] += v;
            }
        }, this);
        this._pop_from_people_queue(UNSET_ACTION, q_data);
    } else if (q_key === UNION_QUEUE_KEY) {
        _.each(q_data, function(v, k) {
            if (_.isArray(v)) {
                if (!(k in union_q)) {
                    union_q[k] = [];
                }
                // We may send duplicates, the server will dedup them.
                union_q[k] = union_q[k].concat(v);
            }
        });
        this._pop_from_people_queue(UNSET_ACTION, q_data);
    } else if (q_key === REMOVE_QUEUE_KEY) {
        remove_q.push(q_data);
        this._pop_from_people_queue(APPEND_ACTION, q_data);
    } else if (q_key === APPEND_QUEUE_KEY) {
        append_q.push(q_data);
        this._pop_from_people_queue(UNSET_ACTION, q_data);
    }

console$1.log('MIXPANEL PEOPLE REQUEST (QUEUED, PENDING IDENTIFY):');
    console$1.log(data);

this.save();
};

MixpanelPersistence.prototype._pop_from_people_queue = function(queue, data) {
    var q = this['props'][this._get_queue_key(queue)];
    if (!_.isUndefined(q)) {
        _.each(data, function(v, k) {
            if (queue === APPEND_ACTION || queue === REMOVE_ACTION) {
                // list actions: only remove if both k+v match
                // e.g. remove should not override append in a case like
                // append({foo: 'bar'}); remove({foo: 'qux'})
                _.each(q, function(queued_action) {
                    if (queued_action[k] === v) {
                        delete queued_action[k];
                    }
                });
            } else {
                delete q[k];
            }
        }, this);
    }
};

MixpanelPersistence.prototype.load_queue = function(queue) {
    return this.load_prop(this._get_queue_key(queue));
};

MixpanelPersistence.prototype._get_queue_key = function(queue) {
    if (queue === SET_ACTION) {
        return SET_QUEUE_KEY;
    } else if (queue === SET_ONCE_ACTION) {
        return SET_ONCE_QUEUE_KEY;
    } else if (queue === UNSET_ACTION) {
        return UNSET_QUEUE_KEY;
    } else if (queue === ADD_ACTION) {
        return ADD_QUEUE_KEY;
    } else if (queue === APPEND_ACTION) {
        return APPEND_QUEUE_KEY;
    } else if (queue === REMOVE_ACTION) {
        return REMOVE_QUEUE_KEY;
    } else if (queue === UNION_ACTION) {
        return UNION_QUEUE_KEY;
    } else {
        console$1.error('Invalid queue:', queue);
    }
};

MixpanelPersistence.prototype._get_or_create_queue = function(queue, default_val) {
    var key = this._get_queue_key(queue);
    default_val = _.isUndefined(default_val) ? {} : default_val;
    return this['props'][key] || (this['props'][key] = default_val);
};

MixpanelPersistence.prototype.set_event_timer = function(event_name, timestamp) {
    var timers = this.load_prop(EVENT_TIMERS_KEY) || {};
    timers[event_name] = timestamp;
    this['props'][EVENT_TIMERS_KEY] = timers;
    this.save();
};

MixpanelPersistence.prototype.remove_event_timer = function(event_name) {
    var timers = this.load_prop(EVENT_TIMERS_KEY) || {};
    var timestamp = timers[event_name];
    if (!_.isUndefined(timestamp)) {
        delete this['props'][EVENT_TIMERS_KEY][event_name];
        this.save();
    }
    return timestamp;
};

/*
 * Mixpanel JS Library
 *
 * Copyright 2012, Mixpanel, Inc. All Rights Reserved
 * http://mixpanel.com/
 *
 * Includes portions of Underscore.js
 * http://documentcloud.github.com/underscore/
 * (c) 2011 Jeremy Ashkenas, DocumentCloud Inc.
 * Released under the MIT License.
 */

// ==ClosureCompiler==
// @compilation_level ADVANCED_OPTIMIZATIONS
// @output_file_name mixpanel-2.8.min.js
// ==/ClosureCompiler==

/*
SIMPLE STYLE GUIDE:

this.x === public function
this._x === internal - only use within this file
this.__x === private - only use within the class

Globals should be all caps
*/

var init_type;       // MODULE or SNIPPET loader
var mixpanel_master; // main mixpanel instance / object
var INIT_MODULE  = 0;
var INIT_SNIPPET = 1;

var IDENTITY_FUNC = function(x) {return x;};
var NOOP_FUNC = function() {};

/** @const */ var PRIMARY_INSTANCE_NAME = 'mixpanel';
/** @const */ var PAYLOAD_TYPE_BASE64   = 'base64';
/** @const */ var PAYLOAD_TYPE_JSON     = 'json';
/** @const */ var DEVICE_ID_PREFIX      = '$device:';

/*
 * Dynamic... constants? Is that an oxymoron?
 */
// http://hacks.mozilla.org/2009/07/cross-site-xmlhttprequest-with-cors/
// https://developer.mozilla.org/en-US/docs/DOM/XMLHttpRequest#withCredentials
var USE_XHR = (window$1.XMLHttpRequest && 'withCredentials' in new XMLHttpRequest());

// IE<10 does not support cross-origin XHR's but script tags
// with defer won't block window.onload; ENQUEUE_REQUESTS
// should only be true for Opera<12
var ENQUEUE_REQUESTS = !USE_XHR && (userAgent.indexOf('MSIE') === -1) && (userAgent.indexOf('Mozilla') === -1);

// save reference to navigator.sendBeacon so it can be minified
var sendBeacon = null;
if (navigator['sendBeacon']) {
    sendBeacon = function() {
        // late reference to navigator.sendBeacon to allow patching/spying
        return navigator['sendBeacon'].apply(navigator, arguments);
    };
}

var DEFAULT_API_ROUTES = {
    'track': 'track/',
    'engage': 'engage/',
    'groups': 'groups/'
};

/*
 * Module-level globals
 */
var DEFAULT_CONFIG = {
    'api_host':                          'https://api-js.mixpanel.com',
    'api_routes':                        DEFAULT_API_ROUTES,
    'api_method':                        'POST',
    'api_transport':                     'XHR',
    'api_payload_format':                PAYLOAD_TYPE_BASE64,
    'app_host':                          'https://mixpanel.com',
    'cdn':                               'https://cdn.mxpnl.com',
    'cross_site_cookie':                 false,
    'cross_subdomain_cookie':            true,
    'error_reporter':                    NOOP_FUNC,
    'persistence':                       'cookie',
    'persistence_name':                  '',
    'cookie_domain':                     '',
    'cookie_name':                       '',
    'loaded':                            NOOP_FUNC,
    'mp_loader':                         null,
    'track_marketing':                   true,
    'track_pageview':                    false,
    'skip_first_touch_marketing':        false,
    'store_google':                      true,
    'stop_utm_persistence':              false,
    'save_referrer':                     true,
    'test':                              false,
    'verbose':                           false,
    'img':                               false,
    'debug':                             false,
    'track_links_timeout':               300,
    'cookie_expiration':                 365,
    'upgrade':                           false,
    'disable_persistence':               false,
    'disable_cookie':                    false,
    'secure_cookie':                     false,
    'ip':                                true,
    'opt_out_tracking_by_default':       false,
    'opt_out_persistence_by_default':    false,
    'opt_out_tracking_persistence_type': 'localStorage',
    'opt_out_tracking_cookie_prefix':    null,
    'property_blacklist':                [],
    'xhr_headers':                       {}, // { header: value, header2: value }
    'ignore_dnt':                        false,
    'batch_requests':                    true,
    'batch_size':                        50,
    'batch_flush_interval_ms':           5000,
    'batch_request_timeout_ms':          90000,
    'batch_autostart':                   true,
    'hooks':                             {}
};

var DOM_LOADED = false;

/**
 * Mixpanel Library Object
 * @constructor
 */
var MixpanelLib = function() {};

/**
 * create_mplib(token:string, config:object, name:string)
 *
 * This function is used by the init method of MixpanelLib objects
 * as well as the main initializer at the end of the JSLib (that
 * initializes document.mixpanel as well as any additional instances
 * declared before this file has loaded).
 */
var create_mplib = function(token, config, name) {
    var instance,
        target = (name === PRIMARY_INSTANCE_NAME) ? mixpanel_master : mixpanel_master[name];

if (target && init_type === INIT_MODULE) {
        instance = target;
    } else {
        if (target && !_.isArray(target)) {
            console$1.error('You have already initialized ' + name);
            return;
        }
        instance = new MixpanelLib();
    }

instance._cached_groups = {}; // cache groups in a pool

instance._init(token, config, name);

instance['people'] = new MixpanelPeople();
    instance['people']._init(instance);

if (!instance.get_config('skip_first_touch_marketing')) {
        // We need null UTM params in the object because
        // UTM parameters act as a tuple. If any UTM param
        // is present, then we set all UTM params including
        // empty ones together
        var utm_params = _.info.campaignParams(null);
        var initial_utm_params = {};
        var has_utm = false;
        _.each(utm_params, function(utm_value, utm_key) {
            initial_utm_params['initial_' + utm_key] = utm_value;
            if (utm_value) {
                has_utm = true;
            }
        });
        if (has_utm) {
            instance['people'].set_once(initial_utm_params);
        }
    }

// if any instance on the page has debug = true, we set the
    // global debug to be true
    Config.DEBUG = Config.DEBUG || instance.get_config('debug');

// if target is not defined, we called init after the lib already
    // loaded, so there won't be an array of things to execute
    if (!_.isUndefined(target) && _.isArray(target)) {
        // Crunch through the people queue first - we queue this data up &
        // flush on identify, so it's better to do all these operations first
        instance._execute_array.call(instance['people'], target['people']);
        instance._execute_array(target);
    }

return instance;
};

// Initialization methods

/**
 * This function initializes a new instance of the Mixpanel tracking object.
 * All new instances are added to the main mixpanel object as sub properties (such as
 * mixpanel.library_name) and also returned by this function. To define a
 * second instance on the page, you would call:
 *
 * mixpanel.init('new token', { your: 'config' }, 'library_name');
 *
 * and use it like so:
 *
 * mixpanel.library_name.track(...);
 *
 * @param {String} token Your Mixpanel API token
 * @param {Object} [config] A dictionary of config options to override. <a href="https://github.com/mixpanel/mixpanel-js/blob/v2.46.0/src/mixpanel-core.js#L88-L127">See a list of default config options</a>.
 * @param {String} [name] The name for the new mixpanel instance that you want created
 */
MixpanelLib.prototype.init = function (token, config, name) {
 if (_.isUndefined(name)) {
 this.report_error('You must name your new library: init(token, config, name)');
 return;
 }
 if (name === PRIMARY_INSTANCE_NAME) {
 this.report_error('You must initialize the main mixpanel object right after you include the Mixpanel js snippet');
 return;
 }

var instance = create_mplib(token, config, name);
    mixpanel_master[name] = instance;
    instance._loaded();

return instance;
};

// mixpanel._init(token:string, config:object, name:string)
//
// This function sets up the current instance of the mixpanel
// library.  The difference between this method and the init(...)
// method is this one initializes the actual instance, whereas the
// init(...) method sets up a new library and calls _init on it.
//
MixpanelLib.prototype._init = function(token, config, name) {
    config = config || {};

this['__loaded'] = true;
    this['config'] = {};

var variable_features = {};

// default to JSON payload for standard mixpanel.com API hosts
    if (!('api_payload_format' in config)) {
        var api_host = config['api_host'] || DEFAULT_CONFIG['api_host'];
        if (api_host.match(/\.mixpanel\.com/)) {
            variable_features['api_payload_format'] = PAYLOAD_TYPE_JSON;
        }
    }

this.set_config(_.extend({}, DEFAULT_CONFIG, variable_features, config, {
        'name': name,
        'token': token,
        'callback_fn': ((name === PRIMARY_INSTANCE_NAME) ? name : PRIMARY_INSTANCE_NAME + '.' + name) + '._jsc'
    }));

this['_jsc'] = NOOP_FUNC;

this.__dom_loaded_queue = [];
    this.__request_queue = [];
    this.__disabled_events = [];
    this._flags = {
        'disable_all_events': false,
        'identify_called': false
    };

// set up request queueing/batching
    this.request_batchers = {};
    this._batch_requests = this.get_config('batch_requests');
    if (this._batch_requests) {
        if (!_.localStorage.is_supported(true) || !USE_XHR) {
            this._batch_requests = false;
            console$1.log('Turning off Mixpanel request-queueing; needs XHR and localStorage support');
            _.each(this.get_batcher_configs(), function(batcher_config) {
                console$1.log('Clearing batch queue ' + batcher_config.queue_key);
                _.localStorage.remove(batcher_config.queue_key);
            });
        } else {
            this.init_batchers();
            if (sendBeacon && window$1.addEventListener) {
                // Before page closes or hides (user tabs away etc), attempt to flush any events
                // queued up via navigator.sendBeacon. Since sendBeacon doesn't report success/failure,
                // events will not be removed from the persistent store; if the site is loaded again,
                // the events will be flushed again on startup and deduplicated on the Mixpanel server
                // side.
                // There is no reliable way to capture only page close events, so we lean on the
                // visibilitychange and pagehide events as recommended at
                // https://developer.mozilla.org/en-US/docs/Web/API/Window/unload_event#usage_notes.
                // These events fire when the user clicks away from the current page/tab, so will occur
                // more frequently than page unload, but are the only mechanism currently for capturing
                // this scenario somewhat reliably.
                var flush_on_unload = _.bind(function() {
                    if (!this.request_batchers.events.stopped) {
                        this.request_batchers.events.flush({unloading: true});
                    }
                }, this);
                window$1.addEventListener('pagehide', function(ev) {
                    if (ev['persisted']) {
                        flush_on_unload();
                    }
                });
                window$1.addEventListener('visibilitychange', function() {
                    if (document$1['visibilityState'] === 'hidden') {
                        flush_on_unload();
                    }
                });
            }
        }
    }

this['persistence'] = this['cookie'] = new MixpanelPersistence(this['config']);
    this.unpersisted_superprops = {};
    this._gdpr_init();

var uuid = _.UUID();
    if (!this.get_distinct_id()) {
        // There is no need to set the distinct id
        // or the device id if something was already stored
        // in the persitence
        this.register_once({
            'distinct_id': DEVICE_ID_PREFIX + uuid,
            '$device_id': uuid
        }, '');
    }

var track_pageview_option = this.get_config('track_pageview');
    if (track_pageview_option) {
        this._init_url_change_tracking(track_pageview_option);
    }
};

// Private methods

MixpanelLib.prototype._loaded = function() {
    this.get_config('loaded')(this);
    this._set_default_superprops();
    this['people'].set_once(this['persistence'].get_referrer_info());

// The original 'store_google' functionality will be deprecated and the config will be
    // used to clear previously managed UTM parameters from persistence.
    // stop_utm_persistence is `false` by default now but will be default `true` in the future.
    if (this.get_config('store_google') && this.get_config('stop_utm_persistence')) {
        var utm_params = _.info.campaignParams(null);
        _.each(utm_params, function(_utm_value, utm_key) {
            // We need to unregister persisted UTM parameters so old values
            // are not mixed with the new UTM parameters
            this.unregister(utm_key);
        }.bind(this));
    }
};

// update persistence with info on referrer, UTM params, etc
MixpanelLib.prototype._set_default_superprops = function() {
    this['persistence'].update_search_keyword(document$1.referrer);
    if (this.get_config('store_google') && !this.get_config('stop_utm_persistence')) {
        this.register(_.info.campaignParams());
    }
    if (this.get_config('save_referrer')) {
        this['persistence'].update_referrer_info(document$1.referrer);
    }
};

MixpanelLib.prototype._dom_loaded = function() {
    _.each(this.__dom_loaded_queue, function(item) {
        this._track_dom.apply(this, item);
    }, this);

if (!this.has_opted_out_tracking()) {
        _.each(this.__request_queue, function(item) {
            this._send_request.apply(this, item);
        }, this);
    }

delete this.__dom_loaded_queue;
    delete this.__request_queue;
};

MixpanelLib.prototype._track_dom = function(DomClass, args) {
    if (this.get_config('img')) {
        this.report_error('You can\'t use DOM tracking functions with img = true.');
        return false;
    }

if (!DOM_LOADED) {
        this.__dom_loaded_queue.push([DomClass, args]);
        return false;
    }

var dt = new DomClass().init(this);
    return dt.track.apply(dt, args);
};

MixpanelLib.prototype._init_url_change_tracking = function(track_pageview_option) {
    var previous_tracked_url = '';
    var tracked = this.track_pageview();
    if (tracked) {
        previous_tracked_url = _.info.currentUrl();
    }

if (_.include(['full-url', 'url-with-path-and-query-string', 'url-with-path'], track_pageview_option)) {
        window$1.addEventListener('popstate', function() {
            window$1.dispatchEvent(new Event('mp_locationchange'));
        });
        window$1.addEventListener('hashchange', function() {
            window$1.dispatchEvent(new Event('mp_locationchange'));
        });
        var nativePushState = window$1.history.pushState;
        if (typeof nativePushState === 'function') {
            window$1.history.pushState = function(state, unused, url) {
                nativePushState.call(window$1.history, state, unused, url);
                window$1.dispatchEvent(new Event('mp_locationchange'));
            };
        }
        var nativeReplaceState = window$1.history.replaceState;
        if (typeof nativeReplaceState === 'function') {
            window$1.history.replaceState = function(state, unused, url) {
                nativeReplaceState.call(window$1.history, state, unused, url);
                window$1.dispatchEvent(new Event('mp_locationchange'));
            };
        }
        window$1.addEventListener('mp_locationchange', function() {
            var current_url = _.info.currentUrl();
            var should_track = false;
            if (track_pageview_option === 'full-url') {
                should_track = current_url !== previous_tracked_url;
            } else if (track_pageview_option === 'url-with-path-and-query-string') {
                should_track = current_url.split('#')[0] !== previous_tracked_url.split('#')[0];
            } else if (track_pageview_option === 'url-with-path') {
                should_track = current_url.split('#')[0].split('?')[0] !== previous_tracked_url.split('#')[0].split('?')[0];
            }

if (should_track) {
                var tracked = this.track_pageview();
                if (tracked) {
                    previous_tracked_url = current_url;
                }
            }
        }.bind(this));
    }
};

/**
 * _prepare_callback() should be called by callers of _send_request for use
 * as the callback argument.
 *
 * If there is no callback, this returns null.
 * If we are going to make XHR/XDR requests, this returns a function.
 * If we are going to use script tags, this returns a string to use as the
 * callback GET param.
 */
MixpanelLib.prototype._prepare_callback = function(callback, data) {
    if (_.isUndefined(callback)) {
        return null;
    }

if (USE_XHR) {
        var callback_function = function(response) {
            callback(response, data);
        };
        return callback_function;
    } else {
        // if the user gives us a callback, we store as a random
        // property on this instances jsc function and update our
        // callback string to reflect that.
        var jsc = this['_jsc'];
        var randomized_cb = '' + Math.floor(Math.random() * 100000000);
        var callback_string = this.get_config('callback_fn') + '[' + randomized_cb + ']';
        jsc[randomized_cb] = function(response) {
            delete jsc[randomized_cb];
            callback(response, data);
        };
        return callback_string;
    }
};

MixpanelLib.prototype._send_request = function(url, data, options, callback) {
    var succeeded = true;

if (ENQUEUE_REQUESTS) {
        this.__request_queue.push(arguments);
        return succeeded;
    }

var DEFAULT_OPTIONS = {
        method: this.get_config('api_method'),
        transport: this.get_config('api_transport'),
        verbose: this.get_config('verbose')
    };
    var body_data = null;

if (!callback && (_.isFunction(options) || typeof options === 'string')) {
        callback = options;
        options = null;
    }
    options = _.extend(DEFAULT_OPTIONS, options || {});
    if (!USE_XHR) {
        options.method = 'GET';
    }
    var use_post = options.method === 'POST';
    var use_sendBeacon = sendBeacon && use_post && options.transport.toLowerCase() === 'sendbeacon';

// needed to correctly format responses
    var verbose_mode = options.verbose;
    if (data['verbose']) { verbose_mode = true; }

if (this.get_config('test')) { data['test'] = 1; }
    if (verbose_mode) { data['verbose'] = 1; }
    if (this.get_config('img')) { data['img'] = 1; }
    if (!USE_XHR) {
        if (callback) {
            data['callback'] = callback;
        } else if (verbose_mode || this.get_config('test')) {
            // Verbose output (from verbose mode, or an error in test mode) is a json blob,
            // which by itself is not valid javascript. Without a callback, this verbose output will
            // cause an error when returned via jsonp, so we force a no-op callback param.
            // See the ECMA script spec: http://www.ecma-international.org/ecma-262/5.1/#sec-12.4
            data['callback'] = '(function(){})';
        }
    }

data['ip'] = this.get_config('ip')?1:0;
    data['_'] = new Date().getTime().toString();

if (use_post) {
        body_data = 'data=' + encodeURIComponent(data['data']);
        delete data['data'];
    }

url += '?' + _.HTTPBuildQuery(data);

var headers = this.get_config('xhr_headers');
            if (use_post) {
                headers['Content-Type'] = 'application/x-www-form-urlencoded';
            }
            _.each(headers, function(headerValue, headerName) {
                req.setRequestHeader(headerName, headerValue);
            });

if (options.timeout_ms && typeof req.timeout !== 'undefined') {
                req.timeout = options.timeout_ms;
                var start_time = new Date().getTime();
            }

// send the mp_optout cookie
            // withCredentials cannot be modified until after calling .open on Android and Mobile Safari
            req.withCredentials = true;
            req.onreadystatechange = function () {
                if (req.readyState === 4) { // XMLHttpRequest.DONE == 4, except in safari 4
                    if (req.status === 200) {
                        if (callback) {
                            if (verbose_mode) {
                                var response;
                                try {
                                    response = _.JSONDecode(req.responseText);
                                } catch (e) {
                                    lib.report_error(e);
                                    if (options.ignore_json_errors) {
                                        response = req.responseText;
                                    } else {
                                        return;
                                    }
                                }
                                callback(response);
                            } else {
                                callback(Number(req.responseText));
                            }
                        }
                    } else {
                        var error;
                        if (
                            req.timeout &&
                            !req.status &&
                            new Date().getTime() - start_time >= req.timeout
                        ) {
                            error = 'timeout';
                        } else {
                            error = 'Bad HTTP status: ' + req.status + ' ' + req.statusText;
                        }
                        lib.report_error(error);
                        if (callback) {
                            if (verbose_mode) {
                                callback({status: 0, error: error, xhr_req: req});
                            } else {
                                callback(0);
                            }
                        }
                    }
                }
            };
            req.send(body_data);
        } catch (e) {
            lib.report_error(e);
            succeeded = false;
        }
    } else {
        var script = document$1.createElement('script');
        script.type = 'text/javascript';
        script.async = true;
        script.defer = true;
        script.src = url;
        var s = document$1.getElementsByTagName('script')[0];
        s.parentNode.insertBefore(script, s);
    }

return succeeded;
};

/**
 * _execute_array() deals with processing any mixpanel function
 * calls that were called before the Mixpanel library were loaded
 * (and are thus stored in an array so they can be called later)
 *
 * Note: we fire off all the mixpanel function calls && user defined
 * functions BEFORE we fire off mixpanel tracking calls. This is so
 * identify/register/set_config calls can properly modify early
 * tracking calls.
 *
 * @param {Array} array
 */
MixpanelLib.prototype._execute_array = function(array) {
    var fn_name, alias_calls = [], other_calls = [], tracking_calls = [];
    _.each(array, function(item) {
        if (item) {
            fn_name = item[0];
            if (_.isArray(fn_name)) {
                tracking_calls.push(item); // chained call e.g. mixpanel.get_group().set()
            } else if (typeof(item) === 'function') {
                item.call(this);
            } else if (_.isArray(item) && fn_name === 'alias') {
                alias_calls.push(item);
            } else if (_.isArray(item) && fn_name.indexOf('track') !== -1 && typeof(this[fn_name]) === 'function') {
                tracking_calls.push(item);
            } else {
                other_calls.push(item);
            }
        }
    }, this);

execute(alias_calls, this);
    execute(other_calls, this);
    execute(tracking_calls, this);
};

// request queueing utils

MixpanelLib.prototype.are_batchers_initialized = function() {
    return !!this.request_batchers.events;
};

MixpanelLib.prototype.get_batcher_configs = function() {
    var queue_prefix = '__mpq_' + this.get_config('token');
    var api_routes = this.get_config('api_routes');
    this._batcher_configs = this._batcher_configs || {
        events: {type: 'events', endpoint: '/' + api_routes['track'], queue_key: queue_prefix + '_ev'},
        people: {type: 'people', endpoint: '/' + api_routes['engage'], queue_key: queue_prefix + '_pp'},
        groups: {type: 'groups', endpoint: '/' + api_routes['groups'], queue_key: queue_prefix + '_gr'}
    };
    return this._batcher_configs;
};

MixpanelLib.prototype.init_batchers = function() {
    if (!this.are_batchers_initialized()) {
        var batcher_for = _.bind(function(attrs) {
            return new RequestBatcher(
                attrs.queue_key,
                {
                    libConfig: this['config'],
                    sendRequestFunc: _.bind(function(data, options, cb) {
                        this._send_request(
                            this.get_config('api_host') + attrs.endpoint,
                            this._encode_data_for_request(data),
                            options,
                            this._prepare_callback(cb, data)
                        );
                    }, this),
                    beforeSendHook: _.bind(function(item) {
                        return this._run_hook('before_send_' + attrs.type, item);
                    }, this),
                    errorReporter: this.get_config('error_reporter'),
                    stopAllBatchingFunc: _.bind(this.stop_batch_senders, this)
                }
            );
        }, this);
        var batcher_configs = this.get_batcher_configs();
        this.request_batchers = {
            events: batcher_for(batcher_configs.events),
            people: batcher_for(batcher_configs.people),
            groups: batcher_for(batcher_configs.groups)
        };
    }
    if (this.get_config('batch_autostart')) {
        this.start_batch_senders();
    }
};

MixpanelLib.prototype.start_batch_senders = function() {
    this._batchers_were_started = true;
    if (this.are_batchers_initialized()) {
        this._batch_requests = true;
        _.each(this.request_batchers, function(batcher) {
            batcher.start();
        });
    }
};

MixpanelLib.prototype.stop_batch_senders = function() {
    this._batch_requests = false;
    _.each(this.request_batchers, function(batcher) {
        batcher.stop();
        batcher.clear();
    });
};

/**
 * push() keeps the standard async-array-push
 * behavior around after the lib is loaded.
 * This is only useful for external integrations that
 * do not wish to rely on our convenience methods
 * (created in the snippet).
 *
 * ### Usage:
 *     mixpanel.push(['register', { a: 'b' }]);
 *
 * @param {Array} item A [function_name, args...] array to be executed
 */
MixpanelLib.prototype.push = function(item) {
    this._execute_array([item]);
};

/**
 * Disable events on the Mixpanel object. If passed no arguments,
 * this function disables tracking of any event. If passed an
 * array of event names, those events will be disabled, but other
 * events will continue to be tracked.
 *
 * Note: this function does not stop other mixpanel functions from
 * firing, such as register() or people.set().
 *
 * @param {Array} [events] An array of event names to disable
 */
MixpanelLib.prototype.disable = function(events) {
    if (typeof(events) === 'undefined') {
        this._flags.disable_all_events = true;
    } else {
        this.__disabled_events = this.__disabled_events.concat(events);
    }
};

MixpanelLib.prototype._encode_data_for_request = function(data) {
    var encoded_data = _.JSONEncode(data);
    if (this.get_config('api_payload_format') === PAYLOAD_TYPE_BASE64) {
        encoded_data = _.base64Encode(encoded_data);
    }
    return {'data': encoded_data};
};

// internal method for handling track vs batch-enqueue logic
MixpanelLib.prototype._track_or_batch = function(options, callback) {
    var truncated_data = _.truncate(options.data, 255);
    var endpoint = options.endpoint;
    var batcher = options.batcher;
    var should_send_immediately = options.should_send_immediately;
    var send_request_options = options.send_request_options || {};
    callback = callback || NOOP_FUNC;

if (this._batch_requests && !should_send_immediately) {
        batcher.enqueue(truncated_data, function(succeeded) {
            if (succeeded) {
                callback(1, truncated_data);
            } else {
                send_request_immediately();
            }
        });
    } else {
        request_enqueued_or_initiated = send_request_immediately();
    }

return request_enqueued_or_initiated && truncated_data;
};

/**
 * Track an event. This is the most important and
 * frequently used Mixpanel function.
 *
 * ### Usage:
 *
 *     // track an event named 'Registered'
 *     mixpanel.track('Registered', {'Gender': 'Male', 'Age': 21});
 *
 *     // track an event using navigator.sendBeacon
 *     mixpanel.track('Left page', {'duration_seconds': 35}, {transport: 'sendBeacon'});
 *
 * To track link clicks or form submissions, see track_links() or track_forms().
 *
 * @param {String} event_name The name of the event. This can be anything the user does - 'Button Click', 'Sign Up', 'Item Purchased', etc.
 * @param {Object} [properties] A set of properties to include with the event you're sending. These describe the user who did the event or details about the event itself.
 * @param {Object} [options] Optional configuration for this track request.
 * @param {String} [options.transport] Transport method for network request ('xhr' or 'sendBeacon').
 * @param {Boolean} [options.send_immediately] Whether to bypass batching/queueing and send track request immediately.
 * @param {Function} [callback] If provided, the callback function will be called after tracking the event.
 * @returns {Boolean|Object} If the tracking request was successfully initiated/queued, an object
 * with the tracking payload sent to the API server is returned; otherwise false.
 */
MixpanelLib.prototype.track = addOptOutCheckMixpanelLib(function(event_name, properties, options, callback) {
    if (!callback && typeof options === 'function') {
        callback = options;
        options = null;
    }
    options = options || {};
    var transport = options['transport']; // external API, don't minify 'transport' prop
    if (transport) {
        options.transport = transport; // 'transport' prop name can be minified internally
    }
    var should_send_immediately = options['send_immediately'];
    if (typeof callback !== 'function') {
        callback = NOOP_FUNC;
    }

if (_.isUndefined(event_name)) {
        this.report_error('No event name provided to mixpanel.track');
        return;
    }

if (this._event_is_disabled(event_name)) {
        callback(0);
        return;
    }

// set defaults
    properties = _.extend({}, properties);
    properties['token'] = this.get_config('token');

// set $duration if time_event was previously called for this event
    var start_timestamp = this['persistence'].remove_event_timer(event_name);
    if (!_.isUndefined(start_timestamp)) {
        var duration_in_ms = new Date().getTime() - start_timestamp;
        properties['$duration'] = parseFloat((duration_in_ms / 1000).toFixed(3));
    }

this._set_default_superprops();

var marketing_properties = this.get_config('track_marketing')
        ? _.info.marketingParams()
        : {};

// note: extend writes to the first object, so lets make sure we
    // don't write to the persistence properties object and info
    // properties object by passing in a new object

// update properties with pageview info and super-properties
    properties = _.extend(
        {},
        _.info.properties({'mp_loader': this.get_config('mp_loader')}),
        marketing_properties,
        this['persistence'].properties(),
        this.unpersisted_superprops,
        properties
    );

var data = {
        'event': event_name,
        'properties': properties
    };
    var ret = this._track_or_batch({
        type: 'events',
        data: data,
        endpoint: this.get_config('api_host') + '/' + this.get_config('api_routes')['track'],
        batcher: this.request_batchers.events,
        should_send_immediately: should_send_immediately,
        send_request_options: options
    }, callback);

return ret;
});

/**
 * Register the current user into one/many groups.
 *
 * ### Usage:
 *
 *      mixpanel.set_group('company', ['mixpanel', 'google']) // an array of IDs
 *      mixpanel.set_group('company', 'mixpanel')
 *      mixpanel.set_group('company', 128746312)
 *
 * @param {String} group_key Group key
 * @param {Array|String|Number} group_ids An array of group IDs, or a singular group ID
 * @param {Function} [callback] If provided, the callback will be called after tracking the event.
 *
 */
MixpanelLib.prototype.set_group = addOptOutCheckMixpanelLib(function(group_key, group_ids, callback) {
    if (!_.isArray(group_ids)) {
        group_ids = [group_ids];
    }
    var prop = {};
    prop[group_key] = group_ids;
    this.register(prop);
    return this['people'].set(group_key, group_ids, callback);
});

/**
 * Add a new group for this user.
 *
 * ### Usage:
 *
 *      mixpanel.add_group('company', 'mixpanel')
 *
 * @param {String} group_key Group key
 * @param {*} group_id A valid Mixpanel property type
 * @param {Function} [callback] If provided, the callback will be called after tracking the event.
 */
MixpanelLib.prototype.add_group = addOptOutCheckMixpanelLib(function(group_key, group_id, callback) {
    var old_values = this.get_property(group_key);
    var prop = {};
    if (old_values === undefined) {
        prop[group_key] = [group_id];
        this.register(prop);
    } else {
        if (old_values.indexOf(group_id) === -1) {
            old_values.push(group_id);
            prop[group_key] = old_values;
            this.register(prop);
        }
    }
    return this['people'].union(group_key, group_id, callback);
});

/**
 * Remove a group from this user.
 *
 * ### Usage:
 *
 *      mixpanel.remove_group('company', 'mixpanel')
 *
 * @param {String} group_key Group key
 * @param {*} group_id A valid Mixpanel property type
 * @param {Function} [callback] If provided, the callback will be called after tracking the event.
 */
MixpanelLib.prototype.remove_group = addOptOutCheckMixpanelLib(function(group_key, group_id, callback) {
    var old_value = this.get_property(group_key);
    // if the value doesn't exist, the persistent store is unchanged
    if (old_value !== undefined) {
        var idx = old_value.indexOf(group_id);
        if (idx > -1) {
            old_value.splice(idx, 1);
            this.register({group_key: old_value});
        }
        if (old_value.length === 0) {
            this.unregister(group_key);
        }
    }
    return this['people'].remove(group_key, group_id, callback);
});

/**
 * Track an event with specific groups.
 *
 * ### Usage:
 *
 *      mixpanel.track_with_groups('purchase', {'product': 'iphone'}, {'University': ['UCB', 'UCLA']})
 *
 * @param {String} event_name The name of the event (see `mixpanel.track()`)
 * @param {Object=} properties A set of properties to include with the event you're sending (see `mixpanel.track()`)
 * @param {Object=} groups An object mapping group name keys to one or more values
 * @param {Function} [callback] If provided, the callback will be called after tracking the event.
 */
MixpanelLib.prototype.track_with_groups = addOptOutCheckMixpanelLib(function(event_name, properties, groups, callback) {
    var tracking_props = _.extend({}, properties || {});
    _.each(groups, function(v, k) {
        if (v !== null && v !== undefined) {
            tracking_props[k] = v;
        }
    });
    return this.track(event_name, tracking_props, callback);
});

MixpanelLib.prototype._create_map_key = function (group_key, group_id) {
    return group_key + '_' + JSON.stringify(group_id);
};

MixpanelLib.prototype._remove_group_from_cache = function (group_key, group_id) {
    delete this._cached_groups[this._create_map_key(group_key, group_id)];
};

/**
 * Look up reference to a Mixpanel group
 *
 * ### Usage:
 *
 *       mixpanel.get_group(group_key, group_id)
 *
 * @param {String} group_key Group key
 * @param {Object} group_id A valid Mixpanel property type
 * @returns {Object} A MixpanelGroup identifier
 */
MixpanelLib.prototype.get_group = function (group_key, group_id) {
    var map_key = this._create_map_key(group_key, group_id);
    var group = this._cached_groups[map_key];
    if (group === undefined || group._group_key !== group_key || group._group_id !== group_id) {
        group = new MixpanelGroup();
        group._init(this, group_key, group_id);
        this._cached_groups[map_key] = group;
    }
    return group;
};

/**
 * Track a default Mixpanel page view event, which includes extra default event properties to
 * improve page view data.
 *
 * ### Usage:
 *
 * // track a default $mp_web_page_view event
 * mixpanel.track_pageview();
 *
 * // track a page view event with additional event properties
 * mixpanel.track_pageview({'ab_test_variant': 'card-layout-b'});
 *
 * // example approach to track page views on different page types as event properties
 * mixpanel.track_pageview({'page': 'pricing'});
 * mixpanel.track_pageview({'page': 'homepage'});
 *
 * // UNCOMMON: Tracking a page view event with a custom event_name option. NOT expected to be used for
 * // individual pages on the same site or product. Use cases for custom event_name may be page
 * // views on different products or internal applications that are considered completely separate
 * mixpanel.track_pageview({'page': 'customer-search'}, {'event_name': '[internal] Admin Page View'});
 *
 * ### Notes:
 *
 * The `config.track_pageview` option for <a href="#mixpanelinit">mixpanel.init()</a>
 * may be turned on for tracking page loads automatically.
 *
 * // track only page loads
 * mixpanel.init(PROJECT_TOKEN, {track_pageview: true});
 *
 * // track when the URL changes in any manner
 * mixpanel.init(PROJECT_TOKEN, {track_pageview: 'full-url'});
 *
 * // track when the URL changes, ignoring any changes in the hash part
 * mixpanel.init(PROJECT_TOKEN, {track_pageview: 'url-with-path-and-query-string'});
 *
 * // track when the path changes, ignoring any query parameter or hash changes
 * mixpanel.init(PROJECT_TOKEN, {track_pageview: 'url-with-path'});
 *
 * @param {Object} [properties] An optional set of additional properties to send with the page view event
 * @param {Object} [options] Page view tracking options
 * @param {String} [options.event_name] - Alternate name for the tracking event
 * @returns {Boolean|Object} If the tracking request was successfully initiated/queued, an object
 * with the tracking payload sent to the API server is returned; otherwise false.
 */
MixpanelLib.prototype.track_pageview = addOptOutCheckMixpanelLib(function(properties, options) {
 if (typeof properties !== 'object') {
 properties = {};
 }
 options = options || {};
 var event_name = options['event_name'] || '$mp_web_page_view';

var default_page_properties = _.extend(
        _.info.mpPageViewProperties(),
        _.info.campaignParams(),
        _.info.clickParams()
    );

var event_properties = _.extend(
        {},
        default_page_properties,
        properties
    );

return this.track(event_name, event_properties);
});

/**
 * Track clicks on a set of document elements. Selector must be a
 * valid query. Elements must exist on the page at the time track_links is called.
 *
 * ### Usage:
 *
 *     // track click for link id #nav
 *     mixpanel.track_links('#nav', 'Clicked Nav Link');
 *
 * ### Notes:
 *
 * This function will wait up to 300 ms for the Mixpanel
 * servers to respond. If they have not responded by that time
 * it will head to the link without ensuring that your event
 * has been tracked.  To configure this timeout please see the
 * set_config() documentation below.
 *
 * If you pass a function in as the properties argument, the
 * function will receive the DOMElement that triggered the
 * event as an argument.  You are expected to return an object
 * from the function; any properties defined on this object
 * will be sent to mixpanel as event properties.
 *
 * @type {Function}
 * @param {Object|String} query A valid DOM query, element or jQuery-esque list
 * @param {String} event_name The name of the event to track
 * @param {Object|Function} [properties] A properties object or function that returns a dictionary of properties when passed a DOMElement
 */
MixpanelLib.prototype.track_links = function() {
    return this._track_dom.call(this, LinkTracker, arguments);
};

/**
 * Track form submissions. Selector must be a valid query.
 *
 * ### Usage:
 *
 *     // track submission for form id 'register'
 *     mixpanel.track_forms('#register', 'Created Account');
 *
 * ### Notes:
 *
 * This function will wait up to 300 ms for the mixpanel
 * servers to respond, if they have not responded by that time
 * it will head to the link without ensuring that your event
 * has been tracked.  To configure this timeout please see the
 * set_config() documentation below.
 *
 * If you pass a function in as the properties argument, the
 * function will receive the DOMElement that triggered the
 * event as an argument.  You are expected to return an object
 * from the function; any properties defined on this object
 * will be sent to mixpanel as event properties.
 *
 * @type {Function}
 * @param {Object|String} query A valid DOM query, element or jQuery-esque list
 * @param {String} event_name The name of the event to track
 * @param {Object|Function} [properties] This can be a set of properties, or a function that returns a set of properties after being passed a DOMElement
 */
MixpanelLib.prototype.track_forms = function() {
    return this._track_dom.call(this, FormTracker, arguments);
};

/**
 * Time an event by including the time between this call and a
 * later 'track' call for the same event in the properties sent
 * with the event.
 *
 * ### Usage:
 *
 *     // time an event named 'Registered'
 *     mixpanel.time_event('Registered');
 *     mixpanel.track('Registered', {'Gender': 'Male', 'Age': 21});
 *
 * When called for a particular event name, the next track call for that event
 * name will include the elapsed time between the 'time_event' and 'track'
 * calls. This value is stored as seconds in the '$duration' property.
 *
 * @param {String} event_name The name of the event.
 */
MixpanelLib.prototype.time_event = function(event_name) {
    if (_.isUndefined(event_name)) {
        this.report_error('No event name provided to mixpanel.time_event');
        return;
    }

if (this._event_is_disabled(event_name)) {
        return;
    }

this['persistence'].set_event_timer(event_name,  new Date().getTime());
};

/**
 * Register a set of super properties, which are included with all
 * events. This will overwrite previous super property values.
 *
 * ### Usage:
 *
 *     // register 'Gender' as a super property
 *     mixpanel.register({'Gender': 'Female'});
 *
 *     // register several super properties when a user signs up
 *     mixpanel.register({
 *         'Email': 'jdoe@example.com',
 *         'Account Type': 'Free'
 *     });
 *
 *     // register only for the current pageload
 *     mixpanel.register({'Name': 'Pat'}, {persistent: false});
 *
 * @param {Object} properties An associative array of properties to store about the user
 * @param {Number|Object} [days_or_options] Options object or number of days since the user's last visit to store the super properties (only valid for persisted props)
 * @param {boolean} [days_or_options.days] - number of days since the user's last visit to store the super properties (only valid for persisted props)
 * @param {boolean} [days_or_options.persistent=true] - whether to put in persistent storage (cookie/localStorage)
 */
MixpanelLib.prototype.register = function(props, days_or_options) {
    var options = options_for_register(days_or_options);
    if (options['persistent']) {
        this['persistence'].register(props, options['days']);
    } else {
        _.extend(this.unpersisted_superprops, props);
    }
};

/**
 * Register a set of super properties only once. This will not
 * overwrite previous super property values, unlike register().
 *
 * ### Usage:
 *
 *     // register a super property for the first time only
 *     mixpanel.register_once({
 *         'First Login Date': new Date().toISOString()
 *     });
 *
 *     // register once, only for the current pageload
 *     mixpanel.register_once({
 *         'First interaction time': new Date().toISOString()
 *     }, 'None', {persistent: false});
 *
 * ### Notes:
 *
 * If default_value is specified, current super properties
 * with that value will be overwritten.
 *
 * @param {Object} properties An associative array of properties to store about the user
 * @param {*} [default_value] Value to override if already set in super properties (ex: 'False') Default: 'None'
 * @param {Number|Object} [days_or_options] Options object or number of days since the user's last visit to store the super properties (only valid for persisted props)
 * @param {boolean} [days_or_options.days] - number of days since the user's last visit to store the super properties (only valid for persisted props)
 * @param {boolean} [days_or_options.persistent=true] - whether to put in persistent storage (cookie/localStorage)
 */
MixpanelLib.prototype.register_once = function(props, default_value, days_or_options) {
    var options = options_for_register(days_or_options);
    if (options['persistent']) {
        this['persistence'].register_once(props, default_value, options['days']);
    } else {
        if (typeof(default_value) === 'undefined') {
            default_value = 'None';
        }
        _.each(props, function(val, prop) {
            if (!this.unpersisted_superprops.hasOwnProperty(prop) || this.unpersisted_superprops[prop] === default_value) {
                this.unpersisted_superprops[prop] = val;
            }
        }, this);
    }
};

/**
 * Delete a super property stored with the current user.
 *
 * @param {String} property The name of the super property to remove
 * @param {Object} [options]
 * @param {boolean} [options.persistent=true] - whether to look in persistent storage (cookie/localStorage)
 */
MixpanelLib.prototype.unregister = function(property, options) {
    options = options_for_register(options);
    if (options['persistent']) {
        this['persistence'].unregister(property);
    } else {
        delete this.unpersisted_superprops[property];
    }
};

MixpanelLib.prototype._register_single = function(prop, value) {
    var props = {};
    props[prop] = value;
    this.register(props);
};

/**
 * Identify a user with a unique ID to track user activity across
 * devices, tie a user to their events, and create a user profile.
 * If you never call this method, unique visitors are tracked using
 * a UUID generated the first time they visit the site.
 *
 * Call identify when you know the identity of the current user,
 * typically after login or signup. We recommend against using
 * identify for anonymous visitors to your site.
 *
 * ### Notes:
 * If your project has
 * <a href="https://help.mixpanel.com/hc/en-us/articles/360039133851">ID Merge</a>
 * enabled, the identify method will connect pre- and
 * post-authentication events when appropriate.
 *
 * If your project does not have ID Merge enabled, identify will
 * change the user's local distinct_id to the unique ID you pass.
 * Events tracked prior to authentication will not be connected
 * to the same user identity. If ID Merge is disabled, alias can
 * be used to connect pre- and post-registration events.
 *
 * @param {String} [unique_id] A string that uniquely identifies a user. If not provided, the distinct_id currently in the persistent store (cookie or localStorage) will be used.
 */
MixpanelLib.prototype.identify = function(
 new_distinct_id, _set_callback, _add_callback, _append_callback, _set_once_callback, _union_callback, _unset_callback, _remove_callback
) {
 // Optional Parameters
 // _set_callback:function A callback to be run if and when the People set queue is flushed
 // _add_callback:function A callback to be run if and when the People add queue is flushed
 // _append_callback:function A callback to be run if and when the People append queue is flushed
 // _set_once_callback:function A callback to be run if and when the People set_once queue is flushed
 // _union_callback:function A callback to be run if and when the People union queue is flushed
 // _unset_callback:function A callback to be run if and when the People unset queue is flushed

if (!this.get_property('$device_id')) {
        // The persisted distinct id might not actually be a device id at all
        // it might be a distinct id of the user from before
        var device_id = previous_distinct_id;
        this.register_once({
            '$had_persisted_distinct_id': true,
            '$device_id': device_id
        }, '');
    }

// identify only changes the distinct id if it doesn't match either the existing or the alias;
    // if it's new, blow away the alias as well.
    if (new_distinct_id !== previous_distinct_id && new_distinct_id !== this.get_property(ALIAS_ID_KEY)) {
        this.unregister(ALIAS_ID_KEY);
        this.register({'distinct_id': new_distinct_id});
    }
    this._flags.identify_called = true;
    // Flush any queued up people requests
    this['people']._flush(_set_callback, _add_callback, _append_callback, _set_once_callback, _union_callback, _unset_callback, _remove_callback);

// send an $identify event any time the distinct_id is changing - logic on the server
    // will determine whether or not to do anything with it.
    if (new_distinct_id !== previous_distinct_id) {
        this.track('$identify', {
            'distinct_id': new_distinct_id,
            '$anon_distinct_id': previous_distinct_id
        }, {skip_hooks: true});
    }
};

/**
 * Clears super properties and generates a new random distinct_id for this instance.
 * Useful for clearing data when a user logs out.
 */
MixpanelLib.prototype.reset = function() {
    this['persistence'].clear();
    this._flags.identify_called = false;
    var uuid = _.UUID();
    this.register_once({
        'distinct_id': DEVICE_ID_PREFIX + uuid,
        '$device_id': uuid
    }, '');
};

/**
 * Returns the current distinct id of the user. This is either the id automatically
 * generated by the library or the id that has been passed by a call to identify().
 *
 * ### Notes:
 *
 * get_distinct_id() can only be called after the Mixpanel library has finished loading.
 * init() has a loaded function available to handle this automatically. For example:
 *
 *     // set distinct_id after the mixpanel library has loaded
 *     mixpanel.init('YOUR PROJECT TOKEN', {
 *         loaded: function(mixpanel) {
 *             distinct_id = mixpanel.get_distinct_id();
 *         }
 *     });
 */
MixpanelLib.prototype.get_distinct_id = function() {
    return this.get_property('distinct_id');
};

/**
 * The alias method creates an alias which Mixpanel will use to
 * remap one id to another. Multiple aliases can point to the
 * same identifier.
 *
 * The following is a valid use of alias:
 *
 * mixpanel.alias('new_id', 'existing_id');
 * // You can add multiple id aliases to the existing ID
 * mixpanel.alias('newer_id', 'existing_id');
 *
 * Aliases can also be chained - the following is a valid example:
 *
 * mixpanel.alias('new_id', 'existing_id');
 * // chain newer_id - new_id - existing_id
 * mixpanel.alias('newer_id', 'new_id');
 *
 * Aliases cannot point to multiple identifiers - the following
 * example will not work:
 *
 * mixpanel.alias('new_id', 'existing_id');
 * // this is invalid as 'new_id' already points to 'existing_id'
 * mixpanel.alias('new_id', 'newer_id');
 *
 * ### Notes:
 *
 * If your project does not have
 * <a href="https://help.mixpanel.com/hc/en-us/articles/360039133851">ID Merge</a>
 * enabled, the best practice is to call alias once when a unique
 * ID is first created for a user (e.g., when a user first registers
 * for an account). Do not use alias multiple times for a single
 * user without ID Merge enabled.
 *
 * @param {String} alias A unique identifier that you want to use for this user in the future.
 * @param {String} [original] The current identifier being used for this user.
 */
MixpanelLib.prototype.alias = function(alias, original) {
 // If the $people_distinct_id key exists in persistence, there has been a previous
 // mixpanel.people.identify() call made for this user. It is VERY BAD to make an alias with
 // this ID, as it will duplicate users.
 if (alias === this.get_property(PEOPLE_DISTINCT_ID_KEY)) {
 this.report_error('Attempting to create alias for existing People user - aborting.');
 return -2;
 }

/**
 * Provide a string to recognize the user by. The string passed to
 * this method will appear in the Mixpanel Streams product rather
 * than an automatically generated name. Name tags do not have to
 * be unique.
 *
 * This value will only be included in Streams data.
 *
 * @param {String} name_tag A human readable name for the user
 * @deprecated
 */
MixpanelLib.prototype.name_tag = function(name_tag) {
    this._register_single('mp_name_tag', name_tag);
};

/**
 * Update the configuration of a mixpanel library instance.
 *
 * The default config is:
 *
 *     {
 *       // host for requests (customizable for e.g. a local proxy)
 *       api_host: 'https://api-js.mixpanel.com',
 *
 *       // endpoints for different types of requests
 *       api_routes: {
 *         track: 'track/',
 *         engage: 'engage/',
 *         groups: 'groups/',
 *       }
 *
 *       // HTTP method for tracking requests
 *       api_method: 'POST'
 *
 *       // transport for sending requests ('XHR' or 'sendBeacon')
 *       // NB: sendBeacon should only be used for scenarios such as
 *       // page unload where a "best-effort" attempt to send is
 *       // acceptable; the sendBeacon API does not support callbacks
 *       // or any way to know the result of the request. Mixpanel
 *       // tracking via sendBeacon will not support any event-
 *       // batching or retry mechanisms.
 *       api_transport: 'XHR'
 *
 *       // request-batching/queueing/retry
 *       batch_requests: true,
 *
 *       // maximum number of events/updates to send in a single
 *       // network request
 *       batch_size: 50,
 *
 *       // milliseconds to wait between sending batch requests
 *       batch_flush_interval_ms: 5000,
 *
 *       // milliseconds to wait for network responses to batch requests
 *       // before they are considered timed-out and retried
 *       batch_request_timeout_ms: 90000,
 *
 *       // override value for cookie domain, only useful for ensuring
 *       // correct cross-subdomain cookies on unusual domains like
 *       // subdomain.mainsite.avocat.fr; NB this cannot be used to
 *       // set cookies on a different domain than the current origin
 *       cookie_domain: ''
 *
 *       // super properties cookie expiration (in days)
 *       cookie_expiration: 365
 *
 *       // if true, cookie will be set with SameSite=None; Secure
 *       // this is only useful in special situations, like embedded
 *       // 3rd-party iframes that set up a Mixpanel instance
 *       cross_site_cookie: false
 *
 *       // super properties span subdomains
 *       cross_subdomain_cookie: true
 *
 *       // debug mode
 *       debug: false
 *
 *       // if this is true, the mixpanel cookie or localStorage entry
 *       // will be deleted, and no user persistence will take place
 *       disable_persistence: false
 *
 *       // if this is true, Mixpanel will automatically determine
 *       // City, Region and Country data using the IP address of
 *       //the client
 *       ip: true
 *
 *       // opt users out of tracking by this Mixpanel instance by default
 *       opt_out_tracking_by_default: false
 *
 *       // opt users out of browser data storage by this Mixpanel instance by default
 *       opt_out_persistence_by_default: false
 *
 *       // persistence mechanism used by opt-in/opt-out methods - cookie
 *       // or localStorage - falls back to cookie if localStorage is unavailable
 *       opt_out_tracking_persistence_type: 'localStorage'
 *
 *       // customize the name of cookie/localStorage set by opt-in/opt-out methods
 *       opt_out_tracking_cookie_prefix: null
 *
 *       // type of persistent store for super properties (cookie/
 *       // localStorage) if set to 'localStorage', any existing
 *       // mixpanel cookie value with the same persistence_name
 *       // will be transferred to localStorage and deleted
 *       persistence: 'cookie'
 *
 *       // name for super properties persistent store
 *       persistence_name: ''
 *
 *       // names of properties/superproperties which should never
 *       // be sent with track() calls
 *       property_blacklist: []
 *
 *       // if this is true, mixpanel cookies will be marked as
 *       // secure, meaning they will only be transmitted over https
 *       secure_cookie: false
 *
 *       // disables enriching user profiles with first touch marketing data
 *       skip_first_touch_marketing: false
 *
 *       // the amount of time track_links will
 *       // wait for Mixpanel's servers to respond
 *       track_links_timeout: 300
 *
 *       // adds any UTM parameters and click IDs present on the page to any events fired
 *       track_marketing: true
 *
 *       // enables automatic page view tracking using default page view events through
 *       // the track_pageview() method
 *       track_pageview: false
 *
 *       // if you set upgrade to be true, the library will check for
 *       // a cookie from our old js library and import super
 *       // properties from it, then the old cookie is deleted
 *       // The upgrade config option only works in the initialization,
 *       // so make sure you set it when you create the library.
 *       upgrade: false
 *
 *       // extra HTTP request headers to set for each API request, in
 *       // the format {'Header-Name': value}
 *       xhr_headers: {}
 *
 *       // whether to ignore or respect the web browser's Do Not Track setting
 *       ignore_dnt: false
 *     }
 *
 *
 * @param {Object} config A dictionary of new configuration values to update
 */
MixpanelLib.prototype.set_config = function(config) {
    if (_.isObject(config)) {
        _.extend(this['config'], config);

var new_batch_size = config['batch_size'];
        if (new_batch_size) {
            _.each(this.request_batchers, function(batcher) {
                batcher.resetBatchSize();
            });
        }

if (!this.get_config('persistence_name')) {
            this['config']['persistence_name'] = this['config']['cookie_name'];
        }
        if (!this.get_config('disable_persistence')) {
            this['config']['disable_persistence'] = this['config']['disable_cookie'];
        }

if (this['persistence']) {
            this['persistence'].update_config(this['config']);
        }
        Config.DEBUG = Config.DEBUG || this.get_config('debug');
    }
};

/**
 * returns the current config object for the library.
 */
MixpanelLib.prototype.get_config = function(prop_name) {
    return this['config'][prop_name];
};

/**
 * Fetch a hook function from config, with safe default, and run it
 * against the given arguments
 * @param {string} hook_name which hook to retrieve
 * @returns {any|null} return value of user-provided hook, or null if nothing was returned
 */
MixpanelLib.prototype._run_hook = function(hook_name) {
    var ret = (this['config']['hooks'][hook_name] || IDENTITY_FUNC).apply(this, slice.call(arguments, 1));
    if (typeof ret === 'undefined') {
        this.report_error(hook_name + ' hook did not return a value');
        ret = null;
    }
    return ret;
};

/**
 * Returns the value of the super property named property_name. If no such
 * property is set, get_property() will return the undefined value.
 *
 * ### Notes:
 *
 * get_property() can only be called after the Mixpanel library has finished loading.
 * init() has a loaded function available to handle this automatically. For example:
 *
 *     // grab value for 'user_id' after the mixpanel library has loaded
 *     mixpanel.init('YOUR PROJECT TOKEN', {
 *         loaded: function(mixpanel) {
 *             user_id = mixpanel.get_property('user_id');
 *         }
 *     });
 *
 * @param {String} property_name The name of the super property you want to retrieve
 */
MixpanelLib.prototype.get_property = function(property_name) {
    return this['persistence'].load_prop([property_name]);
};

MixpanelLib.prototype.toString = function() {
    var name = this.get_config('name');
    if (name !== PRIMARY_INSTANCE_NAME) {
        name = PRIMARY_INSTANCE_NAME + '.' + name;
    }
    return name;
};

MixpanelLib.prototype._event_is_disabled = function(event_name) {
    return _.isBlockedUA(userAgent) ||
        this._flags.disable_all_events ||
        _.include(this.__disabled_events, event_name);
};

// perform some housekeeping around GDPR opt-in/out state
MixpanelLib.prototype._gdpr_init = function() {
    var is_localStorage_requested = this.get_config('opt_out_tracking_persistence_type') === 'localStorage';

// try to convert opt-in/out cookies to localStorage if possible
    if (is_localStorage_requested && _.localStorage.is_supported()) {
        if (!this.has_opted_in_tracking() && this.has_opted_in_tracking({'persistence_type': 'cookie'})) {
            this.opt_in_tracking({'enable_persistence': false});
        }
        if (!this.has_opted_out_tracking() && this.has_opted_out_tracking({'persistence_type': 'cookie'})) {
            this.opt_out_tracking({'clear_persistence': false});
        }
        this.clear_opt_in_out_tracking({
            'persistence_type': 'cookie',
            'enable_persistence': false
        });
    }

// check whether the user has already opted out - if so, clear & disable persistence
    if (this.has_opted_out_tracking()) {
        this._gdpr_update_persistence({'clear_persistence': true});

// check whether we should opt out by default
    // note: we don't clear persistence here by default since opt-out default state is often
    //       used as an initial state while GDPR information is being collected
    } else if (!this.has_opted_in_tracking() && (
        this.get_config('opt_out_tracking_by_default') || _.cookie.get('mp_optout')
    )) {
        _.cookie.remove('mp_optout');
        this.opt_out_tracking({
            'clear_persistence': this.get_config('opt_out_persistence_by_default')
        });
    }
};

/**
 * Enable or disable persistence based on options
 * only enable/disable if persistence is not already in this state
 * @param {boolean} [options.clear_persistence] If true, will delete all data stored by the sdk in persistence and disable it
 * @param {boolean} [options.enable_persistence] If true, will re-enable sdk persistence
 */
MixpanelLib.prototype._gdpr_update_persistence = function(options) {
    var disabled;
    if (options && options['clear_persistence']) {
        disabled = true;
    } else if (options && options['enable_persistence']) {
        disabled = false;
    } else {
        return;
    }

if (!this.get_config('disable_persistence') && this['persistence'].disabled !== disabled) {
        this['persistence'].set_disabled(disabled);
    }

if (disabled) {
        this.stop_batch_senders();
    } else {
        // only start batchers after opt-in if they have previously been started
        // in order to avoid unintentionally starting up batching for the first time
        if (this._batchers_were_started) {
            this.start_batch_senders();
        }
    }
};

// call a base gdpr function after constructing the appropriate token and options args
MixpanelLib.prototype._gdpr_call_func = function(func, options) {
    options = _.extend({
        'track': _.bind(this.track, this),
        'persistence_type': this.get_config('opt_out_tracking_persistence_type'),
        'cookie_prefix': this.get_config('opt_out_tracking_cookie_prefix'),
        'cookie_expiration': this.get_config('cookie_expiration'),
        'cross_site_cookie': this.get_config('cross_site_cookie'),
        'cross_subdomain_cookie': this.get_config('cross_subdomain_cookie'),
        'cookie_domain': this.get_config('cookie_domain'),
        'secure_cookie': this.get_config('secure_cookie'),
        'ignore_dnt': this.get_config('ignore_dnt')
    }, options);

// check if localStorage can be used for recording opt out status, fall back to cookie if not
    if (!_.localStorage.is_supported()) {
        options['persistence_type'] = 'cookie';
    }

return func(this.get_config('token'), {
        track: options['track'],
        trackEventName: options['track_event_name'],
        trackProperties: options['track_properties'],
        persistenceType: options['persistence_type'],
        persistencePrefix: options['cookie_prefix'],
        cookieDomain: options['cookie_domain'],
        cookieExpiration: options['cookie_expiration'],
        crossSiteCookie: options['cross_site_cookie'],
        crossSubdomainCookie: options['cross_subdomain_cookie'],
        secureCookie: options['secure_cookie'],
        ignoreDnt: options['ignore_dnt']
    });
};

/**
 * Opt the user in to data tracking and cookies/localstorage for this Mixpanel instance
 *
 * ### Usage:
 *
 *     // opt user in
 *     mixpanel.opt_in_tracking();
 *
 *     // opt user in with specific event name, properties, cookie configuration
 *     mixpanel.opt_in_tracking({
 *         track_event_name: 'User opted in',
 *         track_event_properties: {
 *             'Email': 'jdoe@example.com'
 *         },
 *         cookie_expiration: 30,
 *         secure_cookie: true
 *     });
 *
 * @param {Object} [options] A dictionary of config options to override
 * @param {function} [options.track] Function used for tracking a Mixpanel event to record the opt-in action (default is this Mixpanel instance's track method)
 * @param {string} [options.track_event_name=$opt_in] Event name to be used for tracking the opt-in action
 * @param {Object} [options.track_properties] Set of properties to be tracked along with the opt-in action
 * @param {boolean} [options.enable_persistence=true] If true, will re-enable sdk persistence
 * @param {string} [options.persistence_type=localStorage] Persistence mechanism used - cookie or localStorage - falls back to cookie if localStorage is unavailable
 * @param {string} [options.cookie_prefix=__mp_opt_in_out] Custom prefix to be used in the cookie/localstorage name
 * @param {Number} [options.cookie_expiration] Number of days until the opt-in cookie expires (overrides value specified in this Mixpanel instance's config)
 * @param {string} [options.cookie_domain] Custom cookie domain (overrides value specified in this Mixpanel instance's config)
 * @param {boolean} [options.cross_site_cookie] Whether the opt-in cookie is set as cross-site-enabled (overrides value specified in this Mixpanel instance's config)
 * @param {boolean} [options.cross_subdomain_cookie] Whether the opt-in cookie is set as cross-subdomain or not (overrides value specified in this Mixpanel instance's config)
 * @param {boolean} [options.secure_cookie] Whether the opt-in cookie is set as secure or not (overrides value specified in this Mixpanel instance's config)
 */
MixpanelLib.prototype.opt_in_tracking = function(options) {
    options = _.extend({
        'enable_persistence': true
    }, options);

this._gdpr_call_func(optIn, options);
    this._gdpr_update_persistence(options);
};

/**
 * Opt the user out of data tracking and cookies/localstorage for this Mixpanel instance
 *
 * ### Usage:
 *
 *     // opt user out
 *     mixpanel.opt_out_tracking();
 *
 *     // opt user out with different cookie configuration from Mixpanel instance
 *     mixpanel.opt_out_tracking({
 *         cookie_expiration: 30,
 *         secure_cookie: true
 *     });
 *
 * @param {Object} [options] A dictionary of config options to override
 * @param {boolean} [options.delete_user=true] If true, will delete the currently identified user's profile and clear all charges after opting the user out
 * @param {boolean} [options.clear_persistence=true] If true, will delete all data stored by the sdk in persistence
 * @param {string} [options.persistence_type=localStorage] Persistence mechanism used - cookie or localStorage - falls back to cookie if localStorage is unavailable
 * @param {string} [options.cookie_prefix=__mp_opt_in_out] Custom prefix to be used in the cookie/localstorage name
 * @param {Number} [options.cookie_expiration] Number of days until the opt-in cookie expires (overrides value specified in this Mixpanel instance's config)
 * @param {string} [options.cookie_domain] Custom cookie domain (overrides value specified in this Mixpanel instance's config)
 * @param {boolean} [options.cross_site_cookie] Whether the opt-in cookie is set as cross-site-enabled (overrides value specified in this Mixpanel instance's config)
 * @param {boolean} [options.cross_subdomain_cookie] Whether the opt-in cookie is set as cross-subdomain or not (overrides value specified in this Mixpanel instance's config)
 * @param {boolean} [options.secure_cookie] Whether the opt-in cookie is set as secure or not (overrides value specified in this Mixpanel instance's config)
 */
MixpanelLib.prototype.opt_out_tracking = function(options) {
    options = _.extend({
        'clear_persistence': true,
        'delete_user': true
    }, options);

// delete user and clear charges since these methods may be disabled by opt-out
    if (options['delete_user'] && this['people'] && this['people']._identify_called()) {
        this['people'].delete_user();
        this['people'].clear_charges();
    }

this._gdpr_call_func(optOut, options);
    this._gdpr_update_persistence(options);
};

/**
 * Check whether the user has opted in to data tracking and cookies/localstorage for this Mixpanel instance
 *
 * ### Usage:
 *
 *     var has_opted_in = mixpanel.has_opted_in_tracking();
 *     // use has_opted_in value
 *
 * @param {Object} [options] A dictionary of config options to override
 * @param {string} [options.persistence_type=localStorage] Persistence mechanism used - cookie or localStorage - falls back to cookie if localStorage is unavailable
 * @param {string} [options.cookie_prefix=__mp_opt_in_out] Custom prefix to be used in the cookie/localstorage name
 * @returns {boolean} current opt-in status
 */
MixpanelLib.prototype.has_opted_in_tracking = function(options) {
    return this._gdpr_call_func(hasOptedIn, options);
};

/**
 * Check whether the user has opted out of data tracking and cookies/localstorage for this Mixpanel instance
 *
 * ### Usage:
 *
 *     var has_opted_out = mixpanel.has_opted_out_tracking();
 *     // use has_opted_out value
 *
 * @param {Object} [options] A dictionary of config options to override
 * @param {string} [options.persistence_type=localStorage] Persistence mechanism used - cookie or localStorage - falls back to cookie if localStorage is unavailable
 * @param {string} [options.cookie_prefix=__mp_opt_in_out] Custom prefix to be used in the cookie/localstorage name
 * @returns {boolean} current opt-out status
 */
MixpanelLib.prototype.has_opted_out_tracking = function(options) {
    return this._gdpr_call_func(hasOptedOut, options);
};

/**
 * Clear the user's opt in/out status of data tracking and cookies/localstorage for this Mixpanel instance
 *
 * ### Usage:
 *
 *     // clear user's opt-in/out status
 *     mixpanel.clear_opt_in_out_tracking();
 *
 *     // clear user's opt-in/out status with specific cookie configuration - should match
 *     // configuration used when opt_in_tracking/opt_out_tracking methods were called.
 *     mixpanel.clear_opt_in_out_tracking({
 *         cookie_expiration: 30,
 *         secure_cookie: true
 *     });
 *
 * @param {Object} [options] A dictionary of config options to override
 * @param {boolean} [options.enable_persistence=true] If true, will re-enable sdk persistence
 * @param {string} [options.persistence_type=localStorage] Persistence mechanism used - cookie or localStorage - falls back to cookie if localStorage is unavailable
 * @param {string} [options.cookie_prefix=__mp_opt_in_out] Custom prefix to be used in the cookie/localstorage name
 * @param {Number} [options.cookie_expiration] Number of days until the opt-in cookie expires (overrides value specified in this Mixpanel instance's config)
 * @param {string} [options.cookie_domain] Custom cookie domain (overrides value specified in this Mixpanel instance's config)
 * @param {boolean} [options.cross_site_cookie] Whether the opt-in cookie is set as cross-site-enabled (overrides value specified in this Mixpanel instance's config)
 * @param {boolean} [options.cross_subdomain_cookie] Whether the opt-in cookie is set as cross-subdomain or not (overrides value specified in this Mixpanel instance's config)
 * @param {boolean} [options.secure_cookie] Whether the opt-in cookie is set as secure or not (overrides value specified in this Mixpanel instance's config)
 */
MixpanelLib.prototype.clear_opt_in_out_tracking = function(options) {
    options = _.extend({
        'enable_persistence': true
    }, options);

this._gdpr_call_func(clearOptInOut, options);
    this._gdpr_update_persistence(options);
};

MixpanelLib.prototype.report_error = function(msg, err) {
    console$1.error.apply(console$1.error, arguments);
    try {
        if (!err && !(msg instanceof Error)) {
            msg = new Error(msg);
        }
        this.get_config('error_reporter')(msg, err);
    } catch(err) {
        console$1.error(err);
    }
};

// EXPORTS (for closure compiler)

// MixpanelLib Exports
MixpanelLib.prototype['init']                      = MixpanelLib.prototype.init;
MixpanelLib.prototype['reset']                     = MixpanelLib.prototype.reset;
MixpanelLib.prototype['disable']                   = MixpanelLib.prototype.disable;
MixpanelLib.prototype['time_event']                = MixpanelLib.prototype.time_event;
MixpanelLib.prototype['track']                     = MixpanelLib.prototype.track;
MixpanelLib.prototype['track_links']               = MixpanelLib.prototype.track_links;
MixpanelLib.prototype['track_forms']               = MixpanelLib.prototype.track_forms;
MixpanelLib.prototype['track_pageview']            = MixpanelLib.prototype.track_pageview;
MixpanelLib.prototype['register']                  = MixpanelLib.prototype.register;
MixpanelLib.prototype['register_once']             = MixpanelLib.prototype.register_once;
MixpanelLib.prototype['unregister']                = MixpanelLib.prototype.unregister;
MixpanelLib.prototype['identify']                  = MixpanelLib.prototype.identify;
MixpanelLib.prototype['alias']                     = MixpanelLib.prototype.alias;
MixpanelLib.prototype['name_tag']                  = MixpanelLib.prototype.name_tag;
MixpanelLib.prototype['set_config']                = MixpanelLib.prototype.set_config;
MixpanelLib.prototype['get_config']                = MixpanelLib.prototype.get_config;
MixpanelLib.prototype['get_property']              = MixpanelLib.prototype.get_property;
MixpanelLib.prototype['get_distinct_id']           = MixpanelLib.prototype.get_distinct_id;
MixpanelLib.prototype['toString']                  = MixpanelLib.prototype.toString;
MixpanelLib.prototype['opt_out_tracking']          = MixpanelLib.prototype.opt_out_tracking;
MixpanelLib.prototype['opt_in_tracking']           = MixpanelLib.prototype.opt_in_tracking;
MixpanelLib.prototype['has_opted_out_tracking']    = MixpanelLib.prototype.has_opted_out_tracking;
MixpanelLib.prototype['has_opted_in_tracking']     = MixpanelLib.prototype.has_opted_in_tracking;
MixpanelLib.prototype['clear_opt_in_out_tracking'] = MixpanelLib.prototype.clear_opt_in_out_tracking;
MixpanelLib.prototype['get_group']                 = MixpanelLib.prototype.get_group;
MixpanelLib.prototype['set_group']                 = MixpanelLib.prototype.set_group;
MixpanelLib.prototype['add_group']                 = MixpanelLib.prototype.add_group;
MixpanelLib.prototype['remove_group']              = MixpanelLib.prototype.remove_group;
MixpanelLib.prototype['track_with_groups']         = MixpanelLib.prototype.track_with_groups;
MixpanelLib.prototype['start_batch_senders']       = MixpanelLib.prototype.start_batch_senders;
MixpanelLib.prototype['stop_batch_senders']        = MixpanelLib.prototype.stop_batch_senders;
MixpanelLib.prototype['DEFAULT_API_ROUTES']        = DEFAULT_API_ROUTES;

// MixpanelPersistence Exports
MixpanelPersistence.prototype['properties']            = MixpanelPersistence.prototype.properties;
MixpanelPersistence.prototype['update_search_keyword'] = MixpanelPersistence.prototype.update_search_keyword;
MixpanelPersistence.prototype['update_referrer_info']  = MixpanelPersistence.prototype.update_referrer_info;
MixpanelPersistence.prototype['get_cross_subdomain']   = MixpanelPersistence.prototype.get_cross_subdomain;
MixpanelPersistence.prototype['clear']                 = MixpanelPersistence.prototype.clear;

// add private functions as _
    mixpanel_master['_'] = _;
};

var override_mp_init_func = function() {
    // we override the snippets init function to handle the case where a
    // user initializes the mixpanel library after the script loads & runs
    mixpanel_master['init'] = function(token, config, name) {
        if (name) {
            // initialize a sub library
            if (!mixpanel_master[name]) {
                mixpanel_master[name] = instances[name] = create_mplib(token, config, name);
                mixpanel_master[name]._loaded();
            }
            return mixpanel_master[name];
        } else {
            var instance = mixpanel_master;

if (instances[PRIMARY_INSTANCE_NAME]) {
                // main mixpanel lib already initialized
                instance = instances[PRIMARY_INSTANCE_NAME];
            } else if (token) {
                // intialize the main mixpanel lib
                instance = create_mplib(token, config, PRIMARY_INSTANCE_NAME);
                instance._loaded();
                instances[PRIMARY_INSTANCE_NAME] = instance;
            }

mixpanel_master = instance;
            if (init_type === INIT_SNIPPET) {
                window$1[PRIMARY_INSTANCE_NAME] = mixpanel_master;
            }
            extend_mp();
        }
    };
};

var add_dom_loaded_handler = function() {
    // Cross browser DOM Loaded support
    function dom_loaded_handler() {
        // function flag since we only want to execute this once
        if (dom_loaded_handler.done) { return; }
        dom_loaded_handler.done = true;

DOM_LOADED = true;
        ENQUEUE_REQUESTS = false;

_.each(instances, function(inst) {
            inst._dom_loaded();
        });
    }

function do_scroll_check() {
        try {
            document$1.documentElement.doScroll('left');
        } catch(e) {
            setTimeout(do_scroll_check, 1);
            return;
        }

dom_loaded_handler();
    }

if (document$1.addEventListener) {
        if (document$1.readyState === 'complete') {
            // safari 4 can fire the DOMContentLoaded event before loading all
            // external JS (including this file). you will see some copypasta
            // on the internet that checks for 'complete' and 'loaded', but
            // 'loaded' is an IE thing
            dom_loaded_handler();
        } else {
            document$1.addEventListener('DOMContentLoaded', dom_loaded_handler, false);
        }
    } else if (document$1.attachEvent) {
        // IE
        document$1.attachEvent('onreadystatechange', dom_loaded_handler);

// check to make sure we arn't in a frame
        var toplevel = false;
        try {
            toplevel = window$1.frameElement === null;
        } catch(e) {
            // noop
        }

if (document$1.documentElement.doScroll && toplevel) {
            do_scroll_check();
        }
    }

// fallback handler, always will work
    _.register_event(window$1, 'load', dom_loaded_handler, true);
};

function init_as_module() {
    init_type = INIT_MODULE;
    mixpanel_master = new MixpanelLib();

override_mp_init_func();
    mixpanel_master['init']();
    add_dom_loaded_handler();

return mixpanel_master;
}

var mixpanel = init_as_module();

var mixpanel_cjs = mixpanel;

//                                      Copyright 2024 WebPros International, LLC
//                                                           All rights reserved.
// copyright@cpanel.net                                         http://cpanel.net
// This code is subject to the cPanel license. Unauthorized copying is prohibited.
/**
 * A place to store constants used by the Mixpanel tool.
 */
const MixpanelConstants = {
  devReportingEnabled: false,
  apiHost: "https://mixpanel-proxy.cpanel.net",
  devProjectToken: "c7c6f1b1bc8e7b3d8254ebe545861955",
  prodProjectToken: "2cca34424fe0e8ad6897d354b9591c45",
  mpUserSession: "mp_cp_user_session",
  mpResetSession: "mp_cp_reset_session",
};

//                                      Copyright 2024 WebPros International, LLC
class MixpanelUtilsService {
  /**
   * Initialize Mixpanel for the workspace (cPanel, Webmail or WHM)
   * that calls this function.
   * Note: It DOES NOT track any analytics data yet.
   */
  initializeMixpanel(config) {
    // Need this for sending into 'loaded' handler.
    const mixpanelUtilsSvc = this;
    let mixpanelConfig = config && typeof config === "string" ? JSON.parse(unescape(config)) : config;
    let debugMode = mixpanelConfig.debugMode || false;
    let isQaBuild = true;
    if (mixpanelConfig.cpAnalyticsData) {
      isQaBuild =
        !mixpanelConfig.cpAnalyticsData.is_nat && mixpanelConfig.cpAnalyticsData.server_main_ip_is_private;
    }
    const isProdEnv = this._isProdEnvironment(mixpanelConfig.isSandbox, isQaBuild);
    const accessToken = isProdEnv ? MixpanelConstants.prodProjectToken : MixpanelConstants.devProjectToken;
    const isDevReportingDisabled = !isProdEnv && !(window["__cpanel_force_dev_reporting"] || MixpanelConstants.devReportingEnabled);
    if (isDevReportingDisabled) {
      console.log("[Mixpanel DRY RUN] Dev reporting disabled. Would have initialized with token:", accessToken);
      console.log("[Mixpanel DRY RUN] Config:", JSON.stringify(mixpanelConfig, null, 2));
      return;
    }
    mixpanel_cjs.init(accessToken, {
      debug: debugMode,
      ignore_dnt: true,
      property_blacklist: [
        // properties that reveal the cpSess CSRF url path
        "$initial_referrer",
        "url",
      ],
      ip: false,
      autotrack: false,
      api_host: window["__cpanel_mixpanel_api_host"] || MixpanelConstants.apiHost,
      loaded: function (mixpanel) {
        // Remove old ones if a new user is detected.
        if (mixpanelConfig.loginUser !== sessionStorage.getItem(MixpanelConstants.mpUserSession)) {
          sessionStorage.removeItem(MixpanelConstants.mpUserSession);
          sessionStorage.removeItem(MixpanelConstants.mpResetSession);
        }
        if (mixpanelConfig.canTrackUserAnalytics) {
          mixpanelUtilsSvc.enableAnalytics(mixpanelConfig, false);
        }
        else {
          // The init allows track events by default. Disable it here and
          // Let it get enabled when the user consent is checked and mixpanel
          // properties are actually getting registered.
          mixpanel.opt_out_tracking();
        }
        window["mixpanel"] = mixpanel;
      },
    });
  }
  /**
   * This method is called when the user logs in for the first time with analytics consent enabled,
   * or after saving their analytics consent preference.
   * @param mixpanelConfig    An object that includes mixpanel specific data.
   * @param isFirstTime       A boolean indicating if this is the first time the user is enabling analytics.
   */
  enableAnalytics(mixpanelConfig, isFirstTime = true) {
    const isAnalyticsDataExists = Object.keys(mixpanelConfig.cpAnalyticsData || {}).length > 0;
    const isAnalyticsEnabled = !!mixpanelConfig.canTrackUserAnalytics && isAnalyticsDataExists;
    if (!isFirstTime && !isAnalyticsEnabled)
      return;
    // Store user logged in event when loaded the first time.
    if (!sessionStorage.getItem(MixpanelConstants.mpUserSession)) {
      sessionStorage.setItem(MixpanelConstants.mpUserSession, mixpanelConfig.loginUser);
    }
    this._registerMixpanel(mixpanel_cjs, mixpanelConfig.cpAnalyticsData);
  }
  /**
   * Registers Mixpanel for the workspace (cPanel, Webmail or WHM)
   * that calls this function.
   * Opts in analytics tracking.
   * Creates super properties and that can be accessed by all events.
   */
  _registerMixpanel(mixpanel, analyticsData) {
    if (Object.keys(analyticsData).length === 0) {
      return;
    }
    // Call Mixpanel's opt-in method.
    if (!mixpanel.has_opted_in_tracking()) {
      // We don't want this to create an unnecessary event.
      mixpanel.opt_in_tracking({ track: () => { } });
    }
    const tokenRegex = /\/cpsess\d+\//i;
    // Sanitize the url path.
    var path = this._getUrlPath().replace(tokenRegex, "/");
    var pageTitle = analyticsData.product_interface + "-" + (analyticsData.product_feature || path);
    // Register $current_url before the identify request to ensure it uses
    // the sanitized path in all requests.
    mixpanel.register({
      $current_url: path,
    });
    // Identify the user only if the UUID exists.
    if (analyticsData.UUID) {
      mixpanel.identify(analyticsData.UUID);
    }
    else if (!sessionStorage.getItem(MixpanelConstants.mpResetSession)) {
      // When UUID doesn't exist, Mixpanel SDK uses the previous UUID
      // stored in the cookie. That may end up identifying the current user
      // with a previous user's login. To avoid such situation, we are clearing
      // old data and recreating the props for the current user IF UUID doesn't exist.
      mixpanel.reset();
      sessionStorage.setItem(MixpanelConstants.mpResetSession, "true");
    }
    // Identify the team user only if is_team_user is true and get roles
    if (analyticsData.is_team_user) {
      mixpanel.people.set({ team_user_roles: analyticsData.team_user_roles });
    }
    // Register MixPanel. The properties set during registration are super properties.
    // These super properties are sent with all events tracked by Mixpanel.
    mixpanel.register(Object.assign({}, analyticsData));
    mixpanel.set_group("company_id", analyticsData.company_id);
    mixpanel.people.set({
      product_locale: analyticsData.product_locale,
      product_version: analyticsData.product_version,
      product_trial_status: analyticsData.product_trial_status,
      server_current_license_kind: analyticsData.server_current_license_kind,
      server_main_ip: analyticsData.server_main_ip,
      server_operating_system: analyticsData.server_operating_system,
      server_is_nat: analyticsData.is_nat,
      account_transferred_or_restored: analyticsData.TRANSFERRED_OR_RESTORED,
    });
    // Track Page view event.
    mixpanel.track(pageTitle, {});
  }
  /**
   * Opts out of analytics tracking for the
   * workspace (cPanel, Webmail or WHM)
   * from where this function is called.
   * Additionally, it also clears the super properties
   * that where set during the opt in phase.
   */
  optOutOfAnalytics() {
    if (mixpanel_cjs.has_opted_in_tracking()) {
      mixpanel_cjs.clear_opt_in_out_tracking();
      // Clear all the super properties before opting out.
      mixpanel_cjs.reset();
      mixpanel_cjs.opt_out_tracking();
    }
  }
  /**
   * Returns the sanitized path of the url.
   */
  _getUrlPath() {
    var path = window.location.pathname;
    if (path) {
      var wholepath = path.split("/");
      var custompath = wholepath.slice(2);
      path = "/" + custompath.join("/");
    }
    return path;
  }
  /**
   * Return if the current environment is Production or Development
   * based on sandbox touchfile and IP addressing.
   */
  _isProdEnvironment(isSandbox, isQaBuild) {
    return isSandbox || isQaBuild ? false : true;
  }
}
const mixpanelUtils = new MixpanelUtilsService();

/**
# cpanel - ui/web-components/src/components/shared/cp-logo/logo-types.ts
#                                                  Copyright 2022 cPanel, L.L.C.
#                                                           All rights reserved.
# copyright@cpanel.net                                         http://cpanel.net
# This code is subject to the cPanel license. Unauthorized copying is prohibited
 */
var LogoType;
(function (LogoType) {
  LogoType["CpanelOrangeLg"] = "./assets/cpanel-logo-orange.svg";
  LogoType["CpanelWhiteLg"] = "./assets/cpanel-logo-white.svg";
})(LogoType || (LogoType = {}));

const cpMainMenuHeaderControlCss = ":host{display:flex}.btn-hamburger-menu{display:flex;background:transparent;border:none;padding:0;cursor:pointer}";

/**
# cpanel - ui/web-components/src/utils/url.ts      Copyright 2022 cPanel, L.L.C.
#                                                           All rights reserved.
# copyright@cpanel.net                                         http://cpanel.net
# This code is subject to the cPanel license. Unauthorized copying is prohibited
 */
/**
 * Tells whether a URL is absolute (i.e., has a scheme and all) or not.
 */
function urlIsAbsolute(input) {
  return input.includes("://");
}

/**
# cpanel - ui/web-components/src/components/shared/services/expanded-left-nav.service.ts
#                                                  Copyright 2022 cPanel, L.L.C.
#                                                           All rights reserved.
# copyright@cpanel.net                                         http://cpanel.net
# This code is subject to the cPanel license. Unauthorized copying is prohibited
 */
class ExpandedLeftNavService {
  /**
   * Focuses the first link in the menu.
   * @param event
   * @param childLogo
   */
  async setFocus(event, childLogo) {
    const menuOpened = event.detail;
    if (menuOpened) {
      await childLogo.doFocus();
    }
  }
}
const expandedLeftNavService = new ExpandedLeftNavService();

/**
 * Is the given input an absolute path?
 */
function _isAbsolutePath(input) {
  return input.startsWith("/");
}
const CpMainMenuNav$1 = class extends HTMLElement {
  constructor() {
    super();
    this.__registerHost();
    this.__attachShadow();
  }
  /**
   * The actual href value
   */
  _finalLinkURL(input) {
    if (urlIsAbsolute(input)) {
      return input;
    }
    if (_isAbsolutePath(input)) {
      // /foo/bar.html needs the security token added
      // (e.g., /cpsessXXXXX/foo/bar.html), but in cP
      // we don’t have the security token for now.
      //
      // This is here as a courtesy so that we get some
      // indicator of a deeper problem once someone tries
      // to send an absolute path in here.
      throw "No security token available!";
    }
    return this.directoryPrefix + input;
  }
  /**
   * Listens for mainMenuOpened event emission on body and focuses the first link in the menu.
   * @param event
   */
  async setFocus(event) {
    expandedLeftNavService.setFocus(event, this.childLogo);
  }
  analyticsInstanceLoadHandler() {
    var _a, _b;
    // Track link clicks from cPanel Jupiter's main menu.
    if (this._appName === AppName.Cpanel) {
      const navLinkEls = (_a = this.navLinks) === null || _a === void 0 ? void 0 : _a.querySelectorAll("li>a");
      if (navLinkEls === null || navLinkEls === void 0 ? void 0 : navLinkEls.length) {
        (_b = window["mixpanel"]) === null || _b === void 0 ? void 0 : _b.track_links(navLinkEls, "cPanel-Main-Menu-Nav-Link", linkEl => {
          return { "nav-link-id": linkEl.id };
        });
      }
    }
  }
  /**
   * Stencil lifecycle method
   */
  componentWillRender() {
    this.directoryPrefix = state.directoryPrefix;
    if (this.directoryPrefix && !this.directoryPrefix.endsWith("/")) {
      this.directoryPrefix += "/";
    }
    this.linkList = state.mainMenuLinks;
  }
  componentDidLoad() {
    this._appName = state.appName;
  }
  render() {
    return (h("cp-style-reset", null, h("cp-dir", null, h("div", { class: "cp-main-menu__container" }, h("div", { class: "cp-main-menu__logo-container" }, h("cp-logo", { ref: el => (this.childLogo = el), "logo-src": this.logoSrc, "logo-alt-text": this.logoAltText, id: "cp-main-menu__logo" })), h("ul", { class: "links", id: "cp-main-menu__link-list", ref: el => (this.navLinks = el) }, this.linkList.map(link => (h("li", { class: "list-item", key: link.id }, h("a", { id: link.id, class: "list-item__link", href: this._finalLinkURL(link.linkUrl) }, h("span", { class: "list-item__icon", role: "img", "aria-hidden": "true", innerHTML: link.iconSvg }), h("span", { class: "list-item__text" }, link.userText))))))))));
  }
  static get style() { return cpMainMenuNavCss; }
};

/**
# cpanel - ui/web-components/src/components/main-menu/cp-main-menu-nav-whm/session-storage-keys.ts
#                                                  Copyright 2022 cPanel, L.L.C.
#                                                           All rights reserved.
# copyright@cpanel.net                                         http://cpanel.net
# This code is subject to the cPanel license. Unauthorized copying is prohibited
*/
/**
 * Keys used sessionStorage
 */
var SessionStorage;
(function (SessionStorage) {
  SessionStorage["SEARCHTERM"] = "searchTerm";
  SessionStorage["USERNAME"] = "userName";
})(SessionStorage || (SessionStorage = {}));

/**
# cpanel - ui/web-components/src/components/shared/classes/category.ts
#                                                  Copyright 2022 cPanel, L.L.C.
#                                                           All rights reserved.
# copyright@cpanel.net                                         http://cpanel.net
# This code is subject to the cPanel license. Unauthorized copying is prohibited
 */
class Category {
  /**
   * @param input - static properties
   * @param initialNavUrl - from the global store/state
   */
  constructor(input, initialNavUrl) {
    this._expansionStateChanged = false;
    Object.assign(this, input);
    this._containsLoadedPageApp = this.items.some(app => app.url === initialNavUrl);
  }
  shownExpanded() {
    if (this._containsLoadedPageApp) {
      if (!this._expansionStateChanged) {
        return true;
      }
    }
    return this.storedExpanded;
  }
  setExpansionState(newState) {
    this._expansionStateChanged = true;
    this.storedExpanded = newState;
  }
  /**
   * Update the list of apps in the category.
   *
   * @param items The list of apps to set for the category.
   */
  update(items) {
    this.items = items;
  }
}

/**
# cpanel - ui/web-components/src/components/shared/services/whm/personalization.service.ts
#                                                  Copyright 2022 cPanel, L.L.C.
#                                                           All rights reserved.
# copyright@cpanel.net                                         http://cpanel.net
# This code is subject to the cPanel license. Unauthorized copying is prohibited
 */
/**
 * Get saved personalization data for user
 */
function getPersonalizationData(securityToken, store, name) {
  const body = {
    "api.version": 1,
    "names": [`${name}`],
    "store": `${store}`,
  };
  const request = new Request(buildRequestURL(securityToken, "personalization_get"), {
    method: "POST",
    headers: {
      "Content-Type": "application/json",
    },
    body: JSON.stringify(body),
  });
  return fetch(request)
    .then(resp => {
    return resp.json();
  })
    .then(data => {
    if (data.metadata && !data.metadata.result) {
      throw data.metadata.reason;
    }
    else {
      return data.data.personalization;
    }
  })
    .catch(error => {
    console.error(`DEV ERROR: ${error}`);
  });
}
/**
 * Set personalization data for user
 */
function setPersonalizationData(securityToken, store, name, data) {
  const body = {
    "api.version": 1,
    "store": `${store}`,
    "personalization": {},
  };
  body["personalization"][`${name}`] = data;
  const request = new Request(buildRequestURL(securityToken, "personalization_set"), {
    method: "POST",
    headers: {
      "Content-Type": "application/json",
    },
    body: JSON.stringify(body),
  });
  return fetch(request)
    .then(resp => {
    return resp.json();
  })
    .then(data => {
    if (data.metadata && !data.metadata.result) {
      throw data.metadata.reason;
    }
    else {
      return data;
    }
  })
    .catch(error => {
    console.error(`DEV ERROR: ${error}`);
  });
}

/**
# cpanel - ui/web-components/src/components/shared/enums/plugins-category.enum.ts
#                                                  Copyright 2022 cPanel, L.L.C.
#                                                           All rights reserved.
# copyright@cpanel.net                                         http://cpanel.net
# This code is subject to the cPanel license. Unauthorized copying is prohibited
 */
/**
 * Plugins category does not exist in dynamicui.conf. It is created dynamically if plugins exist.
 * This enum returns the hard coded key and name of the category if/when plugins exist.
 */
var PluginsCategory;
(function (PluginsCategory) {
  /**
   * Localizable display name
   * Note: Please localize the name wherever it's used.
   *
   * @example
   * const locale = getLocaleInstance();
   * const categoryName = "";
   * if (category.key === PluginsCategory.KEY){
   *      categoryName = locale.maketext(PluginsCategory.NAME)
   * }
   */
  PluginsCategory["NAME"] = "Plugins";
  /**
   * Non localized identifier key
   */
  PluginsCategory["KEY"] = "plugins";
})(PluginsCategory || (PluginsCategory = {}));

/* Should *not* be a property of App because this ID is local to this
 * particular Stencil component.
 */
function navItemID(appUrl) {
 let scrubbed = appUrl.replace(/[^0-9a-zA-Z_-]/g, "_");
 return `app-nav-${scrubbed}`;
}
// https://stackoverflow.com/a/65586985/586723
function doWhenHasSize(el, todo) {
 const checkSize = () => {
 if (!el.offsetWidth && !el.offsetHeight) {
 return requestAnimationFrame(checkSize);
 }
 // If we get here, `el` has a width or height.
 todo(el);
 };
 checkSize();
}
const locale$l = getLocaleInstance();
const CpMainMenuNavWhm$1 = class extends HTMLElement {
 constructor() {
 super();
 this.__registerHost();
 this.__attachShadow();
 /**
 * Store property for personalization APIs
 */
 this._personalizationStore = "left-navigation";
 /**
 * Name property for personalization APIs
 */
 this._personalizationName = "toggle-status";
 }
 /**
 * Show clear button if search input has text in it.
 */
 get showClearSearchButton() {
 var _a;
 return ((_a = this.filterInputText) === null || _a === void 0 ? void 0 : _a.length) > 0;
 }
 watchRenderBoxShadowProp(newValue) {
 this.renderBoxShadow = newValue;
 }
 /**
 * Save category toggle status
 */
 async _propagateCategoriesState() {
 // Since category state manifests only in internals of objects
 // that Stencil holds, Stencil doesn’t see those state changes.
 // Thus, we have to redraw explicitly.
 forceUpdate(this.element);
 const data = {};
 this.categories.forEach(category => {
 data[category.group] = fromBoolean(category.storedExpanded);
 });
 await setPersonalizationData(this._securityToken, this._personalizationStore, this._personalizationName, data);
 }
 /**
 * Toggle visibility of all category lists
 */
 toggleAllCategories(expand) {
 this.categories.forEach(category => {
 category.setExpansionState(expand);
 });
 this._propagateCategoriesState();
 }
 /**
 * Toggle visibility of single category list
 */
 setCategoryExpansion(category, expand) {
 category.setExpansionState(expand);
 this._propagateCategoriesState();
 }
 /**
 * Returns a Category[] of the actual items to display
 * in the left-nav menu.
 */
 _categoriesForDisplay() {
 return this.categories.filter(category => !!category.items.length);
 }
 /**
 * Appends the Favorites category to the list
 * of categories in the left-nav menu.
 */
 _addFavoritesCategory(expanded) {
 const favoritesCategory = {
 dnsonly_ok: "dns",
 group: "favorites",
 groupdesc: "Favorites",
 items: state.favorites,
 key: "favorites",
 searchtext: "favorites",
 };
 this.unfilteredCategories.unshift(new Category(Object.assign(Object.assign({}, JSON.parse(JSON.stringify(favoritesCategory))), { storedExpanded: expanded ? toBoolean(expanded[favoritesCategory.group]) : false }), state.initialNavUrl));
 }
 _findApp(item) {
 return state.appList.find((app) => {
 if (app.key == item.key) {
 return true;
 }
 return false;
 });
 }
 /**
 * Update the favorites after a user edits them.
 *
 * @param favorites List of favorites in the set.
 */
 async updateFavorites(items) {
 // Favorites is always at the top of the list
 let favoritesCategory = this.unfilteredCategories[0];
 if (items.length > 0) {
 if (favoritesCategory.group != "favorites") {
 let expanded = await this._fetchGroupExpansionData();
 this._addFavoritesCategory(expanded);
 favoritesCategory = this.unfilteredCategories[0];
 }
 }
 else {
 if (favoritesCategory.group == "favorites") {
 this.unfilteredCategories.splice(0, 1);
 }
 }
 // Update the items.
 if (favoritesCategory.group == "favorites") {
 let apps = items.reduce((apps, item) => {
 let app = this._findApp(item);
 if (app) {
 apps.push({
 url: "/" + app.url,
 itemorder: 1,
 itemdesc: app.name,
 description: app.description,
 target: app.target,
 searchtext: app.searchText.join(" "),
 key: app.key,
 });
 }
 return apps;
 }, []);
 favoritesCategory.update(apps);
 }
 const filterText = this.filterInputText;
 if (filterText) {
 // Reapply the filters
 this.categories = this._filterApps(filterText);
 }
 else {
 // or Show all categories and items.
 this.categories = this.unfilteredCategories;
 }
 // Since we change child properties possibly.
 forceUpdate(this.element);
 }
 async componentWillLoad() {
 this.flatApplicationList = state.appList;
 this._securityToken = state.directoryPrefix;
 const expandedGroups = await this._fetchGroupExpansionData();
 this.unfilteredCategories = this._getFullCategoriesList(expandedGroups);
 this._addFavoritesCategory(expandedGroups);
 this.categories = this.unfilteredCategories;
 this.searchService = new Fuse(this.flatApplicationList, WHM_MAIN_MENU_SEARCH_OPTIONS);
 }
 /**
 * Fetch personalization data for the user
 * @returns Promise of key value pair of strings describing categories and if they are expanded. Values are perl bools ie 1 or 0
 */
 async _fetchGroupExpansionData() {
 let response;
 if (state.permissions.basicWHMFunctions) {
 response = await getPersonalizationData(this._securityToken, this._personalizationStore, this._personalizationName);
 return response[this._personalizationName].value;
 }
 return null;
 }
 /**
 * Add additional data to categories from state.
 * @param expandedGroups key value pair of strings describing categories and if they are expanded. Values are perl bools ie 1 or 0
 * @returns Categories array
 */
 _getFullCategoriesList(expandedGroups) {
 let categoryList = state.categoryList.map(rawCategory => {
 return new Category(Object.assign(Object.assign({}, JSON.parse(JSON.stringify(rawCategory))), { storedExpanded: expandedGroups ? toBoolean(expandedGroups[rawCategory.group]) : false }), state.initialNavUrl);
 });
 return this._getPlugins(categoryList);
 }
 /**
 * Remove the plugin category if none exist, otherwise add any plugins to that category
 * @param categoryList Category array
 * @returns Categories array with or without plugin category group
 */
 _getPlugins(categoryList) {
 if (!state.plugins.length) {
 return categoryList.filter(category => {
 return category.group !== PluginsCategory.KEY;
 });
 }
 else {
 const idx = categoryList.findIndex(category => {
 return category.group === PluginsCategory.KEY;
 });
 state.plugins.forEach((plugin, index) => {
 categoryList[idx].items.push({
 url: plugin.url(),
 itemorder: index,
 itemdesc: plugin.name,
 description: "",
 key: plugin.key,
 searchtext: plugin.name,
 });
 });
 return categoryList;
 }
 }
 componentDidLoad() {
 var _a, _b, _c;
 let navUrl = state.initialNavUrl;
 const filterTextFromSession = this._getFilterInputText();
 if (filterTextFromSession) {
 this.filterInputText = filterTextFromSession;
 this.categories = this._filterApps(this.filterInputText);
 }
 if (navUrl) {
 let el = (_a = this.element.shadowRoot) === null || _a === void 0 ? void 0 : _a.getElementById(navItemID(navUrl));
 if (el) {
 /**
 * For some reason, when this code first runs
 * the actual nav list isn’t shown. (Confirm by calling
 * window.alert() here.) It’s unclear (?) what causes the
 * list to be rendered, so for now we poll the DOM
 * until the element has size.
 */
 doWhenHasSize(el, el => el.scrollIntoView({ behavior: "smooth", block: "center" }));
 }
 }
 this.searchInputElement = (_c = (_b = this.element) === null || _b === void 0 ? void 0 : _b.shadowRoot) === null || _c === void 0 ? void 0 : _c.querySelector(".cp-main-menu__filter-input");
 }
 /**
 * Get the value of the filter input from sessionStorage.
 * This is done to keep the filter input across page navigations and across different tabs.
 * @returns string for the input text
 */
 _getFilterInputText() {
 const storageSearchTerm = sessionStorage.getItem(SessionStorage.SEARCHTERM);
 const storageUserName = sessionStorage.getItem(SessionStorage.USERNAME);
 const windowUserName = state.user;
 if (storageSearchTerm && storageUserName && storageUserName === windowUserName) {
 return storageSearchTerm;
 }
 // Most likely end up here because the user names don't match. So clear storage.
 sessionStorage.removeItem(SessionStorage.SEARCHTERM);
 sessionStorage.removeItem(SessionStorage.USERNAME);
 return "";
 }
 /**
 * The actual href value
 */
 _finalMenuHref(app) {
 return urlIsAbsolute(app.url) ? app.url : this._securityToken + app.url;
 }
 /**
 * Get the relevant elements that can be focused in the sidebar
 */
 getFocusNavigation(currentEl) {
 var _a;
 let elements = (_a = this.element.shadowRoot) === null || _a === void 0 ? void 0 : _a.querySelectorAll("a");
 if (!elements) {
 return;
 }
 let index = Array.prototype.indexOf.call(elements, currentEl), nextEl = elements[index + 1], previousEl = elements[index - 1], categories = Array.prototype.filter.call(elements, (element, _index) => {
 return _index <= index && element.getAttribute("data-type") === "category";
 }), categoryEl = categories[categories.length - 1], firstEl = elements[0], lastEl = elements[elements.length - 1];
 return {
 nextEl,
 previousEl,
 categoryEl,
 firstEl,
 lastEl,
 };
 }
 /**
 * Handle the keydown event with the commands defined
 */
 handleKeyDown(event, category) {
 const commands = {
 ArrowLeft: function () {
 if (document.dir === "rtl") {
 this.setCategoryExpansion(category, true);
 return;
 }
 this.setCategoryExpansion(category, false);
 categoryEl.focus();
 },
 ArrowRight: function () {
 if (document.dir === "rtl") {
 this.setCategoryExpansion(category, false);
 categoryEl.focus();
 return;
 }
 this.setCategoryExpansion(category, true);
 },
 ArrowUp: function () {
 if (!previousEl) {
 return;
 }
 previousEl.focus();
 },
 ArrowDown: function () {
 if (!nextEl) {
 return;
 }
 nextEl.focus();
 },
 Home: function () {
 firstEl.focus();
 },
 End: function () {
 lastEl.focus();
 },
 };
 if (!commands[event.key]) {
 return;
 }
 const currentEl = (event.target || event.srcElement);
 const { nextEl, previousEl, categoryEl, firstEl, lastEl } = this.getFocusNavigation(currentEl);
 event.preventDefault();
 commands[event.key].bind(this)();
 }
 /**
 * Focus the next category when the down arrow is pressed in either expand/collapse all button
 */
 handleButtonKeyDown(event) {
 if (event.key !== "ArrowDown") {
 return;
 }
 event.preventDefault();
 let element = (event.target || event.srcElement);
 let { firstEl } = this.getFocusNavigation(element);
 firstEl.focus();
 }
 /**
 * Handles keyboard inputs when executed while the filter input is focused.
 * Handles moving down to the list of categories and apps.
 * @param event keyboard event from the input
 */
 handleFilterKeyDown(event) {
 const currentEl = event.target;
 const { nextEl } = this.getFocusNavigation(currentEl);
 if (nextEl) {
 this.handleButtonKeyDown(event);
 }
 }
 /**
 * Handles keyboard inputs when executed while the filter input is focused.
 * Handles clearing the input.
 * @param event keyboard event from the input
 * @returns void
 */
 handleFilterKeyUp(event) {
 if (event.key === "Escape") {
 this._clearFilterInput();
 return;
 }
 }
 /**
 * Filters the categories and their apps to display based on user input.
 * @param event onInput event from the input element
 * @returns void
 */
 _handleFilterInput(event) {
 var _a;
 // Handles the case of clicking the "x" in the input provided by the browser.
 if (!event.data && !event.inputType) {
 this._clearFilterInput();
 return;
 }
 this.filterInputText = (_a = event.target) === null || _a === void 0 ? void 0 : _a.value.trim();
 const emptyString = /^\s+$/g.test(this.filterInputText);
 this.categories = this.unfilteredCategories;
 // Don't do filtering if the input is empty or just spaces
 if (!this.filterInputText || emptyString) {
 this._clearFilterInput();
 return;
 }
 // Make a list of categories with filterd app lists
 this.categories = this._filterApps(this.filterInputText);
 this._saveFilterInput(this.filterInputText);
 event.stopPropagation();
 }
 /**
 * Handles clearing the filter input.
 */
 _clearFilterInput() {
 this.filterInputText = "";
 this.categories = this.unfilteredCategories;
 this._saveFilterInput(this.filterInputText);
 }
 /**
 * Creates a new list of categories whose apps contain the input text in their searchtext key.
 * @param input filter string
 * @returns
 */
 _filterApps(input) {
 // Get the fuzzy search results.
 const result = this.searchService.search(input);
 let resultListByCategory = result.reduce((newList, resultItem) => {
 var _a;
 if (newList[resultItem.item.categoryKey]) {
 (_a = newList[resultItem.item.categoryKey]) === null || _a === void 0 ? void 0 : _a.push(resultItem.item.key);
 }
 else {
 newList[resultItem.item.categoryKey] = [resultItem.item.key];
 }
 return newList;
 }, {});
 return this.categories.reduce((newCategoryList, category) => {
 var _a;
 if (((_a = resultListByCategory[category.group]) === null || _a === void 0 ? void 0 : _a.length) > 0) {
 const filteredAppList = category.items.filter(item => {
 var _a;
 return (_a = resultListByCategory[category.group]) === null || _a === void 0 ? void 0 : _a.includes(item.key);
 });
 const categoryWithFilteredItems = new Category(Object.assign(Object.assign({}, JSON.parse(JSON.stringify(category))), {
 // Set them all to expanded
 storedExpanded: true,
 // Show filtered list of apps
 items: filteredAppList
 }), state.initialNavUrl);
 newCategoryList.push(categoryWithFilteredItems);
 }
 return newCategoryList;
 }, []);
 }
 /**
 * When a user inputs a value in the filter, save it to sessionStorage with the current user name.
 * @param input string value from the filter input
 */
 _saveFilterInput(input) {
 sessionStorage.setItem(SessionStorage.SEARCHTERM, input);
 sessionStorage.setItem(SessionStorage.USERNAME, window["COMMON"].userName);
 }
 /**
 * Expand All/Collapse All when shift+8 is pressed
 */
 toggleCategories(event) {
 if (!(event.code == "Digit8" && event.shiftKey)) {
 return;
 }
 let allCollapsed = this.categories.every(function (category) {
 return !category.shownExpanded();
 });
 this.toggleAllCategories(allCollapsed);
 }
 /**
 * Focus the filter ctrl+/ is pressed
 * @param event keyboard event
 */
 focusFilterInput(event) {
 if (event.ctrlKey && event.key === "/") {
 this.searchInputElement.focus();
 }
 }
 /**
 * Listens for mainMenuOpened event emission on body and focuses the first link in the menu.
 * @param event
 */
 async setFocus(event) {
 expandedLeftNavService.setFocus(event, this.childLogo);
 }
 /**
 * Handle clear search click event.
 */
 handleClearSearchClicked() {
 this._clearFilterInput();
 this.searchInputElement.focus();
 }
 render() {
 return (h("cp-style-reset", null, h("cp-dir", null, h("div", { class: "flex-wrapper" }, h("div", { class: this.renderBoxShadow ? "cp-main-menu__header--box-shadowed" : "cp-main-menu__header" }, h("div", { class: "cp-main-menu__logo-container" }, h("cp-logo", { ref: el => (this.childLogo = el), "logo-src": state.whmLogos.WhmWhiteLg, "logo-alt-text": this.logoAltText ? this.logoAltText : "", "logo-link-href": "/" }), isDnsOnly() && h("cp-dns-only", { class: "text-white" })), h("div", { class: "toggle-all-container" }, h("button", { "data-key": "toggle-all-open-button", class: "toggle-all-container__button", onKeyDown: e => this.handleButtonKeyDown(e), onClick: () => this.toggleAllCategories(true), title: locale$l.maketext("Expand all category lists.") }, h("span", { class: "toggle-all-container__text" }, locale$l.maketext("Expand")), h("cp-icon", { name: "arrow-down-line", size: IconSize.lg })), h("button", { "data-key": "toggle-all-close-button", class: "toggle-all-container__button", onKeyDown: e => this.handleButtonKeyDown(e), onClick: () => this.toggleAllCategories(false), title: locale$l.maketext("Collapse all category lists.") }, h("span", { class: "toggle-all-container__text" }, locale$l.maketext("Collapse")), h("cp-icon", { name: "arrow-up-line", size: IconSize.lg }))), h("div", { class: "cp-main-menu__input-container" }, h("input", { id: "main-menu-filter", class: "cp-main-menu__filter-input hide-browser-clear-button", type: "search", autocomplete: "off", spellcheck: "false", placeholder: locale$l.maketext("Search Tools (Ctrl /)[comment,placeholder text]"), title: locale$l.maketext("Search Tools (Ctrl /)[comment,placeholder text]"), "aria-label": locale$l.maketext("Search Tools (Ctrl /)[comment,placeholder text]"), value: this.filterInputText, onInput: e => this._handleFilterInput(e), onKeyDown: e => this.handleFilterKeyDown(e), onKeyUp: e => this.handleFilterKeyUp(e) }), this.showClearSearchButton && (h("button", { onClick: () => this.handleClearSearchClicked(), class: "cp-main-menu__search-clear-search-button", "aria-label": locale$l.maketext("Clear Search") }, h("cp-icon", { name: "close-line", mode: IconMode.Centered }))))), h("hr", { class: "section-separator" }), h("div", { class: "navlist-container" }, h("ul", { class: "links" }, this._categoriesForDisplay().map(category => (h("li", { class: "list-item", key: category.grouporder }, h("a", { "data-type": "category", class: "list-item__category-link", href: "javascript:void(0)", onKeyDown: e => this.handleKeyDown(e, category), onClick: () => this.setCategoryExpansion(category, !category.shownExpanded()) }, category.shownExpanded() ? (h("cp-icon", { class: "list-item__icon", name: "arrow-down-s-line", size: IconSize.xl, mode: IconMode.Inline })) : (h("cp-icon", { class: "list-item__icon", name: "arrow-right-s-line", size: IconSize.xl, mode: IconMode.Inline })), h("span", { class: "list-item__category-text" }, category.groupdesc)), category.shownExpanded() && (h("ul", { class: "list" }, category.items.map(item => (h("li", { class: "list-item" +
 (state.initialNavUrl === item.url
 ? " whm-current-tool"
 : ""), key: item.itemorder, id: navItemID(item.url) }, h("a", { onKeyDown: event => this.handleKeyDown(event, category), class: "list-item__link", href: this._finalMenuHref(item), target: item.target, "data-type": "application" }, h("span", { class: "list-item__text", innerHTML: item.itemdesc }))))))))))))))));
 }
 get element() { return this; }
 static get watchers() { return {
 "renderBoxShadow": ["watchRenderBoxShadowProp"]
 }; }
 static get style() { return cpMainMenuNavWhmCss; }
};

/*
# cpanel - ui/web-components/src/components/shared/cp-modal/cp-modal-size.ts
#                                                  Copyright 2022 cPanel, L.L.C.
#                                                           All rights reserved.
# copyright@cpanel.net                                         http://cpanel.net
# This code is subject to the cPanel license. Unauthorized copying is prohibited
*/
var ModalSize;
(function (ModalSize) {
  ModalSize["default"] = "";
  ModalSize["sm"] = "cp-modal-sm";
  ModalSize["lg"] = "cp-modal-lg";
  ModalSize["xl"] = "cp-modal-xl";
})(ModalSize || (ModalSize = {}));

/**
# cpanel - ui/web-components/src/components/shared/cp-modal/cp-modal-state.ts
#                                                  Copyright 2022 cPanel, L.L.C.
#                                                           All rights reserved.
# copyright@cpanel.net                                         http://cpanel.net
# This code is subject to the cPanel license. Unauthorized copying is prohibited
 */
var ModalState;
(function (ModalState) {
  ModalState["OPEN"] = "open";
  ModalState["CLOSE"] = "close";
})(ModalState || (ModalState = {}));

// Copyright 2022 cPanel, L.L.C. - All rights reserved.
class UapiServiceController {
  constructor() { }
  /**
   * Package up the api url into a full url for the current application.
   *
   * @param info [description]
   */
  packageUrl(info) {
    const appPath = new ApplicationPath(new LocationService());
    return appPath.buildTokenPath(info.url);
  }
  /**
   * Build a response handler for the request
   *
   * @param url [description]
   */
  packageResponseHandler(response, url) {
    const uapiResponse = new UapiResponse(response);
    uapiResponse.meta.properties["url"] = url ? url : "";
    return uapiResponse;
  }
  /**
   * Start an async GET request
   *
   * @param request - UapiRequest object with details of the API call.
   * @returns response object of type Promise
   */
  get(request) {
    const info = request.generate({
      verb: HttpVerb.GET,
      encoder: new WwwFormUrlArgumentEncoder(),
    });
    const url = this.packageUrl(info);
    return fetch(url, {
      method: "GET",
      headers: info.headers.toObject(),
    })
      .then(response => response.json())
      .then(response => {
      response = this.packageResponseHandler(response);
      if (response.hasErrors) {
        return Promise.reject(response.errors);
      }
      else {
        return Promise.resolve(response);
      }
    });
  }
  /**
   * Start an async POST request
   *
   * @param request - UapiRequest object with details of the API call.
   * @returns response object of type Promise
   */
  post(request) {
    const info = request.generate();
    const url = this.packageUrl(info);
    return fetch(url, {
      method: "POST",
      headers: info.headers.toObject(),
      body: info.body,
    })
      .then(response => response.json())
      .then(response => {
      response = this.packageResponseHandler(response);
      if (response.hasErrors) {
        return Promise.reject(response.errors);
      }
      else {
        return Promise.resolve(response);
      }
    });
  }
}
const UapiService = new UapiServiceController();

/*
# cpanel - ui/web-components/src/components/shared/cp-modal/cp-modal-actions.ts
#                                                  Copyright 2022 cPanel, L.L.C.
#                                                           All rights reserved.
# copyright@cpanel.net                                         http://cpanel.net
# This code is subject to the cPanel license. Unauthorized copying is prohibited
*/
var ModalActions;
(function (ModalActions) {
  ModalActions["Close"] = "CLOSE-MODAL";
  ModalActions["Open"] = "OPEN-MODAL";
})(ModalActions || (ModalActions = {}));

/**
# cpanel - ui/web-components/src/components/shared/classes/plugin.ts
#                                                  Copyright 2022 cPanel, L.L.C.
#                                                           All rights reserved.
# copyright@cpanel.net                                         http://cpanel.net
# This code is subject to the cPanel license. Unauthorized copying is prohibited
 */
class Plugin {
  constructor(attrs) {
    Object.assign(this, attrs);
  }
  /**
   * The absolute URL path to access the plugin.
   *
   * IMPORTANT: This does **NOT** include the security token,
   * which is necessary for the URL to work.
   */
  url() {
    return `/cgi/${this.cgi}`;
  }
}

/**
# cpanel - ui/web-components/src/components/shared/services/whm/app-tools.service.ts
#                                                  Copyright 2022 cPanel, L.L.C.
#                                                           All rights reserved.
# copyright@cpanel.net                                         http://cpanel.net
# This code is subject to the cPanel license. Unauthorized copying is prohibited
 */
const locale$g = getLocaleInstance();
const AppToolsService = {
  /**
   * Set the WHM application list. After the initial API call, set the application list value in the store and pull the data from there.
   */
  getWHMApplicationList(categoryList, plugins) {
    let appList = [];
    categoryList.forEach(category => {
      if (category.items.length) {
        category.items.forEach(app => {
          let thisUrlIsAbsolute = urlIsAbsolute(app.url);
          appList.push({
            name: app.itemdesc,
            searchText: toLocaleLowerCase(app.searchtext).split(/\s+/),
            url: thisUrlIsAbsolute ? app.url : app.url.substring(1),
            url_is_absolute: thisUrlIsAbsolute ? 1 : 0,
            target: app.target,
            key: app.key,
            categoryKey: category.group,
            category: category.groupdesc,
            description: app.description || "",
          });
        });
      }
    });
    plugins.forEach(plugin => {
      appList.push({
        name: plugin.name,
        searchText: toLocaleLowerCase(plugin.name).split(/\s+/),
        url_is_absolute: 0,
        key: plugin.key,
        // Omit leading slash:
        url: plugin.url().substring(1),
        categoryKey: PluginsCategory.KEY,
        category: locale$g.maketext(PluginsCategory.NAME),
        description: "",
      });
    });
    return appList;
  },
  /**
   * Set the cPanel application list. After the initial API call, set the application list value in the store and pull the data from there.
   */
  getCpanelApplicationList(rawAppList) {
    return JSON.parse(unescape(rawAppList)).map(app => {
      app["searchText"] = toLocaleLowerCase(app.searchText).split(/\s+/);
      return app;
    });
  },
  /**
   * Set the Webmail application list. After the initial API call, set the application list value in the store and pull the data from there.
   */
  getWebmailApplicationList(rawAppList, mailClientList) {
    let appList = [];
    // Normalize rawAppList to the AppEntry type.
    appList = JSON.parse(unescape(rawAppList)).map(app => {
      const thisUrlIsAbsolute = urlIsAbsolute(app.url);
      return {
        name: app.name,
        searchText: "",
        url: app.url,
        url_is_absolute: thisUrlIsAbsolute ? 1 : 0,
        key: app.key,
        category: app.category,
        categoryKey: app.category,
        description: app.description,
      };
    });
    appList = appList.concat(JSON.parse(unescape(mailClientList)).map(mailClient => {
      const thisUrlIsAbsolute = urlIsAbsolute(mailClient.url);
      return {
        name: mailClient.displayname,
        searchText: "",
        url: mailClient.url,
        url_is_absolute: thisUrlIsAbsolute ? 1 : 0,
        key: mailClient.id,
        category: "",
        categoryKey: "",
        description: mailClient.displayname,
      };
    }));
    return appList;
  },
};

const cpStyleResetCss = ":host{all:initial;font-family:Roboto;font-size:16px;line-height:1.5}button{line-height:inherit}";

/*
# cpanel - ui/web-components/src/components/welcome-modal/welcome-modal-actions.ts
#                                                  Copyright 2022 cPanel, L.L.C.
#                                                           All rights reserved.
# copyright@cpanel.net                                         http://cpanel.net
# This code is subject to the cPanel license. Unauthorized copying is prohibited
*/
var WelcomeModalActions;
(function (WelcomeModalActions) {
  WelcomeModalActions["Dismiss"] = "DISMISS";
  WelcomeModalActions["CreateWebsite"] = "CREATE-WEBSITE";
  WelcomeModalActions["AfterCreateWebsite"] = "AFTER-CREATE-WEBSITE";
  WelcomeModalActions["NextStep"] = "NEXT-STEP";
  WelcomeModalActions["RedirectToUrl"] = "REDIRECT-TO-URL";
})(WelcomeModalActions || (WelcomeModalActions = {}));

/*
# cpanel - ui/web-components/src/components/welcome-modal/site-install-status.enum.ts
#                                                  Copyright 2022 cPanel, L.L.C.
#                                                           All rights reserved.
# copyright@cpanel.net                                         http://cpanel.net
# This code is subject to the cPanel license. Unauthorized copying is prohibited
*/
var SiteInstallStatus;
(function (SiteInstallStatus) {
  SiteInstallStatus[SiteInstallStatus["Started"] = 0] = "Started";
  SiteInstallStatus[SiteInstallStatus["InProgress"] = 1] = "InProgress";
  SiteInstallStatus[SiteInstallStatus["Success"] = 2] = "Success";
  SiteInstallStatus[SiteInstallStatus["Error"] = 3] = "Error";
})(SiteInstallStatus || (SiteInstallStatus = {}));

/*
# cpanel - ui/web-components/src/components/welcome-modal/welcome-modal-steps.enum.ts
#                                                  Copyright 2022 cPanel, L.L.C.
#                                                           All rights reserved.
# copyright@cpanel.net                                         http://cpanel.net
# This code is subject to the cPanel license. Unauthorized copying is prohibited
*/
var WelcomeModalSteps;
(function (WelcomeModalSteps) {
  WelcomeModalSteps["StartingPoint"] = "starting-point";
  WelcomeModalSteps["WordpressInstall"] = "wp-install";
  WelcomeModalSteps["FinalScreen"] = "congrats";
})(WelcomeModalSteps || (WelcomeModalSteps = {}));

/*
# Copyright 2023 cPanel, L.L.C. - All rights reserved.
# copyright@cpanel.net
# https://cpanel.net
# This code is subject to the cPanel license. Unauthorized copying is prohibited
*/
// These app keys come from app keys used in dynamicui.conf files or for plugins in the install.json file.
var AppKeys;
(function (AppKeys) {
  AppKeys["WpToolkit"] = "wp-toolkit";
  AppKeys["BackupWizard"] = "backup_wizard";
  AppKeys["SitePublisher"] = "site_publisher";
  AppKeys["FileManager"] = "file_manager";
  AppKeys["Tools"] = "tools";
  AppKeys["Solutions"] = "solutions";
  AppKeys["Email"] = "email_accounts";
  AppKeys["PasswordSecurity"] = "change_password";
  AppKeys["Sitejet"] = "cpanel-sitejet-plugin";
})(AppKeys || (AppKeys = {}));

/*
# cpanel - ui/web-components/src/utils/app-feature-check.ts
#                                                  Copyright 2022 cPanel, L.L.C.
#                                                           All rights reserved.
# copyright@cpanel.net                                         http://cpanel.net
# This code is subject to the cPanel license. Unauthorized copying is prohibited
*/
/**
 * Checks the state's appList for the existence of apps. This is used as a feature check until a better method can be implemented.
 * @param appNames List of appNames. The appName comes from the "file" key in dynamicui.conf
 * @returns AppEntry[]. Given a list of appNames, returns the AppEntry for those strings if the user has access to the feature.
 */
function appFeatureCheck(appNames) {
  return state.appList.filter(app => appNames.includes(app.key));
}

/*
# Copyright 2024 cPanel, L.L.C. - All rights reserved.
# copyright@cpanel.net
# https://cpanel.net
# This code is subject to the cPanel license. Unauthorized copying is prohibited
*/
const locale$b = getLocaleInstance();
class StartingPointOption {
  constructor(key, url, title, description, imageKey, show = false, showBadge = false, badgeText) {
    this.key = key;
    this.url = url;
    this.title = title;
    this.description = description;
    this.imageKey = imageKey;
    this.show = show;
    this.showBadge = showBadge;
    this.badgeText = badgeText || locale$b.maketext("Recommended");
  }
  /**
   * Updates the show and url properties for an app when it is available to a user.
   * @param url url string for the option
   */
  updateOptionsInfo(url, show) {
    this.url = url;
    this.show = show;
  }
}

/*
# Copyright 2024 cPanel, L.L.C. - All rights reserved.
# copyright@cpanel.net
# https://cpanel.net
# This code is subject to the cPanel license. Unauthorized copying is prohibited
*/
const locale$a = getLocaleInstance();
let wpToolkitAppInfo = new StartingPointOption(AppKeys.WpToolkit, "", locale$a.maketext("WordPress"), locale$a.maketext("Create and build your website with WordPress."), "wp-toolkit", false, false);
let backupAppInfo = new StartingPointOption(AppKeys.BackupWizard, "backup/wizard-restore.html", locale$a.maketext("Restore from backup"), locale$a.maketext("Have a backup file? Restore it to your account."), "backup-wizard", false, false);
let sitejetAppInfo = new StartingPointOption(AppKeys.Sitejet, "sitejet/index.html#", locale$a.maketext("Sitejet Builder"), locale$a.maketext("An easy path to build a custom website."), AppKeys.Sitejet, true, true, locale$a.maketext("Easy [output,amp] Powerful"));
let solutionsInfo = new StartingPointOption(AppKeys.Tools, `${state.directoryPrefix}index.html`, locale$a.maketext("Explore Account"), locale$a.maketext("Discover your account’s available features."), "solutions", true, false);
// THIS IS AN ORDERED LIST FROM MOST IMPORTANT TO LEAST
let startingPointApps = [wpToolkitAppInfo, sitejetAppInfo, backupAppInfo];
function getAvailableAppEntries(apps) {
  return appFeatureCheck(apps.map(app => app.key));
}
function filterByAvailableApps(apps, availableAppEntries) {
  return apps.filter(app => availableAppEntries.some(entry => entry.key === app.key));
}
function updateAppUrls(apps, availableAppKeys) {
  return apps.map(app => {
    const appEntry = availableAppKeys.find(featureApp => featureApp.key === app.key);
    const fullUrl = app.url
      ? `${state.directoryPrefix}${app.url}`
      : appEntry
        ? `${state.directoryPrefix}${appEntry.url}`
        : "";
    if (fullUrl) {
      app.updateOptionsInfo(fullUrl, true);
    }
    return app;
  });
}
function assembleFinalAppList(apps) {
  return [...apps.slice(0, 2), solutionsInfo];
}
function getAvailableStartOptions() {
  const availableAppKeys = getAvailableAppEntries(startingPointApps);
  const filteredApps = filterByAvailableApps(startingPointApps, availableAppKeys);
  const updatedApps = updateAppUrls(filteredApps, availableAppKeys);
  return assembleFinalAppList(updatedApps);
}

/*
# Copyright 2024 cPanel, L.L.C. - All rights reserved.
# copyright@cpanel.net
# https://cpanel.net
# This code is subject to the cPanel license. Unauthorized copying is prohibited
*/
var SitejetInfo;
(function (SitejetInfo) {
  SitejetInfo["Key"] = "cpanel-sitejet-plugin";
  SitejetInfo["Url"] = "sitejet/index.html#";
})(SitejetInfo || (SitejetInfo = {}));

const cpWelcomeModalStartingPointFooterCss = "";

const cpWelcomeModalWpInstallCss = "";

const cpWelcomeModalWpInstallFooterCss = ":host{display:block}.wp-footer-explore__link{text-decoration:none}.wp-footer-explore__link:hover,.wp-footer-explore__link:focus,.wp-footer-explore__link:active{text-decoration:none}.wp-footer-explore__link-text{vertical-align:middle}.wp-footer-explore__link-text:hover,.wp-footer-explore__link-text:focus,.wp-footer-explore__link-text:active{text-decoration:underline}.wp-footer-explore__link-icon{vertical-align:middle}";

/**
# cpanel - ui/web-components/src/components/shared/services/whm/notifications.service.ts
#                                                  Copyright 2022 cPanel, L.L.C.
#                                                           All rights reserved.
# copyright@cpanel.net                                         http://cpanel.net
# This code is subject to the cPanel license. Unauthorized copying is prohibited
 */
/**
 * Check if WHM version update is available, and if it is what version
 */
function getUpdateAvailabilityNotification(securityToken) {
  const url = `${buildRequestURL(securityToken, "get_update_availability")}?api.version=1`;
  return fetch(url)
    .then(resp => {
    return resp.json();
  })
    .then(data => {
    if (toBoolean(data.metadata.result)) {
      return data.data;
    }
  });
}
/**
 * Get filesystem quota enabled/disabled status
 */
function getQuotaNotification(securityToken) {
  const url = `${buildRequestURL(securityToken, "quota_enabled")}?api.version=1`;
  return fetch(url)
    .then(resp => {
    return resp.json();
  })
    .then(data => {
    if (toBoolean(data.metadata.result)) {
      return toBoolean(data.data);
    }
  });
}

const Fragment = (props, children) => [ ...children ];

const cpWrapFilterCss = ":host{display:inline}";

/**
# cpanel - ui/web-components/src/components/header/cp-header/integration-icon.enum.ts
#                                                  Copyright 2022 cPanel, L.L.C.
#                                                           All rights reserved.
# copyright@cpanel.net                                         http://cpanel.net
# This code is subject to the cPanel license. Unauthorized copying is prohibited
 */
var IntegrationIcon;
(function (IntegrationIcon) {
  IntegrationIcon["customer_service_app_info"] = "customer-service-2-line";
  IntegrationIcon["support_app_info"] = "hand-heart-line";
  IntegrationIcon["billing_app_info"] = "price-tag-line";
  IntegrationIcon["upgrade_app_info"] = "arrow-up-circle-line";
})(IntegrationIcon || (IntegrationIcon = {}));

/**
# cpanel - ui/web-components/src/components/header/cpanel-header/cpanel-menu-items.ts
#                                                  Copyright 2022 cPanel, L.L.C.
#                                                           All rights reserved.
# copyright@cpanel.net                                         http://cpanel.net
# This code is subject to the cPanel license. Unauthorized copying is prohibited
 */
const locale$2 = getLocaleInstance();
/* NOTE: Checking for available apps based on URL could be brittle, but we do not have
any kind of ID field on the applications list. If this causes problems in the future,
the applications should be assigned UIDs when the list is constructed. */
const constructMenuItems = (integrationsInfoJSON) => {
  const apps = state.appList;
  const directoryPrefix = state.directoryPrefix;
  const integrations = JSON.parse(integrationsInfoJSON);
  const feedbackLinkData = sharedUtils.getFeedbackLinkDataForCpanel(state.cpanelFullVersion, state.companyId, state.cpanelAppKey);
  let menuItems = [];
  // Account Settings - always shown
  menuItems.push({
    id: "menu-account-link",
    href: directoryPrefix + "account_preferences/index.html.tt",
    title: locale$2.maketext("Account Preferences"),
    icon: "settings-3-line",
  });
  // Password & Security - if available
  const pwd = apps.find(a => a.url.includes("passwd"));
  if (pwd) {
    menuItems.push({
      id: "menu-password-link",
      href: pwd.url_is_absolute ? pwd.url : directoryPrefix + pwd.url,
      title: pwd.name,
      icon: "lock-2-line",
    });
  }
  // Change Language - if available
  const lang = apps.find(a => a.url.includes("setlang"));
  if (lang) {
    menuItems.push({
      id: "menu-language-link",
      href: lang.url_is_absolute ? lang.url : directoryPrefix + lang.url,
      title: lang.name,
      icon: "translate",
    });
  }
  // Contact Information - if available
  const contact = apps.find(a => a.url.includes("contact/"));
  if (contact) {
    menuItems.push({
      id: "menu-contact-link",
      href: contact.url_is_absolute ? contact.url : directoryPrefix + contact.url,
      title: contact.name,
      icon: "mail-line",
    });
  }
  // Integrations - if available
  for (const item in integrations) {
    if (integrations[item]) {
      menuItems.push({
        id: `menu-${item}-link`,
        href: directoryPrefix + integrations[item].url,
        title: integrations[item].itemdesc,
        icon: IntegrationIcon[item],
      });
    }
  }
  // Reset Page Settings - always shown
  menuItems.push({
    id: "menu-reset-link",
    href: "javascript:void(0)",
    title: locale$2.maketext("Reset Page Settings"),
    icon: "refresh-line",
  });
  // Provide Feedback - always shown
  menuItems.push({
    id: "menu-feedback-link",
    href: feedbackLinkData.url,
    target: feedbackLinkData.target,
    title: feedbackLinkData.title,
    icon: "feedback-line",
  });
  // Log Out - always shown
  menuItems.push({
    id: "menu-logout-link",
    target: "_top",
    href: `/logout/?locale=${document.documentElement.lang}`,
    title: locale$2.maketext("Log Out"),
    icon: "logout-box-line",
  });
  return menuItems;
};

/*
# cpanel - ui/web-components/src/components/cpw-toggle-switch/toggle-states.enum.ts
#                                                  Copyright 2022 cPanel, L.L.C.
#                                                           All rights reserved.
# copyright@cpanel.net                                         http://cpanel.net
# This code is subject to the cPanel license. Unauthorized copying is prohibited
*/
/**
 * Enum for toggle states
 *
 */
var ToggleStates;
(function (ToggleStates) {
  ToggleStates["TOGGLE_ON"] = "on";
  ToggleStates["TOGGLE_OFF"] = "off";
  ToggleStates["TOGGLE_UPDATING"] = "updating";
})(ToggleStates || (ToggleStates = {}));

/*
# cpanel - ui/web-components/src/components/cpw-toggle-switch/toggle-label-positions.enum.ts
#                                                  Copyright 2022 cPanel, L.L.C.
#                                                           All rights reserved.
# copyright@cpanel.net                                         http://cpanel.net
# This code is subject to the cPanel license. Unauthorized copying is prohibited
*/
/**
 * Enum for toggle switch label and spinner positions
 *
 */
var ToggleLabelPositions;
(function (ToggleLabelPositions) {
  ToggleLabelPositions["LEFT"] = "left";
  ToggleLabelPositions["RIGHT"] = "right";
})(ToggleLabelPositions || (ToggleLabelPositions = {}));

/**
# cpanel - ui/web-components/src/components/header/cp-header-user-account-dropdown/whm-user-menu-items.ts
#                                                  Copyright 2022 cPanel, L.L.C.
#                                                           All rights reserved.
# copyright@cpanel.net                                         http://cpanel.net
# This code is subject to the cPanel license. Unauthorized copying is prohibited
 */
const locale = getLocaleInstance();
/* NOTE: Checking for available apps based on URL could be brittle, but we do not have
any kind of ID field on the applications list. If this causes problems in the future,
the applications should be assigned UIDs when the list is constructed. */
const constructWhmAccountMenuItems = (cpSecurityToken) => {
  const menuItems = [];
  // Right now WHM’s only self-password-modification screen is for
  // the “root” user. A root-reseller *can* set their own password,
  // but there’s no dedicated “change my password” UI. We intend to
  // improve that in COBRA-13453.
  if (state.user === "root") {
    menuItems.unshift({
      id: "menu-account-link",
      href: `${cpSecurityToken}scripts/chrootpass`,
      title: locale.maketext("Password Modification"),
      icon: "lock-2-line",
    });
  }
  // Log Out - always shown
  menuItems.push({
    id: "menu-logout-link",
    target: "_top",
    href: `/logout/?locale=${document.documentElement.lang}`,
    title: `${locale.maketext("Log Out")} (${state.user})`,
    icon: "logout-box-line",
  });
  return menuItems;
};

export { CpApp, CpConsentPrivacySettings, CpDir, CpDnsOnly, CpFavorite, CpFavoriteList, CpFavoriteSelector, CpFooter, CpHeader, CpHeaderControl, CpHeaderNotificationsControl, CpHeaderSearch, CpHeaderSearchControl, CpHeaderUserAccountControl, CpHeaderUserAccountDropdown, CpIcon, CpLoadAverages, CpLoadMixpanelJs, CpLogo, CpMainMenu, CpMainMenuHeaderControl, CpMainMenuNav, CpMainMenuNavWhm, CpMigrationModal, CpMigrationModalBody, CpMigrationModalFooter, CpModal, CpRootVariables, CpStyleReset, CpUiLoadAnalytics, CpWebmailConsentPrivacyModal, CpWebmailConsentPrivacyModalBody, CpWebmailConsentPrivacyModalFooter, CpWelcomeModal, CpWelcomeModalCongrats, CpWelcomeModalCongratsFooter, CpWelcomeModalStartingPoint, CpWelcomeModalStartingPointFooter, CpWelcomeModalWpInstall, CpWelcomeModalWpInstallFooter, CpWhmHeaderNotificationsControl, CpWhmHeaderNotificationsDropdown, CpWhmHeaderStatsControl, CpWrapFilter, CpanelHeader, CpwToggleSwitch, WhmHeader, defineCustomElements };

Back to Directory File Manager