/*
	     * Local polyfil of Object.create
	     */

/*

  var zeros = [];
  var groupSizes = [];
  var groupBases = [];

  var s = '';
  var i = -1;
  while (++i < BN.wordSize) {
    zeros[i] = s;
    s += '0';
  }
  groupSizes[0] = 0;
  groupSizes[1] = 0;
  groupBases[0] = 0;
  groupBases[1] = 0;
  var base = 2 - 1;
  while (++base < 36 + 1) {
    var groupSize = 0;
    var groupBase = 1;
    while (groupBase < (1 << BN.wordSize) / base) {
      groupBase *= base;
      groupSize += 1;
    }
    groupSizes[base] = groupSize;
    groupBases[base] = groupBase;
  }

  */

/*
                     * Check if the current character to escape has a name entity we should
                     * replace it with while grabbing the hex value of the character.
                     */

/*
                     * Per OWASP recommendations, we'll use hex entities for any other
                     * characters where a named entity does not exist.
                     */

/*
                     * The following replaces characters undefined in HTML with the
                     * hex entity for the Unicode replacement character.
                     */

/*
                     * While HTML supports far more named entities, the lowest common denominator
                     * has become HTML5's XML Serialisation which is restricted to the those named
                     * entities that XML supports. Using HTML entities would result in this error:
                     *     XML Parsing Error: undefined entity
                     */

/*
         * Optimizes the node when capture is used for a large block of text.
         *
         * {% set foo %}foo{% endset %} is compiled to $context['foo'] = new Twig_Markup("foo");
         */

/*
  // These test cases allowing for missing delimiters are not currently supported
    str_getcsv('"row2""cell1",row2cell2,row2cell3', null, null, '"');
    ['row2"cell1', 'row2cell2', 'row2cell3']
     str_getcsv('row1cell1,"row1,cell2",row1cell3', null, null, '"');
    ['row1cell1', 'row1,cell2', 'row1cell3']
     str_getcsv('"row2""cell1",row2cell2,"row2""""cell3"');
    ['row2"cell1', 'row2cell2', 'row2""cell3']
     str_getcsv('row1cell1,"row1,cell2","row1"",""cell3"', null, null, '"');
    ['row1cell1', 'row1,cell2', 'row1","cell3'];
     Should also test newlines within
  */

/*
  MIT License http://www.opensource.org/licenses/mit-license.php
  Author Tobias Koppers @sokra
*/

/*
  This is just a junk drawer, containing anything used across multiple classes.
  Because Luxon is small(ish), this should stay small and we won't worry about splitting
  it up into, say, parsingUtil.js and basicUtil.js and so on. But they are divided up by feature area.
*/

/*
 *  The following functions define the column width of an ISO 10646
 *  character as follows:
 *  - The null character (U+0000) has a column width of 0.
 *  - Other C0/C1 control characters and DEL will lead to a return value
 *    of -1.
 *  - Non-spacing and enclosing combining characters (general category
 *    code Mn or Me in the
 *    Unicode database) have a column width of 0.
 *  - SOFT HYPHEN (U+00AD) has a column width of 1.
 *  - Other format characters (general category code Cf in the Unicode
 *    database) and ZERO WIDTH
 *    SPACE (U+200B) have a column width of 0.
 *  - Hangul Jamo medial vowels and final consonants (U+1160-U+11FF)
 *    have a column width of 0.
 *  - Spacing characters in the East Asian Wide (W) or East Asian
 *    Full-width (F) category as
 *    defined in Unicode Technical Report #11 have a column width of 2.
 *  - All remaining characters (including all printable ISO 8859-1 and
 *    WGL4 characters, Unicode control characters, etc.) have a column
 *    width of 1.
 *  This implementation assumes that characters are encoded in ISO 10646.
*/

/*
 * A JavaScript implementation of the Secure Hash Algorithm, SHA-0, as defined
 * in FIPS PUB 180-1
 * This source code is derived from sha1.js of the same repository.
 * The difference between SHA-0 and SHA-1 is just a bitwise rotate left
 * operation was added.
 */

/*
 * A JavaScript implementation of the Secure Hash Algorithm, SHA-1, as defined
 * in FIPS PUB 180-1
 * Version 2.1a Copyright Paul Johnston 2000 - 2002.
 * Other contributors: Greg Holt, Andrew Kepert, Ydnar, Lostinet
 * Distributed under the BSD License
 * See http://pajhome.org.uk/crypt/md5 for details.
 */

/*
 * Copyright 2009-2011 Mozilla Foundation and contributors
 * Licensed under the New BSD license. See LICENSE.txt or:
 * http://opensource.org/licenses/BSD-3-Clause
 */

/*
 * Copyright 2011 Mozilla Foundation and contributors
 * Licensed under the New BSD license. See LICENSE or:
 * http://opensource.org/licenses/BSD-3-Clause
 *
 * Based on the Base 64 VLQ implementation in Closure Compiler:
 * https://code.google.com/p/closure-compiler/source/browse/trunk/src/com/google/debugging/sourcemap/Base64VLQ.java
 *
 * Copyright 2011 The Closure Compiler Authors. All rights reserved.
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are
 * met:
 *
 *  * Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 *  * Redistributions in binary form must reproduce the above
 *    copyright notice, this list of conditions and the following
 *    disclaimer in the documentation and/or other materials provided
 *    with the distribution.
 *  * Neither the name of Google Inc. nor the names of its
 *    contributors may be used to endorse or promote products derived
 *    from this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */

/*
 * Copyright 2011 Mozilla Foundation and contributors
 * Licensed under the New BSD license. See LICENSE or:
 * http://opensource.org/licenses/BSD-3-Clause
 */

/*
 * Copyright 2014 Mozilla Foundation and contributors
 * Licensed under the New BSD license. See LICENSE or:
 * http://opensource.org/licenses/BSD-3-Clause
 */

/*
 * Get a copy of the given UTF-8 string truncated to a max *binary* size.
 * Avoid truncating in the middle of an UTF-8 char.
 * If truncated, the returned string will have a trailing "...",
 * still respecting the max binary size.
 *
 * Note : desired binary size must be at last 3.
 * Note : the returned string size may be smaller than desired size due to UTF-8 wide chars.
 *
 * @param [String] string
 * @param [Number] binaryMaxSize - the max size we should enforce
 * @param [function()] truncateCallback - if provided, function to be called when a truncating occur.
 *                   Useful for ex. displaying a warning.
 */

/*
 * Get a copy of the givenstring truncated to a max length.
 * If truncated, the returned string will have a trailing "...",
 * still respecting the max length.
 *
 * Note : desired length must be at last 3.
 *
 * @param [String] string
 * @param [Number] maxLength - the max length we should enforce
 * @param [function()] truncateCallback - if provided, function to be called when a truncating occur.
 *                   Useful for ex. displaying a warning.
 */

/*
 * Need to make sure that buffer isn't trying to write out of bounds.
 */

/*
 * On the given object, apply truncateToBinarySize to all members
 * for whom a binary max size is provided.
 * Useful to quickly truncate a model.
 * @see truncateToBinarySize
 *
 * @param [Object]
 * @param [Object] maxSizes - a hash {<member name>: <max binary size>}
 * @param [function(field, actualSize, maxSize)] truncateCallback
 *                   if provided, function to be called when a truncating occur.
 */

/*
 * This file handles parsing for well-specified formats. Here's how it works:
 * Two things go into parsing: a regex to match with and an extractor to take apart the groups in the match.
 * An extractor is just a function that takes a regex match array and returns a { year: ..., month: ... } object
 * parse() does the work of executing the regex and applying the extractor. It takes multiple regex/extractor pairs to try in sequence.
 * Extractors can take a "cursor" representing the offset in the match to look at. This makes it easy to combine extractors.
 * combineExtractors() does the work of combining them, keeping track of the cursor through multiple extractions.
 * Some extractions are super dumb and simpleParse and fromStrings help DRY them.
 */

/*
 * Tine 2.0
 *
 * @license     http://www.gnu.org/licenses/agpl.html AGPL Version 3
 * @author      Cornelius Weiss <c.weiss@metaways.de>
 * @copyright   Copyright (c) 2025 Metaways Infosystems GmbH (http://www.metaways.de)
 */

/*
 * Tine 2.0
 *
 * @package     Tine
 * @subpackage  Tinebase
 * @license     http://www.gnu.org/licenses/agpl.html AGPL Version 3
 * @author      Cornelius Weiss <c.weiss@metaways.de>
 * @copyright   Copyright (c) 2007-2010 Metaways Infosystems GmbH (http://www.metaways.de)
 */

/*
 * Tine 2.0
 *
 * @package     Tine
 * @subpackage  Tinebase
 * @license     http://www.gnu.org/licenses/agpl.html AGPL Version 3
 * @author      Cornelius Weiss <c.weiss@metaways.de>
 * @copyright   Copyright (c) 2007-2024 Metaways Infosystems GmbH (http://www.metaways.de)
 */

/*
 * Utilities for truncating text fields to fit into some Oracle tables.
 * Truncate must be done binary-wise on an UTF-8 string.
 * Ex. a 4000 chars UTF-8 french string may takes ~4200 bytes (depending on content)
 *
 * Note : even if default, we explicitely specify «utf8» since it's a requirement.
 */

/*
 * borrowed from https://github.com/annexare/toURI/blob/master/lib/toURI.js
 * @license MIT
 *
 * NOTE: this is just an ultraslim transliterate implementation for practical purpuses in client
 *       if you need mor exact transliteration do it on server side!
 */

/*
export const apply = Ext.apply;
export const applyIf = Ext.applyIf;
export const id = Ext.id;
export const extend = Ext.extend;
export const override = Ext.override;
export const namespace = Ext.namespace;
export const urlEncode = Ext.urlEncode;
export const urlDecode = Ext.urlDecode;
export const urlAppend = Ext.urlAppend;
export const toArray = Ext.toArray;
export const isIterable = Ext.isIterable;
export const each = Ext.each;
export const iterate = Ext.iterate;
// export const getDom = Ext.getDom;
// export const getBody = Ext.getBody;
// export const removeNode = Ext.removeNode;
export const isEmpty = Ext.isEmpty;
export const isArray = Ext.isArray;
export const isDate = Ext.isDate;
export const isObject = Ext.isObject;
export const isPrimitive = Ext.isPrimitive;
export const isFunction = Ext.isFunction;
export const isNumber = Ext.isNumber;
export const isString = Ext.isString;
export const isBoolean = Ext.isBoolean;
export const isElement = Ext.isElement;
export const isDefined = Ext.isDefined;
export const escapeRe = Ext.escapeRe;
export const ns = Ext.ns;
*/

/* "__proto__".length */

/* '$' */

/* '_' */

/* 'o' */

/* 'p' */

/* 'r' */

/* 't' */

/* -*- Mode: js; js-indent-level: 2; -*- */

/* -1 -1 */

/* -1 0 */

/* -1 1 */

/* . */

/* .ArraySet */

/* .BaseTransition */

/* .BaseTransitionPropsValidators */

/* .DecoderBuffer */

/* .EffectScope */

/* .EncoderBuffer */

/* .Fragment */

/* .MappingList */

/* .ReactiveEffect */

/* .Reporter */

/* .SourceMapGenerator */

/* .Static */

/* .StringDecoder */

/* .callWithAsyncErrorHandling */

/* .codes */

/* .codes.ERR_INVALID_OPT_VALUE */

/* .codes.ERR_STREAM_PREMATURE_CLOSE */

/* .computed */

/* .contrastColors.getBrightness */

/* .createBlock */

/* .createCommentVNode */

/* .createElementBlock */

/* .createElementVNode */

/* .createHydrationRenderer */

/* .createRenderer */

/* .createTextVNode */

/* .createVNode */

/* .defineComponent */

/* .format_date */

/* .format_time */

/* .getCurrentInstance */

/* .getCurrentScope */

/* .getTransitionRawChildren */

/* .isProxy */

/* .isReactive */

/* .isRef */

/* .isShallow */

/* .markRaw */

/* .nextTick */

/* .onMounted */

/* .onUnmounted */

/* .onUpdated */

/* .openBlock */

/* .pauseTracking */

/* .popScopeId */

/* .proxyRefs */

/* .pushScopeId */

/* .quickSort */

/* .reactive */

/* .ref */

/* .render */

/* .renderList */

/* .renderSlot */

/* .resetTracking */

/* .resolveComponent */

/* .resolveTransitionHooks */

/* .setTransitionHooks */

/* .shallowReactive */

/* .toRaw */

/* .track */

/* .trigger */

/* .useTransitionState */

/* .version */

/* .watchPostEffect */

/* .withCtx */

/* .withDirectives */

/* 0 -1 */

/* 0 0 */

/* 0 1 */

/* 1 */

/* 1 -1 */

/* 1 0 */

/* 3 */

/* 5 */

/* </replacement> */

/* @__PURE__ */

/* APP_INIT */

/* APP_UNMOUNT */

/* Built-in method references for those with the same name as other `lodash` methods. */

/* Built-in method references that are verified to be native. */

/* CLASS */

/* CLASS, STYLE */

/* COLLECTION */

/* COMMENT */

/* COMMON */

/* COMPONENT_ADDED */

/* COMPONENT_EMIT */

/* COMPONENT_REMOVED */

/* COMPONENT_UPDATED */

/* CONTEXT */

/* DATA */

/* DYNAMIC */

/* DateTime */

/* DateTime.fromISO */

/* DateTime.fromJSDate */

/* DateTime.fromMillis */

/* DateTime.fromRFC2822 */

/* DateTime.fromSQL */

/* DateTime.invalid */

/* DateTime.local */

/* Duration */

/* ELEMENT */

/* ErrorTypes.MATCHER_NOT_FOUND */

/* ErrorTypes.NAVIGATION_ABORTED */

/* ErrorTypes.NAVIGATION_CANCELLED */

/* ErrorTypes.NAVIGATION_DUPLICATED */

/* ErrorTypes.NAVIGATION_GUARD_REDIRECT */

/* Fragment */

/* HOISTED */

/* INVALID */

/* KEYED_FRAGMENT */

/* NEED_PATCH */

/* Node.js helper references. */

/* OTHER */

/* PROPS */

/* PROPS, DYNAMIC_SLOTS */

/* PROPS, HYDRATE_EVENTS */

/* PathScore.BonusCaseSensitive */

/* PathScore.BonusCustomRegExp */

/* PathScore.BonusOptional */

/* PathScore.BonusRepeatable */

/* PathScore.BonusStrict */

/* PathScore.BonusWildcard */

/* PathScore.Dynamic */

/* PathScore.Root */

/* PathScore.Segment */

/* PathScore.Static */

/* Return size, in bytes, of the given UTF-8 string.

 * @param [String] string
 * @return [Number] size of the string in bytes
 */

/* SETUP */

/* STABLE */

/* STABLE_FRAGMENT */

/* STYLE */

/* Settings.defaultZoneName */

/* TEXT */

/* TEXT, CLASS, PROPS */

/* Teleport */

/* TokenType.Param */

/* TokenType.Static */

/* TokenizerState.EscapeNext */

/* TokenizerState.Param */

/* TokenizerState.ParamRegExp */

/* TokenizerState.ParamRegExpEnd */

/* TokenizerState.Static */

/* TwingExtensionIntl */

/* UNKEYED_FRAGMENT */

/* We don't support dynamic inclusion of po files any longer!
if (typeof ActiveXObject != 'undefined' && typeof XMLHttpRequest == 'undefined') {
  XMLHttpRequest = function () { try { return new ActiveXObject("Msxml2.XMLHTTP");
  } catch (e) { return new ActiveXObject("Microsoft.XMLHTTP"); } };
}
*/

/* ["default"] */

/* ["default"].locals */

/* asset import */

/* binding */

/* cancelled */

/* computed */

/* createBlock */

/* createCommentVNode */

/* createElementBlock */

/* createElementVNode */

/* createSlots */

/* createTextVNode */

/* createVNode */

/* customRef */

/* default */

/* default.locals */

/* defineComponent */

/* detached */

/* do not include inferred name to avoid breaking existing code */

/* do not throw in dev if user provided error component */

/* effectScope */

/* eslint complexity: [2, 18], max-statements: [2, 33] */

/* eslint no-invalid-this: 1 */

/* eslint no-self-compare: 0 */

/* eslint no-undef: "error" */

/* eslint-disable */

/* eslint-disable camelcase */

/* eslint-disable no-proto */

/* eslint-disable node/no-deprecated-api */

/* eslint-env browser */

/* format_date */

/* getCurrentInstance */

/* getCurrentScope */

/* global Locale */

/* globals document: false */

/* greater-than sign */

/* guardReactiveProps */

/* harmony default export */

/* harmony export */

/* harmony import */

/* hydrating */

/* iPadOS pre v13 */

/* import() | Tinebase/js/dompurify */

/* import() | Tinebase/js/email-addresses */

/* import() | Tinebase/js/marked */

/* inject */

/* internal */

/* isAbsent */

/* isBlock */

/* isBlock: prevent a block from tracking itself */

/* isReactive */

/* isRef */

/* istanbul ignore else */

/* istanbul ignore if  */

/* istanbul ignore if should be unreachable if parseAST and parseText are right */

/* istanbul ignore next  */

/* istanbul ignore next */

/* jshint maxdepth : false */

/* k = 0 */

/* k = 1 */

/* k = 10 */

/* k = 11 */

/* k = 12 */

/* k = 13 */

/* k = 14 */

/* k = 15 */

/* k = 16 */

/* k = 17 */

/* k = 18 */

/* k = 2 */

/* k = 3 */

/* k = 4 */

/* k = 5 */

/* k = 6 */

/* k = 7 */

/* k = 8 */

/* k = 9 */

/* legacy: obj, showHidden, depth, colors*/

/* mergeProps */

/* mergeRef: true */

/* module decorator */

/* nextTick */

/* onActivated */

/* onBeforeMount */

/* onBeforeUnmount */

/* onMounted */

/* onScopeDispose */

/* onUnmounted */

/* openBlock */

/* prepend */

/* provide */

/* provided dependency */

/* reactive */

/* readonly */

/* reexport */

/* reexport safe */

/* ref */

/* renderList */

/* renderSlot */

/* require.ensure | Tinebase/js/linkify */

/* resolveComponent */

/* resolveDynamicComponent */

/* shallow */

/* shallowReadonly */

/* shallowRef */

/* shouldCast */

/* shouldCastTrue */

/* string */

/* toHandlers */

/* toRef */

/* treat default function as factory */

/* unref */

/* unused harmony default export */

/* unused harmony exports ITERATE_KEY, deferredComputed, enableTracking */

/* unused harmony exports PatchFlagNames, escapeHtml, escapeHtmlComment, genPropsAccessExp, generateCodeFrame, isBooleanAttr, isBuiltInDirective, isDate, isHTMLTag, isKnownHtmlAttr, isKnownSvgAttr, isSSRSafeAttrName, isSVGTag, isVoidTag, objectToString, parseStringStyle, propsToAttrMap, slotFlagsText, stringifyStyle, toTypeString */

/* unused harmony exports format_datetime, localizeddate */

/* unused reexport */

/* useAttrs */

/* useSlots */

/* watch */

/* watchEffect */

/* we know it doesn't need it */

/* webpack/runtime/create fake namespace object */

/* webpack/runtime/jsonp chunk loading */

/* webpack/runtime/load script */

/* webpack/runtime/publicPath */

/* withCtx */

/* withDirectives */

/* { [string]: (args?: Object) => any } */

/*!
  * vue-router v4.1.6
  * (c) 2022 Eduardo San Martin Morote
  * @license MIT
  */

/*!
 * Ext JS Library 3.1.1
 * Copyright(c) 2006-2010 Ext JS, LLC
 * licensing@extjs.com
 * http://www.extjs.com/license
 */

/*!
 * The buffer module from node.js, for the browser.
 *
 * @author   Feross Aboukhadijeh <https://feross.org>
 * @license  MIT
 */

/*!
 * is-plain-object <https://github.com/jonschlinkert/is-plain-object>
 *
 * Copyright (c) 2014-2017, Jon Schlinkert.
 * Released under the MIT License.
 */

/*!
 * isobject <https://github.com/jonschlinkert/isobject>
 *
 * Copyright (c) 2014-2017, Jon Schlinkert.
 * Released under the MIT License.
 */

/*! https://mths.be/esrever v0.2.0 by @mathias */

/*! ieee754. BSD-3-Clause License. Feross Aboukhadijeh <https://feross.org/opensource> */

/*#__PURE__*/

/**
	             * Copies properties into this object.
	             *
	             * @param {Object} properties The properties to mix in.
	             *
	             * @example
	             *
	             *     MyType.mixIn({
	             *         field: 'value'
	             *     });
	             */

/**
	             * Creates a copy of this object.
	             *
	             * @return {Object} The clone.
	             *
	             * @example
	             *
	             *     var clone = instance.clone();
	             */

/**
	             * Creates a new object that inherits from this object.
	             *
	             * @param {Object} overrides Properties to copy into the new object.
	             *
	             * @return {Object} The new object.
	             *
	             * @static
	             *
	             * @example
	             *
	             *     var MyType = CryptoJS.lib.Base.extend({
	             *         field: 'value',
	             *
	             *         method: function () {
	             *         }
	             *     });
	             */

/**
	             * Extends this object and runs the init method.
	             * Arguments to create() will be passed to init().
	             *
	             * @return {Object} The new object.
	             *
	             * @static
	             *
	             * @example
	             *
	             *     var instance = MyType.create();
	             */

/**
	             * Initializes a newly created object.
	             * Override this method to add some logic when your objects are created.
	             *
	             * @example
	             *
	             *     var MyType = CryptoJS.lib.Base.extend({
	             *         init: function () {
	             *             // ...
	             *         }
	             *     });
	             */

/**
	         * Adds new data to this block algorithm's buffer.
	         *
	         * @param {WordArray|string} data The data to append. Strings are converted to a WordArray using UTF-8.
	         *
	         * @example
	         *
	         *     bufferedBlockAlgorithm._append('data');
	         *     bufferedBlockAlgorithm._append(wordArray);
	         */

/**
	         * Concatenates a word array to this word array.
	         *
	         * @param {WordArray} wordArray The word array to append.
	         *
	         * @return {WordArray} This word array.
	         *
	         * @example
	         *
	         *     wordArray1.concat(wordArray2);
	         */

/**
	         * Configuration options.
	         */

/**
	         * Converts a Latin1 string to a word array.
	         *
	         * @param {string} latin1Str The Latin1 string.
	         *
	         * @return {WordArray} The word array.
	         *
	         * @static
	         *
	         * @example
	         *
	         *     var wordArray = CryptoJS.enc.Latin1.parse(latin1String);
	         */

/**
	         * Converts a UTF-8 string to a word array.
	         *
	         * @param {string} utf8Str The UTF-8 string.
	         *
	         * @return {WordArray} The word array.
	         *
	         * @static
	         *
	         * @example
	         *
	         *     var wordArray = CryptoJS.enc.Utf8.parse(utf8String);
	         */

/**
	         * Converts a hex string to a word array.
	         *
	         * @param {string} hexStr The hex string.
	         *
	         * @return {WordArray} The word array.
	         *
	         * @static
	         *
	         * @example
	         *
	         *     var wordArray = CryptoJS.enc.Hex.parse(hexString);
	         */

/**
	         * Converts a word array to a Latin1 string.
	         *
	         * @param {WordArray} wordArray The word array.
	         *
	         * @return {string} The Latin1 string.
	         *
	         * @static
	         *
	         * @example
	         *
	         *     var latin1String = CryptoJS.enc.Latin1.stringify(wordArray);
	         */

/**
	         * Converts a word array to a UTF-8 string.
	         *
	         * @param {WordArray} wordArray The word array.
	         *
	         * @return {string} The UTF-8 string.
	         *
	         * @static
	         *
	         * @example
	         *
	         *     var utf8String = CryptoJS.enc.Utf8.stringify(wordArray);
	         */

/**
	         * Converts a word array to a hex string.
	         *
	         * @param {WordArray} wordArray The word array.
	         *
	         * @return {string} The hex string.
	         *
	         * @static
	         *
	         * @example
	         *
	         *     var hexString = CryptoJS.enc.Hex.stringify(wordArray);
	         */

/**
	         * Converts this word array to a string.
	         *
	         * @param {Encoder} encoder (Optional) The encoding strategy to use. Default: CryptoJS.enc.Hex
	         *
	         * @return {string} The stringified word array.
	         *
	         * @example
	         *
	         *     var string = wordArray + '';
	         *     var string = wordArray.toString();
	         *     var string = wordArray.toString(CryptoJS.enc.Utf8);
	         */

/**
	         * Creates a copy of this object.
	         *
	         * @return {Object} The clone.
	         *
	         * @example
	         *
	         *     var clone = bufferedBlockAlgorithm.clone();
	         */

/**
	         * Creates a copy of this word array.
	         *
	         * @return {WordArray} The clone.
	         *
	         * @example
	         *
	         *     var clone = wordArray.clone();
	         */

/**
	         * Creates a shortcut function to a hasher's object interface.
	         *
	         * @param {Hasher} hasher The hasher to create a helper for.
	         *
	         * @return {Function} The shortcut function.
	         *
	         * @static
	         *
	         * @example
	         *
	         *     var SHA256 = CryptoJS.lib.Hasher._createHelper(CryptoJS.algo.SHA256);
	         */

/**
	         * Creates a shortcut function to the HMAC's object interface.
	         *
	         * @param {Hasher} hasher The hasher to use in this HMAC helper.
	         *
	         * @return {Function} The shortcut function.
	         *
	         * @static
	         *
	         * @example
	         *
	         *     var HmacSHA256 = CryptoJS.lib.Hasher._createHmacHelper(CryptoJS.algo.SHA256);
	         */

/**
	         * Creates a word array filled with random bytes.
	         *
	         * @param {number} nBytes The number of random bytes to generate.
	         *
	         * @return {WordArray} The random word array.
	         *
	         * @static
	         *
	         * @example
	         *
	         *     var wordArray = CryptoJS.lib.WordArray.random(16);
	         */

/**
	         * Finalizes the hash computation.
	         * Note that the finalize operation is effectively a destructive, read-once operation.
	         *
	         * @param {WordArray|string} messageUpdate (Optional) A final message update.
	         *
	         * @return {WordArray} The hash.
	         *
	         * @example
	         *
	         *     var hash = hasher.finalize();
	         *     var hash = hasher.finalize('message');
	         *     var hash = hasher.finalize(wordArray);
	         */

/**
	         * Initializes a newly created hasher.
	         *
	         * @param {Object} cfg (Optional) The configuration options to use for this hash computation.
	         *
	         * @example
	         *
	         *     var hasher = CryptoJS.algo.SHA256.create();
	         */

/**
	         * Initializes a newly created word array.
	         *
	         * @param {Array} words (Optional) An array of 32-bit words.
	         * @param {number} sigBytes (Optional) The number of significant bytes in the words.
	         *
	         * @example
	         *
	         *     var wordArray = CryptoJS.lib.WordArray.create();
	         *     var wordArray = CryptoJS.lib.WordArray.create([0x00010203, 0x04050607]);
	         *     var wordArray = CryptoJS.lib.WordArray.create([0x00010203, 0x04050607], 6);
	         */

/**
	         * Processes available data blocks.
	         *
	         * This method invokes _doProcessBlock(offset), which must be implemented by a concrete subtype.
	         *
	         * @param {boolean} doFlush Whether all blocks and partial blocks should be processed.
	         *
	         * @return {WordArray} The processed data.
	         *
	         * @example
	         *
	         *     var processedData = bufferedBlockAlgorithm._process();
	         *     var processedData = bufferedBlockAlgorithm._process(!!'flush');
	         */

/**
	         * Removes insignificant bits.
	         *
	         * @example
	         *
	         *     wordArray.clamp();
	         */

/**
	         * Resets this block algorithm's data buffer to its initial state.
	         *
	         * @example
	         *
	         *     bufferedBlockAlgorithm.reset();
	         */

/**
	         * Resets this hasher to its initial state.
	         *
	         * @example
	         *
	         *     hasher.reset();
	         */

/**
	         * Updates this hasher with a message.
	         *
	         * @param {WordArray|string} messageUpdate The message to append.
	         *
	         * @return {Hasher} This hasher.
	         *
	         * @example
	         *
	         *     hasher.update('message');
	         *     hasher.update(wordArray);
	         */

/**
	     * CryptoJS namespace.
	     */

/**
	     * SHA-256 hash algorithm.
	     */

/**
	     * Shortcut function to the HMAC's object interface.
	     *
	     * @param {WordArray|string} message The message to hash.
	     * @param {WordArray|string} key The secret key.
	     *
	     * @return {WordArray} The HMAC.
	     *
	     * @static
	     *
	     * @example
	     *
	     *     var hmac = CryptoJS.HmacSHA256(message, key);
	     */

/**
	     * Shortcut function to the hasher's object interface.
	     *
	     * @param {WordArray|string} message The message to hash.
	     *
	     * @return {WordArray} The hash.
	     *
	     * @static
	     *
	     * @example
	     *
	     *     var hash = CryptoJS.SHA256('message');
	     *     var hash = CryptoJS.SHA256(wordArray);
	     */

/**
                     * A few characters have short escape sequences in JSON and JavaScript.
                     * Escape sequences supported only by JavaScript, not JSON, are ommitted.
                     * \" is also supported but omitted, because the resulting string is not HTML safe.
                     */

/**
                     * This function is adapted from code coming from Zend Framework.
                     *
                     * @copyright Copyright (c) 2005-2012 Zend Technologies USA Inc. (http://www.zend.com)
                     * @license   http://framework.zend.com/license/new-bsd New BSD License
                     */

/**
         * @type {TwingNodeText}
         */

/**
         * A reference to the `lodash` function.
         *
         * @memberOf _.templateSettings.imports
         * @type {Function}
         */

/**
         * Display information about the currently selected route record
         */

/**
         * English ordinal suffix for the day of the month, 2 characters
         */

/**
         * Inspector of Existing routes
         */

/**
         * if a base tag is provided, and we are on a normal domain, we have to
         * respect the provided `base` attribute because pushState() will use it and
         * potentially erase anything before the `#` like at
         * https://github.com/vuejs/router/issues/685 where a base of
         * `/folder/#` but a base of `/` would erase the `/folder/` section. If
         * there is no host, the `<base>` tag makes no sense and if there isn't a
         * base tag we can just use everything after the `#`.
         */

/**
       * Used to detect `data` property values to be HTML-escaped.
       *
       * @memberOf _.templateSettings
       * @type {RegExp}
       */

/**
       * Used to detect `data` property values to inject.
       *
       * @memberOf _.templateSettings
       * @type {RegExp}
       */

/**
       * Used to detect code to be evaluated.
       *
       * @memberOf _.templateSettings
       * @type {RegExp}
       */

/**
       * Used to import variables into the compiled template.
       *
       * @memberOf _.templateSettings
       * @type {Object}
       */

/**
       * Used to reference the data object in the template text.
       *
       * @memberOf _.templateSettings
       * @type {string}
       */

/**
     *
     * @param node
     * @param nested {boolean}
     * @returns {TwingNode}
     */

/**
     *
     * @param string
     * @returns
     */

/**
     *
     * @param {TwingCompiler} compiler
     * @returns {TwingCompiler}
     */

/**
     *
     * @param {TwingEnvironment} env
     * @param {Array<TwingNodeVisitorInterface>} visitors
     */

/**
     *
     * @param {TwingExtensionInterface} extension
     * @param {string} name A name the extension will be registered as
     */

/**
     *
     * @param {TwingNode} node
     * @returns {Array<string>}
     */

/**
     *
     * @param {string} name
     * @returns any
     */

/**
     *
     * @return {TwingTokenStream}
     */

/**
     *
     * @returns {Map<string, TwingTest>}
     */

/**
     *
     * @returns {{variables: TwingNodeExpression, only: boolean, ignoreMissing: boolean}}
     */

/**
     *
     * Creates an array cache object to store unique values.
     *
     * @private
     * @constructor
     * @param {Array} [values] The values to cache.
     */

/**
     * - Cleans up any navigation guards
     * - Changes the url if necessary
     * - Calls the scrollBehavior
     */

/**
     * <p>Extends one class to create a subclass and optionally overrides members with the passed literal. This method
     * also adds the function "override()" to the subclass that can be used to override members of the class.</p>
     * For example, to create a subclass of Ext GridPanel:
     * <pre><code>
    MyGridPanel = Ext.extend(Ext.grid.GridPanel, {
    constructor: function(config) {
    //      Create configuration for this Grid.
    var store = new Ext.data.Store({...});
    var colModel = new Ext.grid.ColumnModel({...});
    //      Create a new config object containing our computed properties
    //      *plus* whatever was in the config parameter.
    config = Ext.apply({
        store: store,
        colModel: colModel
    }, config);
     MyGridPanel.superclass.constructor.call(this, config);
    //      Your postprocessing here
    },
    yourMethod: function() {
    // etc.
    }
    });
    </code></pre>
     *
     * <p>This function also supports a 3-argument call in which the subclass's constructor is
     * passed as an argument. In this form, the parameters are as follows:</p>
     * <div class="mdetail-params"><ul>
     * <li><code>subclass</code> : Function <div class="sub-desc">The subclass constructor.</div></li>
     * <li><code>superclass</code> : Function <div class="sub-desc">The constructor of class being extended</div></li>
     * <li><code>overrides</code> : Object <div class="sub-desc">A literal with members which are copied into the subclass's
     * prototype, and are therefore shared among all instances of the new class.</div></li>
     * </ul></div>
     *
     * @param {Function} superclass The constructor of class being extended.
     * @param {Object} overrides <p>A literal with members which are copied into the subclass's
     * prototype, and are therefore shared between all instances of the new class.</p>
     * <p>This may contain a special member named <tt><b>constructor</b></tt>. This is used
     * to define the constructor of the new class, and is returned. If this property is
     * <i>not</i> specified, a constructor is generated and returned which just calls the
     * superclass's constructor passing on its parameters.</p>
     * <p><b>It is essential that you call the superclass constructor in any provided constructor. See example code.</b></p>
     * @return {Function} The subclass constructor from the <code>overrides</code> parameter, or a generated one if not provided.
     */

/**
     * <p>Removes this element from the document, removes all DOM event listeners, and deletes the cache reference.
     * All DOM event listeners are removed from this element. If {@link Ext#enableNestedListenerRemoval} is
     * <code>true</code>, then DOM event listeners are also removed from all child nodes. The body node
     * will be ignored if passed in.</p>
     * @param {HTMLElement} node The node to remove
     */

/**
     * <p>Returns true if the passed value is empty.</p>
     * <p>The value is deemed to be empty if it is<div class="mdetail-params"><ul>
     * <li>null</li>
     * <li>undefined</li>
     * <li>an empty array</li>
     * <li>a zero length string (Unless the <tt>allowBlank</tt> parameter is <tt>true</tt>)</li>
     * </ul></div>
     * @param {Mixed} value The value to test
     * @param {Boolean} allowBlank (optional) true to allow empty strings (defaults to false)
     * @return {Boolean}
     */

/**
     * <p>Utility method for returning a default value if the passed value is empty.</p>
     * <p>The value is deemed to be empty if it is<div class="mdetail-params"><ul>
     * <li>null</li>
     * <li>undefined</li>
     * <li>an empty array</li>
     * <li>a zero length string (Unless the <tt>allowBlank</tt> parameter is <tt>true</tt>)</li>
     * </ul></div>
     * @param {Mixed} value The value to test
     * @param {Mixed} defaultValue The value to return if the original value is empty
     * @param {Boolean} allowBlank (optional) true to allow zero length strings to qualify as non-empty (defaults to false)
     * @return {Mixed} value, if non-empty, else defaultValue
     */

/**
     * <p>Zips N sets together.</p>
     * <pre><code>
    // Example 1:
    Ext.zip([1,2,3],[4,5,6]); // [[1,4],[2,5],[3,6]]
    // Example 2:
    Ext.zip(
    [ "+", "-", "+"],
    [  12,  10,  22],
    [  43,  15,  96],
    function(a, b, c){
    return "$" + a + "" + b + "." + c
    }
    ); // ["$+12.43", "$-10.15", "$+22.96"]
     * </code></pre>
     * @param {Arrays|NodeLists} arr This argument may be repeated. Array(s) to contribute values.
     * @param {Function} zipper (optional) The last item in the argument list. This will drive how the items are zipped together.
     * @return {Array} The zipped set.
     */

/**
     * @access private
     */

/**
     * @constructor
     * @param {TokenType} type The type of the token
     * @param {*} value The value of the token
     * @param {number} line The line where the token is located in the source
     * @param {number} column The column where the token is located in the source
     */

/**
     * @constructor
     * @param {string} message The error message
     * @param {number} line The line where the error occurred
     * @param {number} column The column where the error occurred
     */

/**
     * @constructor
     */

/**
     * @internal
     */

/**
     * @param level
     * @param flags Unused, kept for backward compatibility
     */

/**
     * @param name The name of the macro
     */

/**
     * @param nodeType
     *
     * @return TwingSourceMapNodeFactory
     */

/**
     * @param nodeType
     *
     * @return TwingSourceMapNodeFactory | null
     */

/**
     * @param {Array<TwingLoaderInterface>} loaders
     */

/**
     * @param {Token} token
     *
     * @return TwingNodeVerbatim
     */

/**
     * @param {TwingOutputBuffer} outputBuffer
     */

/**
     * @param {TwingSource} source
     *
     * @return {Map<number, TwingTemplate> }
     */

/**
     * @param {number} line 0-based
     * @param {number} column 1-based
     * @param {string} nodeType
     * @param {TwingSource} source
     * @param {TwingOutputBuffer} outputBuffer
     */

/**
     * @param {string | false | TwingEscapingStrategyResolver} defaultStrategy An escaping strategy
     */

/**
     * @param {string} name
     * @param {*} value
     */

/**
     * @param {string} name
     * @param {TwingOperatorType} type
     * @param {number} precedence
     * @param {TwingOperatorExpressionFactory} expressionFactory
     * @param {TwingOperatorAssociativity} associativity
     */

/**
     * @param {string} name The name of the macro
     *
     * @return {Promise<boolean>}
     */

/**
     * @return Map<TwingNodeType, TwingSourceMapNodeFactory>
     */

/**
     * @return Map<string, TwingSourceMapNodeFactory>
     */

/**
     * @return TwingCallableArgument[]
     */

/**
     * @return TwingLoaderInterface[]
     */

/**
     * @return TwingNode
     */

/**
     * @return TwingNodeExpressionArrowFunction|null
     */

/**
     * @return bool
     */

/**
     * @return {Token[]}
     */

/**
     * @return {Token}
     */

/**
     * @return {TwingTemplatesModule}
     */

/**
     * @returns booleqn
     */

/**
     * @returns string | Function | false
     */

/**
     * @returns {Function}
     */

/**
     * @returns {TwingNode}
     */

/**
     * @returns {TwingSource}
     */

/**
     * A `baseRest` alias which can be replaced with `identity` by module
     * replacement plugins.
     *
     * @private
     * @type {Function}
     * @param {Function} func The function to apply a rest parameter to.
     * @returns {Function} Returns the new function.
     */

/**
     * A cancelled navigation is a navigation that failed because a more recent
     * navigation finished started (not necessarily finished).
     */

/**
     * A duplicated navigation is a navigation that failed because it was
     * initiated while already being at the exact same location.
     */

/**
     * A simple wrapper around the global [`clearTimeout`](https://mdn.io/clearTimeout).
     *
     * @private
     * @param {number|Object} id The timer id or timeout object of the timer to clear.
     */

/**
     * A simple wrapper around the global [`setTimeout`](https://mdn.io/setTimeout).
     *
     * @private
     * @param {Function} func The function to delay.
     * @param {number} wait The number of milliseconds to delay invocation.
     * @returns {number|Object} Returns the timer id or timeout object.
     */

/**
     * A specialized version of `_.memoize` which clears the memoized function's
     * cache when it exceeds `MAX_MEMOIZE_SIZE`.
     *
     * @private
     * @param {Function} func The function to have its output memoized.
     * @returns {Function} Returns the new memoized function.
     */

/**
     * A specialized version of `_.sampleSize` for arrays.
     *
     * @private
     * @param {Array} array The array to sample.
     * @param {number} n The number of elements to sample.
     * @returns {Array} Returns the random elements.
     */

/**
     * A specialized version of `_.sample` for arrays.
     *
     * @private
     * @param {Array} array The array to sample.
     * @returns {*} Returns the random element.
     */

/**
     * A specialized version of `_.shuffle` for arrays.
     *
     * @private
     * @param {Array} array The array to shuffle.
     * @returns {Array} Returns the new shuffled array.
     */

/**
     * A specialized version of `_.shuffle` which mutates and sets the size of `array`.
     *
     * @private
     * @param {Array} array The array to shuffle.
     * @param {number} [size=array.length] The size of `array`.
     * @returns {Array} Returns `array`.
     */

/**
     * A specialized version of `baseGetTag` which ignores `Symbol.toStringTag` values.
     *
     * @private
     * @param {*} value The value to query.
     * @returns {string} Returns the raw `toStringTag`.
     */

/**
     * A specialized version of `baseIsEqualDeep` for arrays with support for
     * partial deep comparisons.
     *
     * @private
     * @param {Array} array The array to compare.
     * @param {Array} other The other array to compare.
     * @param {number} bitmask The bitmask flags. See `baseIsEqual` for more details.
     * @param {Function} customizer The function to customize comparisons.
     * @param {Function} equalFunc The function to determine equivalents of values.
     * @param {Object} stack Tracks traversed `array` and `other` objects.
     * @returns {boolean} Returns `true` if the arrays are equivalent, else `false`.
     */

/**
     * A specialized version of `baseIsEqualDeep` for comparing objects of
     * the same `toStringTag`.
     *
     * **Note:** This function only supports comparing values with tags of
     * `Boolean`, `Date`, `Error`, `Number`, `RegExp`, or `String`.
     *
     * @private
     * @param {Object} object The object to compare.
     * @param {Object} other The other object to compare.
     * @param {string} tag The `toStringTag` of the objects to compare.
     * @param {number} bitmask The bitmask flags. See `baseIsEqual` for more details.
     * @param {Function} customizer The function to customize comparisons.
     * @param {Function} equalFunc The function to determine equivalents of values.
     * @param {Object} stack Tracks traversed `object` and `other` objects.
     * @returns {boolean} Returns `true` if the objects are equivalent, else `false`.
     */

/**
     * A specialized version of `baseIsEqualDeep` for objects with support for
     * partial deep comparisons.
     *
     * @private
     * @param {Object} object The object to compare.
     * @param {Object} other The other object to compare.
     * @param {number} bitmask The bitmask flags. See `baseIsEqual` for more details.
     * @param {Function} customizer The function to customize comparisons.
     * @param {Function} equalFunc The function to determine equivalents of values.
     * @param {Object} stack Tracks traversed `object` and `other` objects.
     * @returns {boolean} Returns `true` if the objects are equivalent, else `false`.
     */

/**
     * A specialized version of `baseIsEqual` for arrays and objects which performs
     * deep comparisons and tracks traversed objects enabling objects with circular
     * references to be compared.
     *
     * @private
     * @param {Object} object The object to compare.
     * @param {Object} other The other object to compare.
     * @param {number} bitmask The bitmask flags. See `baseIsEqual` for more details.
     * @param {Function} customizer The function to customize comparisons.
     * @param {Function} equalFunc The function to determine equivalents of values.
     * @param {Object} [stack] Tracks traversed `object` and `other` objects.
     * @returns {boolean} Returns `true` if the objects are equivalent, else `false`.
     */

/**
     * A specialized version of `baseMerge` for arrays and objects which performs
     * deep merges and tracks traversed objects enabling objects with circular
     * references to be merged.
     *
     * @private
     * @param {Object} object The destination object.
     * @param {Object} source The source object.
     * @param {string} key The key of the value to merge.
     * @param {number} srcIndex The index of `source`.
     * @param {Function} mergeFunc The function to merge values.
     * @param {Function} [customizer] The function to customize assigned values.
     * @param {Object} [stack] Tracks traversed source values and their merged
     *  counterparts.
     */

/**
     * A specialized version of `baseProperty` which supports deep paths.
     *
     * @private
     * @param {Array|string} path The path of the property to get.
     * @returns {Function} Returns the new accessor function.
     */

/**
     * A specialized version of `baseRest` which flattens the rest array.
     *
     * @private
     * @param {Function} func The function to apply a rest parameter to.
     * @returns {Function} Returns the new function.
     */

/**
     * A specialized version of `baseRest` which transforms the rest array.
     *
     * @private
     * @param {Function} func The function to apply a rest parameter to.
     * @param {number} [start=func.length-1] The start position of the rest parameter.
     * @param {Function} transform The rest array transform.
     * @returns {Function} Returns the new function.
     */

/**
     * A specialized version of `matchesProperty` for source values suitable
     * for strict equality comparisons, i.e. `===`.
     *
     * @private
     * @param {string} key The key of the property to get.
     * @param {*} srcValue The value to match.
     * @returns {Function} Returns the new spec function.
     */

/**
     * Adds `value` to the array cache.
     *
     * @private
     * @name add
     * @memberOf SetCache
     * @alias push
     * @param {*} value The value to cache.
     * @returns {Object} Returns the cache instance.
     */

/**
     * Adds a list of functions to the prototype of an existing class, overwriting any existing methods with the same name.
     * Usage:<pre><code>
    Ext.override(MyClass, {
    newMethod1: function(){
    // etc.
    },
    newMethod2: function(foo){
    // etc.
    }
    });
    </code></pre>
     * @param {Object} origclass The class to override
     * @param {Object} overrides The list of functions to add to origClass.  This should be specified as an object literal
     * containing one or more methods.
     * @method override
     */

/**
     * Adds a quoted string to the compiled code.
     *
     * @param {string} value The string
     *
     * @returns {TwingCompiler}
     */

/**
     * Adds all own enumerable string keyed function properties of a source
     * object to the destination object. If `object` is a function, then methods
     * are added to its prototype as well.
     *
     * **Note:** Use `_.runInContext` to create a pristine `lodash` function to
     * avoid conflicts caused by modifying the original.
     *
     * @static
     * @since 0.1.0
     * @memberOf _
     * @category Util
     * @param {Function|Object} [object=lodash] The destination object.
     * @param {Object} source The object of functions to add.
     * @param {Object} [options={}] The options object.
     * @param {boolean} [options.chain=true] Specify whether mixins are chainable.
     * @returns {Function|Object} Returns `object`.
     * @example
     *
     * function vowels(string) {
     *   return _.filter(string, function(v) {
     *     return /[aeiou]/i.test(v);
     *   });
     * }
     *
     * _.mixin({ 'vowels': vowels });
     * _.vowels('fred');
     * // => ['e']
     *
     * _('fred').vowels().value();
     * // => ['e']
     *
     * _.mixin({ 'vowels': vowels }, { 'chain': false });
     * _('fred').vowels();
     * // => ['e']
     */

/**
     * Adds source-map enter call.
     *
     * @returns TwingCompiler
     */

/**
     * Adds source-map leave call.
     *
     * @returns TwingCompiler
     */

/**
     * Adds two numbers.
     *
     * @static
     * @memberOf _
     * @since 3.4.0
     * @category Math
     * @param {number} augend The first number in an addition.
     * @param {number} addend The second number in an addition.
     * @returns {number} Returns the total.
     * @example
     *
     * _.add(6, 4);
     * // => 10
     */

/**
     * After any data loads, the raw JSON data is available for further custom processing.  If no data is
     * loaded or there is a load exception this property will be undefined.
     * @type Object
     */

/**
     * Aggregates elements of `collection` on `accumulator` with keys transformed
     * by `iteratee` and values set by `setter`.
     *
     * @private
     * @param {Array|Object} collection The collection to iterate over.
     * @param {Function} setter The function to set `accumulator` values.
     * @param {Function} iteratee The iteratee to transform keys.
     * @param {Object} accumulator The initial aggregated object.
     * @returns {Function} Returns `accumulator`.
     */

/**
     * An aborted navigation is a navigation that failed because a navigation
     * guard returned `false` or called `next(false)`
     */

/**
     * An alternative to `_.reduce`; this method transforms `object` to a new
     * `accumulator` object which is the result of running each of its own
     * enumerable string keyed properties thru `iteratee`, with each invocation
     * potentially mutating the `accumulator` object. If `accumulator` is not
     * provided, a new object with the same `[[Prototype]]` will be used. The
     * iteratee is invoked with four arguments: (accumulator, value, key, object).
     * Iteratee functions may exit iteration early by explicitly returning `false`.
     *
     * @static
     * @memberOf _
     * @since 1.3.0
     * @category Object
     * @param {Object} object The object to iterate over.
     * @param {Function} [iteratee=_.identity] The function invoked per iteration.
     * @param {*} [accumulator] The custom accumulator value.
     * @returns {*} Returns the accumulated value.
     * @example
     *
     * _.transform([2, 3, 4], function(result, n) {
     *   result.push(n *= n);
     *   return n % 2 == 0;
     * }, []);
     * // => [4, 9]
     *
     * _.transform({ 'a': 1, 'b': 2, 'c': 1 }, function(result, value, key) {
     *   (result[value] || (result[value] = [])).push(key);
     * }, {});
     * // => { '1': ['a', 'c'], '2': ['b'] }
     */

/**
     * Append the string to the top-most buffer or return  the string if there is none
     *
     * @param {string} string | void
     */

/**
     * Appends content to the query string of a URL, handling logic for whether to place
     * a question mark or ampersand.
     * @param {String} url The URL to append to.
     * @param {String} s The content to append to the URL.
     * @return (String) The resulting URL
     */

/**
     * Applies event listeners to elements by selectors when the document is ready.
     * The event name is specified with an <tt>&#64;</tt> suffix.
     * <pre><code>
    Ext.addBehaviors({
    // add a listener for click on all anchors in element with id foo
    '#foo a&#64;click' : function(e, t){
    // do something
    },
     // add the same listener to multiple selectors (separated by comma BEFORE the &#64;)
    '#foo a, #bar span.some-class&#64;mouseover' : function(){
    // do something
    }
    });
     * </code></pre> 
     * @param {Object} obj The list of behaviors to apply
     */

/**
     * Assigns `value` to `key` of `object` if the existing value is not equivalent
     * using [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero)
     * for equality comparisons.
     *
     * @private
     * @param {Object} object The object to modify.
     * @param {string} key The key of the property to assign.
     * @param {*} value The value to assign.
     */

/**
     * Assigns own and inherited enumerable string keyed properties of source
     * objects to the destination object for all destination properties that
     * resolve to `undefined`. Source objects are applied from left to right.
     * Once a property is set, additional values of the same property are ignored.
     *
     * **Note:** This method mutates `object`.
     *
     * @static
     * @since 0.1.0
     * @memberOf _
     * @category Object
     * @param {Object} object The destination object.
     * @param {...Object} [sources] The source objects.
     * @returns {Object} Returns `object`.
     * @see _.defaultsDeep
     * @example
     *
     * _.defaults({ 'a': 1 }, { 'b': 2 }, { 'a': 3 });
     * // => { 'a': 1, 'b': 2 }
     */

/**
     * Assigns own enumerable string keyed properties of source objects to the
     * destination object. Source objects are applied from left to right.
     * Subsequent sources overwrite property assignments of previous sources.
     *
     * **Note:** This method mutates `object` and is loosely based on
     * [`Object.assign`](https://mdn.io/Object/assign).
     *
     * @static
     * @memberOf _
     * @since 0.10.0
     * @category Object
     * @param {Object} object The destination object.
     * @param {...Object} [sources] The source objects.
     * @returns {Object} Returns `object`.
     * @see _.assignIn
     * @example
     *
     * function Foo() {
     *   this.a = 1;
     * }
     *
     * function Bar() {
     *   this.c = 3;
     * }
     *
     * Foo.prototype.b = 2;
     * Bar.prototype.d = 4;
     *
     * _.assign({ 'a': 0 }, new Foo, new Bar);
     * // => { 'a': 1, 'c': 3 }
     */

/**
     * Attempts to destroy and then remove a set of named properties of the passed object.
     * @param {Object} o The object (most likely a Component) who's properties you wish to destroy.
     * @param {Mixed} arg1 The name of the property to destroy and remove from the object.
     * @param {Mixed} etc... More property names to destroy and remove.
     */

/**
     * Attempts to destroy any objects passed to it by removing all event listeners, removing them from the
     * DOM (if applicable) and calling their destroy functions (if available).  This method is primarily
     * intended for arguments of type {@link Ext.Element} and {@link Ext.Component}, but any subclass of
     * {@link Ext.util.Observable} can be passed in.  Any number of elements and/or components can be
     * passed into this function in a single call as separate arguments.
     * @param {Mixed} arg1 An {@link Ext.Element}, {@link Ext.Component}, or an Array of either of these to destroy
     * @param {Mixed} arg2 (optional)
     * @param {Mixed} etc... (optional)
     */

/**
     * Attempts to invoke `func`, returning either the result or the caught error
     * object. Any additional arguments are provided to `func` when it's invoked.
     *
     * @static
     * @memberOf _
     * @since 3.0.0
     * @category Util
     * @param {Function} func The function to attempt.
     * @param {...*} [args] The arguments to invoke `func` with.
     * @returns {*} Returns the `func` result or error object.
     * @example
     *
     * // Avoid throwing errors for invalid selectors.
     * var elements = _.attempt(function(selector) {
     *   return document.querySelectorAll(selector);
     * }, '>_>');
     *
     * if (_.isError(elements)) {
     *   elements = [];
     * }
     */

/**
     * Binds methods of an object to the object itself, overwriting the existing
     * method.
     *
     * **Note:** This method doesn't set the "length" property of bound functions.
     *
     * @static
     * @since 0.1.0
     * @memberOf _
     * @category Util
     * @param {Object} object The object to bind and assign the bound methods to.
     * @param {...(string|string[])} methodNames The object method names to bind.
     * @returns {Object} Returns `object`.
     * @example
     *
     * var view = {
     *   'label': 'docs',
     *   'click': function() {
     *     console.log('clicked ' + this.label);
     *   }
     * };
     *
     * _.bindAll(view, ['click']);
     * jQuery(element).on('click', view.click);
     * // => Logs 'clicked docs' when clicked.
     */

/**
     * By default, Ext intelligently decides whether floating elements should be shimmed. If you are using flash,
     * you may want to set this to true.
     * @type Boolean
     */

/**
     * By default, the template delimiters used by lodash are like those in
     * embedded Ruby (ERB) as well as ES2015 template strings. Change the
     * following template settings to use alternative delimiters.
     *
     * @static
     * @memberOf _
     * @type {Object}
     */

/**
     * Calculates the mean of the Array
     * @param {Array} arr The Array to calculate the mean value of.
     * @return {Number} The mean.
     */

/**
     * Calculates the sum of the Array
     * @param {Array} arr The Array to calculate the sum value of.
     * @return {Number} The sum.
     */

/**
     * Called after child nodes are visited.
     *
     * @returns {TwingNode|false} The modified node or null if the node must be removed
     */

/**
     * Called before child nodes are visited.
     *
     * @returns {TwingNode} The modified node
     */

/**
     * 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.
     */

/**
     * Casts `value` as an array if it's not one.
     *
     * @static
     * @memberOf _
     * @since 4.4.0
     * @category Lang
     * @param {*} value The value to inspect.
     * @returns {Array} Returns the cast array.
     * @example
     *
     * _.castArray(1);
     * // => [1]
     *
     * _.castArray({ 'a': 1 });
     * // => [{ 'a': 1 }]
     *
     * _.castArray('abc');
     * // => ['abc']
     *
     * _.castArray(null);
     * // => [null]
     *
     * _.castArray(undefined);
     * // => [undefined]
     *
     * _.castArray();
     * // => []
     *
     * var array = [1, 2, 3];
     * console.log(_.castArray(array) === array);
     * // => true
     */

/**
     * Casts `value` to `identity` if it's not a function.
     *
     * @private
     * @param {*} value The value to inspect.
     * @returns {Function} Returns cast function.
     */

/**
     * Casts `value` to a path array if it's not one.
     *
     * @private
     * @param {*} value The value to inspect.
     * @param {Object} [object] The object to query keys on.
     * @returns {Array} Returns the cast property path array.
     */

/**
     * Casts `value` to an empty array if it's not an array like object.
     *
     * @private
     * @param {*} value The value to inspect.
     * @returns {Array|Object} Returns the cast array-like object.
     */

/**
     * Checks `value` to determine whether a default value should be returned in
     * its place. The `defaultValue` is returned if `value` is `NaN`, `null`,
     * or `undefined`.
     *
     * @static
     * @memberOf _
     * @since 4.14.0
     * @category Util
     * @param {*} value The value to check.
     * @param {*} defaultValue The default value.
     * @returns {*} Returns the resolved value.
     * @example
     *
     * _.defaultTo(1, 10);
     * // => 1
     *
     * _.defaultTo(undefined, 10);
     * // => 10
     */

/**
     * Checks a reference and converts it to empty string if it is undefined
     * @param {Mixed} value Reference to check
     * @return {Mixed} Empty string if converted, otherwise the original value
     */

/**
     * Checks a reference and converts it to the default value if it's empty
     * @param {Mixed} value Reference to check
     * @param {String} defaultValue The value to insert of it's undefined (defaults to "")
     * @return {String}
     */

/**
     * Checks if `func` has a lazy counterpart.
     *
     * @private
     * @param {Function} func The function to check.
     * @returns {boolean} Returns `true` if `func` has a lazy counterpart,
     *  else `false`.
     */

/**
     * Checks if `func` has its source masked.
     *
     * @private
     * @param {Function} func The function to check.
     * @returns {boolean} Returns `true` if `func` is masked, else `false`.
     */

/**
     * Checks if `func` is capable of being masked.
     *
     * @private
     * @param {*} value The value to check.
     * @returns {boolean} Returns `true` if `func` is maskable, else `false`.
     */

/**
     * Checks if `n` is between `start` and up to, but not including, `end`. If
     * `end` is not specified, it's set to `start` with `start` then set to `0`.
     * If `start` is greater than `end` the params are swapped to support
     * negative ranges.
     *
     * @static
     * @memberOf _
     * @since 3.3.0
     * @category Number
     * @param {number} number The number to check.
     * @param {number} [start=0] The start of the range.
     * @param {number} end The end of the range.
     * @returns {boolean} Returns `true` if `number` is in the range, else `false`.
     * @see _.range, _.rangeRight
     * @example
     *
     * _.inRange(3, 2, 4);
     * // => true
     *
     * _.inRange(4, 8);
     * // => true
     *
     * _.inRange(4, 2);
     * // => false
     *
     * _.inRange(2, 2);
     * // => false
     *
     * _.inRange(1.2, 2);
     * // => true
     *
     * _.inRange(5.2, 4);
     * // => false
     *
     * _.inRange(-3, -2, -6);
     * // => true
     */

/**
     * Checks if `object` conforms to `source` by invoking the predicate
     * properties of `source` with the corresponding property values of `object`.
     *
     * **Note:** This method is equivalent to `_.conforms` when `source` is
     * partially applied.
     *
     * @static
     * @memberOf _
     * @since 4.14.0
     * @category Lang
     * @param {Object} object The object to inspect.
     * @param {Object} source The object of property predicates to conform to.
     * @returns {boolean} Returns `true` if `object` conforms, else `false`.
     * @example
     *
     * var object = { 'a': 1, 'b': 2 };
     *
     * _.conformsTo(object, { 'b': function(n) { return n > 1; } });
     * // => true
     *
     * _.conformsTo(object, { 'b': function(n) { return n > 2; } });
     * // => false
     */

/**
     * Checks if `path` exists on `object`.
     *
     * @private
     * @param {Object} object The object to query.
     * @param {Array|string} path The path to check.
     * @param {Function} hasFunc The function to check properties.
     * @returns {boolean} Returns `true` if `path` exists, else `false`.
     */

/**
     * Checks if `path` is a direct or inherited property of `object`.
     *
     * @static
     * @memberOf _
     * @since 4.0.0
     * @category Object
     * @param {Object} object The object to query.
     * @param {Array|string} path The path to check.
     * @returns {boolean} Returns `true` if `path` exists, else `false`.
     * @example
     *
     * var object = _.create({ 'a': _.create({ 'b': 2 }) });
     *
     * _.hasIn(object, 'a');
     * // => true
     *
     * _.hasIn(object, 'a.b');
     * // => true
     *
     * _.hasIn(object, ['a', 'b']);
     * // => true
     *
     * _.hasIn(object, 'b');
     * // => false
     */

/**
     * Checks if `path` is a direct property of `object`.
     *
     * @static
     * @since 0.1.0
     * @memberOf _
     * @category Object
     * @param {Object} object The object to query.
     * @param {Array|string} path The path to check.
     * @returns {boolean} Returns `true` if `path` exists, else `false`.
     * @example
     *
     * var object = { 'a': { 'b': 2 } };
     * var other = _.create({ 'a': _.create({ 'b': 2 }) });
     *
     * _.has(object, 'a');
     * // => true
     *
     * _.has(object, 'a.b');
     * // => true
     *
     * _.has(object, ['a', 'b']);
     * // => true
     *
     * _.has(other, 'a');
     * // => false
     */

/**
     * Checks if `predicate` returns truthy for **all** elements of `collection`.
     * Iteration is stopped once `predicate` returns falsey. The predicate is
     * invoked with three arguments: (value, index|key, collection).
     *
     * **Note:** This method returns `true` for
     * [empty collections](https://en.wikipedia.org/wiki/Empty_set) because
     * [everything is true](https://en.wikipedia.org/wiki/Vacuous_truth) of
     * elements of empty collections.
     *
     * @static
     * @memberOf _
     * @since 0.1.0
     * @category Collection
     * @param {Array|Object} collection The collection to iterate over.
     * @param {Function} [predicate=_.identity] The function invoked per iteration.
     * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`.
     * @returns {boolean} Returns `true` if all elements pass the predicate check,
     *  else `false`.
     * @example
     *
     * _.every([true, 1, null, 'yes'], Boolean);
     * // => false
     *
     * var users = [
     *   { 'user': 'barney', 'age': 36, 'active': false },
     *   { 'user': 'fred',   'age': 40, 'active': false }
     * ];
     *
     * // The `_.matches` iteratee shorthand.
     * _.every(users, { 'user': 'barney', 'active': false });
     * // => false
     *
     * // The `_.matchesProperty` iteratee shorthand.
     * _.every(users, ['active', false]);
     * // => true
     *
     * // The `_.property` iteratee shorthand.
     * _.every(users, 'active');
     * // => false
     */

/**
     * Checks if `predicate` returns truthy for **any** element of `collection`.
     * Iteration is stopped once `predicate` returns truthy. The predicate is
     * invoked with three arguments: (value, index|key, collection).
     *
     * @static
     * @memberOf _
     * @since 0.1.0
     * @category Collection
     * @param {Array|Object} collection The collection to iterate over.
     * @param {Function} [predicate=_.identity] The function invoked per iteration.
     * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`.
     * @returns {boolean} Returns `true` if any element passes the predicate check,
     *  else `false`.
     * @example
     *
     * _.some([null, 0, 'yes', false], Boolean);
     * // => true
     *
     * var users = [
     *   { 'user': 'barney', 'active': true },
     *   { 'user': 'fred',   'active': false }
     * ];
     *
     * // The `_.matches` iteratee shorthand.
     * _.some(users, { 'user': 'barney', 'active': false });
     * // => false
     *
     * // The `_.matchesProperty` iteratee shorthand.
     * _.some(users, ['active', false]);
     * // => true
     *
     * // The `_.property` iteratee shorthand.
     * _.some(users, 'active');
     * // => true
     */

/**
     * Checks if `string` ends with the given target string.
     *
     * @static
     * @memberOf _
     * @since 3.0.0
     * @category String
     * @param {string} [string=''] The string to inspect.
     * @param {string} [target] The string to search for.
     * @param {number} [position=string.length] The position to search up to.
     * @returns {boolean} Returns `true` if `string` ends with `target`,
     *  else `false`.
     * @example
     *
     * _.endsWith('abc', 'c');
     * // => true
     *
     * _.endsWith('abc', 'b');
     * // => false
     *
     * _.endsWith('abc', 'b', 2);
     * // => true
     */

/**
     * Checks if `string` starts with the given target string.
     *
     * @static
     * @memberOf _
     * @since 3.0.0
     * @category String
     * @param {string} [string=''] The string to inspect.
     * @param {string} [target] The string to search for.
     * @param {number} [position=0] The position to search from.
     * @returns {boolean} Returns `true` if `string` starts with `target`,
     *  else `false`.
     * @example
     *
     * _.startsWith('abc', 'a');
     * // => true
     *
     * _.startsWith('abc', 'b');
     * // => false
     *
     * _.startsWith('abc', 'b', 1);
     * // => true
     */

/**
     * Checks if `value` is `NaN`.
     *
     * **Note:** This method is based on
     * [`Number.isNaN`](https://mdn.io/Number/isNaN) and is not the same as
     * global [`isNaN`](https://mdn.io/isNaN) which returns `true` for
     * `undefined` and other non-number values.
     *
     * @static
     * @memberOf _
     * @since 0.1.0
     * @category Lang
     * @param {*} value The value to check.
     * @returns {boolean} Returns `true` if `value` is `NaN`, else `false`.
     * @example
     *
     * _.isNaN(NaN);
     * // => true
     *
     * _.isNaN(new Number(NaN));
     * // => true
     *
     * isNaN(undefined);
     * // => true
     *
     * _.isNaN(undefined);
     * // => false
     */

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

/**
     * 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
     */

/**
     * 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
     */

/**
     * Checks if `value` is a buffer.
     *
     * @static
     * @memberOf _
     * @since 4.3.0
     * @category Lang
     * @param {*} value The value to check.
     * @returns {boolean} Returns `true` if `value` is a buffer, else `false`.
     * @example
     *
     * _.isBuffer(new Buffer(2));
     * // => true
     *
     * _.isBuffer(new Uint8Array(2));
     * // => false
     */

/**
     * Checks if `value` is a finite primitive number.
     *
     * **Note:** This method is based on
     * [`Number.isFinite`](https://mdn.io/Number/isFinite).
     *
     * @static
     * @memberOf _
     * @since 0.1.0
     * @category Lang
     * @param {*} value The value to check.
     * @returns {boolean} Returns `true` if `value` is a finite number, else `false`.
     * @example
     *
     * _.isFinite(3);
     * // => true
     *
     * _.isFinite(Number.MIN_VALUE);
     * // => true
     *
     * _.isFinite(Infinity);
     * // => false
     *
     * _.isFinite('3');
     * // => false
     */

/**
     * Checks if `value` is a flattenable `arguments` object or array.
     *
     * @private
     * @param {*} value The value to check.
     * @returns {boolean} Returns `true` if `value` is flattenable, else `false`.
     */

/**
     * 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
     */

/**
     * Checks if `value` is a pristine native function.
     *
     * **Note:** This method can't reliably detect native functions in the presence
     * of the core-js package because core-js circumvents this kind of detection.
     * Despite multiple requests, the core-js maintainer has made it clear: any
     * attempt to fix the detection will be obstructed. As a result, we're left
     * with little choice but to throw an error. Unfortunately, this also affects
     * packages, like [babel-polyfill](https://www.npmjs.com/package/babel-polyfill),
     * which rely on core-js.
     *
     * @static
     * @memberOf _
     * @since 3.0.0
     * @category Lang
     * @param {*} value The value to check.
     * @returns {boolean} Returns `true` if `value` is a native function,
     *  else `false`.
     * @example
     *
     * _.isNative(Array.prototype.push);
     * // => true
     *
     * _.isNative(_);
     * // => false
     */

/**
     * Checks if `value` is a property name and not a property path.
     *
     * @private
     * @param {*} value The value to check.
     * @param {Object} [object] The object to query keys on.
     * @returns {boolean} Returns `true` if `value` is a property name, else `false`.
     */

/**
     * Checks if `value` is a safe integer. An integer is safe if it's an IEEE-754
     * double precision number which isn't the result of a rounded unsafe integer.
     *
     * **Note:** This method is based on
     * [`Number.isSafeInteger`](https://mdn.io/Number/isSafeInteger).
     *
     * @static
     * @memberOf _
     * @since 4.0.0
     * @category Lang
     * @param {*} value The value to check.
     * @returns {boolean} Returns `true` if `value` is a safe integer, else `false`.
     * @example
     *
     * _.isSafeInteger(3);
     * // => true
     *
     * _.isSafeInteger(Number.MIN_VALUE);
     * // => false
     *
     * _.isSafeInteger(Infinity);
     * // => false
     *
     * _.isSafeInteger('3');
     * // => false
     */

/**
     * Checks if `value` is a valid array-like index.
     *
     * @private
     * @param {*} value The value to check.
     * @param {number} [length=MAX_SAFE_INTEGER] The upper bounds of a valid index.
     * @returns {boolean} Returns `true` if `value` is a valid index, else `false`.
     */

/**
     * Checks if `value` is a valid array-like length.
     *
     * **Note:** This method is loosely based on
     * [`ToLength`](http://ecma-international.org/ecma-262/7.0/#sec-tolength).
     *
     * @static
     * @memberOf _
     * @since 4.0.0
     * @category Lang
     * @param {*} value The value to check.
     * @returns {boolean} Returns `true` if `value` is a valid length, else `false`.
     * @example
     *
     * _.isLength(3);
     * // => true
     *
     * _.isLength(Number.MIN_VALUE);
     * // => false
     *
     * _.isLength(Infinity);
     * // => false
     *
     * _.isLength('3');
     * // => false
     */

/**
     * Checks if `value` is an `Error`, `EvalError`, `RangeError`, `ReferenceError`,
     * `SyntaxError`, `TypeError`, or `URIError` object.
     *
     * @static
     * @memberOf _
     * @since 3.0.0
     * @category Lang
     * @param {*} value The value to check.
     * @returns {boolean} Returns `true` if `value` is an error object, else `false`.
     * @example
     *
     * _.isError(new Error);
     * // => true
     *
     * _.isError(Error);
     * // => false
     */

/**
     * Checks if `value` is an empty object, collection, map, or set.
     *
     * Objects are considered empty if they have no own enumerable string keyed
     * properties.
     *
     * Array-like values such as `arguments` objects, arrays, buffers, strings, or
     * jQuery-like collections are considered empty if they have a `length` of `0`.
     * Similarly, maps and sets are considered empty if they have a `size` of `0`.
     *
     * @static
     * @memberOf _
     * @since 0.1.0
     * @category Lang
     * @param {*} value The value to check.
     * @returns {boolean} Returns `true` if `value` is empty, else `false`.
     * @example
     *
     * _.isEmpty(null);
     * // => true
     *
     * _.isEmpty(true);
     * // => true
     *
     * _.isEmpty(1);
     * // => true
     *
     * _.isEmpty([1, 2, 3]);
     * // => false
     *
     * _.isEmpty({ 'a': 1 });
     * // => false
     */

/**
     * Checks if `value` is an integer.
     *
     * **Note:** This method is based on
     * [`Number.isInteger`](https://mdn.io/Number/isInteger).
     *
     * @static
     * @memberOf _
     * @since 4.0.0
     * @category Lang
     * @param {*} value The value to check.
     * @returns {boolean} Returns `true` if `value` is an integer, else `false`.
     * @example
     *
     * _.isInteger(3);
     * // => true
     *
     * _.isInteger(Number.MIN_VALUE);
     * // => false
     *
     * _.isInteger(Infinity);
     * // => false
     *
     * _.isInteger('3');
     * // => false
     */

/**
     * Checks if `value` is array-like. A value is considered array-like if it's
     * not a function and has a `value.length` that's an integer greater than or
     * equal to `0` and less than or equal to `Number.MAX_SAFE_INTEGER`.
     *
     * @static
     * @memberOf _
     * @since 4.0.0
     * @category Lang
     * @param {*} value The value to check.
     * @returns {boolean} Returns `true` if `value` is array-like, else `false`.
     * @example
     *
     * _.isArrayLike([1, 2, 3]);
     * // => true
     *
     * _.isArrayLike(document.body.children);
     * // => true
     *
     * _.isArrayLike('abc');
     * // => true
     *
     * _.isArrayLike(_.noop);
     * // => false
     */

/**
     * Checks if `value` is classified as a `Date` object.
     *
     * @static
     * @memberOf _
     * @since 0.1.0
     * @category Lang
     * @param {*} value The value to check.
     * @returns {boolean} Returns `true` if `value` is a date object, else `false`.
     * @example
     *
     * _.isDate(new Date);
     * // => true
     *
     * _.isDate('Mon April 23 2012');
     * // => false
     */

/**
     * Checks if `value` is classified as a `Function` object.
     *
     * @static
     * @memberOf _
     * @since 0.1.0
     * @category Lang
     * @param {*} value The value to check.
     * @returns {boolean} Returns `true` if `value` is a function, else `false`.
     * @example
     *
     * _.isFunction(_);
     * // => true
     *
     * _.isFunction(/abc/);
     * // => false
     */

/**
     * Checks if `value` is classified as a `Map` object.
     *
     * @static
     * @memberOf _
     * @since 4.3.0
     * @category Lang
     * @param {*} value The value to check.
     * @returns {boolean} Returns `true` if `value` is a map, else `false`.
     * @example
     *
     * _.isMap(new Map);
     * // => true
     *
     * _.isMap(new WeakMap);
     * // => false
     */

/**
     * 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
     */

/**
     * Checks if `value` is classified as a `RegExp` object.
     *
     * @static
     * @memberOf _
     * @since 0.1.0
     * @category Lang
     * @param {*} value The value to check.
     * @returns {boolean} Returns `true` if `value` is a regexp, else `false`.
     * @example
     *
     * _.isRegExp(/abc/);
     * // => true
     *
     * _.isRegExp('/abc/');
     * // => false
     */

/**
     * Checks if `value` is classified as a `Set` object.
     *
     * @static
     * @memberOf _
     * @since 4.3.0
     * @category Lang
     * @param {*} value The value to check.
     * @returns {boolean} Returns `true` if `value` is a set, else `false`.
     * @example
     *
     * _.isSet(new Set);
     * // => true
     *
     * _.isSet(new WeakSet);
     * // => false
     */

/**
     * 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
     */

/**
     * 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
     */

/**
     * Checks if `value` is classified as a `WeakMap` object.
     *
     * @static
     * @memberOf _
     * @since 4.3.0
     * @category Lang
     * @param {*} value The value to check.
     * @returns {boolean} Returns `true` if `value` is a weak map, else `false`.
     * @example
     *
     * _.isWeakMap(new WeakMap);
     * // => true
     *
     * _.isWeakMap(new Map);
     * // => false
     */

/**
     * Checks if `value` is classified as a `WeakSet` object.
     *
     * @static
     * @memberOf _
     * @since 4.3.0
     * @category Lang
     * @param {*} value The value to check.
     * @returns {boolean} Returns `true` if `value` is a weak set, else `false`.
     * @example
     *
     * _.isWeakSet(new WeakSet);
     * // => true
     *
     * _.isWeakSet(new Set);
     * // => false
     */

/**
     * 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
     */

/**
     * Checks if `value` is classified as a typed array.
     *
     * @static
     * @memberOf _
     * @since 3.0.0
     * @category Lang
     * @param {*} value The value to check.
     * @returns {boolean} Returns `true` if `value` is a typed array, else `false`.
     * @example
     *
     * _.isTypedArray(new Uint8Array);
     * // => true
     *
     * _.isTypedArray([]);
     * // => false
     */

/**
     * Checks if `value` is greater than `other`.
     *
     * @static
     * @memberOf _
     * @since 3.9.0
     * @category Lang
     * @param {*} value The value to compare.
     * @param {*} other The other value to compare.
     * @returns {boolean} Returns `true` if `value` is greater than `other`,
     *  else `false`.
     * @see _.lt
     * @example
     *
     * _.gt(3, 1);
     * // => true
     *
     * _.gt(3, 3);
     * // => false
     *
     * _.gt(1, 3);
     * // => false
     */

/**
     * Checks if `value` is greater than or equal to `other`.
     *
     * @static
     * @memberOf _
     * @since 3.9.0
     * @category Lang
     * @param {*} value The value to compare.
     * @param {*} other The other value to compare.
     * @returns {boolean} Returns `true` if `value` is greater than or equal to
     *  `other`, else `false`.
     * @see _.lte
     * @example
     *
     * _.gte(3, 1);
     * // => true
     *
     * _.gte(3, 3);
     * // => true
     *
     * _.gte(1, 3);
     * // => false
     */

/**
     * Checks if `value` is in `collection`. If `collection` is a string, it's
     * checked for a substring of `value`, otherwise
     * [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero)
     * is used for equality comparisons. If `fromIndex` is negative, it's used as
     * the offset from the end of `collection`.
     *
     * @static
     * @memberOf _
     * @since 0.1.0
     * @category Collection
     * @param {Array|Object|string} collection The collection to inspect.
     * @param {*} value The value to search for.
     * @param {number} [fromIndex=0] The index to search from.
     * @param- {Object} [guard] Enables use as an iteratee for methods like `_.reduce`.
     * @returns {boolean} Returns `true` if `value` is found, else `false`.
     * @example
     *
     * _.includes([1, 2, 3], 1);
     * // => true
     *
     * _.includes([1, 2, 3], 1, 2);
     * // => false
     *
     * _.includes({ 'a': 1, 'b': 2 }, 1);
     * // => true
     *
     * _.includes('abcd', 'bc');
     * // => true
     */

/**
     * Checks if `value` is in the array cache.
     *
     * @private
     * @name has
     * @memberOf SetCache
     * @param {*} value The value to search for.
     * @returns {number} Returns `true` if `value` is found, else `false`.
     */

/**
     * Checks if `value` is less than `other`.
     *
     * @static
     * @memberOf _
     * @since 3.9.0
     * @category Lang
     * @param {*} value The value to compare.
     * @param {*} other The other value to compare.
     * @returns {boolean} Returns `true` if `value` is less than `other`,
     *  else `false`.
     * @see _.gt
     * @example
     *
     * _.lt(1, 3);
     * // => true
     *
     * _.lt(3, 3);
     * // => false
     *
     * _.lt(3, 1);
     * // => false
     */

/**
     * Checks if `value` is less than or equal to `other`.
     *
     * @static
     * @memberOf _
     * @since 3.9.0
     * @category Lang
     * @param {*} value The value to compare.
     * @param {*} other The other value to compare.
     * @returns {boolean} Returns `true` if `value` is less than or equal to
     *  `other`, else `false`.
     * @see _.gte
     * @example
     *
     * _.lte(1, 3);
     * // => true
     *
     * _.lte(3, 3);
     * // => true
     *
     * _.lte(3, 1);
     * // => false
     */

/**
     * Checks if `value` is likely a DOM element.
     *
     * @static
     * @memberOf _
     * @since 0.1.0
     * @category Lang
     * @param {*} value The value to check.
     * @returns {boolean} Returns `true` if `value` is a DOM element, else `false`.
     * @example
     *
     * _.isElement(document.body);
     * // => true
     *
     * _.isElement('<body>');
     * // => false
     */

/**
     * Checks if `value` is likely a prototype object.
     *
     * @private
     * @param {*} value The value to check.
     * @returns {boolean} Returns `true` if `value` is a prototype, else `false`.
     */

/**
     * 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
     */

/**
     * Checks if `value` is suitable for strict equality comparisons, i.e. `===`.
     *
     * @private
     * @param {*} value The value to check.
     * @returns {boolean} Returns `true` if `value` if suitable for strict
     *  equality comparisons, else `false`.
     */

/**
     * Checks if `value` is suitable for use as unique object key.
     *
     * @private
     * @param {*} value The value to check.
     * @returns {boolean} Returns `true` if `value` is suitable, else `false`.
     */

/**
     * 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
     */

/**
     * Checks if a hash value for `key` exists.
     *
     * @private
     * @name has
     * @memberOf Hash
     * @param {string} key The key of the entry to check.
     * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.
     */

/**
     * Checks if a list cache value for `key` exists.
     *
     * @private
     * @name has
     * @memberOf ListCache
     * @param {string} key The key of the entry to check.
     * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.
     */

/**
     * Checks if a map value for `key` exists.
     *
     * @private
     * @name has
     * @memberOf MapCache
     * @param {string} key The key of the entry to check.
     * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.
     */

/**
     * Checks if a stack value for `key` exists.
     *
     * @private
     * @name has
     * @memberOf Stack
     * @param {string} key The key of the entry to check.
     * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.
     */

/**
     * Checks if debug mode is enabled.
     *
     * @return {boolean} true if debug mode is enabled, false otherwise
     */

/**
     * Checks if end of stream was reached.
     *
     * @return boolean
     */

/**
     * Checks if the auto_reload option is enabled.
     *
     * @return {boolean} true if auto_reload is enabled, false otherwise
     */

/**
     * Checks if the given arguments are from an iteratee call.
     *
     * @private
     * @param {*} value The potential iteratee value argument.
     * @param {*} index The potential iteratee index or key argument.
     * @param {*} object The potential iteratee object argument.
     * @returns {boolean} Returns `true` if the arguments are from an iteratee call,
     *  else `false`.
     */

/**
     * Checks if the source_map option is enabled.
     *
     * @return {boolean} true if source_map is enabled, false otherwise
     */

/**
     * Checks if the strict_variables option is enabled.
     *
     * @return {boolean} true if strict_variables is enabled, false otherwise
     */

/**
     * Clamps `number` within the inclusive `lower` and `upper` bounds.
     *
     * @static
     * @memberOf _
     * @since 4.0.0
     * @category Number
     * @param {number} number The number to clamp.
     * @param {number} [lower] The lower bound.
     * @param {number} upper The upper bound.
     * @returns {number} Returns the clamped number.
     * @example
     *
     * _.clamp(-10, -5, 5);
     * // => -5
     *
     * _.clamp(10, -5, 5);
     * // => 5
     */

/**
     * Clean (erase) the output buffer
     *
     * In human terms, empty the top-most buffer
     *
     * ┌─────────┐    ┌─────────┐
     * │   oof   │    │         │
     * ├─────────┤    ├─────────┤
     * │   bar   │ => │   bar   │
     * ├─────────┤    ├─────────┤
     * │   foo   │    │   foo   │ => true
     * └─────────┘    └─────────┘
     *
     */

/**
     * Clean the output buffer, and delete active output buffer
     *
     * In human terms: clean the top-most buffer and remove the top-most buffer
     *
     * ┌─────────┐
     * │   oof   │
     * ├─────────┤    ┌─────────┐
     * │   bar   │ -> │   bar   │
     * ├─────────┤    ├─────────┤
     * │   foo   │    │   foo   │ => true
     * └─────────┘    └─────────┘
     *
     * @returns {boolean}
     */

/**
     * Compares values to sort them in ascending order.
     *
     * @private
     * @param {*} value The value to compare.
     * @param {*} other The other value to compare.
     * @returns {number} Returns the sort order indicator for `value`.
     */

/**
     * Compiles a module node.
     *
     * @return {string}
     */

/**
     * Computes `number` rounded to `precision`.
     *
     * @static
     * @memberOf _
     * @since 3.10.0
     * @category Math
     * @param {number} number The number to round.
     * @param {number} [precision=0] The precision to round to.
     * @returns {number} Returns the rounded number.
     * @example
     *
     * _.round(4.006);
     * // => 4
     *
     * _.round(4.006, 2);
     * // => 4.01
     *
     * _.round(4060, -2);
     * // => 4100
     */

/**
     * Computes `number` rounded up to `precision`.
     *
     * @static
     * @memberOf _
     * @since 3.10.0
     * @category Math
     * @param {number} number The number to round up.
     * @param {number} [precision=0] The precision to round up to.
     * @returns {number} Returns the rounded up number.
     * @example
     *
     * _.ceil(4.006);
     * // => 5
     *
     * _.ceil(6.004, 2);
     * // => 6.01
     *
     * _.ceil(6040, -2);
     * // => 6100
     */

/**
     * Computes the maximum value of `array`. If `array` is empty or falsey,
     * `undefined` is returned.
     *
     * @static
     * @since 0.1.0
     * @memberOf _
     * @category Math
     * @param {Array} array The array to iterate over.
     * @returns {*} Returns the maximum value.
     * @example
     *
     * _.max([4, 2, 8, 6]);
     * // => 8
     *
     * _.max([]);
     * // => undefined
     */

/**
     * Computes the mean of the values in `array`.
     *
     * @static
     * @memberOf _
     * @since 4.0.0
     * @category Math
     * @param {Array} array The array to iterate over.
     * @returns {number} Returns the mean.
     * @example
     *
     * _.mean([4, 2, 8, 6]);
     * // => 5
     */

/**
     * Computes the minimum value of `array`. If `array` is empty or falsey,
     * `undefined` is returned.
     *
     * @static
     * @since 0.1.0
     * @memberOf _
     * @category Math
     * @param {Array} array The array to iterate over.
     * @returns {*} Returns the minimum value.
     * @example
     *
     * _.min([4, 2, 8, 6]);
     * // => 2
     *
     * _.min([]);
     * // => undefined
     */

/**
     * Computes the sum of the values in `array`.
     *
     * @static
     * @memberOf _
     * @since 3.4.0
     * @category Math
     * @param {Array} array The array to iterate over.
     * @returns {number} Returns the sum.
     * @example
     *
     * _.sum([4, 2, 8, 6]);
     * // => 20
     */

/**
     * Construct and return a list of tokens relevant to render a Twig template.
     *
     * @return {Token[]}
     */

/**
     * Constructor.
     *
     * @param {TwingLoaderInterface} loader
     * @param {TwingEnvironmentOptions} options
     */

/**
     * Constructor.
     *
     * The nodes are automatically made available as properties ($this->node).
     * The attributes are automatically made available as array items ($this['name']).
     *
     * @param nodes Map<string | number, TwingNode>  A map of named nodes
     * @param attributes Map<string, any> A map of attributes (should not be nodes)
     * @param lineno number The line number
     * @param columnno number The column number
     * @param tag string The tag name associated with the Node
     */

/**
     * Convert certain characters (&, <, >, and ') from their HTML character equivalents.
     * @param {String} value The string to decode
     * @return {String} The decoded text
     */

/**
     * Convert certain characters (&, <, >, and ') to their HTML character equivalents for literal display in web pages.
     * @param {String} value The string to encode
     * @return {String} The encoded text
     */

/**
     * Convert certain characters (<, >, and ') to their HTML character equivalents but modify them with wit a space and @@@ to separate them from links
     * so we can linkify these links without including characters that are not actual part of them (for example a tailing >) 
     * as they are found in Teams Invitations, in the second step we replace these strings by the proper Characters
     * 
     * @param {String} value The string to encode
     * @return {String} The encoded text
     */

/**
     * Converts `func` to its source code.
     *
     * @private
     * @param {Function} func The function to convert.
     * @returns {string} Returns the source code.
     */

/**
     * Converts `string` to
     * [kebab case](https://en.wikipedia.org/wiki/Letter_case#Special_case_styles).
     *
     * @static
     * @memberOf _
     * @since 3.0.0
     * @category String
     * @param {string} [string=''] The string to convert.
     * @returns {string} Returns the kebab cased string.
     * @example
     *
     * _.kebabCase('Foo Bar');
     * // => 'foo-bar'
     *
     * _.kebabCase('fooBar');
     * // => 'foo-bar'
     *
     * _.kebabCase('__FOO_BAR__');
     * // => 'foo-bar'
     */

/**
     * 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'
     */

/**
     * Converts `string` to
     * [start case](https://en.wikipedia.org/wiki/Letter_case#Stylistic_or_specialised_usage).
     *
     * @static
     * @memberOf _
     * @since 3.1.0
     * @category String
     * @param {string} [string=''] The string to convert.
     * @returns {string} Returns the start cased string.
     * @example
     *
     * _.startCase('--foo-bar--');
     * // => 'Foo Bar'
     *
     * _.startCase('fooBar');
     * // => 'Foo Bar'
     *
     * _.startCase('__FOO_BAR__');
     * // => 'FOO BAR'
     */

/**
     * Converts `string` to [camel case](https://en.wikipedia.org/wiki/CamelCase).
     *
     * @static
     * @memberOf _
     * @since 3.0.0
     * @category String
     * @param {string} [string=''] The string to convert.
     * @returns {string} Returns the camel cased string.
     * @example
     *
     * _.camelCase('Foo Bar');
     * // => 'fooBar'
     *
     * _.camelCase('--foo-bar--');
     * // => 'fooBar'
     *
     * _.camelCase('__FOO_BAR__');
     * // => 'fooBar'
     */

/**
     * Converts `string` to a property path array.
     *
     * @private
     * @param {string} string The string to convert.
     * @returns {Array} Returns the property path array.
     */

/**
     * Converts `string` to an integer of the specified radix. If `radix` is
     * `undefined` or `0`, a `radix` of `10` is used unless `value` is a
     * hexadecimal, in which case a `radix` of `16` is used.
     *
     * **Note:** This method aligns with the
     * [ES5 implementation](https://es5.github.io/#x15.1.2.2) of `parseInt`.
     *
     * @static
     * @memberOf _
     * @since 1.1.0
     * @category String
     * @param {string} string The string to convert.
     * @param {number} [radix=10] The radix to interpret `value` by.
     * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`.
     * @returns {number} Returns the converted integer.
     * @example
     *
     * _.parseInt('08');
     * // => 8
     *
     * _.map(['6', '08', '10'], _.parseInt);
     * // => [6, 8, 10]
     */

/**
     * Converts `string`, as a whole, to lower case just like
     * [String#toLowerCase](https://mdn.io/toLowerCase).
     *
     * @static
     * @memberOf _
     * @since 4.0.0
     * @category String
     * @param {string} [string=''] The string to convert.
     * @returns {string} Returns the lower cased string.
     * @example
     *
     * _.toLower('--Foo-Bar--');
     * // => '--foo-bar--'
     *
     * _.toLower('fooBar');
     * // => 'foobar'
     *
     * _.toLower('__FOO_BAR__');
     * // => '__foo_bar__'
     */

/**
     * Converts `string`, as a whole, to upper case just like
     * [String#toUpperCase](https://mdn.io/toUpperCase).
     *
     * @static
     * @memberOf _
     * @since 4.0.0
     * @category String
     * @param {string} [string=''] The string to convert.
     * @returns {string} Returns the upper cased string.
     * @example
     *
     * _.toUpper('--foo-bar--');
     * // => '--FOO-BAR--'
     *
     * _.toUpper('fooBar');
     * // => 'FOOBAR'
     *
     * _.toUpper('__foo_bar__');
     * // => '__FOO_BAR__'
     */

/**
     * Converts `string`, as space separated words, to lower case.
     *
     * @static
     * @memberOf _
     * @since 4.0.0
     * @category String
     * @param {string} [string=''] The string to convert.
     * @returns {string} Returns the lower cased string.
     * @example
     *
     * _.lowerCase('--Foo-Bar--');
     * // => 'foo bar'
     *
     * _.lowerCase('fooBar');
     * // => 'foo bar'
     *
     * _.lowerCase('__FOO_BAR__');
     * // => 'foo bar'
     */

/**
     * Converts `string`, as space separated words, to upper case.
     *
     * @static
     * @memberOf _
     * @since 4.0.0
     * @category String
     * @param {string} [string=''] The string to convert.
     * @returns {string} Returns the upper cased string.
     * @example
     *
     * _.upperCase('--foo-bar');
     * // => 'FOO BAR'
     *
     * _.upperCase('fooBar');
     * // => 'FOO BAR'
     *
     * _.upperCase('__foo_bar__');
     * // => 'FOO BAR'
     */

/**
     * 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
     */

/**
     * 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
     */

/**
     * Converts `value` to a plain object flattening inherited enumerable string
     * keyed properties of `value` to own properties of the plain object.
     *
     * @static
     * @memberOf _
     * @since 3.0.0
     * @category Lang
     * @param {*} value The value to convert.
     * @returns {Object} Returns the converted plain object.
     * @example
     *
     * function Foo() {
     *   this.b = 2;
     * }
     *
     * Foo.prototype.c = 3;
     *
     * _.assign({ 'a': 1 }, new Foo);
     * // => { 'a': 1, 'b': 2 }
     *
     * _.assign({ 'a': 1 }, _.toPlainObject(new Foo));
     * // => { 'a': 1, 'b': 2, 'c': 3 }
     */

/**
     * Converts `value` to a property path array.
     *
     * @static
     * @memberOf _
     * @since 4.0.0
     * @category Util
     * @param {*} value The value to convert.
     * @returns {Array} Returns the new property path array.
     * @example
     *
     * _.toPath('a.b.c');
     * // => ['a', 'b', 'c']
     *
     * _.toPath('a[0].b.c');
     * // => ['a', '0', 'b', 'c']
     */

/**
     * Converts `value` to a safe integer. A safe integer can be compared and
     * represented correctly.
     *
     * @static
     * @memberOf _
     * @since 4.0.0
     * @category Lang
     * @param {*} value The value to convert.
     * @returns {number} Returns the converted integer.
     * @example
     *
     * _.toSafeInteger(3.2);
     * // => 3
     *
     * _.toSafeInteger(Number.MIN_VALUE);
     * // => 0
     *
     * _.toSafeInteger(Infinity);
     * // => 9007199254740991
     *
     * _.toSafeInteger('3.2');
     * // => 3
     */

/**
     * Converts `value` to a string key if it's not a string or symbol.
     *
     * @private
     * @param {*} value The value to inspect.
     * @returns {string|symbol} Returns the key.
     */

/**
     * Converts `value` to a string using `Object.prototype.toString`.
     *
     * @private
     * @param {*} value The value to convert.
     * @returns {string} Returns the converted string.
     */

/**
     * 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'
     */

/**
     * Converts `value` to an array.
     *
     * @static
     * @since 0.1.0
     * @memberOf _
     * @category Lang
     * @param {*} value The value to convert.
     * @returns {Array} Returns the converted array.
     * @example
     *
     * _.toArray({ 'a': 1, 'b': 2 });
     * // => [1, 2]
     *
     * _.toArray('abc');
     * // => ['a', 'b', 'c']
     *
     * _.toArray(1);
     * // => []
     *
     * _.toArray(null);
     * // => []
     */

/**
     * Converts `value` to an integer suitable for use as the length of an
     * array-like object.
     *
     * **Note:** This method is based on
     * [`ToLength`](http://ecma-international.org/ecma-262/7.0/#sec-tolength).
     *
     * @static
     * @memberOf _
     * @since 4.0.0
     * @category Lang
     * @param {*} value The value to convert.
     * @returns {number} Returns the converted integer.
     * @example
     *
     * _.toLength(3.2);
     * // => 3
     *
     * _.toLength(Number.MIN_VALUE);
     * // => 0
     *
     * _.toLength(Infinity);
     * // => 4294967295
     *
     * _.toLength('3.2');
     * // => 3
     */

/**
     * 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
     */

/**
     * Converts a string to all lower case letters
     * @param {String} value The text to convert
     * @return {String} The converted text
     */

/**
     * Converts a string to all upper case letters
     * @param {String} value The text to convert
     * @return {String} The converted text
     */

/**
     * Converts a token list to a template.
     *
     * @param {TwingTokenStream} stream
     * @param {TwingParserOptions} options
     * @return {TwingNodeModule}
     *
     * @throws {TwingErrorSyntax} When the token stream is syntactically or semantically wrong
     */

/**
     * Converts all elements in `array` into a string separated by `separator`.
     *
     * @static
     * @memberOf _
     * @since 4.0.0
     * @category Array
     * @param {Array} array The array to convert.
     * @param {string} [separator=','] The element separator.
     * @returns {string} Returns the joined string.
     * @example
     *
     * _.join(['a', 'b', 'c'], '~');
     * // => 'a~b~c'
     */

/**
     * Converts any iterable (numeric indices and a length property) into a true array
     * Don't use this on strings. IE doesn't support "abc"[0] which this implementation depends on.
     * For strings, use this instead: "abc".match(/./g) => [a,b,c];
     * @param {Iterable} the iterable object to be turned into a true Array.
     * @return (Array) array
     */

/**
     * Converts newline characters to the HTML tag &lt;br/>
     * @return {String} The string with embedded &lt;br/> tags in place of newlines.
     * @param v
     */

/**
     * 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'
     */

/**
     * Converts the first character of `string` to upper case and the remaining
     * to lower case.
     *
     * @static
     * @memberOf _
     * @since 3.0.0
     * @category String
     * @param {string} [string=''] The string to capitalize.
     * @returns {string} Returns the capitalized string.
     * @example
     *
     * _.capitalize('FRED');
     * // => 'Fred'
     */

/**
     * Converts the first character of `string` to upper case.
     *
     * @static
     * @memberOf _
     * @since 4.0.0
     * @category String
     * @param {string} [string=''] The string to convert.
     * @returns {string} Returns the converted string.
     * @example
     *
     * _.upperFirst('fred');
     * // => 'Fred'
     *
     * _.upperFirst('FRED');
     * // => 'FRED'
     */

/**
     * Converts the first character only of a string to upper case
     * @param {String} value The text to convert
     * @return {String} The converted text
     */

/**
     * Copies a set of named properties fom the source object to the destination object.
     * <p>example:<pre><code>
    ImageComponent = Ext.extend(Ext.BoxComponent, {
    initComponent: function() {
    this.autoEl = { tag: 'img' };
    MyComponent.superclass.initComponent.apply(this, arguments);
    this.initialBox = Ext.copyTo({}, this.initialConfig, 'x,y,width,height');
    }
    });
     * </code></pre> 
     * @param {Object} The destination object.
     * @param {Object} The source object.
     * @param {Array/String} Either an Array of property names, or a comma-delimited list
     * of property names to copy.
     * @return {Object} The modified object.
    */

/**
     * Copies all the properties of config to obj if they don't already exist.
     * @param {Object} obj The receiver of the properties
     * @param {Object} config The source of the properties
     * @return {Object} returns obj
     */

/**
     * Copies own and inherited symbols of `source` to `object`.
     *
     * @private
     * @param {Object} source The object to copy symbols from.
     * @param {Object} [object={}] The object to copy symbols to.
     * @returns {Object} Returns `object`.
     */

/**
     * Copies own symbols of `source` to `object`.
     *
     * @private
     * @param {Object} source The object to copy symbols from.
     * @param {Object} [object={}] The object to copy symbols to.
     * @returns {Object} Returns `object`.
     */

/**
     * Copies properties of `source` to `object`.
     *
     * @private
     * @param {Object} source The object to copy properties from.
     * @param {Array} props The property identifiers to copy.
     * @param {Object} [object={}] The object to copy properties to.
     * @param {Function} [customizer] The function to customize copied values.
     * @returns {Object} Returns `object`.
     */

/**
     * Copies the values of `source` to `array`.
     *
     * @private
     * @param {Array} source The array to copy values from.
     * @param {Array} [array=[]] The array to copy values to.
     * @returns {Array} Returns `array`.
     */

/**
     * Creates a `_.find` or `_.findLast` function.
     *
     * @private
     * @param {Function} findIndexFunc The function to find the collection index.
     * @returns {Function} Returns the new find function.
     */

/**
     * Creates a `_.flow` or `_.flowRight` function.
     *
     * @private
     * @param {boolean} [fromRight] Specify iterating from right to left.
     * @returns {Function} Returns the new flow function.
     */

/**
     * Creates a `_.range` or `_.rangeRight` function.
     *
     * @private
     * @param {boolean} [fromRight] Specify iterating from right to left.
     * @returns {Function} Returns the new range function.
     */

/**
     * Creates a `_.toPairs` or `_.toPairsIn` function.
     *
     * @private
     * @param {Function} keysFunc The function to get the keys of a given object.
     * @returns {Function} Returns the new pairs function.
     */

/**
     * Creates a `baseEach` or `baseEachRight` function.
     *
     * @private
     * @param {Function} eachFunc The function to iterate over a collection.
     * @param {boolean} [fromRight] Specify iterating from right to left.
     * @returns {Function} Returns the new base function.
     */

/**
     * Creates a `lodash` object which wraps `value` to enable implicit method
     * chain sequences. Methods that operate on and return arrays, collections,
     * and functions can be chained together. Methods that retrieve a single value
     * or may return a primitive value will automatically end the chain sequence
     * and return the unwrapped value. Otherwise, the value must be unwrapped
     * with `_#value`.
     *
     * Explicit chain sequences, which must be unwrapped with `_#value`, may be
     * enabled using `_.chain`.
     *
     * The execution of chained methods is lazy, that is, it's deferred until
     * `_#value` is implicitly or explicitly called.
     *
     * Lazy evaluation allows several methods to support shortcut fusion.
     * Shortcut fusion is an optimization to merge iteratee calls; this avoids
     * the creation of intermediate arrays and can greatly reduce the number of
     * iteratee executions. Sections of a chain sequence qualify for shortcut
     * fusion if the section is applied to an array and iteratees accept only
     * one argument. The heuristic for whether a section qualifies for shortcut
     * fusion is subject to change.
     *
     * Chaining is supported in custom builds as long as the `_#value` method is
     * directly or indirectly included in the build.
     *
     * In addition to lodash methods, wrappers have `Array` and `String` methods.
     *
     * The wrapper `Array` methods are:
     * `concat`, `join`, `pop`, `push`, `shift`, `sort`, `splice`, and `unshift`
     *
     * The wrapper `String` methods are:
     * `replace` and `split`
     *
     * The wrapper methods that support shortcut fusion are:
     * `at`, `compact`, `drop`, `dropRight`, `dropWhile`, `filter`, `find`,
     * `findLast`, `head`, `initial`, `last`, `map`, `reject`, `reverse`, `slice`,
     * `tail`, `take`, `takeRight`, `takeRightWhile`, `takeWhile`, and `toArray`
     *
     * The chainable wrapper methods are:
     * `after`, `ary`, `assign`, `assignIn`, `assignInWith`, `assignWith`, `at`,
     * `before`, `bind`, `bindAll`, `bindKey`, `castArray`, `chain`, `chunk`,
     * `commit`, `compact`, `concat`, `conforms`, `constant`, `countBy`, `create`,
     * `curry`, `debounce`, `defaults`, `defaultsDeep`, `defer`, `delay`,
     * `difference`, `differenceBy`, `differenceWith`, `drop`, `dropRight`,
     * `dropRightWhile`, `dropWhile`, `extend`, `extendWith`, `fill`, `filter`,
     * `flatMap`, `flatMapDeep`, `flatMapDepth`, `flatten`, `flattenDeep`,
     * `flattenDepth`, `flip`, `flow`, `flowRight`, `fromPairs`, `functions`,
     * `functionsIn`, `groupBy`, `initial`, `intersection`, `intersectionBy`,
     * `intersectionWith`, `invert`, `invertBy`, `invokeMap`, `iteratee`, `keyBy`,
     * `keys`, `keysIn`, `map`, `mapKeys`, `mapValues`, `matches`, `matchesProperty`,
     * `memoize`, `merge`, `mergeWith`, `method`, `methodOf`, `mixin`, `negate`,
     * `nthArg`, `omit`, `omitBy`, `once`, `orderBy`, `over`, `overArgs`,
     * `overEvery`, `overSome`, `partial`, `partialRight`, `partition`, `pick`,
     * `pickBy`, `plant`, `property`, `propertyOf`, `pull`, `pullAll`, `pullAllBy`,
     * `pullAllWith`, `pullAt`, `push`, `range`, `rangeRight`, `rearg`, `reject`,
     * `remove`, `rest`, `reverse`, `sampleSize`, `set`, `setWith`, `shuffle`,
     * `slice`, `sort`, `sortBy`, `splice`, `spread`, `tail`, `take`, `takeRight`,
     * `takeRightWhile`, `takeWhile`, `tap`, `throttle`, `thru`, `toArray`,
     * `toPairs`, `toPairsIn`, `toPath`, `toPlainObject`, `transform`, `unary`,
     * `union`, `unionBy`, `unionWith`, `uniq`, `uniqBy`, `uniqWith`, `unset`,
     * `unshift`, `unzip`, `unzipWith`, `update`, `updateWith`, `values`,
     * `valuesIn`, `without`, `wrap`, `xor`, `xorBy`, `xorWith`, `zip`,
     * `zipObject`, `zipObjectDeep`, and `zipWith`
     *
     * The wrapper methods that are **not** chainable by default are:
     * `add`, `attempt`, `camelCase`, `capitalize`, `ceil`, `clamp`, `clone`,
     * `cloneDeep`, `cloneDeepWith`, `cloneWith`, `conformsTo`, `deburr`,
     * `defaultTo`, `divide`, `each`, `eachRight`, `endsWith`, `eq`, `escape`,
     * `escapeRegExp`, `every`, `find`, `findIndex`, `findKey`, `findLast`,
     * `findLastIndex`, `findLastKey`, `first`, `floor`, `forEach`, `forEachRight`,
     * `forIn`, `forInRight`, `forOwn`, `forOwnRight`, `get`, `gt`, `gte`, `has`,
     * `hasIn`, `head`, `identity`, `includes`, `indexOf`, `inRange`, `invoke`,
     * `isArguments`, `isArray`, `isArrayBuffer`, `isArrayLike`, `isArrayLikeObject`,
     * `isBoolean`, `isBuffer`, `isDate`, `isElement`, `isEmpty`, `isEqual`,
     * `isEqualWith`, `isError`, `isFinite`, `isFunction`, `isInteger`, `isLength`,
     * `isMap`, `isMatch`, `isMatchWith`, `isNaN`, `isNative`, `isNil`, `isNull`,
     * `isNumber`, `isObject`, `isObjectLike`, `isPlainObject`, `isRegExp`,
     * `isSafeInteger`, `isSet`, `isString`, `isUndefined`, `isTypedArray`,
     * `isWeakMap`, `isWeakSet`, `join`, `kebabCase`, `last`, `lastIndexOf`,
     * `lowerCase`, `lowerFirst`, `lt`, `lte`, `max`, `maxBy`, `mean`, `meanBy`,
     * `min`, `minBy`, `multiply`, `noConflict`, `noop`, `now`, `nth`, `pad`,
     * `padEnd`, `padStart`, `parseInt`, `pop`, `random`, `reduce`, `reduceRight`,
     * `repeat`, `result`, `round`, `runInContext`, `sample`, `shift`, `size`,
     * `snakeCase`, `some`, `sortedIndex`, `sortedIndexBy`, `sortedLastIndex`,
     * `sortedLastIndexBy`, `startCase`, `startsWith`, `stubArray`, `stubFalse`,
     * `stubObject`, `stubString`, `stubTrue`, `subtract`, `sum`, `sumBy`,
     * `template`, `times`, `toFinite`, `toInteger`, `toJSON`, `toLength`,
     * `toLower`, `toNumber`, `toSafeInteger`, `toString`, `toUpper`, `trim`,
     * `trimEnd`, `trimStart`, `truncate`, `unescape`, `uniqueId`, `upperCase`,
     * `upperFirst`, `value`, and `words`
     *
     * @name _
     * @constructor
     * @category Seq
     * @param {*} value The value to wrap in a `lodash` instance.
     * @returns {Object} Returns the new `lodash` wrapper instance.
     * @example
     *
     * function square(n) {
     *   return n * n;
     * }
     *
     * var wrapped = _([1, 2, 3]);
     *
     * // Returns an unwrapped value.
     * wrapped.reduce(_.add);
     * // => 6
     *
     * // Returns a wrapped value.
     * var squares = wrapped.map(square);
     *
     * _.isArray(squares);
     * // => false
     *
     * _.isArray(squares.value());
     * // => true
     */

/**
     * Creates a `lodash` wrapper instance that wraps `value` with explicit method
     * chain sequences enabled. The result of such sequences must be unwrapped
     * with `_#value`.
     *
     * @static
     * @memberOf _
     * @since 1.3.0
     * @category Seq
     * @param {*} value The value to wrap.
     * @returns {Object} Returns the new `lodash` wrapper instance.
     * @example
     *
     * var users = [
     *   { 'user': 'barney',  'age': 36 },
     *   { 'user': 'fred',    'age': 40 },
     *   { 'user': 'pebbles', 'age': 1 }
     * ];
     *
     * var youngest = _
     *   .chain(users)
     *   .sortBy('age')
     *   .map(function(o) {
     *     return o.user + ' is ' + o.age;
     *   })
     *   .head()
     *   .value();
     * // => 'pebbles is 1'
     */

/**
     * Creates a `lodash` wrapper instance with explicit method chain sequences enabled.
     *
     * @name chain
     * @memberOf _
     * @since 0.1.0
     * @category Seq
     * @returns {Object} Returns the new `lodash` wrapper instance.
     * @example
     *
     * var users = [
     *   { 'user': 'barney', 'age': 36 },
     *   { 'user': 'fred',   'age': 40 }
     * ];
     *
     * // A sequence without explicit chaining.
     * _(users).head();
     * // => { 'user': 'barney', 'age': 36 }
     *
     * // A sequence with explicit chaining.
     * _(users)
     *   .chain()
     *   .head()
     *   .pick('user')
     *   .value();
     * // => { 'user': 'barney' }
     */

/**
     * Creates a base function for methods like `_.forIn` and `_.forOwn`.
     *
     * @private
     * @param {boolean} [fromRight] Specify iterating from right to left.
     * @returns {Function} Returns the new base function.
     */

/**
     * Creates a clone of  `buffer`.
     *
     * @private
     * @param {Buffer} buffer The buffer to clone.
     * @param {boolean} [isDeep] Specify a deep clone.
     * @returns {Buffer} Returns the cloned buffer.
     */

/**
     * Creates a clone of `arrayBuffer`.
     *
     * @private
     * @param {ArrayBuffer} arrayBuffer The array buffer to clone.
     * @returns {ArrayBuffer} Returns the cloned array buffer.
     */

/**
     * Creates a clone of `dataView`.
     *
     * @private
     * @param {Object} dataView The data view to clone.
     * @param {boolean} [isDeep] Specify a deep clone.
     * @returns {Object} Returns the cloned data view.
     */

/**
     * Creates a clone of `regexp`.
     *
     * @private
     * @param {Object} regexp The regexp to clone.
     * @returns {Object} Returns the cloned regexp.
     */

/**
     * Creates a clone of `typedArray`.
     *
     * @private
     * @param {Object} typedArray The typed array to clone.
     * @param {boolean} [isDeep] Specify a deep clone.
     * @returns {Object} Returns the cloned typed array.
     */

/**
     * Creates a clone of `wrapper`.
     *
     * @private
     * @param {Object} wrapper The wrapper to clone.
     * @returns {Object} Returns the cloned wrapper.
     */

/**
     * Creates a clone of the `symbol` object.
     *
     * @private
     * @param {Object} symbol The symbol object to clone.
     * @returns {Object} Returns the cloned symbol object.
     */

/**
     * Creates a clone of the chain sequence planting `value` as the wrapped value.
     *
     * @name plant
     * @memberOf _
     * @since 3.2.0
     * @category Seq
     * @param {*} value The value to plant.
     * @returns {Object} Returns the new `lodash` wrapper instance.
     * @example
     *
     * function square(n) {
     *   return n * n;
     * }
     *
     * var wrapped = _([1, 2]).map(square);
     * var other = wrapped.plant([3, 4]);
     *
     * other.value();
     * // => [9, 16]
     *
     * wrapped.value();
     * // => [1, 4]
     */

/**
     * Creates a clone of the lazy wrapper object.
     *
     * @private
     * @name clone
     * @memberOf LazyWrapper
     * @returns {Object} Returns the cloned `LazyWrapper` object.
     */

/**
     * Creates a compiled template function that can interpolate data properties
     * in "interpolate" delimiters, HTML-escape interpolated data properties in
     * "escape" delimiters, and execute JavaScript in "evaluate" delimiters. Data
     * properties may be accessed as free variables in the template. If a setting
     * object is given, it takes precedence over `_.templateSettings` values.
     *
     * **Note:** In the development build `_.template` utilizes
     * [sourceURLs](http://www.html5rocks.com/en/tutorials/developertools/sourcemaps/#toc-sourceurl)
     * for easier debugging.
     *
     * For more information on precompiling templates see
     * [lodash's custom builds documentation](https://lodash.com/custom-builds).
     *
     * For more information on Chrome extension sandboxes see
     * [Chrome's extensions documentation](https://developer.chrome.com/extensions/sandboxingEval).
     *
     * @static
     * @since 0.1.0
     * @memberOf _
     * @category String
     * @param {string} [string=''] The template string.
     * @param {Object} [options={}] The options object.
     * @param {RegExp} [options.escape=_.templateSettings.escape]
     *  The HTML "escape" delimiter.
     * @param {RegExp} [options.evaluate=_.templateSettings.evaluate]
     *  The "evaluate" delimiter.
     * @param {Object} [options.imports=_.templateSettings.imports]
     *  An object to import into the template as free variables.
     * @param {RegExp} [options.interpolate=_.templateSettings.interpolate]
     *  The "interpolate" delimiter.
     * @param {string} [options.sourceURL='lodash.templateSources[n]']
     *  The sourceURL of the compiled template.
     * @param {string} [options.variable='obj']
     *  The data object variable name.
     * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`.
     * @returns {Function} Returns the compiled template function.
     * @example
     *
     * // Use the "interpolate" delimiter to create a compiled template.
     * var compiled = _.template('hello <%= user %>!');
     * compiled({ 'user': 'fred' });
     * // => 'hello fred!'
     *
     * // Use the HTML "escape" delimiter to escape data property values.
     * var compiled = _.template('<b><%- value %></b>');
     * compiled({ 'value': '<script>' });
     * // => '<b>&lt;script&gt;</b>'
     *
     * // Use the "evaluate" delimiter to execute JavaScript and generate HTML.
     * var compiled = _.template('<% _.forEach(users, function(user) { %><li><%- user %></li><% }); %>');
     * compiled({ 'users': ['fred', 'barney'] });
     * // => '<li>fred</li><li>barney</li>'
     *
     * // Use the internal `print` function in "evaluate" delimiters.
     * var compiled = _.template('<% print("hello " + user); %>!');
     * compiled({ 'user': 'barney' });
     * // => 'hello barney!'
     *
     * // Use the ES template literal delimiter as an "interpolate" delimiter.
     * // Disable support by replacing the "interpolate" delimiter.
     * var compiled = _.template('hello ${ user }!');
     * compiled({ 'user': 'pebbles' });
     * // => 'hello pebbles!'
     *
     * // Use backslashes to treat delimiters as plain text.
     * var compiled = _.template('<%= "\\<%- value %\\>" %>');
     * compiled({ 'value': 'ignored' });
     * // => '<%- value %>'
     *
     * // Use the `imports` option to import `jQuery` as `jq`.
     * var text = '<% jq.each(users, function(user) { %><li><%- user %></li><% }); %>';
     * var compiled = _.template(text, { 'imports': { 'jq': jQuery } });
     * compiled({ 'users': ['fred', 'barney'] });
     * // => '<li>fred</li><li>barney</li>'
     *
     * // Use the `sourceURL` option to specify a custom sourceURL for the template.
     * var compiled = _.template('hello <%= user %>!', { 'sourceURL': '/basic/greeting.jst' });
     * compiled(data);
     * // => Find the source of "greeting.jst" under the Sources tab or Resources panel of the web inspector.
     *
     * // Use the `variable` option to ensure a with-statement isn't used in the compiled template.
     * var compiled = _.template('hi <%= data.user %>!', { 'variable': 'data' });
     * compiled.source;
     * // => function(data) {
     * //   var __t, __p = '';
     * //   __p += 'hi ' + ((__t = ( data.user )) == null ? '' : __t) + '!';
     * //   return __p;
     * // }
     *
     * // Use custom template delimiters.
     * _.templateSettings.interpolate = /{{([\s\S]+?)}}/g;
     * var compiled = _.template('hello {{ user }}!');
     * compiled({ 'user': 'mustache' });
     * // => 'hello mustache!'
     *
     * // Use the `source` property to inline compiled templates for meaningful
     * // line numbers in error messages and stack traces.
     * fs.writeFileSync(path.join(process.cwd(), 'jst.js'), '\
     *   var JST = {\
     *     "main": ' + _.template(mainText).source + '\
     *   };\
     * ');
     */

/**
     * Creates a copy of the passed Array with falsy values removed.
     * @param {Array/NodeList} arr The Array from which to remove falsy values.
     * @return {Array} The new, compressed Array.
     */

/**
     * Creates a copy of the passed Array, filtered to contain only unique values.
     * @param {Array} arr The Array to filter
     * @return {Array} The new Array containing unique values.
     */

/**
     * 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);
     */

/**
     * Creates a duplicate-free version of an array, using
     * [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero)
     * for equality comparisons, in which only the first occurrence of each element
     * is kept. The order of result values is determined by the order they occur
     * in the array.
     *
     * @static
     * @memberOf _
     * @since 0.1.0
     * @category Array
     * @param {Array} array The array to inspect.
     * @returns {Array} Returns the new duplicate free array.
     * @example
     *
     * _.uniq([2, 1, 2]);
     * // => [2, 1]
     */

/**
     * Creates a flattened array of values by running each element in `collection`
     * thru `iteratee` and flattening the mapped results. The iteratee is invoked
     * with three arguments: (value, index|key, collection).
     *
     * @static
     * @memberOf _
     * @since 4.0.0
     * @category Collection
     * @param {Array|Object} collection The collection to iterate over.
     * @param {Function} [iteratee=_.identity] The function invoked per iteration.
     * @returns {Array} Returns the new flattened array.
     * @example
     *
     * function duplicate(n) {
     *   return [n, n];
     * }
     *
     * _.flatMap([1, 2], duplicate);
     * // => [1, 1, 2, 2]
     */

/**
     * Creates a function like `_.assign`.
     *
     * @private
     * @param {Function} assigner The function to assign values.
     * @returns {Function} Returns the new assigner function.
     */

/**
     * Creates a function like `_.camelCase`.
     *
     * @private
     * @param {Function} callback The function to combine each word.
     * @returns {Function} Returns the new compounder function.
     */

/**
     * Creates a function like `_.groupBy`.
     *
     * @private
     * @param {Function} setter The function to set accumulator values.
     * @param {Function} [initializer] The accumulator object initializer.
     * @returns {Function} Returns the new aggregator function.
     */

/**
     * Creates a function like `_.invertBy`.
     *
     * @private
     * @param {Function} setter The function to set accumulator values.
     * @param {Function} toIteratee The function to resolve iteratees.
     * @returns {Function} Returns the new inverter function.
     */

/**
     * Creates a function like `_.lowerFirst`.
     *
     * @private
     * @param {string} methodName The name of the `String` case method to use.
     * @returns {Function} Returns the new case function.
     */

/**
     * Creates a function like `_.over`.
     *
     * @private
     * @param {Function} arrayFunc The function to iterate over iteratees.
     * @returns {Function} Returns the new over function.
     */

/**
     * Creates a function like `_.round`.
     *
     * @private
     * @param {string} methodName The name of the `Math` method to use when rounding.
     * @returns {Function} Returns the new round function.
     */

/**
     * Creates a function that accepts arguments of `func` and either invokes
     * `func` returning its result, if at least `arity` number of arguments have
     * been provided, or returns a function that accepts the remaining `func`
     * arguments, and so on. The arity of `func` may be specified if `func.length`
     * is not sufficient.
     *
     * The `_.curry.placeholder` value, which defaults to `_` in monolithic builds,
     * may be used as a placeholder for provided arguments.
     *
     * **Note:** This method doesn't set the "length" property of curried functions.
     *
     * @static
     * @memberOf _
     * @since 2.0.0
     * @category Function
     * @param {Function} func The function to curry.
     * @param {number} [arity=func.length] The arity of `func`.
     * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`.
     * @returns {Function} Returns the new curried function.
     * @example
     *
     * var abc = function(a, b, c) {
     *   return [a, b, c];
     * };
     *
     * var curried = _.curry(abc);
     *
     * curried(1)(2)(3);
     * // => [1, 2, 3]
     *
     * curried(1, 2)(3);
     * // => [1, 2, 3]
     *
     * curried(1, 2, 3);
     * // => [1, 2, 3]
     *
     * // Curried with placeholders.
     * curried(1)(_, 3)(2);
     * // => [1, 2, 3]
     */

/**
     * Creates a function that accepts up to one argument, ignoring any
     * additional arguments.
     *
     * @static
     * @memberOf _
     * @since 4.0.0
     * @category Function
     * @param {Function} func The function to cap arguments for.
     * @returns {Function} Returns the new capped function.
     * @example
     *
     * _.map(['6', '8', '10'], _.unary(parseInt));
     * // => [6, 8, 10]
     */

/**
     * Creates a function that checks if **all** of the `predicates` return
     * truthy when invoked with the arguments it receives.
     *
     * Following shorthands are possible for providing predicates.
     * Pass an `Object` and it will be used as an parameter for `_.matches` to create the predicate.
     * Pass an `Array` of parameters for `_.matchesProperty` and the predicate will be created using them.
     *
     * @static
     * @memberOf _
     * @since 4.0.0
     * @category Util
     * @param {...(Function|Function[])} [predicates=[_.identity]]
     *  The predicates to check.
     * @returns {Function} Returns the new function.
     * @example
     *
     * var func = _.overEvery([Boolean, isFinite]);
     *
     * func('1');
     * // => true
     *
     * func(null);
     * // => false
     *
     * func(NaN);
     * // => false
     */

/**
     * Creates a function that either curries or invokes `func` with optional
     * `this` binding and partially applied arguments.
     *
     * @private
     * @param {Function|string} func The function or method name to wrap.
     * @param {number} bitmask The bitmask flags.
     *    1 - `_.bind`
     *    2 - `_.bindKey`
     *    4 - `_.curry` or `_.curryRight` of a bound function
     *    8 - `_.curry`
     *   16 - `_.curryRight`
     *   32 - `_.partial`
     *   64 - `_.partialRight`
     *  128 - `_.rearg`
     *  256 - `_.ary`
     *  512 - `_.flip`
     * @param {*} [thisArg] The `this` binding of `func`.
     * @param {Array} [partials] The arguments to be partially applied.
     * @param {Array} [holders] The `partials` placeholder indexes.
     * @param {Array} [argPos] The argument positions of the new function.
     * @param {number} [ary] The arity cap of `func`.
     * @param {number} [arity] The arity of `func`.
     * @returns {Function} Returns the new wrapped function.
     */

/**
     * Creates a function that gets the argument at index `n`. If `n` is negative,
     * the nth argument from the end is returned.
     *
     * @static
     * @memberOf _
     * @since 4.0.0
     * @category Util
     * @param {number} [n=0] The index of the argument to return.
     * @returns {Function} Returns the new pass-thru function.
     * @example
     *
     * var func = _.nthArg(1);
     * func('a', 'b', 'c', 'd');
     * // => 'b'
     *
     * var func = _.nthArg(-2);
     * func('a', 'b', 'c', 'd');
     * // => 'c'
     */

/**
     * Creates a function that invokes `func` with `partials` prepended to the
     * arguments it receives. This method is like `_.bind` except it does **not**
     * alter the `this` binding.
     *
     * The `_.partial.placeholder` value, which defaults to `_` in monolithic
     * builds, may be used as a placeholder for partially applied arguments.
     *
     * **Note:** This method doesn't set the "length" property of partially
     * applied functions.
     *
     * @static
     * @memberOf _
     * @since 0.2.0
     * @category Function
     * @param {Function} func The function to partially apply arguments to.
     * @param {...*} [partials] The arguments to be partially applied.
     * @returns {Function} Returns the new partially applied function.
     * @example
     *
     * function greet(greeting, name) {
     *   return greeting + ' ' + name;
     * }
     *
     * var sayHelloTo = _.partial(greet, 'hello');
     * sayHelloTo('fred');
     * // => 'hello fred'
     *
     * // Partially applied with placeholders.
     * var greetFred = _.partial(greet, _, 'fred');
     * greetFred('hi');
     * // => 'hi fred'
     */

/**
     * Creates a function that invokes `func` with arguments reversed.
     *
     * @static
     * @memberOf _
     * @since 4.0.0
     * @category Function
     * @param {Function} func The function to flip arguments for.
     * @returns {Function} Returns the new flipped function.
     * @example
     *
     * var flipped = _.flip(function() {
     *   return _.toArray(arguments);
     * });
     *
     * flipped('a', 'b', 'c', 'd');
     * // => ['d', 'c', 'b', 'a']
     */

/**
     * Creates a function that invokes `func` with its arguments transformed.
     *
     * @static
     * @since 4.0.0
     * @memberOf _
     * @category Function
     * @param {Function} func The function to wrap.
     * @param {...(Function|Function[])} [transforms=[_.identity]]
     *  The argument transforms.
     * @returns {Function} Returns the new function.
     * @example
     *
     * function doubled(n) {
     *   return n * 2;
     * }
     *
     * function square(n) {
     *   return n * n;
     * }
     *
     * var func = _.overArgs(function(x, y) {
     *   return [x, y];
     * }, [square, doubled]);
     *
     * func(9, 3);
     * // => [81, 6]
     *
     * func(10, 5);
     * // => [100, 10]
     */

/**
     * Creates a function that invokes `func` with the `this` binding of `thisArg`
     * and `partials` prepended to the arguments it receives.
     *
     * The `_.bind.placeholder` value, which defaults to `_` in monolithic builds,
     * may be used as a placeholder for partially applied arguments.
     *
     * **Note:** Unlike native `Function#bind`, this method doesn't set the "length"
     * property of bound functions.
     *
     * @static
     * @memberOf _
     * @since 0.1.0
     * @category Function
     * @param {Function} func The function to bind.
     * @param {*} thisArg The `this` binding of `func`.
     * @param {...*} [partials] The arguments to be partially applied.
     * @returns {Function} Returns the new bound function.
     * @example
     *
     * function greet(greeting, punctuation) {
     *   return greeting + ' ' + this.user + punctuation;
     * }
     *
     * var object = { 'user': 'fred' };
     *
     * var bound = _.bind(greet, object, 'hi');
     * bound('!');
     * // => 'hi fred!'
     *
     * // Bound with placeholders.
     * var bound = _.bind(greet, object, _, '!');
     * bound('hi');
     * // => 'hi fred!'
     */

/**
     * Creates a function that invokes `func` with the `this` binding of the
     * create function and an array of arguments much like
     * [`Function#apply`](http://www.ecma-international.org/ecma-262/7.0/#sec-function.prototype.apply).
     *
     * **Note:** This method is based on the
     * [spread operator](https://mdn.io/spread_operator).
     *
     * @static
     * @memberOf _
     * @since 3.2.0
     * @category Function
     * @param {Function} func The function to spread arguments over.
     * @param {number} [start=0] The start position of the spread.
     * @returns {Function} Returns the new function.
     * @example
     *
     * var say = _.spread(function(who, what) {
     *   return who + ' says ' + what;
     * });
     *
     * say(['fred', 'hello']);
     * // => 'fred says hello'
     *
     * var numbers = Promise.all([
     *   Promise.resolve(40),
     *   Promise.resolve(36)
     * ]);
     *
     * numbers.then(_.spread(function(x, y) {
     *   return x + y;
     * }));
     * // => a Promise of 76
     */

/**
     * Creates a function that invokes `func` with the `this` binding of the
     * created function and arguments from `start` and beyond provided as
     * an array.
     *
     * **Note:** This method is based on the
     * [rest parameter](https://mdn.io/rest_parameters).
     *
     * @static
     * @memberOf _
     * @since 4.0.0
     * @category Function
     * @param {Function} func The function to apply a rest parameter to.
     * @param {number} [start=func.length-1] The start position of the rest parameter.
     * @returns {Function} Returns the new function.
     * @example
     *
     * var say = _.rest(function(what, names) {
     *   return what + ' ' + _.initial(names).join(', ') +
     *     (_.size(names) > 1 ? ', & ' : '') + _.last(names);
     * });
     *
     * say('hello', 'fred', 'barney', 'pebbles');
     * // => 'hello fred, barney, & pebbles'
     */

/**
     * Creates a function that invokes `func` with the arguments of the created
     * function. If `func` is a property name, the created function returns the
     * property value for a given element. If `func` is an array or object, the
     * created function returns `true` for elements that contain the equivalent
     * source properties, otherwise it returns `false`.
     *
     * @static
     * @since 4.0.0
     * @memberOf _
     * @category Util
     * @param {*} [func=_.identity] The value to convert to a callback.
     * @returns {Function} Returns the callback.
     * @example
     *
     * var users = [
     *   { 'user': 'barney', 'age': 36, 'active': true },
     *   { 'user': 'fred',   'age': 40, 'active': false }
     * ];
     *
     * // The `_.matches` iteratee shorthand.
     * _.filter(users, _.iteratee({ 'user': 'barney', 'active': true }));
     * // => [{ 'user': 'barney', 'age': 36, 'active': true }]
     *
     * // The `_.matchesProperty` iteratee shorthand.
     * _.filter(users, _.iteratee(['user', 'fred']));
     * // => [{ 'user': 'fred', 'age': 40 }]
     *
     * // The `_.property` iteratee shorthand.
     * _.map(users, _.iteratee('user'));
     * // => ['barney', 'fred']
     *
     * // Create custom iteratee shorthands.
     * _.iteratee = _.wrap(_.iteratee, function(iteratee, func) {
     *   return !_.isRegExp(func) ? iteratee(func) : function(string) {
     *     return func.test(string);
     *   };
     * });
     *
     * _.filter(['abc', 'def'], /ef/);
     * // => ['def']
     */

/**
     * Creates a function that invokes `func`, with the `this` binding and arguments
     * of the created function, while it's called less than `n` times. Subsequent
     * calls to the created function return the result of the last `func` invocation.
     *
     * @static
     * @memberOf _
     * @since 3.0.0
     * @category Function
     * @param {number} n The number of calls at which `func` is no longer invoked.
     * @param {Function} func The function to restrict.
     * @returns {Function} Returns the new restricted function.
     * @example
     *
     * jQuery(element).on('click', _.before(5, addContactToList));
     * // => Allows adding up to 4 contacts to the list.
     */

/**
     * Creates a function that invokes `func`, with up to `n` arguments,
     * ignoring any additional arguments.
     *
     * @static
     * @memberOf _
     * @since 3.0.0
     * @category Function
     * @param {Function} func The function to cap arguments for.
     * @param {number} [n=func.length] The arity cap.
     * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`.
     * @returns {Function} Returns the new capped function.
     * @example
     *
     * _.map(['6', '8', '10'], _.ary(parseInt, 1));
     * // => [6, 8, 10]
     */

/**
     * Creates a function that invokes `iteratees` with the arguments it receives
     * and returns their results.
     *
     * @static
     * @memberOf _
     * @since 4.0.0
     * @category Util
     * @param {...(Function|Function[])} [iteratees=[_.identity]]
     *  The iteratees to invoke.
     * @returns {Function} Returns the new function.
     * @example
     *
     * var func = _.over([Math.max, Math.min]);
     *
     * func(1, 2, 3, 4);
     * // => [4, 1]
     */

/**
     * Creates a function that invokes the method at `object[key]` with `partials`
     * prepended to the arguments it receives.
     *
     * This method differs from `_.bind` by allowing bound functions to reference
     * methods that may be redefined or don't yet exist. See
     * [Peter Michaux's article](http://peter.michaux.ca/articles/lazy-function-definition-pattern)
     * for more details.
     *
     * The `_.bindKey.placeholder` value, which defaults to `_` in monolithic
     * builds, may be used as a placeholder for partially applied arguments.
     *
     * @static
     * @memberOf _
     * @since 0.10.0
     * @category Function
     * @param {Object} object The object to invoke the method on.
     * @param {string} key The key of the method.
     * @param {...*} [partials] The arguments to be partially applied.
     * @returns {Function} Returns the new bound function.
     * @example
     *
     * var object = {
     *   'user': 'fred',
     *   'greet': function(greeting, punctuation) {
     *     return greeting + ' ' + this.user + punctuation;
     *   }
     * };
     *
     * var bound = _.bindKey(object, 'greet', 'hi');
     * bound('!');
     * // => 'hi fred!'
     *
     * object.greet = function(greeting, punctuation) {
     *   return greeting + 'ya ' + this.user + punctuation;
     * };
     *
     * bound('!');
     * // => 'hiya fred!'
     *
     * // Bound with placeholders.
     * var bound = _.bindKey(object, 'greet', _, '!');
     * bound('hi');
     * // => 'hiya fred!'
     */

/**
     * Creates a function that invokes the method at `path` of a given object.
     * Any additional arguments are provided to the invoked method.
     *
     * @static
     * @memberOf _
     * @since 3.7.0
     * @category Util
     * @param {Array|string} path The path of the method to invoke.
     * @param {...*} [args] The arguments to invoke the method with.
     * @returns {Function} Returns the new invoker function.
     * @example
     *
     * var objects = [
     *   { 'a': { 'b': _.constant(2) } },
     *   { 'a': { 'b': _.constant(1) } }
     * ];
     *
     * _.map(objects, _.method('a.b'));
     * // => [2, 1]
     *
     * _.map(objects, _.method(['a', 'b']));
     * // => [2, 1]
     */

/**
     * Creates a function that invokes the predicate properties of `source` with
     * the corresponding property values of a given object, returning `true` if
     * all predicates return truthy, else `false`.
     *
     * **Note:** The created function is equivalent to `_.conformsTo` with
     * `source` partially applied.
     *
     * @static
     * @memberOf _
     * @since 4.0.0
     * @category Util
     * @param {Object} source The object of property predicates to conform to.
     * @returns {Function} Returns the new spec function.
     * @example
     *
     * var objects = [
     *   { 'a': 2, 'b': 1 },
     *   { 'a': 1, 'b': 2 }
     * ];
     *
     * _.filter(objects, _.conforms({ 'b': function(n) { return n > 1; } }));
     * // => [{ 'a': 1, 'b': 2 }]
     */

/**
     * Creates a function that is restricted to invoking `func` once. Repeat calls
     * to the function return the value of the first invocation. The `func` is
     * invoked with the `this` binding and arguments of the created function.
     *
     * @static
     * @memberOf _
     * @since 0.1.0
     * @category Function
     * @param {Function} func The function to restrict.
     * @returns {Function} Returns the new restricted function.
     * @example
     *
     * var initialize = _.once(createApplication);
     * initialize();
     * initialize();
     * // => `createApplication` is invoked once
     */

/**
     * Creates a function that iterates over `pairs` and invokes the corresponding
     * function of the first predicate to return truthy. The predicate-function
     * pairs are invoked with the `this` binding and arguments of the created
     * function.
     *
     * @static
     * @memberOf _
     * @since 4.0.0
     * @category Util
     * @param {Array} pairs The predicate-function pairs.
     * @returns {Function} Returns the new composite function.
     * @example
     *
     * var func = _.cond([
     *   [_.matches({ 'a': 1 }),           _.constant('matches A')],
     *   [_.conforms({ 'b': _.isNumber }), _.constant('matches B')],
     *   [_.stubTrue,                      _.constant('no match')]
     * ]);
     *
     * func({ 'a': 1, 'b': 2 });
     * // => 'matches A'
     *
     * func({ 'a': 0, 'b': 1 });
     * // => 'matches B'
     *
     * func({ 'a': '1', 'b': '2' });
     * // => 'no match'
     */

/**
     * Creates a function that memoizes the result of `func`. If `resolver` is
     * provided, it determines the cache key for storing the result based on the
     * arguments provided to the memoized function. By default, the first argument
     * provided to the memoized function is used as the map cache key. The `func`
     * is invoked with the `this` binding of the memoized function.
     *
     * **Note:** The cache is exposed as the `cache` property on the memoized
     * function. Its creation may be customized by replacing the `_.memoize.Cache`
     * constructor with one whose instances implement the
     * [`Map`](http://ecma-international.org/ecma-262/7.0/#sec-properties-of-the-map-prototype-object)
     * method interface of `clear`, `delete`, `get`, `has`, and `set`.
     *
     * @static
     * @memberOf _
     * @since 0.1.0
     * @category Function
     * @param {Function} func The function to have its output memoized.
     * @param {Function} [resolver] The function to resolve the cache key.
     * @returns {Function} Returns the new memoized function.
     * @example
     *
     * var object = { 'a': 1, 'b': 2 };
     * var other = { 'c': 3, 'd': 4 };
     *
     * var values = _.memoize(_.values);
     * values(object);
     * // => [1, 2]
     *
     * values(other);
     * // => [3, 4]
     *
     * object.a = 2;
     * values(object);
     * // => [1, 2]
     *
     * // Modify the result cache.
     * values.cache.set(object, ['a', 'b']);
     * values(object);
     * // => ['a', 'b']
     *
     * // Replace `_.memoize.Cache`.
     * _.memoize.Cache = WeakMap;
     */

/**
     * Creates a function that negates the result of the predicate `func`. The
     * `func` predicate is invoked with the `this` binding and arguments of the
     * created function.
     *
     * @static
     * @memberOf _
     * @since 3.0.0
     * @category Function
     * @param {Function} predicate The predicate to negate.
     * @returns {Function} Returns the new negated function.
     * @example
     *
     * function isEven(n) {
     *   return n % 2 == 0;
     * }
     *
     * _.filter([1, 2, 3, 4, 5, 6], _.negate(isEven));
     * // => [1, 3, 5]
     */

/**
     * Creates a function that performs a mathematical operation on two values.
     *
     * @private
     * @param {Function} operator The function to perform the operation.
     * @param {number} [defaultValue] The value used for `undefined` arguments.
     * @returns {Function} Returns the new mathematical operation function.
     */

/**
     * Creates a function that performs a partial deep comparison between a given
     * object and `source`, returning `true` if the given object has equivalent
     * property values, else `false`.
     *
     * **Note:** The created function is equivalent to `_.isMatch` with `source`
     * partially applied.
     *
     * Partial comparisons will match empty array and empty object `source`
     * values against any array or object value, respectively. See `_.isEqual`
     * for a list of supported value comparisons.
     *
     * **Note:** Multiple values can be checked by combining several matchers
     * using `_.overSome`
     *
     * @static
     * @memberOf _
     * @since 3.0.0
     * @category Util
     * @param {Object} source The object of property values to match.
     * @returns {Function} Returns the new spec function.
     * @example
     *
     * var objects = [
     *   { 'a': 1, 'b': 2, 'c': 3 },
     *   { 'a': 4, 'b': 5, 'c': 6 }
     * ];
     *
     * _.filter(objects, _.matches({ 'a': 4, 'c': 6 }));
     * // => [{ 'a': 4, 'b': 5, 'c': 6 }]
     *
     * // Checking for several possible values
     * _.filter(objects, _.overSome([_.matches({ 'a': 1 }), _.matches({ 'a': 4 })]));
     * // => [{ 'a': 1, 'b': 2, 'c': 3 }, { 'a': 4, 'b': 5, 'c': 6 }]
     */

/**
     * Creates a function that performs a partial deep comparison between the
     * value at `path` of a given object to `srcValue`, returning `true` if the
     * object value is equivalent, else `false`.
     *
     * **Note:** Partial comparisons will match empty array and empty object
     * `srcValue` values against any array or object value, respectively. See
     * `_.isEqual` for a list of supported value comparisons.
     *
     * **Note:** Multiple values can be checked by combining several matchers
     * using `_.overSome`
     *
     * @static
     * @memberOf _
     * @since 3.2.0
     * @category Util
     * @param {Array|string} path The path of the property to get.
     * @param {*} srcValue The value to match.
     * @returns {Function} Returns the new spec function.
     * @example
     *
     * var objects = [
     *   { 'a': 1, 'b': 2, 'c': 3 },
     *   { 'a': 4, 'b': 5, 'c': 6 }
     * ];
     *
     * _.find(objects, _.matchesProperty('a', 4));
     * // => { 'a': 4, 'b': 5, 'c': 6 }
     *
     * // Checking for several possible values
     * _.filter(objects, _.overSome([_.matchesProperty('a', 1), _.matchesProperty('a', 4)]));
     * // => [{ 'a': 1, 'b': 2, 'c': 3 }, { 'a': 4, 'b': 5, 'c': 6 }]
     */

/**
     * Creates a function that performs a relational operation on two values.
     *
     * @private
     * @param {Function} operator The function to perform the operation.
     * @returns {Function} Returns the new relational operation function.
     */

/**
     * Creates a function that produces an instance of `Ctor` regardless of
     * whether it was invoked as part of a `new` expression or by `call` or `apply`.
     *
     * @private
     * @param {Function} Ctor The constructor to wrap.
     * @returns {Function} Returns the new wrapped function.
     */

/**
     * Creates a function that provides `value` to `wrapper` as its first
     * argument. Any additional arguments provided to the function are appended
     * to those provided to the `wrapper`. The wrapper is invoked with the `this`
     * binding of the created function.
     *
     * @static
     * @memberOf _
     * @since 0.1.0
     * @category Function
     * @param {*} value The value to wrap.
     * @param {Function} [wrapper=identity] The wrapper function.
     * @returns {Function} Returns the new function.
     * @example
     *
     * var p = _.wrap(_.escape, function(func, text) {
     *   return '<p>' + func(text) + '</p>';
     * });
     *
     * p('fred, barney, & pebbles');
     * // => '<p>fred, barney, &amp; pebbles</p>'
     */

/**
     * Creates a function that returns `value`.
     *
     * @static
     * @memberOf _
     * @since 2.4.0
     * @category Util
     * @param {*} value The value to return from the new function.
     * @returns {Function} Returns the new constant function.
     * @example
     *
     * var objects = _.times(2, _.constant({ 'a': 1 }));
     *
     * console.log(objects);
     * // => [{ 'a': 1 }, { 'a': 1 }]
     *
     * console.log(objects[0] === objects[1]);
     * // => true
     */

/**
     * Creates a function that returns the result of invoking the given functions
     * with the `this` binding of the created function, where each successive
     * invocation is supplied the return value of the previous.
     *
     * @static
     * @memberOf _
     * @since 3.0.0
     * @category Util
     * @param {...(Function|Function[])} [funcs] The functions to invoke.
     * @returns {Function} Returns the new composite function.
     * @see _.flowRight
     * @example
     *
     * function square(n) {
     *   return n * n;
     * }
     *
     * var addSquare = _.flow([_.add, square]);
     * addSquare(1, 2);
     * // => 9
     */

/**
     * Creates a function that returns the value at `path` of a given object.
     *
     * @static
     * @memberOf _
     * @since 2.4.0
     * @category Util
     * @param {Array|string} path The path of the property to get.
     * @returns {Function} Returns the new accessor function.
     * @example
     *
     * var objects = [
     *   { 'a': { 'b': 2 } },
     *   { 'a': { 'b': 1 } }
     * ];
     *
     * _.map(objects, _.property('a.b'));
     * // => [2, 1]
     *
     * _.map(_.sortBy(objects, _.property(['a', 'b'])), 'a.b');
     * // => [1, 2]
     */

/**
     * Creates a function that wraps `func` to continue currying.
     *
     * @private
     * @param {Function} func The function to wrap.
     * @param {number} bitmask The bitmask flags. See `createWrap` for more details.
     * @param {Function} wrapFunc The function to create the `func` wrapper.
     * @param {*} placeholder The placeholder value.
     * @param {*} [thisArg] The `this` binding of `func`.
     * @param {Array} [partials] The arguments to prepend to those provided to
     *  the new function.
     * @param {Array} [holders] The `partials` placeholder indexes.
     * @param {Array} [argPos] The argument positions of the new function.
     * @param {number} [ary] The arity cap of `func`.
     * @param {number} [arity] The arity of `func`.
     * @returns {Function} Returns the new wrapped function.
     */

/**
     * Creates a function that wraps `func` to enable currying.
     *
     * @private
     * @param {Function} func The function to wrap.
     * @param {number} bitmask The bitmask flags. See `createWrap` for more details.
     * @param {number} arity The arity of `func`.
     * @returns {Function} Returns the new wrapped function.
     */

/**
     * Creates a function that wraps `func` to invoke it with optional `this`
     * binding of `thisArg`, partial application, and currying.
     *
     * @private
     * @param {Function|string} func The function or method name to wrap.
     * @param {number} bitmask The bitmask flags. See `createWrap` for more details.
     * @param {*} [thisArg] The `this` binding of `func`.
     * @param {Array} [partials] The arguments to prepend to those provided to
     *  the new function.
     * @param {Array} [holders] The `partials` placeholder indexes.
     * @param {Array} [partialsRight] The arguments to append to those provided
     *  to the new function.
     * @param {Array} [holdersRight] The `partialsRight` placeholder indexes.
     * @param {Array} [argPos] The argument positions of the new function.
     * @param {number} [ary] The arity cap of `func`.
     * @param {number} [arity] The arity of `func`.
     * @returns {Function} Returns the new wrapped function.
     */

/**
     * Creates a function that wraps `func` to invoke it with the `this` binding
     * of `thisArg` and `partials` prepended to the arguments it receives.
     *
     * @private
     * @param {Function} func The function to wrap.
     * @param {number} bitmask The bitmask flags. See `createWrap` for more details.
     * @param {*} thisArg The `this` binding of `func`.
     * @param {Array} partials The arguments to prepend to those provided to
     *  the new function.
     * @returns {Function} Returns the new wrapped function.
     */

/**
     * Creates a function that wraps `func` to invoke it with the optional `this`
     * binding of `thisArg`.
     *
     * @private
     * @param {Function} func The function to wrap.
     * @param {number} bitmask The bitmask flags. See `createWrap` for more details.
     * @param {*} [thisArg] The `this` binding of `func`.
     * @returns {Function} Returns the new wrapped function.
     */

/**
     * Creates a function that'll short out and invoke `identity` instead
     * of `func` when it's called `HOT_COUNT` or more times in `HOT_SPAN`
     * milliseconds.
     *
     * @private
     * @param {Function} func The function to restrict.
     * @returns {Function} Returns the new shortable function.
     */

/**
     * Creates a hash object.
     *
     * @private
     * @constructor
     * @param {Array} [entries] The key-value pairs to cache.
     */

/**
     * Creates a lazy wrapper object which wraps `value` to enable lazy evaluation.
     *
     * @private
     * @constructor
     * @param {*} value The value to wrap.
     */

/**
     * Creates a map cache object to store key-value pairs.
     *
     * @private
     * @constructor
     * @param {Array} [entries] The key-value pairs to cache.
     */

/**
     * Creates a new array concatenating `array` with any additional arrays
     * and/or values.
     *
     * @static
     * @memberOf _
     * @since 4.0.0
     * @category Array
     * @param {Array} array The array to concatenate.
     * @param {...*} [values] The values to concatenate.
     * @returns {Array} Returns the new concatenated array.
     * @example
     *
     * var array = [1];
     * var other = _.concat(array, 2, [3], [[4]]);
     *
     * console.log(other);
     * // => [1, 2, 3, [4]]
     *
     * console.log(array);
     * // => [1]
     */

/**
     * Creates a set object of `values`.
     *
     * @private
     * @param {Array} values The values to add to the set.
     * @returns {Object} Returns the new set.
     */

/**
     * Creates a shallow clone of `value`.
     *
     * **Note:** This method is loosely based on the
     * [structured clone algorithm](https://mdn.io/Structured_clone_algorithm)
     * and supports cloning arrays, array buffers, booleans, date objects, maps,
     * numbers, `Object` objects, regexes, sets, strings, symbols, and typed
     * arrays. The own enumerable properties of `arguments` objects are cloned
     * as plain objects. An empty object is returned for uncloneable values such
     * as error objects, functions, DOM nodes, and WeakMaps.
     *
     * @static
     * @memberOf _
     * @since 0.1.0
     * @category Lang
     * @param {*} value The value to clone.
     * @returns {*} Returns the cloned value.
     * @see _.cloneDeep
     * @example
     *
     * var objects = [{ 'a': 1 }, { 'b': 2 }];
     *
     * var shallow = _.clone(objects);
     * console.log(shallow[0] === objects[0]);
     * // => true
     */

/**
     * Creates a slice of `array` excluding elements dropped from the beginning.
     * Elements are dropped until `predicate` returns falsey. The predicate is
     * invoked with three arguments: (value, index, array).
     *
     * @static
     * @memberOf _
     * @since 3.0.0
     * @category Array
     * @param {Array} array The array to query.
     * @param {Function} [predicate=_.identity] The function invoked per iteration.
     * @returns {Array} Returns the slice of `array`.
     * @example
     *
     * var users = [
     *   { 'user': 'barney',  'active': false },
     *   { 'user': 'fred',    'active': false },
     *   { 'user': 'pebbles', 'active': true }
     * ];
     *
     * _.dropWhile(users, function(o) { return !o.active; });
     * // => objects for ['pebbles']
     *
     * // The `_.matches` iteratee shorthand.
     * _.dropWhile(users, { 'user': 'barney', 'active': false });
     * // => objects for ['fred', 'pebbles']
     *
     * // The `_.matchesProperty` iteratee shorthand.
     * _.dropWhile(users, ['active', false]);
     * // => objects for ['pebbles']
     *
     * // The `_.property` iteratee shorthand.
     * _.dropWhile(users, 'active');
     * // => objects for ['barney', 'fred', 'pebbles']
     */

/**
     * Creates a slice of `array` excluding elements dropped from the end.
     * Elements are dropped until `predicate` returns falsey. The predicate is
     * invoked with three arguments: (value, index, array).
     *
     * @static
     * @memberOf _
     * @since 3.0.0
     * @category Array
     * @param {Array} array The array to query.
     * @param {Function} [predicate=_.identity] The function invoked per iteration.
     * @returns {Array} Returns the slice of `array`.
     * @example
     *
     * var users = [
     *   { 'user': 'barney',  'active': true },
     *   { 'user': 'fred',    'active': false },
     *   { 'user': 'pebbles', 'active': false }
     * ];
     *
     * _.dropRightWhile(users, function(o) { return !o.active; });
     * // => objects for ['barney']
     *
     * // The `_.matches` iteratee shorthand.
     * _.dropRightWhile(users, { 'user': 'pebbles', 'active': false });
     * // => objects for ['barney', 'fred']
     *
     * // The `_.matchesProperty` iteratee shorthand.
     * _.dropRightWhile(users, ['active', false]);
     * // => objects for ['barney']
     *
     * // The `_.property` iteratee shorthand.
     * _.dropRightWhile(users, 'active');
     * // => objects for ['barney', 'fred', 'pebbles']
     */

/**
     * Creates a slice of `array` from `start` up to, but not including, `end`.
     *
     * **Note:** This method is used instead of
     * [`Array#slice`](https://mdn.io/Array/slice) to ensure dense arrays are
     * returned.
     *
     * @static
     * @memberOf _
     * @since 3.0.0
     * @category Array
     * @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`.
     */

/**
     * Creates a slice of `array` with `n` elements dropped from the beginning.
     *
     * @static
     * @memberOf _
     * @since 0.5.0
     * @category Array
     * @param {Array} array The array to query.
     * @param {number} [n=1] The number of elements to drop.
     * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`.
     * @returns {Array} Returns the slice of `array`.
     * @example
     *
     * _.drop([1, 2, 3]);
     * // => [2, 3]
     *
     * _.drop([1, 2, 3], 2);
     * // => [3]
     *
     * _.drop([1, 2, 3], 5);
     * // => []
     *
     * _.drop([1, 2, 3], 0);
     * // => [1, 2, 3]
     */

/**
     * Creates a slice of `array` with `n` elements dropped from the end.
     *
     * @static
     * @memberOf _
     * @since 3.0.0
     * @category Array
     * @param {Array} array The array to query.
     * @param {number} [n=1] The number of elements to drop.
     * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`.
     * @returns {Array} Returns the slice of `array`.
     * @example
     *
     * _.dropRight([1, 2, 3]);
     * // => [1, 2]
     *
     * _.dropRight([1, 2, 3], 2);
     * // => [1]
     *
     * _.dropRight([1, 2, 3], 5);
     * // => []
     *
     * _.dropRight([1, 2, 3], 0);
     * // => [1, 2, 3]
     */

/**
     * Creates a slice of `array` with `n` elements taken from the beginning.
     *
     * @static
     * @memberOf _
     * @since 0.1.0
     * @category Array
     * @param {Array} array The array to query.
     * @param {number} [n=1] The number of elements to take.
     * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`.
     * @returns {Array} Returns the slice of `array`.
     * @example
     *
     * _.take([1, 2, 3]);
     * // => [1]
     *
     * _.take([1, 2, 3], 2);
     * // => [1, 2]
     *
     * _.take([1, 2, 3], 5);
     * // => [1, 2, 3]
     *
     * _.take([1, 2, 3], 0);
     * // => []
     */

/**
     * Creates a slice of `array` with `n` elements taken from the end.
     *
     * @static
     * @memberOf _
     * @since 3.0.0
     * @category Array
     * @param {Array} array The array to query.
     * @param {number} [n=1] The number of elements to take.
     * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`.
     * @returns {Array} Returns the slice of `array`.
     * @example
     *
     * _.takeRight([1, 2, 3]);
     * // => [3]
     *
     * _.takeRight([1, 2, 3], 2);
     * // => [2, 3]
     *
     * _.takeRight([1, 2, 3], 5);
     * // => [1, 2, 3]
     *
     * _.takeRight([1, 2, 3], 0);
     * // => []
     */

/**
     * Creates a slice of `array` with elements taken from the beginning. Elements
     * are taken until `predicate` returns falsey. The predicate is invoked with
     * three arguments: (value, index, array).
     *
     * @static
     * @memberOf _
     * @since 3.0.0
     * @category Array
     * @param {Array} array The array to query.
     * @param {Function} [predicate=_.identity] The function invoked per iteration.
     * @returns {Array} Returns the slice of `array`.
     * @example
     *
     * var users = [
     *   { 'user': 'barney',  'active': false },
     *   { 'user': 'fred',    'active': false },
     *   { 'user': 'pebbles', 'active': true }
     * ];
     *
     * _.takeWhile(users, function(o) { return !o.active; });
     * // => objects for ['barney', 'fred']
     *
     * // The `_.matches` iteratee shorthand.
     * _.takeWhile(users, { 'user': 'barney', 'active': false });
     * // => objects for ['barney']
     *
     * // The `_.matchesProperty` iteratee shorthand.
     * _.takeWhile(users, ['active', false]);
     * // => objects for ['barney', 'fred']
     *
     * // The `_.property` iteratee shorthand.
     * _.takeWhile(users, 'active');
     * // => []
     */

/**
     * Creates a slice of `array` with elements taken from the end. Elements are
     * taken until `predicate` returns falsey. The predicate is invoked with
     * three arguments: (value, index, array).
     *
     * @static
     * @memberOf _
     * @since 3.0.0
     * @category Array
     * @param {Array} array The array to query.
     * @param {Function} [predicate=_.identity] The function invoked per iteration.
     * @returns {Array} Returns the slice of `array`.
     * @example
     *
     * var users = [
     *   { 'user': 'barney',  'active': true },
     *   { 'user': 'fred',    'active': false },
     *   { 'user': 'pebbles', 'active': false }
     * ];
     *
     * _.takeRightWhile(users, function(o) { return !o.active; });
     * // => objects for ['fred', 'pebbles']
     *
     * // The `_.matches` iteratee shorthand.
     * _.takeRightWhile(users, { 'user': 'pebbles', 'active': false });
     * // => objects for ['pebbles']
     *
     * // The `_.matchesProperty` iteratee shorthand.
     * _.takeRightWhile(users, ['active', false]);
     * // => objects for ['fred', 'pebbles']
     *
     * // The `_.property` iteratee shorthand.
     * _.takeRightWhile(users, 'active');
     * // => []
     */

/**
     * Creates a stack cache object to store key-value pairs.
     *
     * @private
     * @constructor
     * @param {Array} [entries] The key-value pairs to cache.
     */

/**
     * Creates a template from source.
     *
     * This method should not be used as a generic way to load templates.
     *
     * @param {string} template The template name
     * @param {string} name An optional name for the template to be used in error messages
     *
     * @return {Promise<TwingTemplate>} A template instance representing the given template name
     *
     * @throws TwingErrorLoader When the template cannot be found
     * @throws TwingErrorSyntax When an error occurred during compilation
     */

/**
     * Creates a template function.
     *
     * @param {string} name Name of this function
     * @param {TwingCallable<any>} callable A callable implementing the function. If null, you need to overwrite the "expression_factory" option to customize compilation.
     * @param {TwingCallableArgument[]} acceptedArguments
     * @param {TwingCallableWrapperOptions} options Options
     */

/**
     * Creates a template test.
     *
     * @param {string} name Name of this test
     * @param {TwingCallable<boolean>} callable A callable implementing the test. If null, you need to overwrite the "node_class" option to customize compilation.
     * @param {TwingCallableArgument[]} acceptedArguments
     * @param {TwingCallableWrapperOptions} options Options
     */

/**
     * Creates a throttled function that only invokes `func` at most once per
     * every `wait` milliseconds. The throttled 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
     * throttled function. Subsequent calls to the throttled 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 throttled 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 `_.throttle` and `_.debounce`.
     *
     * @static
     * @memberOf _
     * @since 0.1.0
     * @category Function
     * @param {Function} func The function to throttle.
     * @param {number} [wait=0] The number of milliseconds to throttle invocations to.
     * @param {Object} [options={}] The options object.
     * @param {boolean} [options.leading=true]
     *  Specify invoking on the leading edge of the timeout.
     * @param {boolean} [options.trailing=true]
     *  Specify invoking on the trailing edge of the timeout.
     * @returns {Function} Returns the new throttled function.
     * @example
     *
     * // Avoid excessively updating the position while scrolling.
     * jQuery(window).on('scroll', _.throttle(updatePosition, 100));
     *
     * // Invoke `renewToken` when the click event is fired, but not more than once every 5 minutes.
     * var throttled = _.throttle(renewToken, 300000, { 'trailing': false });
     * jQuery(element).on('click', throttled);
     *
     * // Cancel the trailing throttled invocation.
     * jQuery(window).on('popstate', throttled.cancel);
     */

/**
     * Creates an array excluding all given values using
     * [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero)
     * for equality comparisons.
     *
     * **Note:** Unlike `_.pull`, this method returns a new array.
     *
     * @static
     * @memberOf _
     * @since 0.1.0
     * @category Array
     * @param {Array} array The array to inspect.
     * @param {...*} [values] The values to exclude.
     * @returns {Array} Returns the new array of filtered values.
     * @see _.difference, _.xor
     * @example
     *
     * _.without([2, 1, 2, 3], 1, 2);
     * // => [3]
     */

/**
     * Creates an array of `array` values not included in the other given arrays
     * using [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero)
     * for equality comparisons. The order and references of result values are
     * determined by the first array.
     *
     * **Note:** Unlike `_.pullAll`, this method returns a new array.
     *
     * @static
     * @memberOf _
     * @since 0.1.0
     * @category Array
     * @param {Array} array The array to inspect.
     * @param {...Array} [values] The values to exclude.
     * @returns {Array} Returns the new array of filtered values.
     * @see _.without, _.xor
     * @example
     *
     * _.difference([2, 1], [2, 3]);
     * // => [1]
     */

/**
     * Creates an array of elements split into groups the length of `size`.
     * If `array` can't be split evenly, the final chunk will be the remaining
     * elements.
     *
     * @static
     * @memberOf _
     * @since 3.0.0
     * @category Array
     * @param {Array} array The array to process.
     * @param {number} [size=1] The length of each chunk
     * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`.
     * @returns {Array} Returns the new array of chunks.
     * @example
     *
     * _.chunk(['a', 'b', 'c', 'd'], 2);
     * // => [['a', 'b'], ['c', 'd']]
     *
     * _.chunk(['a', 'b', 'c', 'd'], 3);
     * // => [['a', 'b', 'c'], ['d']]
     */

/**
     * Creates an array of elements split into two groups, the first of which
     * contains elements `predicate` returns truthy for, the second of which
     * contains elements `predicate` returns falsey for. The predicate is
     * invoked with one argument: (value).
     *
     * @static
     * @memberOf _
     * @since 3.0.0
     * @category Collection
     * @param {Array|Object} collection The collection to iterate over.
     * @param {Function} [predicate=_.identity] The function invoked per iteration.
     * @returns {Array} Returns the array of grouped elements.
     * @example
     *
     * var users = [
     *   { 'user': 'barney',  'age': 36, 'active': false },
     *   { 'user': 'fred',    'age': 40, 'active': true },
     *   { 'user': 'pebbles', 'age': 1,  'active': false }
     * ];
     *
     * _.partition(users, function(o) { return o.active; });
     * // => objects for [['fred'], ['barney', 'pebbles']]
     *
     * // The `_.matches` iteratee shorthand.
     * _.partition(users, { 'age': 1, 'active': false });
     * // => objects for [['pebbles'], ['barney', 'fred']]
     *
     * // The `_.matchesProperty` iteratee shorthand.
     * _.partition(users, ['active', false]);
     * // => objects for [['barney', 'pebbles'], ['fred']]
     *
     * // The `_.property` iteratee shorthand.
     * _.partition(users, 'active');
     * // => objects for [['fred'], ['barney', 'pebbles']]
     */

/**
     * Creates an array of elements, sorted in ascending order by the results of
     * running each element in a collection thru each iteratee. This method
     * performs a stable sort, that is, it preserves the original sort order of
     * equal elements. The iteratees are invoked with one argument: (value).
     *
     * @static
     * @memberOf _
     * @since 0.1.0
     * @category Collection
     * @param {Array|Object} collection The collection to iterate over.
     * @param {...(Function|Function[])} [iteratees=[_.identity]]
     *  The iteratees to sort by.
     * @returns {Array} Returns the new sorted array.
     * @example
     *
     * var users = [
     *   { 'user': 'fred',   'age': 48 },
     *   { 'user': 'barney', 'age': 36 },
     *   { 'user': 'fred',   'age': 30 },
     *   { 'user': 'barney', 'age': 34 }
     * ];
     *
     * _.sortBy(users, [function(o) { return o.user; }]);
     * // => objects for [['barney', 36], ['barney', 34], ['fred', 48], ['fred', 30]]
     *
     * _.sortBy(users, ['user', 'age']);
     * // => objects for [['barney', 34], ['barney', 36], ['fred', 30], ['fred', 48]]
     */

/**
     * Creates an array of function property names from own and inherited
     * enumerable properties of `object`.
     *
     * @static
     * @memberOf _
     * @since 4.0.0
     * @category Object
     * @param {Object} object The object to inspect.
     * @returns {Array} Returns the function names.
     * @see _.functions
     * @example
     *
     * function Foo() {
     *   this.a = _.constant('a');
     *   this.b = _.constant('b');
     * }
     *
     * Foo.prototype.c = _.constant('c');
     *
     * _.functionsIn(new Foo);
     * // => ['a', 'b', 'c']
     */

/**
     * Creates an array of function property names from own enumerable properties
     * of `object`.
     *
     * @static
     * @since 0.1.0
     * @memberOf _
     * @category Object
     * @param {Object} object The object to inspect.
     * @returns {Array} Returns the function names.
     * @see _.functionsIn
     * @example
     *
     * function Foo() {
     *   this.a = _.constant('a');
     *   this.b = _.constant('b');
     * }
     *
     * Foo.prototype.c = _.constant('c');
     *
     * _.functions(new Foo);
     * // => ['a', 'b']
     */

/**
     * Creates an array of numbers (positive and/or negative) progressing from
     * `start` up to, but not including, `end`. A step of `-1` is used if a negative
     * `start` is specified without an `end` or `step`. If `end` is not specified,
     * it's set to `start` with `start` then set to `0`.
     *
     * **Note:** JavaScript follows the IEEE-754 standard for resolving
     * floating-point values which can produce unexpected results.
     *
     * @static
     * @since 0.1.0
     * @memberOf _
     * @category Util
     * @param {number} [start=0] The start of the range.
     * @param {number} end The end of the range.
     * @param {number} [step=1] The value to increment or decrement by.
     * @returns {Array} Returns the range of numbers.
     * @see _.inRange, _.rangeRight
     * @example
     *
     * _.range(4);
     * // => [0, 1, 2, 3]
     *
     * _.range(-4);
     * // => [0, -1, -2, -3]
     *
     * _.range(1, 5);
     * // => [1, 2, 3, 4]
     *
     * _.range(0, 20, 5);
     * // => [0, 5, 10, 15]
     *
     * _.range(0, -4, -1);
     * // => [0, -1, -2, -3]
     *
     * _.range(1, 4, 0);
     * // => [1, 1, 1]
     *
     * _.range(0);
     * // => []
     */

/**
     * Creates an array of own and inherited enumerable property names and
     * symbols of `object`.
     *
     * @private
     * @param {Object} object The object to query.
     * @returns {Array} Returns the array of property names and symbols.
     */

/**
     * Creates an array of own and inherited enumerable string keyed-value pairs
     * for `object` which can be consumed by `_.fromPairs`. If `object` is a map
     * or set, its entries are returned.
     *
     * @static
     * @memberOf _
     * @since 4.0.0
     * @alias entriesIn
     * @category Object
     * @param {Object} object The object to query.
     * @returns {Array} Returns the key-value pairs.
     * @example
     *
     * function Foo() {
     *   this.a = 1;
     *   this.b = 2;
     * }
     *
     * Foo.prototype.c = 3;
     *
     * _.toPairsIn(new Foo);
     * // => [['a', 1], ['b', 2], ['c', 3]] (iteration order is not guaranteed)
     */

/**
     * Creates an array of own enumerable property names and symbols of `object`.
     *
     * @private
     * @param {Object} object The object to query.
     * @returns {Array} Returns the array of property names and symbols.
     */

/**
     * Creates an array of own enumerable string keyed-value pairs for `object`
     * which can be consumed by `_.fromPairs`. If `object` is a map or set, its
     * entries are returned.
     *
     * @static
     * @memberOf _
     * @since 4.0.0
     * @alias entries
     * @category Object
     * @param {Object} object The object to query.
     * @returns {Array} Returns the key-value pairs.
     * @example
     *
     * function Foo() {
     *   this.a = 1;
     *   this.b = 2;
     * }
     *
     * Foo.prototype.c = 3;
     *
     * _.toPairs(new Foo);
     * // => [['a', 1], ['b', 2]] (iteration order is not guaranteed)
     */

/**
     * Creates an array of shuffled values, using a version of the
     * [Fisher-Yates shuffle](https://en.wikipedia.org/wiki/Fisher-Yates_shuffle).
     *
     * @static
     * @memberOf _
     * @since 0.1.0
     * @category Collection
     * @param {Array|Object} collection The collection to shuffle.
     * @returns {Array} Returns the new shuffled array.
     * @example
     *
     * _.shuffle([1, 2, 3, 4]);
     * // => [4, 1, 3, 2]
     */

/**
     * Creates an array of the enumerable property names of the array-like `value`.
     *
     * @private
     * @param {*} value The value to query.
     * @param {boolean} inherited Specify returning inherited property names.
     * @returns {Array} Returns the array of property names.
     */

/**
     * Creates an array of the own and inherited enumerable property names of `object`.
     *
     * **Note:** Non-object values are coerced to objects.
     *
     * @static
     * @memberOf _
     * @since 3.0.0
     * @category Object
     * @param {Object} object The object to query.
     * @returns {Array} Returns the array of property names.
     * @example
     *
     * function Foo() {
     *   this.a = 1;
     *   this.b = 2;
     * }
     *
     * Foo.prototype.c = 3;
     *
     * _.keysIn(new Foo);
     * // => ['a', 'b', 'c'] (iteration order is not guaranteed)
     */

/**
     * Creates an array of the own and inherited enumerable string keyed property
     * values of `object`.
     *
     * **Note:** Non-object values are coerced to objects.
     *
     * @static
     * @memberOf _
     * @since 3.0.0
     * @category Object
     * @param {Object} object The object to query.
     * @returns {Array} Returns the array of property values.
     * @example
     *
     * function Foo() {
     *   this.a = 1;
     *   this.b = 2;
     * }
     *
     * Foo.prototype.c = 3;
     *
     * _.valuesIn(new Foo);
     * // => [1, 2, 3] (iteration order is not guaranteed)
     */

/**
     * Creates an array of the own and inherited enumerable symbols of `object`.
     *
     * @private
     * @param {Object} object The object to query.
     * @returns {Array} Returns the array of symbols.
     */

/**
     * Creates an array of the own enumerable property names of `object`.
     *
     * **Note:** Non-object values are coerced to objects. See the
     * [ES spec](http://ecma-international.org/ecma-262/7.0/#sec-object.keys)
     * for more details.
     *
     * @static
     * @since 0.1.0
     * @memberOf _
     * @category Object
     * @param {Object} object The object to query.
     * @returns {Array} Returns the array of property names.
     * @example
     *
     * function Foo() {
     *   this.a = 1;
     *   this.b = 2;
     * }
     *
     * Foo.prototype.c = 3;
     *
     * _.keys(new Foo);
     * // => ['a', 'b'] (iteration order is not guaranteed)
     *
     * _.keys('hi');
     * // => ['0', '1']
     */

/**
     * Creates an array of the own enumerable string keyed property values of `object`.
     *
     * **Note:** Non-object values are coerced to objects.
     *
     * @static
     * @since 0.1.0
     * @memberOf _
     * @category Object
     * @param {Object} object The object to query.
     * @returns {Array} Returns the array of property values.
     * @example
     *
     * function Foo() {
     *   this.a = 1;
     *   this.b = 2;
     * }
     *
     * Foo.prototype.c = 3;
     *
     * _.values(new Foo);
     * // => [1, 2] (iteration order is not guaranteed)
     *
     * _.values('hi');
     * // => ['h', 'i']
     */

/**
     * Creates an array of the own enumerable symbols of `object`.
     *
     * @private
     * @param {Object} object The object to query.
     * @returns {Array} Returns the array of symbols.
     */

/**
     * Creates an array of unique values that are included in all given arrays
     * using [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero)
     * for equality comparisons. The order and references of result values are
     * determined by the first array.
     *
     * @static
     * @memberOf _
     * @since 0.1.0
     * @category Array
     * @param {...Array} [arrays] The arrays to inspect.
     * @returns {Array} Returns the new array of intersecting values.
     * @example
     *
     * _.intersection([2, 1], [2, 3]);
     * // => [2]
     */

/**
     * Creates an array of unique values that is the
     * [symmetric difference](https://en.wikipedia.org/wiki/Symmetric_difference)
     * of the given arrays. The order of result values is determined by the order
     * they occur in the arrays.
     *
     * @static
     * @memberOf _
     * @since 2.4.0
     * @category Array
     * @param {...Array} [arrays] The arrays to inspect.
     * @returns {Array} Returns the new array of filtered values.
     * @see _.difference, _.without
     * @example
     *
     * _.xor([2, 1], [2, 3]);
     * // => [1, 3]
     */

/**
     * Creates an array of unique values, in order, from all given arrays using
     * [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero)
     * for equality comparisons.
     *
     * @static
     * @memberOf _
     * @since 0.1.0
     * @category Array
     * @param {...Array} [arrays] The arrays to inspect.
     * @returns {Array} Returns the new array of combined values.
     * @example
     *
     * _.union([2], [1, 2]);
     * // => [2, 1]
     */

/**
     * Creates an array of values by running each element in `collection` thru
     * `iteratee`. The iteratee is invoked with three arguments:
     * (value, index|key, collection).
     *
     * Many lodash methods are guarded to work as iteratees for methods like
     * `_.every`, `_.filter`, `_.map`, `_.mapValues`, `_.reject`, and `_.some`.
     *
     * The guarded methods are:
     * `ary`, `chunk`, `curry`, `curryRight`, `drop`, `dropRight`, `every`,
     * `fill`, `invert`, `parseInt`, `random`, `range`, `rangeRight`, `repeat`,
     * `sampleSize`, `slice`, `some`, `sortBy`, `split`, `take`, `takeRight`,
     * `template`, `trim`, `trimEnd`, `trimStart`, and `words`
     *
     * @static
     * @memberOf _
     * @since 0.1.0
     * @category Collection
     * @param {Array|Object} collection The collection to iterate over.
     * @param {Function} [iteratee=_.identity] The function invoked per iteration.
     * @returns {Array} Returns the new mapped array.
     * @example
     *
     * function square(n) {
     *   return n * n;
     * }
     *
     * _.map([4, 8], square);
     * // => [16, 64]
     *
     * _.map({ 'a': 4, 'b': 8 }, square);
     * // => [16, 64] (iteration order is not guaranteed)
     *
     * var users = [
     *   { 'user': 'barney' },
     *   { 'user': 'fred' }
     * ];
     *
     * // The `_.property` iteratee shorthand.
     * _.map(users, 'user');
     * // => ['barney', 'fred']
     */

/**
     * Creates an array that is the composition of partially applied arguments,
     * placeholders, and provided arguments into a single array of arguments.
     *
     * @private
     * @param {Array} args The provided arguments.
     * @param {Array} partials The arguments to prepend to those provided.
     * @param {Array} holders The `partials` placeholder indexes.
     * @params {boolean} [isCurried] Specify composing for a curried function.
     * @returns {Array} Returns the new array of composed arguments.
     */

/**
     * Creates an array with all falsey values removed. The values `false`, `null`,
     * `0`, `""`, `undefined`, and `NaN` are falsey.
     *
     * @static
     * @memberOf _
     * @since 0.1.0
     * @category Array
     * @param {Array} array The array to compact.
     * @returns {Array} Returns the new array of filtered values.
     * @example
     *
     * _.compact([0, 1, false, 2, '', 3]);
     * // => [1, 2, 3]
     */

/**
     * Creates an list cache object.
     *
     * @private
     * @constructor
     * @param {Array} [entries] The key-value pairs to cache.
     */

/**
     * Creates an object composed of keys generated from the results of running
     * each element of `collection` thru `iteratee`. The corresponding value of
     * each key is the last element responsible for generating the key. The
     * iteratee is invoked with one argument: (value).
     *
     * @static
     * @memberOf _
     * @since 4.0.0
     * @category Collection
     * @param {Array|Object} collection The collection to iterate over.
     * @param {Function} [iteratee=_.identity] The iteratee to transform keys.
     * @returns {Object} Returns the composed aggregate object.
     * @example
     *
     * var array = [
     *   { 'dir': 'left', 'code': 97 },
     *   { 'dir': 'right', 'code': 100 }
     * ];
     *
     * _.keyBy(array, function(o) {
     *   return String.fromCharCode(o.code);
     * });
     * // => { 'a': { 'dir': 'left', 'code': 97 }, 'd': { 'dir': 'right', 'code': 100 } }
     *
     * _.keyBy(array, 'dir');
     * // => { 'left': { 'dir': 'left', 'code': 97 }, 'right': { 'dir': 'right', 'code': 100 } }
     */

/**
     * Creates an object composed of keys generated from the results of running
     * each element of `collection` thru `iteratee`. The corresponding value of
     * each key is the number of times the key was returned by `iteratee`. The
     * iteratee is invoked with one argument: (value).
     *
     * @static
     * @memberOf _
     * @since 0.5.0
     * @category Collection
     * @param {Array|Object} collection The collection to iterate over.
     * @param {Function} [iteratee=_.identity] The iteratee to transform keys.
     * @returns {Object} Returns the composed aggregate object.
     * @example
     *
     * _.countBy([6.1, 4.2, 6.3], Math.floor);
     * // => { '4': 1, '6': 2 }
     *
     * // The `_.property` iteratee shorthand.
     * _.countBy(['one', 'two', 'three'], 'length');
     * // => { '3': 2, '5': 1 }
     */

/**
     * Creates an object composed of keys generated from the results of running
     * each element of `collection` thru `iteratee`. The order of grouped values
     * is determined by the order they occur in `collection`. The corresponding
     * value of each key is an array of elements responsible for generating the
     * key. The iteratee is invoked with one argument: (value).
     *
     * @static
     * @memberOf _
     * @since 0.1.0
     * @category Collection
     * @param {Array|Object} collection The collection to iterate over.
     * @param {Function} [iteratee=_.identity] The iteratee to transform keys.
     * @returns {Object} Returns the composed aggregate object.
     * @example
     *
     * _.groupBy([6.1, 4.2, 6.3], Math.floor);
     * // => { '4': [4.2], '6': [6.1, 6.3] }
     *
     * // The `_.property` iteratee shorthand.
     * _.groupBy(['one', 'two', 'three'], 'length');
     * // => { '3': ['one', 'two'], '5': ['three'] }
     */

/**
     * Creates an object composed of the `object` properties `predicate` returns
     * truthy for. The predicate is invoked with two arguments: (value, key).
     *
     * @static
     * @memberOf _
     * @since 4.0.0
     * @category Object
     * @param {Object} object The source object.
     * @param {Function} [predicate=_.identity] The function invoked per property.
     * @returns {Object} Returns the new object.
     * @example
     *
     * var object = { 'a': 1, 'b': '2', 'c': 3 };
     *
     * _.pickBy(object, _.isNumber);
     * // => { 'a': 1, 'c': 3 }
     */

/**
     * Creates an object composed of the inverted keys and values of `object`.
     * If `object` contains duplicate values, subsequent values overwrite
     * property assignments of previous values.
     *
     * @static
     * @memberOf _
     * @since 0.7.0
     * @category Object
     * @param {Object} object The object to invert.
     * @returns {Object} Returns the new inverted object.
     * @example
     *
     * var object = { 'a': 1, 'b': 2, 'c': 1 };
     *
     * _.invert(object);
     * // => { '1': 'c', '2': 'b' }
     */

/**
     * Creates an object composed of the picked `object` properties.
     *
     * @static
     * @since 0.1.0
     * @memberOf _
     * @category Object
     * @param {Object} object The source object.
     * @param {...(string|string[])} [paths] The property paths to pick.
     * @returns {Object} Returns the new object.
     * @example
     *
     * var object = { 'a': 1, 'b': '2', 'c': 3 };
     *
     * _.pick(object, ['a', 'c']);
     * // => { 'a': 1, 'c': 3 }
     */

/**
     * Creates an object that inherits from the `prototype` object. If a
     * `properties` object is given, its own enumerable string keyed properties
     * are assigned to the created object.
     *
     * @static
     * @memberOf _
     * @since 2.3.0
     * @category Object
     * @param {Object} prototype The object to inherit from.
     * @param {Object} [properties] The properties to assign to the object.
     * @returns {Object} Returns the new object.
     * @example
     *
     * function Shape() {
     *   this.x = 0;
     *   this.y = 0;
     * }
     *
     * function Circle() {
     *   Shape.call(this);
     * }
     *
     * Circle.prototype = _.create(Shape.prototype, {
     *   'constructor': Circle
     * });
     *
     * var circle = new Circle;
     * circle instanceof Circle;
     * // => true
     *
     * circle instanceof Shape;
     * // => true
     */

/**
     * Creates an object with the same keys as `object` and values generated
     * by running each own enumerable string keyed property of `object` thru
     * `iteratee`. The iteratee is invoked with three arguments:
     * (value, key, object).
     *
     * @static
     * @memberOf _
     * @since 2.4.0
     * @category Object
     * @param {Object} object The object to iterate over.
     * @param {Function} [iteratee=_.identity] The function invoked per iteration.
     * @returns {Object} Returns the new mapped object.
     * @see _.mapKeys
     * @example
     *
     * var users = {
     *   'fred':    { 'user': 'fred',    'age': 40 },
     *   'pebbles': { 'user': 'pebbles', 'age': 1 }
     * };
     *
     * _.mapValues(users, function(o) { return o.age; });
     * // => { 'fred': 40, 'pebbles': 1 } (iteration order is not guaranteed)
     *
     * // The `_.property` iteratee shorthand.
     * _.mapValues(users, 'age');
     * // => { 'fred': 40, 'pebbles': 1 } (iteration order is not guaranteed)
     */

/**
     * Creates namespaces to be used for scoping variables and classes so that they are not global.
     * Specifying the last node of a namespace implicitly creates all other nodes. Usage:
     * <pre><code>
    Ext.namespace('Company', 'Company.data');
    Ext.namespace('Company.data'); // equivalent and preferable to above syntax
    Company.Widget = function() { ... }
    Company.data.CustomStore = function(config) { ... }
    </code></pre>
     * @param {String} namespace1
     * @param {String} namespace2
     * @param {String} etc
     * @return {Object} The namespace object. (If multiple arguments are passed, this will be the last namespace created)
     * @method namespace
     */

/**
     * 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`.
     */

/**
     * 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'
     */

/**
     * Defers invoking the `func` until the current call stack has cleared. Any
     * additional arguments are provided to `func` when it's invoked.
     *
     * @static
     * @memberOf _
     * @since 0.1.0
     * @category Function
     * @param {Function} func The function to defer.
     * @param {...*} [args] The arguments to invoke `func` with.
     * @returns {number} Returns the timer id.
     * @example
     *
     * _.defer(function(text) {
     *   console.log(text);
     * }, 'deferred');
     * // => Logs 'deferred' after one millisecond.
     */

/**
     * Defines a new escaper to be used via the escape filter.
     *
     * @param {string} strategy     The strategy name that should be used as a strategy in the escape call
     * @param {Function} callable   A valid PHP callable
     */

/**
     * Disables debugging mode.
     */

/**
     * Disables the auto_reload option.
     */

/**
     * Disables the strict_variables option.
     */

/**
     * Displays a block.
     *
     * @param {string} name The block name to display
     * @param {any} context The context
     * @param {TwingOutputBuffer} outputBuffer
     * @param {TwingTemplateBlocksMap} blocks The active set of blocks
     * @param {boolean} useBlocks Whether to use the active set of blocks
     *
     * @returns {Promise<void>}
     */

/**
     * Displays a parent block.
     *
     * @param {string} name The block name to display from the parent
     * @param {any} context The context
     * @param {TwingOutputBuffer} outputBuffer
     * @param {TwingTemplateBlocksMap} blocks The active set of blocks
     *
     * @returns {Promise<void>}
     */

/**
     * Displays a template.
     *
     * @param {string} name The template name
     * @param {{}} context An array of parameters to pass to the template
     * @return {Promise<void>}
     *
     * @throws TwingErrorLoader  When the template cannot be found
     * @throws TwingErrorSyntax  When an error occurred during compilation
     * @throws TwingErrorRuntime When an error occurred during rendering
     */

/**
     * EXPERIMENTAL - True to cascade listener removal to child elements when an element is removed.
     * Currently not optimized for performance.
     * @type Boolean
     */

/**
     * Enables debugging mode.
     */

/**
     * Enables the auto_reload option.
     */

/**
     * Enables the strict_variables option.
     */

/**
     * Enables the wrapper to be iterable.
     *
     * @name Symbol.iterator
     * @memberOf _
     * @since 4.0.0
     * @category Seq
     * @returns {Object} Returns the wrapper object.
     * @example
     *
     * var wrapped = _([1, 2]);
     *
     * wrapped[Symbol.iterator]() === wrapped;
     * // => true
     *
     * Array.from(wrapped);
     * // => [1, 2]
     */

/**
     * Escapes the `RegExp` special characters "^", "$", "\", ".", "*", "+",
     * "?", "(", ")", "[", "]", "{", "}", and "|" in `string`.
     *
     * @static
     * @memberOf _
     * @since 3.0.0
     * @category String
     * @param {string} [string=''] The string to escape.
     * @returns {string} Returns the escaped string.
     * @example
     *
     * _.escapeRegExp('[lodash](https://lodash.com/)');
     * // => '\[lodash\]\(https://lodash\.com/\)'
     */

/**
     * Escapes the passed string for use in a regular expression
     * @param {String} str
     * @return {String}
     */

/**
     * Executes the chain sequence and returns the wrapped result.
     *
     * @name commit
     * @memberOf _
     * @since 3.2.0
     * @category Seq
     * @returns {Object} Returns the new `lodash` wrapper instance.
     * @example
     *
     * var array = [1, 2];
     * var wrapped = _(array).push(3);
     *
     * console.log(array);
     * // => [1, 2]
     *
     * wrapped = wrapped.commit();
     * console.log(array);
     * // => [1, 2, 3]
     *
     * wrapped.last();
     * // => 3
     *
     * console.log(array);
     * // => [1, 2, 3]
     */

/**
     * Executes the chain sequence to resolve the unwrapped value.
     *
     * @name value
     * @memberOf _
     * @since 0.1.0
     * @alias toJSON, valueOf
     * @category Seq
     * @returns {*} Returns the resolved unwrapped value.
     * @example
     *
     * _([1, 2, 3]).value();
     * // => [1, 2, 3]
     */

/**
     * Extracts the unwrapped value from its lazy wrapper.
     *
     * @private
     * @name value
     * @memberOf LazyWrapper
     * @returns {*} Returns the unwrapped value.
     */

/**
     * Extracts wrapper details from the `source` body comment.
     *
     * @private
     * @param {string} source The source to inspect.
     * @returns {Array} Returns the wrapper details.
     */

/**
     * Fills elements of `array` with `value` from `start` up to, but not
     * including, `end`.
     *
     * **Note:** This method mutates `array`.
     *
     * @static
     * @memberOf _
     * @since 3.2.0
     * @category Array
     * @param {Array} array The array to fill.
     * @param {*} value The value to fill `array` with.
     * @param {number} [start=0] The start position.
     * @param {number} [end=array.length] The end position.
     * @returns {Array} Returns `array`.
     * @example
     *
     * var array = [1, 2, 3];
     *
     * _.fill(array, 'a');
     * console.log(array);
     * // => ['a', 'a', 'a']
     *
     * _.fill(Array(3), 2);
     * // => [2, 2, 2]
     *
     * _.fill([4, 6, 8, 10], '*', 1, 3);
     * // => [4, '*', '*', 10]
     */

/**
     * Flattens `array` a single level deep.
     *
     * @static
     * @memberOf _
     * @since 0.1.0
     * @category Array
     * @param {Array} array The array to flatten.
     * @returns {Array} Returns the new flattened array.
     * @example
     *
     * _.flatten([1, [2, [3, [4]], 5]]);
     * // => [1, 2, [3, [4]], 5]
     */

/**
     * Flush (send) contents of the output buffer. The last buffer content is sent to next buffer
     *
     * In human terms, append the top-most buffer to the second-top-most buffer and empty the top-most buffer
     *
     * ┌─────────┐    ┌─────────┐
     * │   oof   │    │         │
     * ├─────────┤    ├─────────┤
     * │   bar   │ => │  baroof │
     * ├─────────┤    ├─────────┤
     * │   foo   │    │   foo   │ => true
     * └─────────┘    └─────────┘
     *
     */

/**
     * Flush (send) the output buffer, and delete current output buffer
     *
     * In human terms: append the top-most buffer to the second-top-most buffer and remove the top-most buffer
     *
     * ┌─────────┐
     * │   oof   │
     * ├─────────┤    ┌─────────┐
     * │   bar   │ -> │  baroof │
     * ├─────────┤    ├─────────┤
     * │   foo   │    │   foo   │ => true
     * └─────────┘    └─────────┘
     *
     * @returns {boolean}
     */

/**
     * Format a number as US currency
     * @param {Number/String} value The numeric value to format
     * @return {String} The formatted currency string
     */

/**
     * Formats the number according to the format string.
     * <div style="margin-left:40px">examples (123456.789):
     * <div style="margin-left:10px">
     * 0 - (123456) show only digits, no precision<br>
     * 0.00 - (123456.78) show only digits, 2 precision<br>
     * 0.0000 - (123456.7890) show only digits, 4 precision<br>
     * 0,000 - (123,456) show comma and digits, no precision<br>
     * 0,000.00 - (123,456.78) show comma and digits, 2 precision<br>
     * 0,0.00 - (123,456.78) shortcut method, show comma and digits, 2 precision<br>
     * To reverse the grouping (,) and decimal (.) for international numbers, add /i to the end.
     * For example: 0.000,00/i
     * </div></div>
     * @param {Number} v The number to format.
     * @param {String} format The way you would like to format this text.
     * @return {String} The formatted number.
     */

/**
     * Generates a unique ID. If `prefix` is given, the ID is appended to it.
     *
     * @static
     * @since 0.1.0
     * @memberOf _
     * @category Util
     * @param {string} [prefix=''] The value to prefix the ID with.
     * @returns {string} Returns the unique ID.
     * @example
     *
     * _.uniqueId('contact_');
     * // => 'contact_104'
     *
     * _.uniqueId();
     * // => '105'
     */

/**
     * Generates unique ids. If the element already has an id, it is unchanged
     * @param {Mixed} el (optional) The element to generate an id for
     * @param {String} prefix (optional) Id prefix (defaults "ext-gen")
     * @return {String} The generated Id.
     */

/**
     * Get a filter by name.
     *
     * @param {string} name
     *
     * @return Twig_Filter|false A Twig_Filter instance or null if the filter does not exist
     */

/**
     * Get a filter by name.
     *
     * @param {string} name The filter name
     *
     * @return {TwingFilter|false} A TwingFilter instance or false if the filter does not exist
     */

/**
     * Get a function by name.
     *
     * @param {string} name         function name
     * @returns {TwingFunction}     A TwingFunction instance or null if the function does not exist
     */

/**
     * Get a function by name.
     *
     * Subclasses may override this method and load functions differently;
     * so no list of functions is available.
     *
     * @param {string} name function name
     *
     * @return {TwingFunction} A TwingFunction instance or null if the function does not exist
     *
     * @internal
     */

/**
     * Get a singleton instance of UTC
     * @return {FixedOffsetZone}
     */

/**
     * Get a singleton instance of the local zone
     * @return {LocalZone}
     */

/**
     * Get active buffer contents and delete active output buffer
     *
     * In human terms: Remove the top-most buffer and returns its content
     *
     * ┌─────────┐
     * │   oof   │
     * ├─────────┤    ┌─────────┐
     * │   bar   │ -> │   bar   │
     * ├─────────┤    ├─────────┤
     * │   foo   │    │   foo   │ => oof
     * └─────────┘    └─────────┘
     *
     * @returns {string | false}
     */

/**
     * Get active buffer contents, flush (send) the output buffer, and delete active output buffer
     *
     * In human terms: append the top-most buffer to the second-top-most buffer, remove the top-most buffer and returns its content
     *
     * ┌─────────┐
     * │   oof   │
     * ├─────────┤    ┌─────────┐
     * │   bar   │ -> │  baroof │
     * ├─────────┤    ├─────────┤
     * │   foo   │    │   foo   │ => oof
     * └─────────┘    └─────────┘
     *
     * @returns {string | false}
     */

/**
     * Get the UTC offset of this DateTime in minutes
     * @example DateTime.local().offset //=> -240
     * @example DateTime.utc().offset //=> 0
     * @type {number}
     */

/**
     * Get the callback for returning the current timestamp.
     * @type {function}
     */

/**
     * Get the day of the month (1-30ish).
     * @example DateTime.local(2017, 5, 25).day //=> 25
     * @type {number}
     */

/**
     * Get the day of the week.
     * 1 is Monday and 7 is Sunday
     * @see https://en.wikipedia.org/wiki/ISO_week_date
     * @example DateTime.local(2014, 11, 31).weekday //=> 4
     * @type {number}
     */

/**
     * Get the days.
     * @type {number}
     */

/**
     * Get the default format used by the number_format filter.
     *
     * @return array The arguments for number_format()
     */

/**
     * Get the default locale to create DateTimes with. Does not affect existing instances.
     * @type {string}
     */

/**
     * Get the default numbering system to create DateTimes with. Does not affect existing instances.
     * @type {string}
     */

/**
     * Get the default output calendar to create DateTimes with. Does not affect existing instances.
     * @type {string}
     */

/**
     * Get the default time zone object to create DateTimes in. Does not affect existing instances.
     * @type {Zone}
     */

/**
     * Get the default time zone to create DateTimes in.
     * @type {string}
     */

/**
     * Get the hour of the day (0-23).
     * @example DateTime.local(2017, 5, 25, 9).hour //=> 9
     * @type {number}
     */

/**
     * Get the hours.
     * @type {number}
     */

/**
     * Get the human readable long month name, such as 'October'.
     * Defaults to the system's locale if no locale has been specified
     * @example DateTime.local(2017, 10, 30).monthLong //=> October
     * @type {string}
     */

/**
     * Get the human readable long weekday, such as 'Monday'.
     * Defaults to the system's locale if no locale has been specified
     * @example DateTime.local(2017, 10, 30).weekdayLong //=> Monday
     * @type {string}
     */

/**
     * Get the human readable short month name, such as 'Oct'.
     * Defaults to the system's locale if no locale has been specified
     * @example DateTime.local(2017, 10, 30).monthShort //=> Oct
     * @type {string}
     */

/**
     * Get the human readable short weekday, such as 'Mon'.
     * Defaults to the system's locale if no locale has been specified
     * @example DateTime.local(2017, 10, 30).weekdayShort //=> Mon
     * @type {string}
     */

/**
     * Get the locale of a DateTime, such 'en-GB'. The locale is used when formatting the DateTime
     *
     * @type {string}
     */

/**
     * Get the long human name for the zone's current offset, for example "Eastern Standard Time" or "Eastern Daylight Time".
     * Defaults to the system's locale if no locale has been specified
     * @type {string}
     */

/**
     * Get the millisecond of the second (0-999).
     * @example DateTime.local(2017, 5, 25, 9, 30, 52, 654).millisecond //=> 654
     * @type {number}
     */

/**
     * Get the milliseconds.
     * @return {number}
     */

/**
     * Get the minute of the hour (0-59).
     * @example DateTime.local(2017, 5, 25, 9, 30).minute //=> 30
     * @type {number}
     */

/**
     * Get the minutes.
     * @type {number}
     */

/**
     * Get the month (1-12).
     * @example DateTime.local(2017, 5, 25).month //=> 5
     * @type {number}
     */

/**
     * Get the months.
     * @type {number}
     */

/**
     * Get the name of the time zone.
     * @type {string}
     */

/**
     * Get the numbering system of a DateTime, such 'beng'. The numbering system is used when formatting the DateTime
     *
     * @type {string}
     */

/**
     * Get the numbering system of a Duration, such 'beng'. The numbering system is used when formatting the Duration
     *
     * @type {string}
     */

/**
     * Get the ordinal (meaning the day of the year)
     * @example DateTime.local(2017, 5, 25).ordinal //=> 145
     * @type {number|DateTime}
     */

/**
     * Get the output calendar of a DateTime, such 'islamic'. The output calendar is used when formatting the DateTime
     *
     * @type {string}
     */

/**
     * Get the quarter
     * @example DateTime.local(2017, 5, 25).quarter //=> 2
     * @type {number}
     */

/**
     * Get the quarters.
     * @type {number}
     */

/**
     * Get the second of the minute (0-59).
     * @example DateTime.local(2017, 5, 25, 9, 30, 52).second //=> 52
     * @type {number}
     */

/**
     * Get the seconds.
     * @return {number}
     */

/**
     * Get the short human name for the zone's current offset, for example "EST" or "EDT".
     * Defaults to the system's locale if no locale has been specified
     * @type {string}
     */

/**
     * Get the time zone associated with this DateTime.
     * @type {Zone}
     */

/**
     * Get the week number of the week year (1-52ish).
     * @see https://en.wikipedia.org/wiki/ISO_week_date
     * @example DateTime.local(2017, 5, 25).weekNumber //=> 21
     * @type {number}
     */

/**
     * Get the week year
     * @see https://en.wikipedia.org/wiki/ISO_week_date
     * @example DateTime.local(2014, 11, 31).weekYear //=> 2015
     * @type {number}
     */

/**
     * Get the weeks
     * @type {number}
     */

/**
     * Get the year
     * @example DateTime.local(2017, 5, 25).year //=> 2017
     * @type {number}
     */

/**
     * Get whether Luxon will throw when it encounters invalid DateTimes, Durations, or Intervals
     * @type {boolean}
     */

/**
     * Get whether the DateTime is in a DST.
     * @type {boolean}
     */

/**
     * Get whether this zone's offset ever changes, as in a DST.
     * @type {boolean}
     */

/**
     * Gets `n` random elements at unique keys from `collection` up to the
     * size of `collection`.
     *
     * @static
     * @memberOf _
     * @since 4.0.0
     * @category Collection
     * @param {Array|Object} collection The collection to sample.
     * @param {number} [n=1] The number of elements to sample.
     * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`.
     * @returns {Array} Returns the random elements.
     * @example
     *
     * _.sampleSize([1, 2, 3], 2);
     * // => [3, 1]
     *
     * _.sampleSize([1, 2, 3], 4);
     * // => [2, 3, 1]
     */

/**
     * Gets a random element from `collection`.
     *
     * @static
     * @memberOf _
     * @since 2.0.0
     * @category Collection
     * @param {Array|Object} collection The collection to sample.
     * @returns {*} Returns the random element.
     * @example
     *
     * _.sample([1, 2, 3, 4]);
     * // => 2
     */

/**
     * Gets a test by name.
     *
     * @param {string} name The test name
     * @return {TwingTest} A TwingTest instance or null if the test does not exist
     */

/**
     * Gets a test by name.
     *
     * @param {string} name The test name
     * @returns {TwingTest} A TwingTest instance or null if the test does not exist
     */

/**
     * Gets all but the first element of `array`.
     *
     * @static
     * @memberOf _
     * @since 4.0.0
     * @category Array
     * @param {Array} array The array to query.
     * @returns {Array} Returns the slice of `array`.
     * @example
     *
     * _.tail([1, 2, 3]);
     * // => [2, 3]
     */

/**
     * Gets all but the last element of `array`.
     *
     * @static
     * @memberOf _
     * @since 0.1.0
     * @category Array
     * @param {Array} array The array to query.
     * @returns {Array} Returns the slice of `array`.
     * @example
     *
     * _.initial([1, 2, 3]);
     * // => [1, 2]
     */

/**
     * Gets all defined escapers.
     *
     * @returns {Map<string, Function>}
     */

/**
     * Gets an extension by name.
     *
     * @param {string} name
     * @return {TwingExtensionInterface}
     */

/**
     * Gets metadata for `func`.
     *
     * @private
     * @param {Function} func The function to query.
     * @returns {*} Returns the metadata for `func`.
     */

/**
     * Gets registered functions.
     *
     * Be warned that this method cannot return functions defined with registerUndefinedFunctionCallback.
     *
     * @return Twig_Function[]
     *
     * @see registerUndefinedFunctionCallback
     *
     * @internal
     */

/**
     * Gets registered tags.
     *
     * @return Map<string, TwingTokenParserInterface>
     *
     * @internal
     */

/**
     * Gets the Loader instance.
     *
     * @return TwingLoaderInterface
     */

/**
     * Gets the active cache implementation.
     *
     * @param {boolean} original Whether to return the original cache option or the real cache instance
     *
     * @return {TwingCacheInterface|string|false} A TwingCacheInterface implementation, an absolute path to the compiled templates or false to disable cache
     */

/**
     * Gets the appropriate "iteratee" function. If `_.iteratee` is customized,
     * this function returns the custom method, otherwise it returns `baseIteratee`.
     * If arguments are provided, the chosen function is invoked with them and
     * its result is returned.
     *
     * @private
     * @param {*} [value] The value to convert to an iteratee.
     * @param {number} [arity] The arity of the created iteratee.
     * @returns {Function} Returns the chosen function or its result.
     */

/**
     * Gets the argument placeholder value for `func`.
     *
     * @private
     * @param {Function} func The function to inspect.
     * @returns {*} Returns the placeholder value.
     */

/**
     * Gets the data for `map`.
     *
     * @private
     * @param {Object} map The map to query.
     * @param {string} key The reference key.
     * @returns {*} Returns the map data.
     */

/**
     * Gets the default escaping strategy.
     *
     * @param {string} name The template name
     *
     * @returns {string | false} The default strategy to use for the template
     */

/**
     * Gets the default format to be used by the date filter.
     *
     * @return array The default date format string and the default date interval format string
     */

/**
     * Gets the default template charset.
     *
     * @return {string} The default charset
     */

/**
     * Gets the default timezone to be used by the date filter.
     *
     * @returns {string} The default timezone currently in use
     */

/**
     * Gets the element at index `n` of `array`. If `n` is negative, the nth
     * element from the end is returned.
     *
     * @static
     * @memberOf _
     * @since 4.11.0
     * @category Array
     * @param {Array} array The array to query.
     * @param {number} [n=0] The index of the element to return.
     * @returns {*} Returns the nth element of `array`.
     * @example
     *
     * var array = ['a', 'b', 'c', 'd'];
     *
     * _.nth(array, 1);
     * // => 'b'
     *
     * _.nth(array, -2);
     * // => 'c';
     */

/**
     * Gets the first element of `array`.
     *
     * @static
     * @memberOf _
     * @since 0.1.0
     * @alias first
     * @category Array
     * @param {Array} array The array to query.
     * @returns {*} Returns the first element of `array`.
     * @example
     *
     * _.head([1, 2, 3]);
     * // => 1
     *
     * _.head([]);
     * // => undefined
     */

/**
     * Gets the hash value for `key`.
     *
     * @private
     * @name get
     * @memberOf Hash
     * @param {string} key The key of the value to get.
     * @returns {*} Returns the entry value.
     */

/**
     * Gets the index at which the `key` is found in `array` of key-value pairs.
     *
     * @private
     * @param {Array} array The array to inspect.
     * @param {*} key The key to search for.
     * @returns {number} Returns the index of the matched value, else `-1`.
     */

/**
     * Gets the index at which the first occurrence of `value` is found in `array`
     * using [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero)
     * for equality comparisons. If `fromIndex` is negative, it's used as the
     * offset from the end of `array`.
     *
     * @static
     * @memberOf _
     * @since 0.1.0
     * @category Array
     * @param {Array} array The array to inspect.
     * @param {*} value The value to search for.
     * @param {number} [fromIndex=0] The index to search from.
     * @returns {number} Returns the index of the matched value, else `-1`.
     * @example
     *
     * _.indexOf([1, 2, 1, 2], 2);
     * // => 1
     *
     * // Search from the `fromIndex`.
     * _.indexOf([1, 2, 1, 2], 2, 2);
     * // => 3
     */

/**
     * Gets the last element of `array`.
     *
     * @static
     * @memberOf _
     * @since 0.1.0
     * @category Array
     * @param {Array} array The array to query.
     * @returns {*} Returns the last element of `array`.
     * @example
     *
     * _.last([1, 2, 3]);
     * // => 3
     */

/**
     * Gets the list cache value for `key`.
     *
     * @private
     * @name get
     * @memberOf ListCache
     * @param {string} key The key of the value to get.
     * @returns {*} Returns the entry value.
     */

/**
     * Gets the map value for `key`.
     *
     * @private
     * @name get
     * @memberOf MapCache
     * @param {string} key The key of the value to get.
     * @returns {*} Returns the entry value.
     */

/**
     * Gets the name of `func`.
     *
     * @private
     * @param {Function} func The function to query.
     * @returns {string} Returns the function name.
     */

/**
     * Gets the native function at `key` of `object`.
     *
     * @private
     * @param {Object} object The object to query.
     * @param {string} key The key of the method to get.
     * @returns {*} Returns the function if it's native, else `undefined`.
     */

/**
     * Gets the next value on a wrapped object following the
     * [iterator protocol](https://mdn.io/iteration_protocols#iterator).
     *
     * @name next
     * @memberOf _
     * @since 4.0.0
     * @category Seq
     * @returns {Object} Returns the next iterator value.
     * @example
     *
     * var wrapped = _([1, 2]);
     *
     * wrapped.next();
     * // => { 'done': false, 'value': 1 }
     *
     * wrapped.next();
     * // => { 'done': false, 'value': 2 }
     *
     * wrapped.next();
     * // => { 'done': true, 'value': undefined }
     */

/**
     * Gets the parent value at `path` of `object`.
     *
     * @private
     * @param {Object} object The object to query.
     * @param {Array} path The path to get the parent value of.
     * @returns {*} Returns the parent value.
     */

/**
     * Gets the property names, values, and compare flags of `object`.
     *
     * @private
     * @param {Object} object The object to query.
     * @returns {Array} Returns the match data of `object`.
     */

/**
     * Gets the raw message.
     *
     * @return string The raw message
     */

/**
     * Gets the registered Filters.
     *
     * Be warned that this method cannot return filters defined with registerUndefinedFilterCallback.
     *
     * @return Twig_Filter[]
     *
     * @see registerUndefinedFilterCallback
     *
     * @internal
     */

/**
     * Gets the registered Globals.
     *
     * @return Map<any, any> A map of globals
     */

/**
     * Gets the registered Node Visitors.
     *
     * @return {Array<TwingNodeVisitorInterface>}
     *
     * @internal
     */

/**
     * Gets the registered Tests.
     *
     * @return {Map<string, TwingTest>}
     */

/**
     * Gets the registered Token Parsers.
     *
     * @return {Array<TwingTokenParserInterface>}
     *
     * @internal
     */

/**
     * Gets the registered binary Operators.
     *
     * @return Map<string, TwingOperator> A map of binary operators
     */

/**
     * Gets the registered binary Operators.
     *
     * @return Map<string, TwingOperator> An array of binary operators
     *
     * @internal
     */

/**
     * Gets the registered unary Operators.
     *
     * @return Map<string, TwingOperator> A map of unary operator definitions
     */

/**
     * Gets the registered unary Operators.
     *
     * @return Map<string, TwingOperator> A map of unary operators
     *
     * @internal
     */

/**
     * Gets the size of `collection` by returning its length for array-like
     * values or the number of own enumerable string keyed properties for objects.
     *
     * @static
     * @memberOf _
     * @since 0.1.0
     * @category Collection
     * @param {Array|Object|string} collection The collection to inspect.
     * @returns {number} Returns the collection size.
     * @example
     *
     * _.size([1, 2, 3]);
     * // => 3
     *
     * _.size({ 'a': 1, 'b': 2 });
     * // => 2
     *
     * _.size('pebbles');
     * // => 7
     */

/**
     * Gets the source associated with this stream.
     *
     * @return TwingSource
     */

/**
     * Gets the source context of the Twig template where the error occurred.
     *
     * @return {TwingSource}
     */

/**
     * Gets the stack value for `key`.
     *
     * @private
     * @name get
     * @memberOf Stack
     * @param {string} key The key of the value to get.
     * @returns {*} Returns the entry value.
     */

/**
     * Gets the template class associated with the given string.
     *
     * The generated template class is based on the following parameters:
     *
     *  * The cache key for the given template;
     *  * The currently enabled extensions;
     *  * Twing version;
     *  * Options with what environment was created.
     *
     * @param {string} name The name for which to calculate the template class name
     * @param {number} index The index of the template
     * @param {TwingSource} from The source that initiated the template loading
     *
     * @return {Promise<string>} The template hash
     */

/**
     * Gets the template line where the error occurred.
     *
     * @return int The template line
     */

/**
     * 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.
     */

/**
     * Gets the value at `key`, unless `key` is "__proto__" or "constructor".
     *
     * @private
     * @param {Object} object The object to query.
     * @param {string} key The key of the property to get.
     * @returns {*} Returns the property value.
     */

/**
     * Gets the value at `path` of `object`. If the resolved value is
     * `undefined`, the `defaultValue` is returned in its place.
     *
     * @static
     * @memberOf _
     * @since 3.7.0
     * @category Object
     * @param {Object} object The object to query.
     * @param {Array|string} path The path of the property to get.
     * @param {*} [defaultValue] The value returned for `undefined` resolved values.
     * @returns {*} Returns the resolved value.
     * @example
     *
     * var object = { 'a': [{ 'b': { 'c': 3 } }] };
     *
     * _.get(object, 'a[0].b.c');
     * // => 3
     *
     * _.get(object, ['a', '0', 'b', 'c']);
     * // => 3
     *
     * _.get(object, 'a.b.c', 'default');
     * // => 'default'
     */

/**
     * Gets the view, applying any `transforms` to the `start` and `end` positions.
     *
     * @private
     * @param {number} start The start of the view.
     * @param {number} end The end of the view.
     * @param {Array} transforms The transformations to apply to the view.
     * @returns {Object} Returns an object containing the `start` and `end`
     *  positions of the view.
     */

/**
     * Helper to reject and skip all navigation guards if a new navigation happened
     * @param to
     * @param from
     */

/**
     * Indents the generated code.
     *
     * @param {number} step The number of indentation to add
     *
     * @returns TwingCompiler
     */

/**
     * Indicates whether to use native browser parsing for JSON methods.
     * This option is ignored if the browser does not support native JSON methods.
     * <b>Note: Native JSON methods will not work with objects that have functions.
     * Also, property names must be quoted, otherwise the data will not parse.</b> (Defaults to false)
     * @type Boolean
     */

/**
     * Initializes an array clone.
     *
     * @private
     * @param {Array} array The array to clone.
     * @returns {Array} Returns the initialized clone.
     */

/**
     * Initializes an object clone based on its `toStringTag`.
     *
     * **Note:** This function only supports cloning values with tags of
     * `Boolean`, `Date`, `Error`, `Map`, `Number`, `RegExp`, `Set`, or `String`.
     *
     * @private
     * @param {Object} object The object to clone.
     * @param {string} tag The `toStringTag` of the object to clone.
     * @param {boolean} [isDeep] Specify a deep clone.
     * @returns {Object} Returns the initialized clone.
     */

/**
     * Initializes an object clone.
     *
     * @private
     * @param {Object} object The object to clone.
     * @returns {Object} Returns the initialized clone.
     */

/**
     * Inject tokens after the current one.
     *
     * @param tokens
     */

/**
     * Inserts wrapper `details` in a comment at the top of the `source` body.
     *
     * @private
     * @param {string} source The source to modify.
     * @returns {Array} details The details to insert.
     * @returns {string} Returns the modified source.
     */

/**
     * Invokes `func` after `wait` milliseconds. Any additional arguments are
     * provided to `func` when it's invoked.
     *
     * @static
     * @memberOf _
     * @since 0.1.0
     * @category Function
     * @param {Function} func The function to delay.
     * @param {number} wait The number of milliseconds to delay invocation.
     * @param {...*} [args] The arguments to invoke `func` with.
     * @returns {number} Returns the timer id.
     * @example
     *
     * _.delay(function(text) {
     *   console.log(text);
     * }, 1000, 'later');
     * // => Logs 'later' after one second.
     */

/**
     * Invokes a method on each item in an Array.
     * <pre><code>
    // Example:
    Ext.invoke(Ext.query("p"), "getAttribute", "id");
    // [el1.getAttribute("id"), el2.getAttribute("id"), ..., elN.getAttribute("id")]
     * </code></pre>
     * @param {Array|NodeList} arr The Array of items to invoke the method on.
     * @param {String} methodName The method name to invoke.
     * @param {Anything} ... Arguments to send into the method invocation.
     * @return {Array} The results of invoking the method on each item in the array.
     */

/**
     * Invokes the iteratee `n` times, returning an array of the results of
     * each invocation. The iteratee is invoked with one argument; (index).
     *
     * @static
     * @since 0.1.0
     * @memberOf _
     * @category Util
     * @param {number} n The number of times to invoke `iteratee`.
     * @param {Function} [iteratee=_.identity] The function invoked per iteration.
     * @returns {Array} Returns the array of results.
     * @example
     *
     * _.times(3, String);
     * // => ['0', '1', '2']
     *
     *  _.times(4, _.constant(0));
     * // => [0, 0, 0, 0]
     */

/**
     * Invokes the method at `path` of each element in `collection`, returning
     * an array of the results of each invoked method. Any additional arguments
     * are provided to each invoked method. If `path` is a function, it's invoked
     * for, and `this` bound to, each element in `collection`.
     *
     * @static
     * @memberOf _
     * @since 4.0.0
     * @category Collection
     * @param {Array|Object} collection The collection to iterate over.
     * @param {Array|Function|string} path The path of the method to invoke or
     *  the function invoked per iteration.
     * @param {...*} [args] The arguments to invoke each method with.
     * @returns {Array} Returns the array of results.
     * @example
     *
     * _.invokeMap([[5, 1, 7], [3, 2, 1]], 'sort');
     * // => [[1, 5, 7], [1, 2, 3]]
     *
     * _.invokeMap([123, 456], String.prototype.split, '');
     * // => [['1', '2', '3'], ['4', '5', '6']]
     */

/**
     * It does simple math for use in a template, for example:<pre><code>
     * var tpl = new Ext.Template('{value} * 10 = {value:math("* 10")}');
     * </code></pre>
     * @return {Function} A function that operates on the passed value.
     */

/**
     * Iterates an array calling the supplied function.
     * @param {Array/NodeList/Mixed} array The array to be iterated. If this
     * argument is not really an array, the supplied function is called once.
     * @param {Function} fn The function to be called with each item. If the
     * supplied function returns false, iteration stops and this method returns
     * the current <code>index</code>. This function is called with
     * the following arguments:
     * <div class="mdetail-params"><ul>
     * <li><code>item</code> : <i>Mixed</i>
     * <div class="sub-desc">The item at the current <code>index</code>
     * in the passed <code>array</code></div></li>
     * <li><code>index</code> : <i>Number</i>
     * <div class="sub-desc">The current index within the array</div></li>
     * <li><code>allItems</code> : <i>Array</i>
     * <div class="sub-desc">The <code>array</code> passed as the first
     * argument to <code>Ext.each</code>.</div></li>
     * </ul></div>
     * @param {Object} scope The scope (<code>this</code> reference) in which the specified function is executed.
     * Defaults to the <code>item</code> at the current <code>index</code>
     * within the passed <code>array</code>.
     * @return See description for the fn parameter.
     */

/**
     * Iterates either the elements in an array, or each of the properties in an object.
     * <b>Note</b>: If you are only iterating arrays, it is better to call {@link #each}.
     * @param {Object/Array} object The object or array to be iterated
     * @param {Function} fn The function to be called for each iteration.
     * The iteration will stop if the supplied function returns false, or
     * all array elements / object properties have been covered. The signature
     * varies depending on the type of object being interated:
     * <div class="mdetail-params"><ul>
     * <li>Arrays : <tt>(Object item, Number index, Array allItems)</tt>
     * <div class="sub-desc">
     * When iterating an array, the supplied function is called with each item.</div></li>
     * <li>Objects : <tt>(String key, Object value, Object)</tt>
     * <div class="sub-desc">
     * When iterating an object, the supplied function is called with each key-value pair in
     * the object, and the iterated object</div></li>
     * </ul></div>
     * @param {Object} scope The scope (<code>this</code> reference) in which the specified function is executed. Defaults to
     * the <code>object</code> being iterated.
     */

/**
     * Iterates over elements of `collection` and invokes `iteratee` for each element.
     * The iteratee is invoked with three arguments: (value, index|key, collection).
     * Iteratee functions may exit iteration early by explicitly returning `false`.
     *
     * **Note:** As with other "Collections" methods, objects with a "length"
     * property are iterated like arrays. To avoid this behavior use `_.forIn`
     * or `_.forOwn` for object iteration.
     *
     * @static
     * @memberOf _
     * @since 0.1.0
     * @alias each
     * @category Collection
     * @param {Array|Object} collection The collection to iterate over.
     * @param {Function} [iteratee=_.identity] The function invoked per iteration.
     * @returns {Array|Object} Returns `collection`.
     * @see _.forEachRight
     * @example
     *
     * _.forEach([1, 2], function(value) {
     *   console.log(value);
     * });
     * // => Logs `1` then `2`.
     *
     * _.forEach({ 'a': 1, 'b': 2 }, function(value, key) {
     *   console.log(key);
     * });
     * // => Logs 'a' then 'b' (iteration order is not guaranteed).
     */

/**
     * Iterates over elements of `collection`, returning an array of all elements
     * `predicate` returns truthy for. The predicate is invoked with three
     * arguments: (value, index|key, collection).
     *
     * **Note:** Unlike `_.remove`, this method returns a new array.
     *
     * @static
     * @memberOf _
     * @since 0.1.0
     * @category Collection
     * @param {Array|Object} collection The collection to iterate over.
     * @param {Function} [predicate=_.identity] The function invoked per iteration.
     * @returns {Array} Returns the new filtered array.
     * @see _.reject
     * @example
     *
     * var users = [
     *   { 'user': 'barney', 'age': 36, 'active': true },
     *   { 'user': 'fred',   'age': 40, 'active': false }
     * ];
     *
     * _.filter(users, function(o) { return !o.active; });
     * // => objects for ['fred']
     *
     * // The `_.matches` iteratee shorthand.
     * _.filter(users, { 'age': 36, 'active': true });
     * // => objects for ['barney']
     *
     * // The `_.matchesProperty` iteratee shorthand.
     * _.filter(users, ['active', false]);
     * // => objects for ['fred']
     *
     * // The `_.property` iteratee shorthand.
     * _.filter(users, 'active');
     * // => objects for ['barney']
     *
     * // Combining several predicates using `_.overEvery` or `_.overSome`.
     * _.filter(users, _.overSome([{ 'age': 36 }, ['age', 40]]));
     * // => objects for ['fred', 'barney']
     */

/**
     * Iterates over elements of `collection`, returning the first element
     * `predicate` returns truthy for. The predicate is invoked with three
     * arguments: (value, index|key, collection).
     *
     * @static
     * @memberOf _
     * @since 0.1.0
     * @category Collection
     * @param {Array|Object} collection The collection to inspect.
     * @param {Function} [predicate=_.identity] The function invoked per iteration.
     * @param {number} [fromIndex=0] The index to search from.
     * @returns {*} Returns the matched element, else `undefined`.
     * @example
     *
     * var users = [
     *   { 'user': 'barney',  'age': 36, 'active': true },
     *   { 'user': 'fred',    'age': 40, 'active': false },
     *   { 'user': 'pebbles', 'age': 1,  'active': true }
     * ];
     *
     * _.find(users, function(o) { return o.age < 40; });
     * // => object for 'barney'
     *
     * // The `_.matches` iteratee shorthand.
     * _.find(users, { 'age': 1, 'active': true });
     * // => object for 'pebbles'
     *
     * // The `_.matchesProperty` iteratee shorthand.
     * _.find(users, ['active', false]);
     * // => object for 'fred'
     *
     * // The `_.property` iteratee shorthand.
     * _.find(users, 'active');
     * // => object for 'barney'
     */

/**
     * Iterates over own and inherited enumerable string keyed properties of an
     * object and invokes `iteratee` for each property. The iteratee is invoked
     * with three arguments: (value, key, object). Iteratee functions may exit
     * iteration early by explicitly returning `false`.
     *
     * @static
     * @memberOf _
     * @since 0.3.0
     * @category Object
     * @param {Object} object The object to iterate over.
     * @param {Function} [iteratee=_.identity] The function invoked per iteration.
     * @returns {Object} Returns `object`.
     * @see _.forInRight
     * @example
     *
     * function Foo() {
     *   this.a = 1;
     *   this.b = 2;
     * }
     *
     * Foo.prototype.c = 3;
     *
     * _.forIn(new Foo, function(value, key) {
     *   console.log(key);
     * });
     * // => Logs 'a', 'b', then 'c' (iteration order is not guaranteed).
     */

/**
     * Iterates over own enumerable string keyed properties of an object and
     * invokes `iteratee` for each property. The iteratee is invoked with three
     * arguments: (value, key, object). Iteratee functions may exit iteration
     * early by explicitly returning `false`.
     *
     * @static
     * @memberOf _
     * @since 0.3.0
     * @category Object
     * @param {Object} object The object to iterate over.
     * @param {Function} [iteratee=_.identity] The function invoked per iteration.
     * @returns {Object} Returns `object`.
     * @see _.forOwnRight
     * @example
     *
     * function Foo() {
     *   this.a = 1;
     *   this.b = 2;
     * }
     *
     * Foo.prototype.c = 3;
     *
     * _.forOwn(new Foo, function(value, key) {
     *   console.log(key);
     * });
     * // => Logs 'a' then 'b' (iteration order is not guaranteed).
     */

/**
     * Loads a template internal representation.
     *
     * @param {string} name The template name
     * @param {number} index The index of the template
     * @param {TwingSource} from The source that initiated the template loading
     *
     * @return {Promise<TwingTemplate>} A template instance representing the given template name
     *
     * @throws {TwingErrorLoader}  When the template cannot be found
     * @throws {TwingErrorRuntime} When a previously generated cache is corrupted
     * @throws {TwingErrorSyntax}  When an error occurred during compilation
     */

/**
     * Loads a template.
     *
     * @param {string | TwingTemplate} name The template name
     *
     * @throws {TwingErrorLoader}  When the template cannot be found
     * @throws {TwingErrorRuntime} When a previously generated cache is corrupted
     * @throws {TwingErrorSyntax}  When an error occurred during compilation
     *
     * @return {Promise<TwingTemplate>}
     */

/**
     * Look at the next token.
     *
     * @param {number} number
     *
     * @return {Token}
     */

/**
     * Merges a context with the defined globals.
     *
     * @param {Map<*, *>} context
     * @return {Map<*, *>}
     */

/**
     * Merges the function metadata of `source` into `data`.
     *
     * Merging metadata reduces the number of wrappers used to invoke a function.
     * This is possible because methods like `_.bind`, `_.curry`, and `_.partial`
     * may be applied regardless of execution order. Methods like `_.ary` and
     * `_.rearg` modify function arguments, making the order in which they are
     * executed important, preventing the merging of metadata. However, we make
     * an exception for a safe combined case where curried functions have `_.ary`
     * and or `_.rearg` applied.
     *
     * @private
     * @param {Array} data The destination metadata.
     * @param {Array} source The source metadata.
     * @returns {Array} Returns `data`.
     */

/**
     * Multiply two numbers.
     *
     * @static
     * @memberOf _
     * @since 4.7.0
     * @category Math
     * @param {number} multiplier The first number in a multiplication.
     * @param {number} multiplicand The second number in a multiplication.
     * @returns {number} Returns the product.
     * @example
     *
     * _.multiply(6, 4);
     * // => 24
     */

/**
     * NOTE: update {@link _RouterLinkI}'s `$slots` type when updating this
     */

/**
     * Outdents the generated code.
     *
     * @param {number} step The number of indentation to remove
     *
     * @return TwingCompiler
     *
     * @throws Error When trying to outdent too much so the indentation would become negative
     */

/**
     * Pads `string` on the left and right sides if it's shorter than `length`.
     * Padding characters are truncated if they can't be evenly divided by `length`.
     *
     * @static
     * @memberOf _
     * @since 3.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
     *
     * _.pad('abc', 8);
     * // => '  abc   '
     *
     * _.pad('abc', 8, '_-');
     * // => '_-abc_-_'
     *
     * _.pad('abc', 3);
     * // => 'abc'
     */

/**
     * 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'
     */

/**
     * Pads `string` on the right 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
     *
     * _.padEnd('abc', 6);
     * // => 'abc   '
     *
     * _.padEnd('abc', 6, '_-');
     * // => 'abc_-_'
     *
     * _.padEnd('abc', 3);
     * // => 'abc'
     */

/**
     * Parse a value into a formatted date using the specified format pattern.
     * @param {String/Date} value The value to format (Strings must conform to the format expected by the javascript Date object's <a href="http://www.w3schools.com/jsref/jsref_parse.asp">parse()</a> method)
     * @param {String} format (optional) Any valid date format string (defaults to 'm/d/Y')
     * @return {String} The formatted date string
     */

/**
     * Parses arguments.
     *
     * @param namedArguments {boolean} Whether to allow named arguments or not
     * @param definition {boolean} Whether we are parsing arguments for a function definition
     * @param allowArrow {boolean}
     *
     * @return TwingNode
     *
     * @throws TwingErrorSyntax
     */

/**
     * Partitions the set into two sets: a true set and a false set.
     * Example: 
     * Example2: 
     * <pre><code>
    // Example 1:
    Ext.partition([true, false, true, true, false]); // [[true, true, true], [false, false]]
    // Example 2:
    Ext.partition(
    Ext.query("p"),
    function(val){
    return val.className == "class1"
    }
    );
    // true are those paragraph elements with a className of "class1",
    // false set are those that do not have that className.
     * </code></pre>
     * @param {Array|NodeList} arr The array to partition
     * @param {Function} truth (optional) a function to determine truth.  If this is omitted the element
     *                   itself must be able to be evaluated for its truthfulness.
     * @return {Array} [true<Array>,false<Array>]
     */

/**
     * Performs a
     * [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero)
     * comparison between two values to determine if they are equivalent.
     *
     * @static
     * @memberOf _
     * @since 4.0.0
     * @category Lang
     * @param {*} value The value to compare.
     * @param {*} other The other value to compare.
     * @returns {boolean} Returns `true` if the values are equivalent, else `false`.
     * @example
     *
     * var object = { 'a': 1 };
     * var other = { 'a': 1 };
     *
     * _.eq(object, object);
     * // => true
     *
     * _.eq(object, other);
     * // => false
     *
     * _.eq('a', 'a');
     * // => true
     *
     * _.eq('a', Object('a'));
     * // => false
     *
     * _.eq(NaN, NaN);
     * // => true
     */

/**
     * Performs a deep comparison between two values to determine if they are
     * equivalent.
     *
     * **Note:** This method supports comparing arrays, array buffers, booleans,
     * date objects, error objects, maps, numbers, `Object` objects, regexes,
     * sets, strings, symbols, and typed arrays. `Object` objects are compared
     * by their own, not inherited, enumerable properties. Functions and DOM
     * nodes are compared by strict equality, i.e. `===`.
     *
     * @static
     * @memberOf _
     * @since 0.1.0
     * @category Lang
     * @param {*} value The value to compare.
     * @param {*} other The other value to compare.
     * @returns {boolean} Returns `true` if the values are equivalent, else `false`.
     * @example
     *
     * var object = { 'a': 1 };
     * var other = { 'a': 1 };
     *
     * _.isEqual(object, other);
     * // => true
     *
     * object === other;
     * // => false
     */

/**
     * Performs a partial deep comparison between `object` and `source` to
     * determine if `object` contains equivalent property values.
     *
     * **Note:** This method is equivalent to `_.matches` when `source` is
     * partially applied.
     *
     * Partial comparisons will match empty array and empty object `source`
     * values against any array or object value, respectively. See `_.isEqual`
     * for a list of supported value comparisons.
     *
     * @static
     * @memberOf _
     * @since 3.0.0
     * @category Lang
     * @param {Object} object The object to inspect.
     * @param {Object} source The object of property values to match.
     * @returns {boolean} Returns `true` if `object` is a match, else `false`.
     * @example
     *
     * var object = { 'a': 1, 'b': 2 };
     *
     * _.isMatch(object, { 'b': 2 });
     * // => true
     *
     * _.isMatch(object, { 'b': 1 });
     * // => false
     */

/**
     * Plucks the value of a property from each item in the Array
     * <pre><code>
    // Example:
    Ext.pluck(Ext.query("p"), "className"); // [el1.className, el2.className, ..., elN.className]
     * </code></pre>
     * @param {Array|NodeList} arr The Array of items to pluck the value from.
     * @param {String} prop The property name to pluck from each element.
     * @return {Array} The value from each item in the Array.
     */

/**
     * Produces a random number between the inclusive `lower` and `upper` bounds.
     * If only one argument is provided a number between `0` and the given number
     * is returned. If `floating` is `true`, or either `lower` or `upper` are
     * floats, a floating-point number is returned instead of an integer.
     *
     * **Note:** JavaScript follows the IEEE-754 standard for resolving
     * floating-point values which can produce unexpected results.
     *
     * @static
     * @memberOf _
     * @since 0.7.0
     * @category Number
     * @param {number} [lower=0] The lower bound.
     * @param {number} [upper=1] The upper bound.
     * @param {boolean} [floating] Specify returning a floating-point number.
     * @returns {number} Returns the random number.
     * @example
     *
     * _.random(0, 5);
     * // => an integer between 0 and 5
     *
     * _.random(5);
     * // => also an integer between 0 and 5
     *
     * _.random(5, true);
     * // => a floating-point number between 0 and 5
     *
     * _.random(1.2, 5.2);
     * // => a floating-point number between 1.2 and 5.2
     */

/**
     * Recursively flatten `array` up to `depth` times.
     *
     * @static
     * @memberOf _
     * @since 4.4.0
     * @category Array
     * @param {Array} array The array to flatten.
     * @param {number} [depth=1] The maximum recursion depth.
     * @returns {Array} Returns the new flattened array.
     * @example
     *
     * var array = [1, [2, [3, [4]], 5]];
     *
     * _.flattenDepth(array, 1);
     * // => [1, 2, [3, [4]], 5]
     *
     * _.flattenDepth(array, 2);
     * // => [1, 2, 3, [4], 5]
     */

/**
     * Recursively flattens `array`.
     *
     * @static
     * @memberOf _
     * @since 3.0.0
     * @category Array
     * @param {Array} array The array to flatten.
     * @returns {Array} Returns the new flattened array.
     * @example
     *
     * _.flattenDeep([1, [2, [3, [4]], 5]]);
     * // => [1, 2, 3, 4, 5]
     */

/**
     * Recursively flattens into 1-d Array. Injects Arrays inline.
     * @param {Array} arr The array to flatten
     * @return {Array} The new, flattened array.
     */

/**
     * Reduces `collection` to a value which is the accumulated result of running
     * each element in `collection` thru `iteratee`, where each successive
     * invocation is supplied the return value of the previous. If `accumulator`
     * is not given, the first element of `collection` is used as the initial
     * value. The iteratee is invoked with four arguments:
     * (accumulator, value, index|key, collection).
     *
     * Many lodash methods are guarded to work as iteratees for methods like
     * `_.reduce`, `_.reduceRight`, and `_.transform`.
     *
     * The guarded methods are:
     * `assign`, `defaults`, `defaultsDeep`, `includes`, `merge`, `orderBy`,
     * and `sortBy`
     *
     * @static
     * @memberOf _
     * @since 0.1.0
     * @category Collection
     * @param {Array|Object} collection The collection to iterate over.
     * @param {Function} [iteratee=_.identity] The function invoked per iteration.
     * @param {*} [accumulator] The initial value.
     * @returns {*} Returns the accumulated value.
     * @see _.reduceRight
     * @example
     *
     * _.reduce([1, 2], function(sum, n) {
     *   return sum + n;
     * }, 0);
     * // => 3
     *
     * _.reduce({ 'a': 1, 'b': 2, 'c': 1 }, function(result, value, key) {
     *   (result[value] || (result[value] = [])).push(key);
     *   return result;
     * }, {});
     * // => { '1': ['a', 'c'], '2': ['b'] } (iteration order is not guaranteed)
     */

/**
     * Register a template under an arbitrary name.
     *
     * @param {TwingTemplate} template The template to register
     * @param {string} name The name of the template
     */

/**
     * Register a templates module under an arbitrary name.
     *
     * @param {TwingTemplatesModule} module
     * @param {string} name
     */

/**
     * Registers a Global.
     *
     * New globals can be added before compiling or rendering a template, but after, you can only update existing globals.
     *
     * @param {string} name The global name
     * @param {*} value The global value
     */

/**
     * Registers a Test.
     *
     * @param {TwingTest} test
     */

/**
     * Registers an extension.
     *
     * @param {TwingExtensionInterface} extension A TwingExtensionInterface instance
     * @param {string} name A name the extension will be registered as
     */

/**
     * Registers some extensions.
     *
     * @param {Map<string, TwingExtensionInterface>} extensions
     */

/**
     * Registers somes extensions.
     *
     * @param {Map<string, TwingExtensionInterface>} extensions
     */

/**
     * Removes `key` and its value from the hash.
     *
     * @private
     * @name delete
     * @memberOf Hash
     * @param {Object} hash The hash to modify.
     * @param {string} key The key of the value to remove.
     * @returns {boolean} Returns `true` if the entry was removed, else `false`.
     */

/**
     * Removes `key` and its value from the list cache.
     *
     * @private
     * @name delete
     * @memberOf ListCache
     * @param {string} key The key of the value to remove.
     * @returns {boolean} Returns `true` if the entry was removed, else `false`.
     */

/**
     * Removes `key` and its value from the map.
     *
     * @private
     * @name delete
     * @memberOf MapCache
     * @param {string} key The key of the value to remove.
     * @returns {boolean} Returns `true` if the entry was removed, else `false`.
     */

/**
     * Removes `key` and its value from the stack.
     *
     * @private
     * @name delete
     * @memberOf Stack
     * @param {string} key The key of the value to remove.
     * @returns {boolean} Returns `true` if the entry was removed, else `false`.
     */

/**
     * Removes a DOM node from the document.
     */

/**
     * Removes all elements from `array` that `predicate` returns truthy for
     * and returns an array of the removed elements. The predicate is invoked
     * with three arguments: (value, index, array).
     *
     * **Note:** Unlike `_.filter`, this method mutates `array`. Use `_.pull`
     * to pull elements from an array by value.
     *
     * @static
     * @memberOf _
     * @since 2.0.0
     * @category Array
     * @param {Array} array The array to modify.
     * @param {Function} [predicate=_.identity] The function invoked per iteration.
     * @returns {Array} Returns the new array of removed elements.
     * @example
     *
     * var array = [1, 2, 3, 4];
     * var evens = _.remove(array, function(n) {
     *   return n % 2 == 0;
     * });
     *
     * console.log(array);
     * // => [1, 3]
     *
     * console.log(evens);
     * // => [2, 4]
     */

/**
     * Removes all given values from `array` using
     * [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero)
     * for equality comparisons.
     *
     * **Note:** Unlike `_.without`, this method mutates `array`. Use `_.remove`
     * to remove elements from an array by predicate.
     *
     * @static
     * @memberOf _
     * @since 2.0.0
     * @category Array
     * @param {Array} array The array to modify.
     * @param {...*} [values] The values to remove.
     * @returns {Array} Returns `array`.
     * @example
     *
     * var array = ['a', 'b', 'c', 'a', 'b', 'c'];
     *
     * _.pull(array, 'a', 'c');
     * console.log(array);
     * // => ['b', 'b']
     */

/**
     * Removes all key-value entries from the hash.
     *
     * @private
     * @name clear
     * @memberOf Hash
     */

/**
     * Removes all key-value entries from the list cache.
     *
     * @private
     * @name clear
     * @memberOf ListCache
     */

/**
     * Removes all key-value entries from the map.
     *
     * @private
     * @name clear
     * @memberOf MapCache
     */

/**
     * Removes all key-value entries from the stack.
     *
     * @private
     * @name clear
     * @memberOf Stack
     */

/**
     * Removes elements from `array` corresponding to `indexes` and returns an
     * array of removed elements.
     *
     * **Note:** Unlike `_.at`, this method mutates `array`.
     *
     * @static
     * @memberOf _
     * @since 3.0.0
     * @category Array
     * @param {Array} array The array to modify.
     * @param {...(number|number[])} [indexes] The indexes of elements to remove.
     * @returns {Array} Returns the new array of removed elements.
     * @example
     *
     * var array = ['a', 'b', 'c', 'd'];
     * var pulled = _.pullAt(array, [1, 3]);
     *
     * console.log(array);
     * // => ['a', 'c']
     *
     * console.log(pulled);
     * // => ['b', 'd']
     */

/**
     * Removes leading and trailing whitespace or specified characters from `string`.
     *
     * @static
     * @memberOf _
     * @since 3.0.0
     * @category String
     * @param {string} [string=''] The string to trim.
     * @param {string} [chars=whitespace] The characters to trim.
     * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`.
     * @returns {string} Returns the trimmed string.
     * @example
     *
     * _.trim('  abc  ');
     * // => 'abc'
     *
     * _.trim('-_-abc-_-', '_-');
     * // => 'abc'
     *
     * _.map(['  foo  ', '  bar  '], _.trim);
     * // => ['foo', 'bar']
     */

/**
     * Removes leading whitespace or specified characters from `string`.
     *
     * @static
     * @memberOf _
     * @since 4.0.0
     * @category String
     * @param {string} [string=''] The string to trim.
     * @param {string} [chars=whitespace] The characters to trim.
     * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`.
     * @returns {string} Returns the trimmed string.
     * @example
     *
     * _.trimStart('  abc  ');
     * // => 'abc  '
     *
     * _.trimStart('-_-abc-_-', '_-');
     * // => 'abc-_-'
     */

/**
     * Removes the property at `path` of `object`.
     *
     * **Note:** This method mutates `object`.
     *
     * @static
     * @memberOf _
     * @since 4.0.0
     * @category Object
     * @param {Object} object The object to modify.
     * @param {Array|string} path The path of the property to unset.
     * @returns {boolean} Returns `true` if the property is deleted, else `false`.
     * @example
     *
     * var object = { 'a': [{ 'b': { 'c': 7 } }] };
     * _.unset(object, 'a[0].b.c');
     * // => true
     *
     * console.log(object);
     * // => { 'a': [{ 'b': {} }] };
     *
     * _.unset(object, ['a', '0', 'b', 'c']);
     * // => true
     *
     * console.log(object);
     * // => { 'a': [{ 'b': {} }] };
     */

/**
     * Removes trailing whitespace or specified characters from `string`.
     *
     * @static
     * @memberOf _
     * @since 4.0.0
     * @category String
     * @param {string} [string=''] The string to trim.
     * @param {string} [chars=whitespace] The characters to trim.
     * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`.
     * @returns {string} Returns the trimmed string.
     * @example
     *
     * _.trimEnd('  abc  ');
     * // => '  abc'
     *
     * _.trimEnd('-_-abc-_-', '_-');
     * // => '-_-abc'
     */

/**
     * Renders a block.
     *
     * @param {string} name The block name to display
     * @param {any} context The context
     * @param {TwingOutputBuffer} outputBuffer
     * @param {TwingTemplateBlocksMap} blocks The active set of blocks
     * @param {boolean} useBlocks Whether to use the active set of blocks
     *
     * @return {Promise<string>} The rendered block
     */

/**
     * Renders a parent block.
     *
     * @param {string} name The block name to display from the parent
     * @param {*} context The context
     * @param {TwingOutputBuffer} outputBuffer
     * @param {TwingTemplateBlocksMap} blocks The active set of blocks
     *
     * @returns {Promise<string>} The rendered block
     */

/**
     * Renders a template.
     *
     * @param {string} name The template name
     * @param {{}} context An array of parameters to pass to the template
     * @return {Promise<string>}
     */

/**
     * Reorder `array` according to the specified indexes where the element at
     * the first index is assigned as the first element, the element at
     * the second index is assigned as the second element, and so on.
     *
     * @private
     * @param {Array} array The array to reorder.
     * @param {Array} indexes The arranged array indexes.
     * @returns {Array} Returns `array`.
     */

/**
     * Repeats the given string `n` times.
     *
     * @static
     * @memberOf _
     * @since 3.0.0
     * @category String
     * @param {string} [string=''] The string to repeat.
     * @param {number} [n=1] The number of times to repeat the string.
     * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`.
     * @returns {string} Returns the repeated string.
     * @example
     *
     * _.repeat('*', 3);
     * // => '***'
     *
     * _.repeat('abc', 2);
     * // => 'abcabc'
     *
     * _.repeat('abc', 0);
     * // => ''
     */

/**
     * Replace our custom html characters with the proper characters
     *
     * @param {String} value The string to encode
     * @return {String} The encoded text
     */

/**
     * Replaces matches for `pattern` in `string` with `replacement`.
     *
     * **Note:** This method is based on
     * [`String#replace`](https://mdn.io/String/replace).
     *
     * @static
     * @memberOf _
     * @since 4.0.0
     * @category String
     * @param {string} [string=''] The string to modify.
     * @param {RegExp|string} pattern The pattern to replace.
     * @param {Function|string} replacement The match replacement.
     * @returns {string} Returns the modified string.
     * @example
     *
     * _.replace('Hi Fred', 'Fred', 'Barney');
     * // => 'Hi Barney'
     */

/**
     * Return the column where the token is located in the source.
     *
     * @return {number}
     */

/**
     * Return the contents of the output buffer
     *
     * @returns {string | false}
     */

/**
     * Return the dom node for the passed String (id), dom node, or Ext.Element.
     * Optional 'strict' flag is needed for IE since it can return 'name' and
     * 'id' elements by using getElementById.
     * Here are some examples:
     * <pre><code>
    // gets dom node based on id
    var elDom = Ext.getDom('elId');
    // gets dom node based on the dom node
    var elDom1 = Ext.getDom(elDom);
    // If we don&#39;t know if we are working with an
    // Ext.Element or a dom node use Ext.getDom
    function(el){
    var dom = Ext.getDom(el);
    // do something with the dom node
    }
     * </code></pre>
     * <b>Note</b>: the dom node to be found actually needs to exist (be rendered, etc)
     * when this method is called to be successful.
     * @param {Mixed} el
     * @return HTMLElement
     */

/**
     * Return the human-readable representation of the token.
     *
     * @return {string}
     */

/**
     * Return the line where the token is located in the source.
     *
     * @return {number}
     */

/**
     * Return the nesting level of the output buffering mechanism
     *
     * @returns {number}
     */

/**
     * Return the type of the token.
     *
     * @return {TokenType}
     */

/**
     * Return the value of the token.
     *
     * @return {*}
     */

/**
     * Returns a date rendering function that can be reused to apply a date format multiple times efficiently
     * @param {String} format Any valid date format string
     * @return {Function} The date formatting function
     */

/**
     * Returns a number rendering function that can be reused to apply a number format multiple times efficiently
     * @param {String} format Any valid number format string for {@link #number}
     * @return {Function} The number formatting function
     */

/**
     * Returns a substring from within an original string
     * @param {String} value The original text
     * @param {Number} start The start index of the substring
     * @param {Number} length The length of the substring
     * @return {String} The substring
     */

/**
     * Returns all registered extensions.
     *
     * @return Map<string, TwingExtensionInterface>
     */

/**
     * Returns an error code if this DateTime is invalid, or null if the DateTime is valid
     * @type {string}
     */

/**
     * Returns an error code if this Duration became invalid, or null if the Duration is valid
     * @return {string}
     */

/**
     * Returns an error code if this Interval is invalid, or null if the Interval is valid
     * @type {string}
     */

/**
     * Returns an explanation of why this DateTime became invalid, or null if the DateTime is valid
     * @type {string}
     */

/**
     * Returns an explanation of why this Duration became invalid, or null if the Duration is valid
     * @type {string}
     */

/**
     * Returns an explanation of why this Interval became invalid, or null if the Interval is valid
     * @type {string}
     */

/**
     * Returns template blocks.
     *
     * @returns {Promise<TwingTemplateBlocksMap>} A map of blocks
     */

/**
     * Returns template traits.
     *
     * @returns {Promise<TwingTemplateBlocksMap>} A map of traits
     */

/**
     * Returns the current HTML document object as an {@link Ext.Element}.
     * @return Ext.Element The document
     */

/**
     * Returns the current document body as an {@link Ext.Element}.
     * @return Ext.Element The document body
     */

/**
     * Returns the end of the Interval
     * @type {DateTime}
     */

/**
     * Returns the environment instance related to this compiler.
     *
     * @returns TwingEnvironment
     */

/**
     * Returns the maximum value in the Array
     * @param {Array|NodeList} arr The Array from which to select the maximum value.
     * @param {Function} comp (optional) a function to perform the comparision which determines maximization.
     *                   If omitted the ">" operator will be used. Note: gt = 1; eq = 0; lt = -1
     * @return {Object} The maximum value in the Array.
     */

/**
     * Returns the minimum value in the Array.
     * @param {Array|NodeList} arr The Array from which to select the minimum value.
     * @param {Function} comp (optional) a function to perform the comparision which determines minimization.
     *                   If omitted the "<" operator will be used. Note: gt = 1; eq = 0; lt = -1
     * @return {Object} The minimum value in the Array.
     */

/**
     * Returns the number of days in this DateTime's month
     * @example DateTime.local(2016, 2).daysInMonth //=> 29
     * @example DateTime.local(2016, 3).daysInMonth //=> 31
     * @type {number}
     */

/**
     * Returns the number of days in this DateTime's year
     * @example DateTime.local(2016).daysInYear //=> 366
     * @example DateTime.local(2013).daysInYear //=> 365
     * @type {number}
     */

/**
     * Returns the number of weeks in this DateTime's year
     * @see https://en.wikipedia.org/wiki/ISO_week_date
     * @example DateTime.local(2004).weeksInWeekYear //=> 53
     * @example DateTime.local(2013).weeksInWeekYear //=> 52
     * @type {number}
     */

/**
     * Returns the parent template.
     *
     * @param {any} context
     *
     * @returns {Promise<TwingTemplate|false>} The parent template or false if there is no parent
     */

/**
     * Returns the template name.
     *
     * @returns {string} The template name
     */

/**
     * Returns the traceable callable.
     *
     * @param {number} lineno
     * @param {TwingSource} source
     *
     * @return {TwingCallable<T>}
     */

/**
     * Returns the type of object that is passed in. If the object passed in is null or undefined it
     * return false otherwise it returns one of the following values:<div class="mdetail-params"><ul>
     * <li><b>string</b>: If the object passed is a string</li>
     * <li><b>number</b>: If the object passed is a number</li>
     * <li><b>boolean</b>: If the object passed is a boolean value</li>
     * <li><b>date</b>: If the object passed is a Date object</li>
     * <li><b>function</b>: If the object passed is a function reference</li>
     * <li><b>object</b>: If the object passed is an object</li>
     * <li><b>array</b>: If the object passed is an array</li>
     * <li><b>regexp</b>: If the object passed is a regular expression</li>
     * <li><b>element</b>: If the object passed is a DOM Element</li>
     * <li><b>nodelist</b>: If the object passed is a DOM NodeList</li>
     * <li><b>textnode</b>: If the object passed is a DOM text node and contains something other than whitespace</li>
     * <li><b>whitespace</b>: If the object passed is a DOM text node and contains only whitespace</li>
     * </ul></div>
     * @param {Mixed} object
     * @return {String}
     */

/**
     * Returns true if the given extension is registered.
     *
     * @param {string} name
     * @return {boolean}
     */

/**
     * Returns true if the passed object is a JavaScript date object, otherwise false.
     * @param {Object} object The object to test
     * @return {Boolean}
     */

/**
     * Returns true if the passed value is a JavaScript 'primitive', a string, number or boolean.
     * @param {Mixed} value The value to test
     * @return {Boolean}
     */

/**
     * Returns true if the passed value is a JavaScript Function, otherwise false.
     * @param {Mixed} value The value to test
     * @return {Boolean}
     */

/**
     * Returns true if the passed value is a JavaScript Object, otherwise false.
     * @param {Mixed} value The value to test
     * @return {Boolean}
     */

/**
     * Returns true if the passed value is a JavaScript array, otherwise false.
     * @param {Mixed} value The value to test
     * @return {Boolean}
     */

/**
     * Returns true if the passed value is a boolean.
     * @param {Mixed} value The value to test
     * @return {Boolean}
     */

/**
     * Returns true if the passed value is a number. Returns false for non-finite numbers.
     * @param {Mixed} value The value to test
     * @return {Boolean}
     */

/**
     * Returns true if the passed value is a string.
     * @param {Mixed} value The value to test
     * @return {Boolean}
     */

/**
     * Returns true if the passed value is an HTMLElement
     * @param {Mixed} value The value to test
     * @return {Boolean}
     */

/**
     * Returns true if the passed value is not undefined.
     * @param {Mixed} value The value to test
     * @return {Boolean}
     */

/**
     * Returns true if this DateTime is in a leap year, false otherwise
     * @example DateTime.local(2016).isInLeapYear //=> true
     * @example DateTime.local(2013).isInLeapYear //=> false
     * @type {boolean}
     */

/**
     * Returns whether a block exists or not in the active context of the template.
     *
     * This method checks blocks defined in the active template or defined in "used" traits or defined in parent templates.
     *
     * @param {string} name The block name
     * @param {any} context The context
     * @param {TwingTemplateBlocksMap} blocks The active set of blocks
     *
     * @return {Promise<boolean>} true if the block exists, false otherwise
     */

/**
     * Returns whether the Duration is invalid. Invalid durations are returned by diff operations
     * on invalid DateTimes or Intervals.
     * @return {boolean}
     */

/**
     * Returns whether the offset is known to be fixed for the whole year.
     * @abstract
     * @type {boolean}
     */

/**
     * Returns whether this Interval's end is at least its start, meaning that the Interval isn't 'backwards'.
     * @type {boolean}
     */

/**
     * Reverses `array` so that the first element becomes the last, the second
     * element becomes the second to last, and so on.
     *
     * **Note:** This method mutates `array` and is based on
     * [`Array#reverse`](https://mdn.io/Array/reverse).
     *
     * @static
     * @memberOf _
     * @since 4.0.0
     * @category Array
     * @param {Array} array The array to modify.
     * @returns {Array} Returns `array`.
     * @example
     *
     * var array = [1, 2, 3];
     *
     * _.reverse(array);
     * // => [3, 2, 1]
     *
     * console.log(array);
     * // => [3, 2, 1]
     */

/**
     * Reverses the direction of lazy iteration.
     *
     * @private
     * @name reverse
     * @memberOf LazyWrapper
     * @returns {Object} Returns the new reversed `LazyWrapper` object.
     */

/**
     * Reverts the `_` variable to its previous value and returns a reference to
     * the `lodash` function.
     *
     * @static
     * @since 0.1.0
     * @memberOf _
     * @category Util
     * @returns {Function} Returns the `lodash` function.
     * @example
     *
     * var lodash = _.noConflict();
     */

/**
     * Rounds the passed number to the required decimal precision.
     * @param {Number/String} value The numeric value to round.
     * @param {Number} precision The number of decimal places to which to round the first parameter's value.
     * @return {Number} The rounded value.
     */

/**
     * Selectively do a plural form of a word based on a numeric value. For example, in a template,
     * {commentCount:plural("Comment")}  would result in "1 Comment" if commentCount was 1 or would be "x Comments"
     * if the value is 0 or greater than 1.
     * @param {Number} value The value to compare against
     * @param {String} singular The singular form of the word
     * @param {String} plural (optional) The plural form of the word (defaults to the singular with an "s")
     */

/**
     * Serialize the stream to a Twig string.
     *
     * @return {string}
     */

/**
     * Serialize the token to a Twig source.
     *
     * @return {string}
     */

/**
     * Set the callback for returning the current timestamp.
     * The function should return a number, which will be interpreted as an Epoch millisecond count
     * @type {function}
     * @example Settings.now = () => Date.now() + 3000 // pretend it is 3 seconds in the future
     * @example Settings.now = () => 0 // always pretend it's Jan 1, 1970 at midnight in UTC time
     */

/**
     * Set the default locale to create DateTimes with. Does not affect existing instances.
     * @type {string}
     */

/**
     * Set the default numbering system to create DateTimes with. Does not affect existing instances.
     * @type {string}
     */

/**
     * Set the default output calendar to create DateTimes with. Does not affect existing instances.
     * @type {string}
     */

/**
     * Set the default time zone to create DateTimes in. Does not affect existing instances.
     * @type {string}
     */

/**
     * Set the pointer to the next token and returns the previous one.
     *
     * @return {Token}
     */

/**
     * Set whether Luxon will throw when it encounters invalid DateTimes, Durations, or Intervals
     * @type {boolean}
     */

/**
     * Sets metadata for `func`.
     *
     * **Note:** If this function becomes hot, i.e. is invoked a lot in a short
     * period of time, it will trip its breaker and transition to an identity
     * function to avoid garbage collection pauses in V8. See
     * [V8 issue 2070](https://bugs.chromium.org/p/v8/issues/detail?id=2070)
     * for more details.
     *
     * @private
     * @param {Function} func The function to associate metadata with.
     * @param {*} data The metadata.
     * @returns {Function} Returns `func`.
     */

/**
     * Sets the `toString` method of `wrapper` to mimic the source of `reference`
     * with wrapper details in a comment at the top of the source body.
     *
     * @private
     * @param {Function} wrapper The function to modify.
     * @param {Function} reference The reference function.
     * @param {number} bitmask The bitmask flags. See `createWrap` for more details.
     * @returns {Function} Returns `wrapper`.
     */

/**
     * Sets the active cache implementation.
     *
     * @param {TwingCacheInterface|string|false} cache A TwingCacheInterface implementation, a string or false to disable cache
     */

/**
     * Sets the default format to be used by the date filter.
     *
     * @param {string} format The default date format string
     * @param {string} dateIntervalFormat The default date interval format string
     */

/**
     * Sets the default format to be used by the number_format filter.
     *
     * @param {number} decimal the number of decimal places to use
     * @param {string} decimalPoint the character(s) to use for the decimal point
     * @param {string} thousandSep  the character(s) to use for the thousands separator
     */

/**
     * Sets the default strategy to use when not defined by the user.
     *
     * @param {string | false | TwingEscapingStrategyResolver} defaultStrategy An escaping strategy
     */

/**
     * Sets the default template charset.
     *
     * @param {string} charset The default charset
     */

/**
     * Sets the default timezone to be used by the date filter.
     *
     * @param {string} timezone The default timezone string or a TwingDateTimeZone object
     */

/**
     * Sets the hash `key` to `value`.
     *
     * @private
     * @name set
     * @memberOf Hash
     * @param {string} key The key of the value to set.
     * @param {*} value The value to set.
     * @returns {Object} Returns the hash instance.
     */

/**
     * Sets the list cache `key` to `value`.
     *
     * @private
     * @name set
     * @memberOf ListCache
     * @param {string} key The key of the value to set.
     * @param {*} value The value to set.
     * @returns {Object} Returns the list cache instance.
     */

/**
     * Sets the map `key` to `value`.
     *
     * @private
     * @name set
     * @memberOf MapCache
     * @param {string} key The key of the value to set.
     * @param {*} value The value to set.
     * @returns {Object} Returns the map cache instance.
     */

/**
     * Sets the source context of the Twig template where the error occurred.
     */

/**
     * Sets the stack `key` to `value`.
     *
     * @private
     * @name set
     * @memberOf Stack
     * @param {string} key The key of the value to set.
     * @param {*} value The value to set.
     * @returns {Object} Returns the stack cache instance.
     */

/**
     * Sets the template line where the error occurred.
     *
     * @param {number} lineno The template line
     */

/**
     * Sets the value at `path` of `object`. If a portion of `path` doesn't exist,
     * it's created. Arrays are created for missing index properties while objects
     * are created for all other missing properties. Use `_.setWith` to customize
     * `path` creation.
     *
     * **Note:** This method mutates `object`.
     *
     * @static
     * @memberOf _
     * @since 3.7.0
     * @category Object
     * @param {Object} object The object to modify.
     * @param {Array|string} path The path of the property to set.
     * @param {*} value The value to set.
     * @returns {Object} Returns `object`.
     * @example
     *
     * var object = { 'a': [{ 'b': { 'c': 3 } }] };
     *
     * _.set(object, 'a[0].b.c', 4);
     * console.log(object.a[0].b.c);
     * // => 4
     *
     * _.set(object, ['x', '0', 'y', 'z'], 5);
     * console.log(object.x[0].y.z);
     * // => 5
     */

/**
     * Simple format for a file size (xxx bytes, xxx KB, xxx MB)
     * @param {Number/String} size The numeric value to format
     * @return {String} The formatted file size
     */

/**
     * Splits `string` by `separator`.
     *
     * **Note:** This method is based on
     * [`String#split`](https://mdn.io/String/split).
     *
     * @static
     * @memberOf _
     * @since 4.0.0
     * @category String
     * @param {string} [string=''] The string to split.
     * @param {RegExp|string} separator The separator pattern to split by.
     * @param {number} [limit] The length to truncate results to.
     * @returns {Array} Returns the string segments.
     * @example
     *
     * _.split('a-b-c', '-', 2);
     * // => ['a', 'b']
     */

/**
     * 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']
     */

/**
     * Strips all HTML tags
     * @param {Mixed} value The text from which to strip tags
     * @return {String} The stripped text
     */

/**
     * Strips all script tags
     * @param {Mixed} value The text from which to strip script tags
     * @return {String} The stripped text
     */

/**
     * Takes an encoded URL and and converts it to an object. Example: <pre><code>
    Ext.urlDecode("foo=1&bar=2"); // returns {foo: "1", bar: "2"}
    Ext.urlDecode("foo=1&bar=2&bar=3&bar=4", false); // returns {foo: "1", bar: ["2", "3", "4"]}
    </code></pre>
     * @param {String} string
     * @param {Boolean} overwrite (optional) Items of the same name will overwrite previous values instead of creating an an array (Defaults to false).
     * @return {Object} A literal with members
     */

/**
     * Takes an object and converts it to an encoded URL. e.g. Ext.urlEncode({foo: 1, bar: 2}); would return "foo=1&bar=2".  Optionally, property values can be arrays, instead of keys and the resulting string that's returned will contain a name/value pair for each array value.
     * @param {Object} o
     * @param {String} pre (optional) A prefix to add to the url encoded string
     * @return {String}
     */

/**
     * Test the current token, then, if the test is successful, sets the pointer to the next one and returns the tested token.
     *
     * @return {Token} The next token if the condition is true, null otherwise
     */

/**
     * Test the current token.
     *
     * @param {TokenType} type
     * @param {string|string[]|number} value
     * @returns {boolean}
     */

/**
     * Test the token for a type and/or a content.
     *
     * @param {TokenType} type
     * @param {string|string[]|number} value
     * @returns {boolean}
     */

/**
     * Tests a token and returns it or throws a syntax error.
     *
     * @return {Token}
     */

/**
     * The base constructor for creating `lodash` wrapper objects.
     *
     * @private
     * @param {*} value The value to wrap.
     * @param {boolean} [chainAll] Enable explicit method chain sequences.
     */

/**
     * The base implementation of  `_.pickBy` without support for iteratee shorthands.
     *
     * @private
     * @param {Object} object The source object.
     * @param {string[]} paths The property paths to pick.
     * @param {Function} predicate The function invoked per property.
     * @returns {Object} Returns the new object.
     */

/**
     * The base implementation of `_.assignIn` without support for multiple sources
     * or `customizer` functions.
     *
     * @private
     * @param {Object} object The destination object.
     * @param {Object} source The source object.
     * @returns {Object} Returns `object`.
     */

/**
     * The base implementation of `_.assign` without support for multiple sources
     * or `customizer` functions.
     *
     * @private
     * @param {Object} object The destination object.
     * @param {Object} source The source object.
     * @returns {Object} Returns `object`.
     */

/**
     * The base implementation of `_.at` without support for individual paths.
     *
     * @private
     * @param {Object} object The object to iterate over.
     * @param {string[]} paths The property paths to pick.
     * @returns {Array} Returns the picked elements.
     */

/**
     * The base implementation of `_.clamp` which doesn't coerce arguments.
     *
     * @private
     * @param {number} number The number to clamp.
     * @param {number} [lower] The lower bound.
     * @param {number} upper The upper bound.
     * @returns {number} Returns the clamped number.
     */

/**
     * The base implementation of `_.clone` and `_.cloneDeep` which tracks
     * traversed objects.
     *
     * @private
     * @param {*} value The value to clone.
     * @param {boolean} bitmask The bitmask flags.
     *  1 - Deep clone
     *  2 - Flatten inherited properties
     *  4 - Clone symbols
     * @param {Function} [customizer] The function to customize cloning.
     * @param {string} [key] The key of `value`.
     * @param {Object} [object] The parent object of `value`.
     * @param {Object} [stack] Tracks traversed objects and their clone counterparts.
     * @returns {*} Returns the cloned value.
     */

/**
     * The base implementation of `_.conformsTo` which accepts `props` to check.
     *
     * @private
     * @param {Object} object The object to inspect.
     * @param {Object} source The object of property predicates to conform to.
     * @returns {boolean} Returns `true` if `object` conforms, else `false`.
     */

/**
     * The base implementation of `_.conforms` which doesn't clone `source`.
     *
     * @private
     * @param {Object} source The object of property predicates to conform to.
     * @returns {Function} Returns the new spec function.
     */

/**
     * The base implementation of `_.create` without support for assigning
     * properties to the created object.
     *
     * @private
     * @param {Object} proto The object to inherit from.
     * @returns {Object} Returns the new object.
     */

/**
     * The base implementation of `_.delay` and `_.defer` which accepts `args`
     * to provide to `func`.
     *
     * @private
     * @param {Function} func The function to delay.
     * @param {number} wait The number of milliseconds to delay invocation.
     * @param {Array} args The arguments to provide to `func`.
     * @returns {number|Object} Returns the timer id or timeout object.
     */

/**
     * The base implementation of `_.every` without support for iteratee shorthands.
     *
     * @private
     * @param {Array|Object} collection The collection to iterate over.
     * @param {Function} predicate The function invoked per iteration.
     * @returns {boolean} Returns `true` if all elements pass the predicate check,
     *  else `false`
     */

/**
     * The base implementation of `_.fill` without an iteratee call guard.
     *
     * @private
     * @param {Array} array The array to fill.
     * @param {*} value The value to fill `array` with.
     * @param {number} [start=0] The start position.
     * @param {number} [end=array.length] The end position.
     * @returns {Array} Returns `array`.
     */

/**
     * The base implementation of `_.filter` without support for iteratee shorthands.
     *
     * @private
     * @param {Array|Object} collection The collection to iterate over.
     * @param {Function} predicate The function invoked per iteration.
     * @returns {Array} Returns the new filtered array.
     */

/**
     * The base implementation of `_.flatten` with support for restricting flattening.
     *
     * @private
     * @param {Array} array The array to flatten.
     * @param {number} depth The maximum recursion depth.
     * @param {boolean} [predicate=isFlattenable] The function invoked per iteration.
     * @param {boolean} [isStrict] Restrict to values that pass `predicate` checks.
     * @param {Array} [result=[]] The initial result value.
     * @returns {Array} Returns the new flattened array.
     */

/**
     * The base implementation of `_.forEachRight` without support for iteratee shorthands.
     *
     * @private
     * @param {Array|Object} collection The collection to iterate over.
     * @param {Function} iteratee The function invoked per iteration.
     * @returns {Array|Object} Returns `collection`.
     */

/**
     * The base implementation of `_.forEach` without support for iteratee shorthands.
     *
     * @private
     * @param {Array|Object} collection The collection to iterate over.
     * @param {Function} iteratee The function invoked per iteration.
     * @returns {Array|Object} Returns `collection`.
     */

/**
     * The base implementation of `_.forOwnRight` without support for iteratee shorthands.
     *
     * @private
     * @param {Object} object The object to iterate over.
     * @param {Function} iteratee The function invoked per iteration.
     * @returns {Object} Returns `object`.
     */

/**
     * The base implementation of `_.forOwn` without support for iteratee shorthands.
     *
     * @private
     * @param {Object} object The object to iterate over.
     * @param {Function} iteratee The function invoked per iteration.
     * @returns {Object} Returns `object`.
     */

/**
     * The base implementation of `_.functions` which creates an array of
     * `object` function property names filtered from `props`.
     *
     * @private
     * @param {Object} object The object to inspect.
     * @param {Array} props The property names to filter.
     * @returns {Array} Returns the function names.
     */

/**
     * The base implementation of `_.get` without support for default values.
     *
     * @private
     * @param {Object} object The object to query.
     * @param {Array|string} path The path of the property to get.
     * @returns {*} Returns the resolved value.
     */

/**
     * The base implementation of `_.gt` which doesn't coerce arguments.
     *
     * @private
     * @param {*} value The value to compare.
     * @param {*} other The other value to compare.
     * @returns {boolean} Returns `true` if `value` is greater than `other`,
     *  else `false`.
     */

/**
     * The base implementation of `_.hasIn` without support for deep paths.
     *
     * @private
     * @param {Object} [object] The object to query.
     * @param {Array|string} key The key to check.
     * @returns {boolean} Returns `true` if `key` exists, else `false`.
     */

/**
     * The base implementation of `_.has` without support for deep paths.
     *
     * @private
     * @param {Object} [object] The object to query.
     * @param {Array|string} key The key to check.
     * @returns {boolean} Returns `true` if `key` exists, else `false`.
     */

/**
     * The base implementation of `_.inRange` which doesn't coerce arguments.
     *
     * @private
     * @param {number} number The number to check.
     * @param {number} start The start of the range.
     * @param {number} end The end of the range.
     * @returns {boolean} Returns `true` if `number` is in the range, else `false`.
     */

/**
     * The base implementation of `_.invert` and `_.invertBy` which inverts
     * `object` with values transformed by `iteratee` and set by `setter`.
     *
     * @private
     * @param {Object} object The object to iterate over.
     * @param {Function} setter The function to set `accumulator` values.
     * @param {Function} iteratee The iteratee to transform values.
     * @param {Object} accumulator The initial inverted object.
     * @returns {Function} Returns `accumulator`.
     */

/**
     * The base implementation of `_.invoke` without support for individual
     * method arguments.
     *
     * @private
     * @param {Object} object The object to query.
     * @param {Array|string} path The path of the method to invoke.
     * @param {Array} args The arguments to invoke the method with.
     * @returns {*} Returns the result of the invoked method.
     */

/**
     * The base implementation of `_.isArguments`.
     *
     * @private
     * @param {*} value The value to check.
     * @returns {boolean} Returns `true` if `value` is an `arguments` object,
     */

/**
     * The base implementation of `_.isArrayBuffer` without Node.js optimizations.
     *
     * @private
     * @param {*} value The value to check.
     * @returns {boolean} Returns `true` if `value` is an array buffer, else `false`.
     */

/**
     * The base implementation of `_.isDate` without Node.js optimizations.
     *
     * @private
     * @param {*} value The value to check.
     * @returns {boolean} Returns `true` if `value` is a date object, else `false`.
     */

/**
     * The base implementation of `_.isEqual` which supports partial comparisons
     * and tracks traversed objects.
     *
     * @private
     * @param {*} value The value to compare.
     * @param {*} other The other value to compare.
     * @param {boolean} bitmask The bitmask flags.
     *  1 - Unordered comparison
     *  2 - Partial comparison
     * @param {Function} [customizer] The function to customize comparisons.
     * @param {Object} [stack] Tracks traversed `value` and `other` objects.
     * @returns {boolean} Returns `true` if the values are equivalent, else `false`.
     */

/**
     * The base implementation of `_.isMap` without Node.js optimizations.
     *
     * @private
     * @param {*} value The value to check.
     * @returns {boolean} Returns `true` if `value` is a map, else `false`.
     */

/**
     * The base implementation of `_.isMatch` without support for iteratee shorthands.
     *
     * @private
     * @param {Object} object The object to inspect.
     * @param {Object} source The object of property values to match.
     * @param {Array} matchData The property names, values, and compare flags to match.
     * @param {Function} [customizer] The function to customize comparisons.
     * @returns {boolean} Returns `true` if `object` is a match, else `false`.
     */

/**
     * The base implementation of `_.isNative` without bad shim checks.
     *
     * @private
     * @param {*} value The value to check.
     * @returns {boolean} Returns `true` if `value` is a native function,
     *  else `false`.
     */

/**
     * The base implementation of `_.isRegExp` without Node.js optimizations.
     *
     * @private
     * @param {*} value The value to check.
     * @returns {boolean} Returns `true` if `value` is a regexp, else `false`.
     */

/**
     * The base implementation of `_.isSet` without Node.js optimizations.
     *
     * @private
     * @param {*} value The value to check.
     * @returns {boolean} Returns `true` if `value` is a set, else `false`.
     */

/**
     * The base implementation of `_.isTypedArray` without Node.js optimizations.
     *
     * @private
     * @param {*} value The value to check.
     * @returns {boolean} Returns `true` if `value` is a typed array, else `false`.
     */

/**
     * The base implementation of `_.iteratee`.
     *
     * @private
     * @param {*} [value=_.identity] The value to convert to an iteratee.
     * @returns {Function} Returns the iteratee.
     */

/**
     * The base implementation of `_.keysIn` which doesn't treat sparse arrays as dense.
     *
     * @private
     * @param {Object} object The object to query.
     * @returns {Array} Returns the array of property names.
     */

/**
     * The base implementation of `_.keys` which doesn't treat sparse arrays as dense.
     *
     * @private
     * @param {Object} object The object to query.
     * @returns {Array} Returns the array of property names.
     */

/**
     * The base implementation of `_.lt` which doesn't coerce arguments.
     *
     * @private
     * @param {*} value The value to compare.
     * @param {*} other The other value to compare.
     * @returns {boolean} Returns `true` if `value` is less than `other`,
     *  else `false`.
     */

/**
     * The base implementation of `_.map` without support for iteratee shorthands.
     *
     * @private
     * @param {Array|Object} collection The collection to iterate over.
     * @param {Function} iteratee The function invoked per iteration.
     * @returns {Array} Returns the new mapped array.
     */

/**
     * The base implementation of `_.matchesProperty` which doesn't clone `srcValue`.
     *
     * @private
     * @param {string} path The path of the property to get.
     * @param {*} srcValue The value to match.
     * @returns {Function} Returns the new spec function.
     */

/**
     * The base implementation of `_.matches` which doesn't clone `source`.
     *
     * @private
     * @param {Object} source The object of property values to match.
     * @returns {Function} Returns the new spec function.
     */

/**
     * The base implementation of `_.merge` without support for multiple sources.
     *
     * @private
     * @param {Object} object The destination object.
     * @param {Object} source The source object.
     * @param {number} srcIndex The index of `source`.
     * @param {Function} [customizer] The function to customize merged values.
     * @param {Object} [stack] Tracks traversed source values and their merged
     *  counterparts.
     */

/**
     * The base implementation of `_.nth` which doesn't coerce arguments.
     *
     * @private
     * @param {Array} array The array to query.
     * @param {number} n The index of the element to return.
     * @returns {*} Returns the nth element of `array`.
     */

/**
     * The base implementation of `_.orderBy` without param guards.
     *
     * @private
     * @param {Array|Object} collection The collection to iterate over.
     * @param {Function[]|Object[]|string[]} iteratees The iteratees to sort by.
     * @param {string[]} orders The sort orders of `iteratees`.
     * @returns {Array} Returns the new sorted array.
     */

/**
     * The base implementation of `_.pick` without support for individual
     * property identifiers.
     *
     * @private
     * @param {Object} object The source object.
     * @param {string[]} paths The property paths to pick.
     * @returns {Object} Returns the new object.
     */

/**
     * The base implementation of `_.pullAllBy` without support for iteratee
     * shorthands.
     *
     * @private
     * @param {Array} array The array to modify.
     * @param {Array} values The values to remove.
     * @param {Function} [iteratee] The iteratee invoked per element.
     * @param {Function} [comparator] The comparator invoked per element.
     * @returns {Array} Returns `array`.
     */

/**
     * The base implementation of `_.pullAt` without support for individual
     * indexes or capturing the removed elements.
     *
     * @private
     * @param {Array} array The array to modify.
     * @param {number[]} indexes The indexes of elements to remove.
     * @returns {Array} Returns `array`.
     */

/**
     * The base implementation of `_.random` without support for returning
     * floating-point numbers.
     *
     * @private
     * @param {number} lower The lower bound.
     * @param {number} upper The upper bound.
     * @returns {number} Returns the random number.
     */

/**
     * The base implementation of `_.range` and `_.rangeRight` which doesn't
     * coerce arguments.
     *
     * @private
     * @param {number} start The start of the range.
     * @param {number} end The end of the range.
     * @param {number} step The value to increment or decrement by.
     * @param {boolean} [fromRight] Specify iterating from right to left.
     * @returns {Array} Returns the range of numbers.
     */

/**
     * 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.
     */

/**
     * The base implementation of `_.rest` which doesn't validate or coerce arguments.
     *
     * @private
     * @param {Function} func The function to apply a rest parameter to.
     * @param {number} [start=func.length-1] The start position of the rest parameter.
     * @returns {Function} Returns the new function.
     */

/**
     * The base implementation of `_.sampleSize` without param guards.
     *
     * @private
     * @param {Array|Object} collection The collection to sample.
     * @param {number} n The number of elements to sample.
     * @returns {Array} Returns the random elements.
     */

/**
     * The base implementation of `_.sample`.
     *
     * @private
     * @param {Array|Object} collection The collection to sample.
     * @returns {*} Returns the random element.
     */

/**
     * The base implementation of `_.set`.
     *
     * @private
     * @param {Object} object The object to modify.
     * @param {Array|string} path The path of the property to set.
     * @param {*} value The value to set.
     * @param {Function} [customizer] The function to customize path creation.
     * @returns {Object} Returns `object`.
     */

/**
     * The base implementation of `_.shuffle`.
     *
     * @private
     * @param {Array|Object} collection The collection to shuffle.
     * @returns {Array} Returns the new shuffled array.
     */

/**
     * 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`.
     */

/**
     * The base implementation of `_.some` without support for iteratee shorthands.
     *
     * @private
     * @param {Array|Object} collection The collection to iterate over.
     * @param {Function} predicate The function invoked per iteration.
     * @returns {boolean} Returns `true` if any element passes the predicate check,
     *  else `false`.
     */

/**
     * The base implementation of `_.sortedIndexBy` and `_.sortedLastIndexBy`
     * which invokes `iteratee` for `value` and each element of `array` to compute
     * their sort ranking. The iteratee is invoked with one argument; (value).
     *
     * @private
     * @param {Array} array The sorted array to inspect.
     * @param {*} value The value to evaluate.
     * @param {Function} iteratee The iteratee invoked per element.
     * @param {boolean} [retHighest] Specify returning the highest qualified index.
     * @returns {number} Returns the index at which `value` should be inserted
     *  into `array`.
     */

/**
     * The base implementation of `_.sortedIndex` and `_.sortedLastIndex` which
     * performs a binary search of `array` to determine the index at which `value`
     * should be inserted into `array` in order to maintain its sort order.
     *
     * @private
     * @param {Array} array The sorted array to inspect.
     * @param {*} value The value to evaluate.
     * @param {boolean} [retHighest] Specify returning the highest qualified index.
     * @returns {number} Returns the index at which `value` should be inserted
     *  into `array`.
     */

/**
     * The base implementation of `_.sortedUniq` and `_.sortedUniqBy` without
     * support for iteratee shorthands.
     *
     * @private
     * @param {Array} array The array to inspect.
     * @param {Function} [iteratee] The iteratee invoked per element.
     * @returns {Array} Returns the new duplicate free array.
     */

/**
     * The base implementation of `_.toNumber` which doesn't ensure correct
     * conversions of binary, hexadecimal, or octal string values.
     *
     * @private
     * @param {*} value The value to process.
     * @returns {number} Returns the number.
     */

/**
     * 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.
     */

/**
     * The base implementation of `_.uniqBy` without support for iteratee shorthands.
     *
     * @private
     * @param {Array} array The array to inspect.
     * @param {Function} [iteratee] The iteratee invoked per element.
     * @param {Function} [comparator] The comparator invoked per element.
     * @returns {Array} Returns the new duplicate free array.
     */

/**
     * The base implementation of `_.unset`.
     *
     * @private
     * @param {Object} object The object to modify.
     * @param {Array|string} path The property path to unset.
     * @returns {boolean} Returns `true` if the property is deleted, else `false`.
     */

/**
     * The base implementation of `_.update`.
     *
     * @private
     * @param {Object} object The object to modify.
     * @param {Array|string} path The path of the property to update.
     * @param {Function} updater The function to produce the updated value.
     * @param {Function} [customizer] The function to customize path creation.
     * @returns {Object} Returns `object`.
     */

/**
     * The base implementation of `assignValue` and `assignMergeValue` without
     * value checks.
     *
     * @private
     * @param {Object} object The object to modify.
     * @param {string} key The key of the property to assign.
     * @param {*} value The value to assign.
     */

/**
     * The base implementation of `baseForOwn` which iterates over `object`
     * properties returned by `keysFunc` and invokes `iteratee` for each property.
     * Iteratee functions may exit iteration early by explicitly returning `false`.
     *
     * @private
     * @param {Object} object The object to iterate over.
     * @param {Function} iteratee The function invoked per iteration.
     * @param {Function} keysFunc The function to get the keys of `object`.
     * @returns {Object} Returns `object`.
     */

/**
     * The base implementation of `getAllKeys` and `getAllKeysIn` which uses
     * `keysFunc` and `symbolsFunc` to get the enumerable property names and
     * symbols of `object`.
     *
     * @private
     * @param {Object} object The object to query.
     * @param {Function} keysFunc The function to get the keys of `object`.
     * @param {Function} symbolsFunc The function to get the symbols of `object`.
     * @returns {Array} Returns the array of property names and symbols.
     */

/**
     * The base implementation of `getTag` without fallbacks for buggy environments.
     *
     * @private
     * @param {*} value The value to query.
     * @returns {string} Returns the `toStringTag`.
     */

/**
     * The base implementation of `setData` without support for hot loop shorting.
     *
     * @private
     * @param {Function} func The function to associate metadata with.
     * @param {*} data The metadata.
     * @returns {Function} Returns `func`.
     */

/**
     * The base implementation of `setToString` without support for hot loop shorting.
     *
     * @private
     * @param {Function} func The function to modify.
     * @param {Function} string The `toString` result.
     * @returns {Function} Returns `func`.
     */

/**
     * The base implementation of `wrapperValue` which returns the result of
     * performing a sequence of actions on the unwrapped `value`, where each
     * successive action is supplied the return value of the previous.
     *
     * @private
     * @param {*} value The unwrapped value.
     * @param {Array} actions Actions to perform to resolve the unwrapped value.
     * @returns {*} Returns the resolved value.
     */

/**
     * The base implementation of methods like `_.difference` without support
     * for excluding multiple arrays or iteratee shorthands.
     *
     * @private
     * @param {Array} array The array to inspect.
     * @param {Array} values The values to exclude.
     * @param {Function} [iteratee] The iteratee invoked per element.
     * @param {Function} [comparator] The comparator invoked per element.
     * @returns {Array} Returns the new array of filtered values.
     */

/**
     * The base implementation of methods like `_.dropWhile` and `_.takeWhile`
     * without support for iteratee shorthands.
     *
     * @private
     * @param {Array} array The array to query.
     * @param {Function} predicate The function invoked per iteration.
     * @param {boolean} [isDrop] Specify dropping elements instead of taking them.
     * @param {boolean} [fromRight] Specify iterating from right to left.
     * @returns {Array} Returns the slice of `array`.
     */

/**
     * The base implementation of methods like `_.intersection`, without support
     * for iteratee shorthands, that accepts an array of arrays to inspect.
     *
     * @private
     * @param {Array} arrays The arrays to inspect.
     * @param {Function} [iteratee] The iteratee invoked per element.
     * @param {Function} [comparator] The comparator invoked per element.
     * @returns {Array} Returns the new array of shared values.
     */

/**
     * The base implementation of methods like `_.max` and `_.min` which accepts a
     * `comparator` to determine the extremum value.
     *
     * @private
     * @param {Array} array The array to iterate over.
     * @param {Function} iteratee The iteratee invoked per iteration.
     * @param {Function} comparator The comparator used to compare values.
     * @returns {*} Returns the extremum value.
     */

/**
     * The base implementation of methods like `_.xor`, without support for
     * iteratee shorthands, that accepts an array of arrays to inspect.
     *
     * @private
     * @param {Array} arrays The arrays to inspect.
     * @param {Function} [iteratee] The iteratee invoked per element.
     * @param {Function} [comparator] The comparator invoked per element.
     * @returns {Array} Returns the new array of values.
     */

/**
     * The function whose prototype chain sequence wrappers inherit from.
     *
     * @private
     */

/**
     * 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'
     */

/**
     * The inverse of `_.toPairs`; this method returns an object composed
     * from key-value `pairs`.
     *
     * @static
     * @memberOf _
     * @since 4.0.0
     * @category Array
     * @param {Array} pairs The key-value pairs.
     * @returns {Object} Returns the new object.
     * @example
     *
     * _.fromPairs([['a', 1], ['b', 2]]);
     * // => { 'a': 1, 'b': 2 }
     */

/**
     * The name of this zone.
     * @abstract
     * @type {string}
     */

/**
     * The opposite of `_.before`; this method creates a function that invokes
     * `func` once it's called `n` or more times.
     *
     * @static
     * @memberOf _
     * @since 0.1.0
     * @category Function
     * @param {number} n The number of calls before `func` is invoked.
     * @param {Function} func The function to restrict.
     * @returns {Function} Returns the new restricted function.
     * @example
     *
     * var saves = ['profile', 'settings'];
     *
     * var done = _.after(saves.length, function() {
     *   console.log('done saving!');
     * });
     *
     * _.forEach(saves, function(type) {
     *   asyncSave({ 'type': type, 'complete': done });
     * });
     * // => Logs 'done saving!' after the two async saves have completed.
     */

/**
     * The opposite of `_.filter`; this method returns the elements of `collection`
     * that `predicate` does **not** return truthy for.
     *
     * @static
     * @memberOf _
     * @since 0.1.0
     * @category Collection
     * @param {Array|Object} collection The collection to iterate over.
     * @param {Function} [predicate=_.identity] The function invoked per iteration.
     * @returns {Array} Returns the new filtered array.
     * @see _.filter
     * @example
     *
     * var users = [
     *   { 'user': 'barney', 'age': 36, 'active': false },
     *   { 'user': 'fred',   'age': 40, 'active': true }
     * ];
     *
     * _.reject(users, function(o) { return !o.active; });
     * // => objects for ['fred']
     *
     * // The `_.matches` iteratee shorthand.
     * _.reject(users, { 'age': 40, 'active': true });
     * // => objects for ['barney']
     *
     * // The `_.matchesProperty` iteratee shorthand.
     * _.reject(users, ['active', false]);
     * // => objects for ['fred']
     *
     * // The `_.property` iteratee shorthand.
     * _.reject(users, 'active');
     * // => objects for ['barney']
     */

/**
     * The opposite of `_.mapValues`; this method creates an object with the
     * same values as `object` and keys generated by running each own enumerable
     * string keyed property of `object` thru `iteratee`. The iteratee is invoked
     * with three arguments: (value, key, object).
     *
     * @static
     * @memberOf _
     * @since 3.8.0
     * @category Object
     * @param {Object} object The object to iterate over.
     * @param {Function} [iteratee=_.identity] The function invoked per iteration.
     * @returns {Object} Returns the new mapped object.
     * @see _.mapValues
     * @example
     *
     * _.mapKeys({ 'a': 1, 'b': 2 }, function(value, key) {
     *   return key + value;
     * });
     * // => { 'a1': 1, 'b2': 2 }
     */

/**
     * The opposite of `_.method`; this method creates a function that invokes
     * the method at a given path of `object`. Any additional arguments are
     * provided to the invoked method.
     *
     * @static
     * @memberOf _
     * @since 3.7.0
     * @category Util
     * @param {Object} object The object to query.
     * @param {...*} [args] The arguments to invoke the method with.
     * @returns {Function} Returns the new invoker function.
     * @example
     *
     * var array = _.times(3, _.constant),
     *     object = { 'a': array, 'b': array, 'c': array };
     *
     * _.map(['a[2]', 'c[0]'], _.methodOf(object));
     * // => [2, 0]
     *
     * _.map([['a', '2'], ['c', '0']], _.methodOf(object));
     * // => [2, 0]
     */

/**
     * The opposite of `_.pickBy`; this method creates an object composed of
     * the own and inherited enumerable string keyed properties of `object` that
     * `predicate` doesn't return truthy for. The predicate is invoked with two
     * arguments: (value, key).
     *
     * @static
     * @memberOf _
     * @since 4.0.0
     * @category Object
     * @param {Object} object The source object.
     * @param {Function} [predicate=_.identity] The function invoked per property.
     * @returns {Object} Returns the new object.
     * @example
     *
     * var object = { 'a': 1, 'b': '2', 'c': 3 };
     *
     * _.omitBy(object, _.isNumber);
     * // => { 'b': '2' }
     */

/**
     * The opposite of `_.property`; this method creates a function that returns
     * the value at a given path of `object`.
     *
     * @static
     * @memberOf _
     * @since 3.0.0
     * @category Util
     * @param {Object} object The object to query.
     * @returns {Function} Returns the new accessor function.
     * @example
     *
     * var array = [0, 1, 2],
     *     object = { 'a': array, 'b': array, 'c': array };
     *
     * _.map(['a[2]', 'c[0]'], _.propertyOf(object));
     * // => [2, 0]
     *
     * _.map([['a', '2'], ['c', '0']], _.propertyOf(object));
     * // => [2, 0]
     */

/**
     * The semantic version number.
     *
     * @static
     * @memberOf _
     * @type {string}
     */

/**
     * The type of zone
     * @abstract
     * @type {string}
     */

/**
     * The {@link Ext.data.Store} to which this Record belongs.
     * @property store
     * @type {Ext.data.Store}
     */

/**
     * This base implementation of `_.zipObject` which assigns values using `assignFunc`.
     *
     * @private
     * @param {Array} props The property identifiers.
     * @param {Array} values The property values.
     * @param {Function} assignFunc The function to assign values.
     * @returns {Object} Returns the new object.
     */

/**
     * This function is like
     * [`Object.keys`](http://ecma-international.org/ecma-262/7.0/#sec-object.keys)
     * except that it includes inherited enumerable properties.
     *
     * @private
     * @param {Object} object The object to query.
     * @returns {Array} Returns the array of property names.
     */

/**
     * This function is like `assignValue` except that it doesn't assign
     * `undefined` values.
     *
     * @private
     * @param {Object} object The object to modify.
     * @param {string} key The key of the property to assign.
     * @param {*} value The value to assign.
     */

/**
     * This function is like `baseFor` except that it iterates over properties
     * in the opposite order.
     *
     * @private
     * @param {Object} object The object to iterate over.
     * @param {Function} iteratee The function invoked per iteration.
     * @param {Function} keysFunc The function to get the keys of `object`.
     * @returns {Object} Returns `object`.
     */

/**
     * This function is like `composeArgs` except that the arguments composition
     * is tailored for `_.partialRight`.
     *
     * @private
     * @param {Array} args The provided arguments.
     * @param {Array} partials The arguments to append to those provided.
     * @param {Array} holders The `partials` placeholder indexes.
     * @params {boolean} [isCurried] Specify composing for a curried function.
     * @returns {Array} Returns the new array of composed arguments.
     */

/**
     * This is shorthand reference to {@link Ext.ComponentMgr#get}.
     * Looks up an existing {@link Ext.Component Component} by {@link Ext.Component#id id}
     * @param {String} id The component {@link Ext.Component#id id}
     * @return Ext.Component The Component, <tt>undefined</tt> if not found, or <tt>null</tt> if a
     * Class was found.
    */

/**
     * This method invokes `interceptor` and returns `value`. The interceptor
     * is invoked with one argument; (value). The purpose of this method is to
     * "tap into" a method chain sequence in order to modify intermediate results.
     *
     * @static
     * @memberOf _
     * @since 0.1.0
     * @category Seq
     * @param {*} value The value to provide to `interceptor`.
     * @param {Function} interceptor The function to invoke.
     * @returns {*} Returns `value`.
     * @example
     *
     * _([1, 2, 3])
     *  .tap(function(array) {
     *    // Mutate input array.
     *    array.pop();
     *  })
     *  .reverse()
     *  .value();
     * // => [2, 1]
     */

/**
     * This method is like `_.assign` except that it iterates over own and
     * inherited source properties.
     *
     * **Note:** This method mutates `object`.
     *
     * @static
     * @memberOf _
     * @since 4.0.0
     * @alias extend
     * @category Object
     * @param {Object} object The destination object.
     * @param {...Object} [sources] The source objects.
     * @returns {Object} Returns `object`.
     * @see _.assign
     * @example
     *
     * function Foo() {
     *   this.a = 1;
     * }
     *
     * function Bar() {
     *   this.c = 3;
     * }
     *
     * Foo.prototype.b = 2;
     * Bar.prototype.d = 4;
     *
     * _.assignIn({ 'a': 0 }, new Foo, new Bar);
     * // => { 'a': 1, 'b': 2, 'c': 3, 'd': 4 }
     */

/**
     * This method is like `_.assign` except that it recursively merges own and
     * inherited enumerable string keyed properties of source objects into the
     * destination object. Source properties that resolve to `undefined` are
     * skipped if a destination value exists. Array and plain object properties
     * are merged recursively. Other objects and value types are overridden by
     * assignment. Source objects are applied from left to right. Subsequent
     * sources overwrite property assignments of previous sources.
     *
     * **Note:** This method mutates `object`.
     *
     * @static
     * @memberOf _
     * @since 0.5.0
     * @category Object
     * @param {Object} object The destination object.
     * @param {...Object} [sources] The source objects.
     * @returns {Object} Returns `object`.
     * @example
     *
     * var object = {
     *   'a': [{ 'b': 2 }, { 'd': 4 }]
     * };
     *
     * var other = {
     *   'a': [{ 'c': 3 }, { 'e': 5 }]
     * };
     *
     * _.merge(object, other);
     * // => { 'a': [{ 'b': 2, 'c': 3 }, { 'd': 4, 'e': 5 }] }
     */

/**
     * This method is like `_.cloneWith` except that it recursively clones `value`.
     *
     * @static
     * @memberOf _
     * @since 4.0.0
     * @category Lang
     * @param {*} value The value to recursively clone.
     * @param {Function} [customizer] The function to customize cloning.
     * @returns {*} Returns the deep cloned value.
     * @see _.cloneWith
     * @example
     *
     * function customizer(value) {
     *   if (_.isElement(value)) {
     *     return value.cloneNode(true);
     *   }
     * }
     *
     * var el = _.cloneDeepWith(document.body, customizer);
     *
     * console.log(el === document.body);
     * // => false
     * console.log(el.nodeName);
     * // => 'BODY'
     * console.log(el.childNodes.length);
     * // => 20
     */

/**
     * This method is like `_.clone` except that it accepts `customizer` which
     * is invoked to produce the cloned value. If `customizer` returns `undefined`,
     * cloning is handled by the method instead. The `customizer` is invoked with
     * up to four arguments; (value [, index|key, object, stack]).
     *
     * @static
     * @memberOf _
     * @since 4.0.0
     * @category Lang
     * @param {*} value The value to clone.
     * @param {Function} [customizer] The function to customize cloning.
     * @returns {*} Returns the cloned value.
     * @see _.cloneDeepWith
     * @example
     *
     * function customizer(value) {
     *   if (_.isElement(value)) {
     *     return value.cloneNode(false);
     *   }
     * }
     *
     * var el = _.cloneWith(document.body, customizer);
     *
     * console.log(el === document.body);
     * // => false
     * console.log(el.nodeName);
     * // => 'BODY'
     * console.log(el.childNodes.length);
     * // => 0
     */

/**
     * This method is like `_.clone` except that it recursively clones `value`.
     *
     * @static
     * @memberOf _
     * @since 1.0.0
     * @category Lang
     * @param {*} value The value to recursively clone.
     * @returns {*} Returns the deep cloned value.
     * @see _.clone
     * @example
     *
     * var objects = [{ 'a': 1 }, { 'b': 2 }];
     *
     * var deep = _.cloneDeep(objects);
     * console.log(deep[0] === objects[0]);
     * // => false
     */

/**
     * This method is like `_.curry` except that arguments are applied to `func`
     * in the manner of `_.partialRight` instead of `_.partial`.
     *
     * The `_.curryRight.placeholder` value, which defaults to `_` in monolithic
     * builds, may be used as a placeholder for provided arguments.
     *
     * **Note:** This method doesn't set the "length" property of curried functions.
     *
     * @static
     * @memberOf _
     * @since 3.0.0
     * @category Function
     * @param {Function} func The function to curry.
     * @param {number} [arity=func.length] The arity of `func`.
     * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`.
     * @returns {Function} Returns the new curried function.
     * @example
     *
     * var abc = function(a, b, c) {
     *   return [a, b, c];
     * };
     *
     * var curried = _.curryRight(abc);
     *
     * curried(3)(2)(1);
     * // => [1, 2, 3]
     *
     * curried(2, 3)(1);
     * // => [1, 2, 3]
     *
     * curried(1, 2, 3);
     * // => [1, 2, 3]
     *
     * // Curried with placeholders.
     * curried(3)(1, _)(2);
     * // => [1, 2, 3]
     */

/**
     * This method is like `_.defaults` except that it recursively assigns
     * default properties.
     *
     * **Note:** This method mutates `object`.
     *
     * @static
     * @memberOf _
     * @since 3.10.0
     * @category Object
     * @param {Object} object The destination object.
     * @param {...Object} [sources] The source objects.
     * @returns {Object} Returns `object`.
     * @see _.defaults
     * @example
     *
     * _.defaultsDeep({ 'a': { 'b': 2 } }, { 'a': { 'b': 1, 'c': 3 } });
     * // => { 'a': { 'b': 2, 'c': 3 } }
     */

/**
     * This method is like `_.difference` except that it accepts `iteratee` which
     * is invoked for each element of `array` and `values` to generate the criterion
     * by which they're compared. The order and references of result values are
     * determined by the first array. The iteratee is invoked with one argument:
     * (value).
     *
     * **Note:** Unlike `_.pullAllBy`, this method returns a new array.
     *
     * @static
     * @memberOf _
     * @since 4.0.0
     * @category Array
     * @param {Array} array The array to inspect.
     * @param {...Array} [values] The values to exclude.
     * @param {Function} [iteratee=_.identity] The iteratee invoked per element.
     * @returns {Array} Returns the new array of filtered values.
     * @example
     *
     * _.differenceBy([2.1, 1.2], [2.3, 3.4], Math.floor);
     * // => [1.2]
     *
     * // The `_.property` iteratee shorthand.
     * _.differenceBy([{ 'x': 2 }, { 'x': 1 }], [{ 'x': 1 }], 'x');
     * // => [{ 'x': 2 }]
     */

/**
     * This method is like `_.findIndex` except that it iterates over elements
     * of `collection` from right to left.
     *
     * @static
     * @memberOf _
     * @since 2.0.0
     * @category Array
     * @param {Array} array The array to inspect.
     * @param {Function} [predicate=_.identity] The function invoked per iteration.
     * @param {number} [fromIndex=array.length-1] The index to search from.
     * @returns {number} Returns the index of the found element, else `-1`.
     * @example
     *
     * var users = [
     *   { 'user': 'barney',  'active': true },
     *   { 'user': 'fred',    'active': false },
     *   { 'user': 'pebbles', 'active': false }
     * ];
     *
     * _.findLastIndex(users, function(o) { return o.user == 'pebbles'; });
     * // => 2
     *
     * // The `_.matches` iteratee shorthand.
     * _.findLastIndex(users, { 'user': 'barney', 'active': true });
     * // => 0
     *
     * // The `_.matchesProperty` iteratee shorthand.
     * _.findLastIndex(users, ['active', false]);
     * // => 2
     *
     * // The `_.property` iteratee shorthand.
     * _.findLastIndex(users, 'active');
     * // => 0
     */

/**
     * This method is like `_.findKey` except that it iterates over elements of
     * a collection in the opposite order.
     *
     * @static
     * @memberOf _
     * @since 2.0.0
     * @category Object
     * @param {Object} object The object to inspect.
     * @param {Function} [predicate=_.identity] The function invoked per iteration.
     * @returns {string|undefined} Returns the key of the matched element,
     *  else `undefined`.
     * @example
     *
     * var users = {
     *   'barney':  { 'age': 36, 'active': true },
     *   'fred':    { 'age': 40, 'active': false },
     *   'pebbles': { 'age': 1,  'active': true }
     * };
     *
     * _.findLastKey(users, function(o) { return o.age < 40; });
     * // => returns 'pebbles' assuming `_.findKey` returns 'barney'
     *
     * // The `_.matches` iteratee shorthand.
     * _.findLastKey(users, { 'age': 36, 'active': true });
     * // => 'barney'
     *
     * // The `_.matchesProperty` iteratee shorthand.
     * _.findLastKey(users, ['active', false]);
     * // => 'fred'
     *
     * // The `_.property` iteratee shorthand.
     * _.findLastKey(users, 'active');
     * // => 'pebbles'
     */

/**
     * This method is like `_.find` except that it iterates over elements of
     * `collection` from right to left.
     *
     * @static
     * @memberOf _
     * @since 2.0.0
     * @category Collection
     * @param {Array|Object} collection The collection to inspect.
     * @param {Function} [predicate=_.identity] The function invoked per iteration.
     * @param {number} [fromIndex=collection.length-1] The index to search from.
     * @returns {*} Returns the matched element, else `undefined`.
     * @example
     *
     * _.findLast([1, 2, 3, 4], function(n) {
     *   return n % 2 == 1;
     * });
     * // => 3
     */

/**
     * This method is like `_.find` except that it returns the index of the first
     * element `predicate` returns truthy for instead of the element itself.
     *
     * @static
     * @memberOf _
     * @since 1.1.0
     * @category Array
     * @param {Array} array The array to inspect.
     * @param {Function} [predicate=_.identity] The function invoked per iteration.
     * @param {number} [fromIndex=0] The index to search from.
     * @returns {number} Returns the index of the found element, else `-1`.
     * @example
     *
     * var users = [
     *   { 'user': 'barney',  'active': false },
     *   { 'user': 'fred',    'active': false },
     *   { 'user': 'pebbles', 'active': true }
     * ];
     *
     * _.findIndex(users, function(o) { return o.user == 'barney'; });
     * // => 0
     *
     * // The `_.matches` iteratee shorthand.
     * _.findIndex(users, { 'user': 'fred', 'active': false });
     * // => 1
     *
     * // The `_.matchesProperty` iteratee shorthand.
     * _.findIndex(users, ['active', false]);
     * // => 0
     *
     * // The `_.property` iteratee shorthand.
     * _.findIndex(users, 'active');
     * // => 2
     */

/**
     * This method is like `_.find` except that it returns the key of the first
     * element `predicate` returns truthy for instead of the element itself.
     *
     * @static
     * @memberOf _
     * @since 1.1.0
     * @category Object
     * @param {Object} object The object to inspect.
     * @param {Function} [predicate=_.identity] The function invoked per iteration.
     * @returns {string|undefined} Returns the key of the matched element,
     *  else `undefined`.
     * @example
     *
     * var users = {
     *   'barney':  { 'age': 36, 'active': true },
     *   'fred':    { 'age': 40, 'active': false },
     *   'pebbles': { 'age': 1,  'active': true }
     * };
     *
     * _.findKey(users, function(o) { return o.age < 40; });
     * // => 'barney' (iteration order is not guaranteed)
     *
     * // The `_.matches` iteratee shorthand.
     * _.findKey(users, { 'age': 1, 'active': true });
     * // => 'pebbles'
     *
     * // The `_.matchesProperty` iteratee shorthand.
     * _.findKey(users, ['active', false]);
     * // => 'fred'
     *
     * // The `_.property` iteratee shorthand.
     * _.findKey(users, 'active');
     * // => 'barney'
     */

/**
     * This method is like `_.flatMap` except that it recursively flattens the
     * mapped results up to `depth` times.
     *
     * @static
     * @memberOf _
     * @since 4.7.0
     * @category Collection
     * @param {Array|Object} collection The collection to iterate over.
     * @param {Function} [iteratee=_.identity] The function invoked per iteration.
     * @param {number} [depth=1] The maximum recursion depth.
     * @returns {Array} Returns the new flattened array.
     * @example
     *
     * function duplicate(n) {
     *   return [[[n, n]]];
     * }
     *
     * _.flatMapDepth([1, 2], duplicate, 2);
     * // => [[1, 1], [2, 2]]
     */

/**
     * This method is like `_.flatMap` except that it recursively flattens the
     * mapped results.
     *
     * @static
     * @memberOf _
     * @since 4.7.0
     * @category Collection
     * @param {Array|Object} collection The collection to iterate over.
     * @param {Function} [iteratee=_.identity] The function invoked per iteration.
     * @returns {Array} Returns the new flattened array.
     * @example
     *
     * function duplicate(n) {
     *   return [[[n, n]]];
     * }
     *
     * _.flatMapDeep([1, 2], duplicate);
     * // => [1, 1, 2, 2]
     */

/**
     * This method is like `_.flow` except that it creates a function that
     * invokes the given functions from right to left.
     *
     * @static
     * @since 3.0.0
     * @memberOf _
     * @category Util
     * @param {...(Function|Function[])} [funcs] The functions to invoke.
     * @returns {Function} Returns the new composite function.
     * @see _.flow
     * @example
     *
     * function square(n) {
     *   return n * n;
     * }
     *
     * var addSquare = _.flowRight([square, _.add]);
     * addSquare(1, 2);
     * // => 9
     */

/**
     * This method is like `_.forEach` except that it iterates over elements of
     * `collection` from right to left.
     *
     * @static
     * @memberOf _
     * @since 2.0.0
     * @alias eachRight
     * @category Collection
     * @param {Array|Object} collection The collection to iterate over.
     * @param {Function} [iteratee=_.identity] The function invoked per iteration.
     * @returns {Array|Object} Returns `collection`.
     * @see _.forEach
     * @example
     *
     * _.forEachRight([1, 2], function(value) {
     *   console.log(value);
     * });
     * // => Logs `2` then `1`.
     */

/**
     * This method is like `_.forIn` except that it iterates over properties of
     * `object` in the opposite order.
     *
     * @static
     * @memberOf _
     * @since 2.0.0
     * @category Object
     * @param {Object} object The object to iterate over.
     * @param {Function} [iteratee=_.identity] The function invoked per iteration.
     * @returns {Object} Returns `object`.
     * @see _.forIn
     * @example
     *
     * function Foo() {
     *   this.a = 1;
     *   this.b = 2;
     * }
     *
     * Foo.prototype.c = 3;
     *
     * _.forInRight(new Foo, function(value, key) {
     *   console.log(key);
     * });
     * // => Logs 'c', 'b', then 'a' assuming `_.forIn` logs 'a', 'b', then 'c'.
     */

/**
     * This method is like `_.forOwn` except that it iterates over properties of
     * `object` in the opposite order.
     *
     * @static
     * @memberOf _
     * @since 2.0.0
     * @category Object
     * @param {Object} object The object to iterate over.
     * @param {Function} [iteratee=_.identity] The function invoked per iteration.
     * @returns {Object} Returns `object`.
     * @see _.forOwn
     * @example
     *
     * function Foo() {
     *   this.a = 1;
     *   this.b = 2;
     * }
     *
     * Foo.prototype.c = 3;
     *
     * _.forOwnRight(new Foo, function(value, key) {
     *   console.log(key);
     * });
     * // => Logs 'b' then 'a' assuming `_.forOwn` logs 'a' then 'b'.
     */

/**
     * This method is like `_.fromPairs` except that it accepts two arrays,
     * one of property identifiers and one of corresponding values.
     *
     * @static
     * @memberOf _
     * @since 0.4.0
     * @category Array
     * @param {Array} [props=[]] The property identifiers.
     * @param {Array} [values=[]] The property values.
     * @returns {Object} Returns the new object.
     * @example
     *
     * _.zipObject(['a', 'b'], [1, 2]);
     * // => { 'a': 1, 'b': 2 }
     */

/**
     * This method is like `_.get` except that if the resolved value is a
     * function it's invoked with the `this` binding of its parent object and
     * its result is returned.
     *
     * @static
     * @since 0.1.0
     * @memberOf _
     * @category Object
     * @param {Object} object The object to query.
     * @param {Array|string} path The path of the property to resolve.
     * @param {*} [defaultValue] The value returned for `undefined` resolved values.
     * @returns {*} Returns the resolved value.
     * @example
     *
     * var object = { 'a': [{ 'b': { 'c1': 3, 'c2': _.constant(4) } }] };
     *
     * _.result(object, 'a[0].b.c1');
     * // => 3
     *
     * _.result(object, 'a[0].b.c2');
     * // => 4
     *
     * _.result(object, 'a[0].b.c3', 'default');
     * // => 'default'
     *
     * _.result(object, 'a[0].b.c3', _.constant('default'));
     * // => 'default'
     */

/**
     * This method is like `_.indexOf` except that it iterates over elements of
     * `array` from right to left.
     *
     * @static
     * @memberOf _
     * @since 0.1.0
     * @category Array
     * @param {Array} array The array to inspect.
     * @param {*} value The value to search for.
     * @param {number} [fromIndex=array.length-1] The index to search from.
     * @returns {number} Returns the index of the matched value, else `-1`.
     * @example
     *
     * _.lastIndexOf([1, 2, 1, 2], 2);
     * // => 3
     *
     * // Search from the `fromIndex`.
     * _.lastIndexOf([1, 2, 1, 2], 2, 2);
     * // => 1
     */

/**
     * This method is like `_.indexOf` except that it performs a binary
     * search on a sorted `array`.
     *
     * @static
     * @memberOf _
     * @since 4.0.0
     * @category Array
     * @param {Array} array The array to inspect.
     * @param {*} value The value to search for.
     * @returns {number} Returns the index of the matched value, else `-1`.
     * @example
     *
     * _.sortedIndexOf([4, 5, 5, 5, 6], 5);
     * // => 1
     */

/**
     * This method is like `_.intersection` except that it accepts `iteratee`
     * which is invoked for each element of each `arrays` to generate the criterion
     * by which they're compared. The order and references of result values are
     * determined by the first array. The iteratee is invoked with one argument:
     * (value).
     *
     * @static
     * @memberOf _
     * @since 4.0.0
     * @category Array
     * @param {...Array} [arrays] The arrays to inspect.
     * @param {Function} [iteratee=_.identity] The iteratee invoked per element.
     * @returns {Array} Returns the new array of intersecting values.
     * @example
     *
     * _.intersectionBy([2.1, 1.2], [2.3, 3.4], Math.floor);
     * // => [2.1]
     *
     * // The `_.property` iteratee shorthand.
     * _.intersectionBy([{ 'x': 1 }], [{ 'x': 2 }, { 'x': 1 }], 'x');
     * // => [{ 'x': 1 }]
     */

/**
     * This method is like `_.invert` except that the inverted object is generated
     * from the results of running each element of `object` thru `iteratee`. The
     * corresponding inverted value of each inverted key is an array of keys
     * responsible for generating the inverted value. The iteratee is invoked
     * with one argument: (value).
     *
     * @static
     * @memberOf _
     * @since 4.1.0
     * @category Object
     * @param {Object} object The object to invert.
     * @param {Function} [iteratee=_.identity] The iteratee invoked per element.
     * @returns {Object} Returns the new inverted object.
     * @example
     *
     * var object = { 'a': 1, 'b': 2, 'c': 1 };
     *
     * _.invertBy(object);
     * // => { '1': ['a', 'c'], '2': ['b'] }
     *
     * _.invertBy(object, function(value) {
     *   return 'group' + value;
     * });
     * // => { 'group1': ['a', 'c'], 'group2': ['b'] }
     */

/**
     * This method is like `_.isArrayLike` except that it also checks if `value`
     * is an object.
     *
     * @static
     * @memberOf _
     * @since 4.0.0
     * @category Lang
     * @param {*} value The value to check.
     * @returns {boolean} Returns `true` if `value` is an array-like object,
     *  else `false`.
     * @example
     *
     * _.isArrayLikeObject([1, 2, 3]);
     * // => true
     *
     * _.isArrayLikeObject(document.body.children);
     * // => true
     *
     * _.isArrayLikeObject('abc');
     * // => false
     *
     * _.isArrayLikeObject(_.noop);
     * // => false
     */

/**
     * This method is like `_.isEqual` except that it accepts `customizer` which
     * is invoked to compare values. If `customizer` returns `undefined`, comparisons
     * are handled by the method instead. The `customizer` is invoked with up to
     * six arguments: (objValue, othValue [, index|key, object, other, stack]).
     *
     * @static
     * @memberOf _
     * @since 4.0.0
     * @category Lang
     * @param {*} value The value to compare.
     * @param {*} other The other value to compare.
     * @param {Function} [customizer] The function to customize comparisons.
     * @returns {boolean} Returns `true` if the values are equivalent, else `false`.
     * @example
     *
     * function isGreeting(value) {
     *   return /^h(?:i|ello)$/.test(value);
     * }
     *
     * function customizer(objValue, othValue) {
     *   if (isGreeting(objValue) && isGreeting(othValue)) {
     *     return true;
     *   }
     * }
     *
     * var array = ['hello', 'goodbye'];
     * var other = ['hi', 'goodbye'];
     *
     * _.isEqualWith(array, other, customizer);
     * // => true
     */

/**
     * This method is like `_.isMatch` except that it accepts `customizer` which
     * is invoked to compare values. If `customizer` returns `undefined`, comparisons
     * are handled by the method instead. The `customizer` is invoked with five
     * arguments: (objValue, srcValue, index|key, object, source).
     *
     * @static
     * @memberOf _
     * @since 4.0.0
     * @category Lang
     * @param {Object} object The object to inspect.
     * @param {Object} source The object of property values to match.
     * @param {Function} [customizer] The function to customize comparisons.
     * @returns {boolean} Returns `true` if `object` is a match, else `false`.
     * @example
     *
     * function isGreeting(value) {
     *   return /^h(?:i|ello)$/.test(value);
     * }
     *
     * function customizer(objValue, srcValue) {
     *   if (isGreeting(objValue) && isGreeting(srcValue)) {
     *     return true;
     *   }
     * }
     *
     * var object = { 'greeting': 'hello' };
     * var source = { 'greeting': 'hi' };
     *
     * _.isMatchWith(object, source, customizer);
     * // => true
     */

/**
     * This method is like `_.lastIndexOf` except that it performs a binary
     * search on a sorted `array`.
     *
     * @static
     * @memberOf _
     * @since 4.0.0
     * @category Array
     * @param {Array} array The array to inspect.
     * @param {*} value The value to search for.
     * @returns {number} Returns the index of the matched value, else `-1`.
     * @example
     *
     * _.sortedLastIndexOf([4, 5, 5, 5, 6], 5);
     * // => 3
     */

/**
     * This method is like `_.max` except that it accepts `iteratee` which is
     * invoked for each element in `array` to generate the criterion by which
     * the value is ranked. The iteratee is invoked with one argument: (value).
     *
     * @static
     * @memberOf _
     * @since 4.0.0
     * @category Math
     * @param {Array} array The array to iterate over.
     * @param {Function} [iteratee=_.identity] The iteratee invoked per element.
     * @returns {*} Returns the maximum value.
     * @example
     *
     * var objects = [{ 'n': 1 }, { 'n': 2 }];
     *
     * _.maxBy(objects, function(o) { return o.n; });
     * // => { 'n': 2 }
     *
     * // The `_.property` iteratee shorthand.
     * _.maxBy(objects, 'n');
     * // => { 'n': 2 }
     */

/**
     * This method is like `_.mean` except that it accepts `iteratee` which is
     * invoked for each element in `array` to generate the value to be averaged.
     * The iteratee is invoked with one argument: (value).
     *
     * @static
     * @memberOf _
     * @since 4.7.0
     * @category Math
     * @param {Array} array The array to iterate over.
     * @param {Function} [iteratee=_.identity] The iteratee invoked per element.
     * @returns {number} Returns the mean.
     * @example
     *
     * var objects = [{ 'n': 4 }, { 'n': 2 }, { 'n': 8 }, { 'n': 6 }];
     *
     * _.meanBy(objects, function(o) { return o.n; });
     * // => 5
     *
     * // The `_.property` iteratee shorthand.
     * _.meanBy(objects, 'n');
     * // => 5
     */

/**
     * This method is like `_.merge` except that it accepts `customizer` which
     * is invoked to produce the merged values of the destination and source
     * properties. If `customizer` returns `undefined`, merging is handled by the
     * method instead. The `customizer` is invoked with six arguments:
     * (objValue, srcValue, key, object, source, stack).
     *
     * **Note:** This method mutates `object`.
     *
     * @static
     * @memberOf _
     * @since 4.0.0
     * @category Object
     * @param {Object} object The destination object.
     * @param {...Object} sources The source objects.
     * @param {Function} customizer The function to customize assigned values.
     * @returns {Object} Returns `object`.
     * @example
     *
     * function customizer(objValue, srcValue) {
     *   if (_.isArray(objValue)) {
     *     return objValue.concat(srcValue);
     *   }
     * }
     *
     * var object = { 'a': [1], 'b': [2] };
     * var other = { 'a': [3], 'b': [4] };
     *
     * _.mergeWith(object, other, customizer);
     * // => { 'a': [1, 3], 'b': [2, 4] }
     */

/**
     * This method is like `_.min` except that it accepts `iteratee` which is
     * invoked for each element in `array` to generate the criterion by which
     * the value is ranked. The iteratee is invoked with one argument: (value).
     *
     * @static
     * @memberOf _
     * @since 4.0.0
     * @category Math
     * @param {Array} array The array to iterate over.
     * @param {Function} [iteratee=_.identity] The iteratee invoked per element.
     * @returns {*} Returns the minimum value.
     * @example
     *
     * var objects = [{ 'n': 1 }, { 'n': 2 }];
     *
     * _.minBy(objects, function(o) { return o.n; });
     * // => { 'n': 1 }
     *
     * // The `_.property` iteratee shorthand.
     * _.minBy(objects, 'n');
     * // => { 'n': 1 }
     */

/**
     * This method is like `_.pullAll` except that it accepts `comparator` which
     * is invoked to compare elements of `array` to `values`. The comparator is
     * invoked with two arguments: (arrVal, othVal).
     *
     * **Note:** Unlike `_.differenceWith`, this method mutates `array`.
     *
     * @static
     * @memberOf _
     * @since 4.6.0
     * @category Array
     * @param {Array} array The array to modify.
     * @param {Array} values The values to remove.
     * @param {Function} [comparator] The comparator invoked per element.
     * @returns {Array} Returns `array`.
     * @example
     *
     * var array = [{ 'x': 1, 'y': 2 }, { 'x': 3, 'y': 4 }, { 'x': 5, 'y': 6 }];
     *
     * _.pullAllWith(array, [{ 'x': 3, 'y': 4 }], _.isEqual);
     * console.log(array);
     * // => [{ 'x': 1, 'y': 2 }, { 'x': 5, 'y': 6 }]
     */

/**
     * This method is like `_.pullAll` except that it accepts `iteratee` which is
     * invoked for each element of `array` and `values` to generate the criterion
     * by which they're compared. The iteratee is invoked with one argument: (value).
     *
     * **Note:** Unlike `_.differenceBy`, this method mutates `array`.
     *
     * @static
     * @memberOf _
     * @since 4.0.0
     * @category Array
     * @param {Array} array The array to modify.
     * @param {Array} values The values to remove.
     * @param {Function} [iteratee=_.identity] The iteratee invoked per element.
     * @returns {Array} Returns `array`.
     * @example
     *
     * var array = [{ 'x': 1 }, { 'x': 2 }, { 'x': 3 }, { 'x': 1 }];
     *
     * _.pullAllBy(array, [{ 'x': 1 }, { 'x': 3 }], 'x');
     * console.log(array);
     * // => [{ 'x': 2 }]
     */

/**
     * This method is like `_.pull` except that it accepts an array of values to remove.
     *
     * **Note:** Unlike `_.difference`, this method mutates `array`.
     *
     * @static
     * @memberOf _
     * @since 4.0.0
     * @category Array
     * @param {Array} array The array to modify.
     * @param {Array} values The values to remove.
     * @returns {Array} Returns `array`.
     * @example
     *
     * var array = ['a', 'b', 'c', 'a', 'b', 'c'];
     *
     * _.pullAll(array, ['a', 'c']);
     * console.log(array);
     * // => ['b', 'b']
     */

/**
     * This method is like `_.range` except that it populates values in
     * descending order.
     *
     * @static
     * @memberOf _
     * @since 4.0.0
     * @category Util
     * @param {number} [start=0] The start of the range.
     * @param {number} end The end of the range.
     * @param {number} [step=1] The value to increment or decrement by.
     * @returns {Array} Returns the range of numbers.
     * @see _.inRange, _.range
     * @example
     *
     * _.rangeRight(4);
     * // => [3, 2, 1, 0]
     *
     * _.rangeRight(-4);
     * // => [-3, -2, -1, 0]
     *
     * _.rangeRight(1, 5);
     * // => [4, 3, 2, 1]
     *
     * _.rangeRight(0, 20, 5);
     * // => [15, 10, 5, 0]
     *
     * _.rangeRight(0, -4, -1);
     * // => [-3, -2, -1, 0]
     *
     * _.rangeRight(1, 4, 0);
     * // => [1, 1, 1]
     *
     * _.rangeRight(0);
     * // => []
     */

/**
     * This method is like `_.reduce` except that it iterates over elements of
     * `collection` from right to left.
     *
     * @static
     * @memberOf _
     * @since 0.1.0
     * @category Collection
     * @param {Array|Object} collection The collection to iterate over.
     * @param {Function} [iteratee=_.identity] The function invoked per iteration.
     * @param {*} [accumulator] The initial value.
     * @returns {*} Returns the accumulated value.
     * @see _.reduce
     * @example
     *
     * var array = [[0, 1], [2, 3], [4, 5]];
     *
     * _.reduceRight(array, function(flattened, other) {
     *   return flattened.concat(other);
     * }, []);
     * // => [4, 5, 2, 3, 0, 1]
     */

/**
     * This method is like `_.set` except that accepts `updater` to produce the
     * value to set. Use `_.updateWith` to customize `path` creation. The `updater`
     * is invoked with one argument: (value).
     *
     * **Note:** This method mutates `object`.
     *
     * @static
     * @memberOf _
     * @since 4.6.0
     * @category Object
     * @param {Object} object The object to modify.
     * @param {Array|string} path The path of the property to set.
     * @param {Function} updater The function to produce the updated value.
     * @returns {Object} Returns `object`.
     * @example
     *
     * var object = { 'a': [{ 'b': { 'c': 3 } }] };
     *
     * _.update(object, 'a[0].b.c', function(n) { return n * n; });
     * console.log(object.a[0].b.c);
     * // => 9
     *
     * _.update(object, 'x[0].y.z', function(n) { return n ? n + 1 : 0; });
     * console.log(object.x[0].y.z);
     * // => 0
     */

/**
     * This method is like `_.set` except that it accepts `customizer` which is
     * invoked to produce the objects of `path`.  If `customizer` returns `undefined`
     * path creation is handled by the method instead. The `customizer` is invoked
     * with three arguments: (nsValue, key, nsObject).
     *
     * **Note:** This method mutates `object`.
     *
     * @static
     * @memberOf _
     * @since 4.0.0
     * @category Object
     * @param {Object} object The object to modify.
     * @param {Array|string} path The path of the property to set.
     * @param {*} value The value to set.
     * @param {Function} [customizer] The function to customize assigned values.
     * @returns {Object} Returns `object`.
     * @example
     *
     * var object = {};
     *
     * _.setWith(object, '[0][1]', 'a', Object);
     * // => { '0': { '1': 'a' } }
     */

/**
     * This method is like `_.sortBy` except that it allows specifying the sort
     * orders of the iteratees to sort by. If `orders` is unspecified, all values
     * are sorted in ascending order. Otherwise, specify an order of "desc" for
     * descending or "asc" for ascending sort order of corresponding values.
     *
     * @static
     * @memberOf _
     * @since 4.0.0
     * @category Collection
     * @param {Array|Object} collection The collection to iterate over.
     * @param {Array[]|Function[]|Object[]|string[]} [iteratees=[_.identity]]
     *  The iteratees to sort by.
     * @param {string[]} [orders] The sort orders of `iteratees`.
     * @param- {Object} [guard] Enables use as an iteratee for methods like `_.reduce`.
     * @returns {Array} Returns the new sorted array.
     * @example
     *
     * var users = [
     *   { 'user': 'fred',   'age': 48 },
     *   { 'user': 'barney', 'age': 34 },
     *   { 'user': 'fred',   'age': 40 },
     *   { 'user': 'barney', 'age': 36 }
     * ];
     *
     * // Sort by `user` in ascending order and by `age` in descending order.
     * _.orderBy(users, ['user', 'age'], ['asc', 'desc']);
     * // => objects for [['barney', 36], ['barney', 34], ['fred', 48], ['fred', 40]]
     */

/**
     * This method is like `_.sortedIndex` except that it accepts `iteratee`
     * which is invoked for `value` and each element of `array` to compute their
     * sort ranking. The iteratee is invoked with one argument: (value).
     *
     * @static
     * @memberOf _
     * @since 4.0.0
     * @category Array
     * @param {Array} array The sorted array to inspect.
     * @param {*} value The value to evaluate.
     * @param {Function} [iteratee=_.identity] The iteratee invoked per element.
     * @returns {number} Returns the index at which `value` should be inserted
     *  into `array`.
     * @example
     *
     * var objects = [{ 'x': 4 }, { 'x': 5 }];
     *
     * _.sortedIndexBy(objects, { 'x': 4 }, function(o) { return o.x; });
     * // => 0
     *
     * // The `_.property` iteratee shorthand.
     * _.sortedIndexBy(objects, { 'x': 4 }, 'x');
     * // => 0
     */

/**
     * This method is like `_.sortedIndex` except that it returns the highest
     * index at which `value` should be inserted into `array` in order to
     * maintain its sort order.
     *
     * @static
     * @memberOf _
     * @since 3.0.0
     * @category Array
     * @param {Array} array The sorted array to inspect.
     * @param {*} value The value to evaluate.
     * @returns {number} Returns the index at which `value` should be inserted
     *  into `array`.
     * @example
     *
     * _.sortedLastIndex([4, 5, 5, 5, 6], 5);
     * // => 4
     */

/**
     * This method is like `_.sortedLastIndex` except that it accepts `iteratee`
     * which is invoked for `value` and each element of `array` to compute their
     * sort ranking. The iteratee is invoked with one argument: (value).
     *
     * @static
     * @memberOf _
     * @since 4.0.0
     * @category Array
     * @param {Array} array The sorted array to inspect.
     * @param {*} value The value to evaluate.
     * @param {Function} [iteratee=_.identity] The iteratee invoked per element.
     * @returns {number} Returns the index at which `value` should be inserted
     *  into `array`.
     * @example
     *
     * var objects = [{ 'x': 4 }, { 'x': 5 }];
     *
     * _.sortedLastIndexBy(objects, { 'x': 4 }, function(o) { return o.x; });
     * // => 1
     *
     * // The `_.property` iteratee shorthand.
     * _.sortedLastIndexBy(objects, { 'x': 4 }, 'x');
     * // => 1
     */

/**
     * This method is like `_.sum` except that it accepts `iteratee` which is
     * invoked for each element in `array` to generate the value to be summed.
     * The iteratee is invoked with one argument: (value).
     *
     * @static
     * @memberOf _
     * @since 4.0.0
     * @category Math
     * @param {Array} array The array to iterate over.
     * @param {Function} [iteratee=_.identity] The iteratee invoked per element.
     * @returns {number} Returns the sum.
     * @example
     *
     * var objects = [{ 'n': 4 }, { 'n': 2 }, { 'n': 8 }, { 'n': 6 }];
     *
     * _.sumBy(objects, function(o) { return o.n; });
     * // => 20
     *
     * // The `_.property` iteratee shorthand.
     * _.sumBy(objects, 'n');
     * // => 20
     */

/**
     * This method is like `_.tap` except that it returns the result of `interceptor`.
     * The purpose of this method is to "pass thru" values replacing intermediate
     * results in a method chain sequence.
     *
     * @static
     * @memberOf _
     * @since 3.0.0
     * @category Seq
     * @param {*} value The value to provide to `interceptor`.
     * @param {Function} interceptor The function to invoke.
     * @returns {*} Returns the result of `interceptor`.
     * @example
     *
     * _('  abc  ')
     *  .chain()
     *  .trim()
     *  .thru(function(value) {
     *    return [value];
     *  })
     *  .value();
     * // => ['abc']
     */

/**
     * This method is like `_.union` except that it accepts `iteratee` which is
     * invoked for each element of each `arrays` to generate the criterion by
     * which uniqueness is computed. Result values are chosen from the first
     * array in which the value occurs. The iteratee is invoked with one argument:
     * (value).
     *
     * @static
     * @memberOf _
     * @since 4.0.0
     * @category Array
     * @param {...Array} [arrays] The arrays to inspect.
     * @param {Function} [iteratee=_.identity] The iteratee invoked per element.
     * @returns {Array} Returns the new array of combined values.
     * @example
     *
     * _.unionBy([2.1], [1.2, 2.3], Math.floor);
     * // => [2.1, 1.2]
     *
     * // The `_.property` iteratee shorthand.
     * _.unionBy([{ 'x': 1 }], [{ 'x': 2 }, { 'x': 1 }], 'x');
     * // => [{ 'x': 1 }, { 'x': 2 }]
     */

/**
     * This method is like `_.uniqBy` except that it's designed and optimized
     * for sorted arrays.
     *
     * @static
     * @memberOf _
     * @since 4.0.0
     * @category Array
     * @param {Array} array The array to inspect.
     * @param {Function} [iteratee] The iteratee invoked per element.
     * @returns {Array} Returns the new duplicate free array.
     * @example
     *
     * _.sortedUniqBy([1.1, 1.2, 2.3, 2.4], Math.floor);
     * // => [1.1, 2.3]
     */

/**
     * This method is like `_.uniq` except that it accepts `comparator` which
     * is invoked to compare elements of `array`. The order of result values is
     * determined by the order they occur in the array.The comparator is invoked
     * with two arguments: (arrVal, othVal).
     *
     * @static
     * @memberOf _
     * @since 4.0.0
     * @category Array
     * @param {Array} array The array to inspect.
     * @param {Function} [comparator] The comparator invoked per element.
     * @returns {Array} Returns the new duplicate free array.
     * @example
     *
     * var objects = [{ 'x': 1, 'y': 2 }, { 'x': 2, 'y': 1 }, { 'x': 1, 'y': 2 }];
     *
     * _.uniqWith(objects, _.isEqual);
     * // => [{ 'x': 1, 'y': 2 }, { 'x': 2, 'y': 1 }]
     */

/**
     * This method is like `_.uniq` except that it accepts `iteratee` which is
     * invoked for each element in `array` to generate the criterion by which
     * uniqueness is computed. The order of result values is determined by the
     * order they occur in the array. The iteratee is invoked with one argument:
     * (value).
     *
     * @static
     * @memberOf _
     * @since 4.0.0
     * @category Array
     * @param {Array} array The array to inspect.
     * @param {Function} [iteratee=_.identity] The iteratee invoked per element.
     * @returns {Array} Returns the new duplicate free array.
     * @example
     *
     * _.uniqBy([2.1, 1.2, 2.3], Math.floor);
     * // => [2.1, 1.2]
     *
     * // The `_.property` iteratee shorthand.
     * _.uniqBy([{ 'x': 1 }, { 'x': 2 }, { 'x': 1 }], 'x');
     * // => [{ 'x': 1 }, { 'x': 2 }]
     */

/**
     * This method is like `_.uniq` except that it's designed and optimized
     * for sorted arrays.
     *
     * @static
     * @memberOf _
     * @since 4.0.0
     * @category Array
     * @param {Array} array The array to inspect.
     * @returns {Array} Returns the new duplicate free array.
     * @example
     *
     * _.sortedUniq([1, 1, 2]);
     * // => [1, 2]
     */

/**
     * This method is like `_.unzip` except that it accepts `iteratee` to specify
     * how regrouped values should be combined. The iteratee is invoked with the
     * elements of each group: (...group).
     *
     * @static
     * @memberOf _
     * @since 3.8.0
     * @category Array
     * @param {Array} array The array of grouped elements to process.
     * @param {Function} [iteratee=_.identity] The function to combine
     *  regrouped values.
     * @returns {Array} Returns the new array of regrouped elements.
     * @example
     *
     * var zipped = _.zip([1, 2], [10, 20], [100, 200]);
     * // => [[1, 10, 100], [2, 20, 200]]
     *
     * _.unzipWith(zipped, _.add);
     * // => [3, 30, 300]
     */

/**
     * This method is like `_.update` except that it accepts `customizer` which is
     * invoked to produce the objects of `path`.  If `customizer` returns `undefined`
     * path creation is handled by the method instead. The `customizer` is invoked
     * with three arguments: (nsValue, key, nsObject).
     *
     * **Note:** This method mutates `object`.
     *
     * @static
     * @memberOf _
     * @since 4.6.0
     * @category Object
     * @param {Object} object The object to modify.
     * @param {Array|string} path The path of the property to set.
     * @param {Function} updater The function to produce the updated value.
     * @param {Function} [customizer] The function to customize assigned values.
     * @returns {Object} Returns `object`.
     * @example
     *
     * var object = {};
     *
     * _.updateWith(object, '[0][1]', _.constant('a'), Object);
     * // => { '0': { '1': 'a' } }
     */

/**
     * This method is like `_.zipObject` except that it supports property paths.
     *
     * @static
     * @memberOf _
     * @since 4.1.0
     * @category Array
     * @param {Array} [props=[]] The property identifiers.
     * @param {Array} [values=[]] The property values.
     * @returns {Object} Returns the new object.
     * @example
     *
     * _.zipObjectDeep(['a.b[0].c', 'a.b[1].d'], [1, 2]);
     * // => { 'a': { 'b': [{ 'c': 1 }, { 'd': 2 }] } }
     */

/**
     * This method is like `_.zip` except that it accepts `iteratee` to specify
     * how grouped values should be combined. The iteratee is invoked with the
     * elements of each group: (...group).
     *
     * @static
     * @memberOf _
     * @since 3.8.0
     * @category Array
     * @param {...Array} [arrays] The arrays to process.
     * @param {Function} [iteratee=_.identity] The function to combine
     *  grouped values.
     * @returns {Array} Returns the new array of grouped elements.
     * @example
     *
     * _.zipWith([1, 2], [10, 20], [100, 200], function(a, b, c) {
     *   return a + b + c;
     * });
     * // => [111, 222]
     */

/**
     * This method is like `_.zip` except that it accepts an array of grouped
     * elements and creates an array regrouping the elements to their pre-zip
     * configuration.
     *
     * @static
     * @memberOf _
     * @since 1.2.0
     * @category Array
     * @param {Array} array The array of grouped elements to process.
     * @returns {Array} Returns the new array of regrouped elements.
     * @example
     *
     * var zipped = _.zip(['a', 'b'], [1, 2], [true, false]);
     * // => [['a', 1, true], ['b', 2, false]]
     *
     * _.unzip(zipped);
     * // => [['a', 'b'], [1, 2], [true, false]]
     */

/**
     * This method is the wrapper version of `_.at`.
     *
     * @name at
     * @memberOf _
     * @since 1.0.0
     * @category Seq
     * @param {...(string|string[])} [paths] The property paths to pick.
     * @returns {Object} Returns the new `lodash` wrapper instance.
     * @example
     *
     * var object = { 'a': [{ 'b': { 'c': 3 } }, 4] };
     *
     * _(object).at(['a[0].b.c', 'a[1]']).value();
     * // => [3, 4]
     */

/**
     * This method is the wrapper version of `_.reverse`.
     *
     * **Note:** This method mutates the wrapped array.
     *
     * @name reverse
     * @memberOf _
     * @since 0.1.0
     * @category Seq
     * @returns {Object} Returns the new `lodash` wrapper instance.
     * @example
     *
     * var array = [1, 2, 3];
     *
     * _(array).reverse().value()
     * // => [3, 2, 1]
     *
     * console.log(array);
     * // => [3, 2, 1]
     */

/**
     * This method returns `false`.
     *
     * @static
     * @memberOf _
     * @since 4.13.0
     * @category Util
     * @returns {boolean} Returns `false`.
     * @example
     *
     * _.times(2, _.stubFalse);
     * // => [false, false]
     */

/**
     * This method returns `true`.
     *
     * @static
     * @memberOf _
     * @since 4.13.0
     * @category Util
     * @returns {boolean} Returns `true`.
     * @example
     *
     * _.times(2, _.stubTrue);
     * // => [true, true]
     */

/**
     * This method returns `undefined`.
     *
     * @static
     * @memberOf _
     * @since 2.3.0
     * @category Util
     * @example
     *
     * _.times(2, _.noop);
     * // => [undefined, undefined]
     */

/**
     * This method returns a new empty array.
     *
     * @static
     * @memberOf _
     * @since 4.13.0
     * @category Util
     * @returns {Array} Returns the new empty array.
     * @example
     *
     * var arrays = _.times(2, _.stubArray);
     *
     * console.log(arrays);
     * // => [[], []]
     *
     * console.log(arrays[0] === arrays[1]);
     * // => false
     */

/**
     * This method returns a new empty object.
     *
     * @static
     * @memberOf _
     * @since 4.13.0
     * @category Util
     * @returns {Object} Returns the new empty object.
     * @example
     *
     * var objects = _.times(2, _.stubObject);
     *
     * console.log(objects);
     * // => [{}, {}]
     *
     * console.log(objects[0] === objects[1]);
     * // => false
     */

/**
     * This method returns an empty string.
     *
     * @static
     * @memberOf _
     * @since 4.13.0
     * @category Util
     * @returns {string} Returns the empty string.
     * @example
     *
     * _.times(2, _.stubString);
     * // => ['', '']
     */

/**
     * This method returns the first argument it receives.
     *
     * @static
     * @since 0.1.0
     * @memberOf _
     * @category Util
     * @param {*} value Any value.
     * @returns {*} Returns `value`.
     * @example
     *
     * var object = { 'a': 1 };
     *
     * console.log(_.identity(object) === object);
     * // => true
     */

/**
     * Tokenize a source into a list of tokens.
     *
     * @param {string} source
     *
     * @return {Token[]}
     */

/**
     * Tokenizes a source code.
     *
     * @param {TwingSource} source The source to tokenize
     * @return {TwingTokenStream}
     *
     * @throws {TwingErrorSyntax} When the code is syntactically wrong
     */

/**
     * Traverse the stream using a visitor.
     *
     * @param {TokenVisitor} visitor
     * @return {Token[]}
     */

/**
     * Traverses a node and calls the registered visitors.
     *
     * @return TwingNode
     */

/**
     * Tries to load templates consecutively from an array.
     *
     * Similar to loadTemplate() but it also accepts instances of TwingTemplate and an array of templates where each is tried to be loaded.
     *
     * @param {string|TwingTemplate|Array<string|TwingTemplate>} names A template or an array of templates to try consecutively
     * @param {TwingSource} from The source of the template that initiated the resolving.
     *
     * @return {Promise<TwingTemplate>}
     *
     * @throws {TwingErrorLoader} When none of the templates can be found
     * @throws {TwingErrorSyntax} When an error occurred during compilation
     */

/**
     * Trigger errorHandlers added via onError and throws the error as well
     *
     * @param error - error to throw
     * @param to - location we were navigating to when the error happened
     * @param from - location we were navigating from when the error happened
     * @returns the error as a rejected promise
     */

/**
     * Trims any whitespace from either side of a string
     * @param {String} value The text to trim
     * @return {String} The trimmed text
     */

/**
     * True if the browser is in strict (standards-compliant) mode, as opposed to quirks mode
     * @type Boolean
     */

/**
     * True if the detected browser is Chrome.
     * @type Boolean
     */

/**
     * True if the detected browser is Internet Explorer 6.x.
     * @type Boolean
     */

/**
     * True if the detected browser is Internet Explorer 7.x.
     * @type Boolean
     */

/**
     * True if the detected browser is Internet Explorer 8.x.
     * @type Boolean
     */

/**
     * True if the detected browser is Internet Explorer running in non-strict mode.
     * @type Boolean
     */

/**
     * True if the detected browser is Internet Explorer.
     * @type Boolean
     */

/**
     * True if the detected browser is Opera.
     * @type Boolean
     */

/**
     * True if the detected browser is Safari 2.x.
     * @type Boolean
     */

/**
     * True if the detected browser is Safari 3.x.
     * @type Boolean
     */

/**
     * True if the detected browser is Safari 4.x.
     * @type Boolean
     */

/**
     * True if the detected browser is Safari.
     * @type Boolean
     */

/**
     * True if the detected browser uses WebKit.
     * @type Boolean
     */

/**
     * True if the detected browser uses a Gecko 1.9+ layout engine (e.g. Firefox 3.x).
     * @type Boolean
     */

/**
     * True if the detected browser uses a pre-Gecko 1.9 layout engine (e.g. Firefox 2.x).
     * @type Boolean
     */

/**
     * True if the detected browser uses the Gecko layout engine (e.g. Mozilla, Firefox).
     * @type Boolean
     */

/**
     * True if the detected platform is Adobe Air.
     * @type Boolean
     */

/**
     * True if the detected platform is Linux.
     * @type Boolean
     */

/**
     * True if the detected platform is Mac OS.
     * @type Boolean
     */

/**
     * True if the detected platform is Windows.
     * @type Boolean
     */

/**
     * True if the page is running over SSL
     * @type Boolean
     */

/**
     * True if the {@link Ext.Fx} Class is available
     * @type Boolean
     * @property enableFx
     */

/**
     * True to automatically purge event listeners during garbageCollection (defaults to false).
     * @type Boolean
     */

/**
     * True to automatically uncache orphaned Ext.Elements periodically (defaults to true)
     * @type Boolean
     */

/**
     * True when the document is fully initialized and ready for action
     * @type Boolean
     */

/**
     * Truncate a string and add an ellipsis ('...') to the end if it exceeds the specified length
     * @param {String} value The string to truncate
     * @param {Number} length The maximum length to allow before truncating
     * @param {Boolean} word True to try to find a common work break
     * @return {String} The converted text
     */

/**
     * Truncates `string` if it's longer than the given maximum string length.
     * The last characters of the truncated string are replaced with the omission
     * string which defaults to "...".
     *
     * @static
     * @memberOf _
     * @since 4.0.0
     * @category String
     * @param {string} [string=''] The string to truncate.
     * @param {Object} [options={}] The options object.
     * @param {number} [options.length=30] The maximum string length.
     * @param {string} [options.omission='...'] The string to indicate text is omitted.
     * @param {RegExp|string} [options.separator] The separator pattern to truncate to.
     * @returns {string} Returns the truncated string.
     * @example
     *
     * _.truncate('hi-diddly-ho there, neighborino');
     * // => 'hi-diddly-ho there, neighbo...'
     *
     * _.truncate('hi-diddly-ho there, neighborino', {
     *   'length': 24,
     *   'separator': ' '
     * });
     * // => 'hi-diddly-ho there,...'
     *
     * _.truncate('hi-diddly-ho there, neighborino', {
     *   'length': 24,
     *   'separator': /,? +/
     * });
     * // => 'hi-diddly-ho there...'
     *
     * _.truncate('hi-diddly-ho there, neighborino', {
     *   'omission': ' [...]'
     * });
     * // => 'hi-diddly-ho there, neig [...]'
     */

/**
     * Turn on Output Buffering (specifying an optional output handler).
     *
     * @returns {boolean}
     */

/**
     * Tweaks the error message to include suggestions.
     *
     * @param {string} name The original name of the item that does not exist
     * @param {Array<string>} items An array of possible items
     */

/**
     * TwingSourceMapNode constructor
     *
     * @param {number} line 0-based
     * @param {number} column 0-based
     * @param {TwingSource} source
     * @param {string} name
     */

/**
     * TwingSourceMapNodeSpaceless constructor
     *
     * @param {number} line 0-based
     * @param {number} column 0-based
     * @param {TwingSource} source
     */

/**
     * URL to a 1x1 transparent gif image used by Ext to create inline icons with CSS background images. 
     * In older versions of IE, this defaults to "http://extjs.com/s.gif" and you should change this to a URL on your server.
     * For other browsers it uses an inline data URL.
     * @type String
     */

/**
     * URL to a blank file used by Ext when in secure mode for iframe src and onReady src to prevent
     * the IE insecure content warning (<tt>'about:blank'</tt>, except for IE in secure mode, which is <tt>'javascript:""'</tt>).
     * @type String
     */

/**
     * Updates wrapper `details` based on `bitmask` flags.
     *
     * @private
     * @returns {Array} details The details to modify.
     * @param {number} bitmask The bitmask flags. See `createWrap` for more details.
     * @returns {Array} Returns `details`.
     */

/**
     * Used by `_.defaultsDeep` to customize its `_.merge` use to merge source
     * objects into destination objects that are passed thru.
     *
     * @private
     * @param {*} objValue The destination value.
     * @param {*} srcValue The source value.
     * @param {string} key The key of the property to merge.
     * @param {Object} object The parent object of `objValue`.
     * @param {Object} source The parent object of `srcValue`.
     * @param {Object} [stack] Tracks traversed source values and their merged
     *  counterparts.
     * @returns {*} Returns the value to assign.
     */

/**
     * Used by `_.defaults` to customize its `_.assignIn` use to assign properties
     * of source objects to the destination object for all destination properties
     * that resolve to `undefined`.
     *
     * @private
     * @param {*} objValue The destination value.
     * @param {*} srcValue The source value.
     * @param {string} key The key of the property to assign.
     * @param {Object} object The parent object of `objValue`.
     * @returns {*} Returns the value to assign.
     */

/**
     * Used by `_.omit` to customize its `_.cloneDeep` use to only clone plain
     * objects.
     *
     * @private
     * @param {*} value The value to inspect.
     * @param {string} key The key of the property to inspect.
     * @returns {*} Returns the uncloned value or `undefined` to defer cloning to `_.cloneDeep`.
     */

/**
     * Used by `_.orderBy` to compare multiple properties of a value to another
     * and stable sort them.
     *
     * If `orders` is unspecified, all values are sorted in ascending order. Otherwise,
     * specify an order of "desc" for descending or "asc" for ascending sort order
     * of corresponding values.
     *
     * @private
     * @param {Object} object The object to compare.
     * @param {Object} other The other object to compare.
     * @param {boolean[]|string[]} orders The order to sort by for each property.
     * @returns {number} Returns the sort order indicator for `object`.
     */

/**
     * Uses a binary search to determine the lowest index at which `value`
     * should be inserted into `array` in order to maintain its sort order.
     *
     * @static
     * @memberOf _
     * @since 0.1.0
     * @category Array
     * @param {Array} array The sorted array to inspect.
     * @param {*} value The value to evaluate.
     * @returns {number} Returns the index at which `value` should be inserted
     *  into `array`.
     * @example
     *
     * _.sortedIndex([30, 50], 40);
     * // => 1
     */

/**
     * Utility method for getting the width of the browser scrollbar. This can differ depending on
     * operating system settings, such as the theme or font size.
     * @param {Boolean} force (optional) true to force a recalculation of the value.
     * @return {Number} The width of the scrollbar.
     */

/**
     * Utility method for validating that a value is numeric, returning the specified default value if it is not.
     * @param {Mixed} value Should be a number, but any type will be handled appropriately
     * @param {Number} defaultValue The value to return if the original value is non-numeric
     * @return {Number} Value, if numeric, else defaultValue
     */

/**
     * Writes a string to the compiled code by adding indentation.
     *
     * @returns {TwingCompiler}
     */

/**
     * hash node is also an array node.
     *
     * @param type
     */

/**
     * null-coallesce node is also a conditional node.
     *
     * @param type
     */

/**
     * render proxy which gets replaced after with rendered content
     *
     * @param context
     * @param buffer
     * @returns {HTMLProxy}
     */

/**
     * wrap emojis like 😊 in value with <em class="emoji">😊</em>
     * usefull for dark mode
     * @param value
     * @returns {*|string}
     */

/**
     * {@link toLocaleString} format like '09:30 AM'. Only 12-hour if the locale is.
     * @type {Object}
     */

/**
     * {@link toLocaleString} format like '09:30', always 24-hour.
     * @type {Object}
     */

/**
     * {@link toLocaleString} format like '09:30:23 AM EDT'. Only 12-hour if the locale is.
     * @type {Object}
     */

/**
     * {@link toLocaleString} format like '09:30:23 AM Eastern Daylight Time'. Only 12-hour if the locale is.
     * @type {Object}
     */

/**
     * {@link toLocaleString} format like '09:30:23 AM'. Only 12-hour if the locale is.
     * @type {Object}
     */

/**
     * {@link toLocaleString} format like '09:30:23 EDT', always 24-hour.
     * @type {Object}
     */

/**
     * {@link toLocaleString} format like '09:30:23 Eastern Daylight Time', always 24-hour.
     * @type {Object}
     */

/**
     * {@link toLocaleString} format like '09:30:23', always 24-hour.
     * @type {Object}
     */

/**
     * {@link toLocaleString} format like '10/14/1983, 9:30 AM'. Only 12-hour if the locale is.
     * @type {Object}
     */

/**
     * {@link toLocaleString} format like '10/14/1983, 9:30:33 AM'. Only 12-hour if the locale is.
     * @type {Object}
     */

/**
     * {@link toLocaleString} format like 'Fri, 14 Oct 1983, 9:30 AM'. Only 12-hour if the locale is.
     * @type {Object}
     */

/**
     * {@link toLocaleString} format like 'Friday, October 14, 1983, 9:30 AM Eastern Daylight Time'. Only 12-hour if the locale is.
     * @type {Object}
     */

/**
     * {@link toLocaleString} format like 'Friday, October 14, 1983, 9:30:33 AM Eastern Daylight Time'. Only 12-hour if the locale is.
     * @type {Object}
     */

/**
     * {@link toLocaleString} format like 'Oct 14, 1983'
     * @type {Object}
     */

/**
     * {@link toLocaleString} format like 'Oct 14, 1983, 9:30 AM'. Only 12-hour if the locale is.
     * @type {Object}
     */

/**
     * {@link toLocaleString} format like 'Oct 14, 1983, 9:30:33 AM'. Only 12-hour if the locale is.
     * @type {Object}
     */

/**
     * {@link toLocaleString} format like 'October 14, 1983'
     * @type {Object}
     */

/**
     * {@link toLocaleString} format like 'October 14, 1983, 9:30 AM EDT'. Only 12-hour if the locale is.
     * @type {Object}
     */

/**
     * {@link toLocaleString} format like 'October 14, 1983, 9:30:33 AM EDT'. Only 12-hour if the locale is.
     * @type {Object}
     */

/**
     * {@link toLocaleString} format like 'Tuesday, October 14, 1983'
     * @type {Object}
     */

/**
    * A reusable empty function
    * @property
    * @type Function
    */

/**
    * Determine if a URL shares the same origin as the current location
    *
    * @param {String} requestURL The URL to test
    * @returns {boolean} True if URL shares the same origin, otherwise false
    */

/**
    * MixedCollection has a generic way to fetch keys if you implement getKey.  The default implementation
    * simply returns <b><code>item.id</code></b> but you can provide your own implementation
    * to return a different value as in the following examples:<pre><code>
  // normal way
  var mc = new Ext.util.MixedCollection();
  mc.add(someEl.dom.id, someEl);
  mc.add(otherEl.dom.id, otherEl);
  //and so on
  // using getKey
  var mc = new Ext.util.MixedCollection();
  mc.getKey = function(el){
  return el.dom.id;
  };
  mc.add(someEl);
  mc.add(otherEl);
  // or via the constructor
  var mc = new Ext.util.MixedCollection(false, function(el){
  return el.dom.id;
  });
  mc.add(someEl);
  mc.add(otherEl);
   * </code></pre>
   * @param {Object} item The item for which to find the key.
   * @return {Object} The key for the passed item.
   */

/**
    * Parse a URL to discover it's components
    *
    * @param {String} url The URL to be parsed
    * @returns {Object}
    */

/**
   *
   * @param {String} part
   */

/**
   * "Set" the DateTime's zone to UTC. Returns a newly-constructed DateTime.
   *
   * Equivalent to {@link setZone}('utc')
   * @param {number} [offset=0] - optionally, an offset from UTC in minutes
   * @param {Object} [opts={}] - options to pass to `setZone()`
   * @return {DateTime}
   */

/**
   * "Set" the DateTime's zone to specified zone. Returns a newly-constructed DateTime.
   *
   * By default, the setter keeps the underlying time the same (as in, the same timestamp), but the new instance will report different local times and consider DSTs when making computations, as with {@link plus}. You may wish to use {@link toLocal} and {@link toUTC} which provide simple convenience wrappers for commonly used zones.
   * @param {string|Zone} [zone='local'] - a zone identifier. As a string, that can be any IANA zone supported by the host environment, or a fixed-offset name of the form 'UTC+3', or the strings 'local' or 'utc'. You may also supply an instance of a {@link Zone} class.
   * @param {Object} opts - options
   * @param {boolean} [opts.keepLocalTime=false] - If true, adjust the underlying time so that the local time stays the same, but in the target zone. You should rarely need this.
   * @return {DateTime}
   */

/**
   * "Set" the DateTime's zone to the host's local zone. Returns a newly-constructed DateTime.
   *
   * Equivalent to `setZone('local')`
   * @return {DateTime}
   */

/**
   * "Set" the locale and/or numberingSystem.  Returns a newly-constructed Duration.
   * @example dur.reconfigure({ locale: 'en-GB' })
   * @return {Duration}
   */

/**
   * "Set" the locale, numberingSystem, or outputCalendar. Returns a newly-constructed DateTime.
   * @param {Object} properties - the properties to set
   * @example DateTime.local(2017, 5, 25).reconfigure({ locale: 'en-GB' })
   * @return {DateTime}
   */

/**
   * "Set" the locale. Returns a newly-constructed DateTime.
   * Just a convenient alias for reconfigure({ locale })
   * @example DateTime.local(2017, 5, 25).setLocale('en-GB')
   * @return {DateTime}
   */

/**
   * "Set" the values of specified units. Return a newly-constructed Duration.
   * @param {Object} values - a mapping of units to numbers
   * @example dur.set({ years: 2017 })
   * @example dur.set({ hours: 8, minutes: 30 })
   * @return {Duration}
   */

/**
   * "Set" the values of specified units. Returns a newly-constructed DateTime.
   * You can only set units with this method; for "setting" metadata, see {@link reconfigure} and {@link setZone}.
   * @param {Object} values - a mapping of units to numbers
   * @example dt.set({ year: 2017 })
   * @example dt.set({ hour: 8, minute: 30 })
   * @example dt.set({ weekday: 5 })
   * @example dt.set({ year: 2005, ordinal: 234 })
   * @return {DateTime}
   */

/**
   * "Set" this DateTime to the beginning of a unit of time.
   * @param {string} unit - The unit to go to the beginning of. Can be 'year', 'quarter', 'month', 'week', 'day', 'hour', 'minute', 'second', or 'millisecond'.
   * @example DateTime.local(2014, 3, 3).startOf('month').toISODate(); //=> '2014-03-01'
   * @example DateTime.local(2014, 3, 3).startOf('year').toISODate(); //=> '2014-01-01'
   * @example DateTime.local(2014, 3, 3, 5, 30).startOf('day').toISOTime(); //=> '00:00.000-05:00'
   * @example DateTime.local(2014, 3, 3, 5, 30).startOf('hour').toISOTime(); //=> '05:00:00.000-05:00'
   * @return {DateTime}
   */

/**
   * "Set" this DateTime to the end (meaning the last millisecond) of a unit of time
   * @param {string} unit - The unit to go to the end of. Can be 'year', 'month', 'day', 'hour', 'minute', 'second', or 'millisecond'.
   * @example DateTime.local(2014, 3, 3).endOf('month').toISO(); //=> '2014-03-31T23:59:59.999-05:00'
   * @example DateTime.local(2014, 3, 3).endOf('year').toISO(); //=> '2014-12-31T23:59:59.999-05:00'
   * @example DateTime.local(2014, 3, 3, 5, 30).endOf('day').toISO(); //=> '2014-03-03T23:59:59.999-05:00'
   * @example DateTime.local(2014, 3, 3, 5, 30).endOf('hour').toISO(); //=> '2014-03-03T05:59:59.999-05:00'
   * @return {DateTime}
   */

/**
   * "Sets" the start and/or end dates. Returns a newly-constructed Interval.
   * @param {Object} values - the values to set
   * @param {DateTime} values.start - the starting DateTime
   * @param {DateTime} values.end - the ending DateTime
   * @return {Interval}
   */

/**
   * <p><b>Only present if this Record was created by an {@link Ext.data.ArrayReader ArrayReader} or a {@link Ext.data.JsonReader JsonReader}</b>.</p>
   * <p>The Array or object which was the source of the data for this Record.</p>
   * @property json
   * @type {Array|Object}
   */

/**
   * <p><b>Only present if this Record was created by an {@link Ext.data.XmlReader XmlReader}</b>.</p>
   * <p>The XML element which was the source of the data for this Record.</p>
   * @property node
   * @type {XMLElement}
   */

/**
   * <p><b>This property is stored in the Record definition's <u>prototype</u></b></p>
   * A MixedCollection containing the defined {@link Ext.data.Field Field}s for this Record.  Read-only.
   * @property fields
   * @type Ext.util.MixedCollection
   */

/**
   * <p>Fires the specified event with the passed parameters (minus the event name).</p>
   * <p>An event may be set to bubble up an Observable parent hierarchy (See {@link Ext.Component#getBubbleTarget})
   * by calling {@link #enableBubble}.</p>
   * @param {String} eventName The name of the event to fire.
   * @param {Object...} args Variable number of parameters are passed to handlers.
   * @return {Boolean} returns false if any of the handlers return false otherwise it returns true.
   */

/**
   * <p>Marks this <b>Record</b> as <code>{@link #dirty}</code>.  This method
   * is used interally when adding <code>{@link #phantom}</code> records to a
   * {@link Ext.data.Store#writer writer enabled store}.</p>
   * <br><p>Marking a record <code>{@link #dirty}</code> causes the phantom to
   * be returned by {@link Ext.data.Store#getModifiedRecords} where it will
   * have a create action composed for it during {@link Ext.data.Store#save store save}
   * operations.</p>
   */

/**
   * <tt>true</tt> when the record does not yet exist in a server-side database (see
   * {@link #markDirty}).  Any record which has a real database pk set as its id property
   * is NOT a phantom -- it's real.
   * @property phantom
   * @type {Boolean}
   */

/**
   * @access private
   */

/**
   * @cfg {Array/Object} data
   */

/**
   * @cfg {Array/Object} fields
   * <p>Either an Array of {@link Ext.data.Field Field} definition objects (which
   * will be passed to {@link Ext.data.Record#create}, or a {@link Ext.data.Record Record}
   * constructor created from {@link Ext.data.Record#create}.</p>
   */

/**
   * @cfg {Boolean} allowBlank
   * (Optional) Used for validating a {@link Ext.data.Record record}, defaults to <tt>true</tt>.
   * An empty value here will cause {@link Ext.data.Record}.{@link Ext.data.Record#isValid isValid}
   * to evaluate to <tt>false</tt>.
   */

/**
   * @cfg {Boolean} allowFunctions Specify <tt>true</tt> if the {@link #addAll}
   * function should add function references to the collection. Defaults to
   * <tt>false</tt>.
   */

/**
   * @cfg {Boolean} success
   */

/**
   * @cfg {Ext.data.Record/Ext.data.Record[]} records related to the Request action
   */

/**
   * @cfg {Function} convert
   * (Optional) A function which converts the value provided by the Reader into an object that will be stored
   * in the Record. It is passed the following parameters:<div class="mdetail-params"><ul>
   * <li><b>v</b> : Mixed<div class="sub-desc">The data value as read by the Reader, if undefined will use
   * the configured <tt>{@link Ext.data.Field#defaultValue defaultValue}</tt>.</div></li>
   * <li><b>rec</b> : Mixed<div class="sub-desc">The data object containing the row as read by the Reader.
   * Depending on the Reader type, this could be an Array ({@link Ext.data.ArrayReader ArrayReader}), an object
   *  ({@link Ext.data.JsonReader JsonReader}), or an XML element ({@link Ext.data.XMLReader XMLReader}).</div></li>
   * </ul></div>
   * <pre><code>
  // example of convert function
  function fullName(v, record){
  return record.name.last + ', ' + record.name.first;
  }
  function location(v, record){
  return !record.city ? '' : (record.city + ', ' + record.state);
  }
  var Dude = Ext.data.Record.create([
  {name: 'fullname',  convert: fullName},
  {name: 'firstname', mapping: 'name.first'},
  {name: 'lastname',  mapping: 'name.last'},
  {name: 'city', defaultValue: 'homeless'},
  'state',
  {name: 'location',  convert: location}
  ]);
  // create the data store
  var store = new Ext.data.Store({
  reader: new Ext.data.JsonReader(
      {
          idProperty: 'key',
          root: 'daRoot',
          totalProperty: 'total'
      },
      Dude  // recordType
  )
  });
  var myData = [
  { key: 1,
    name: { first: 'Fat',    last:  'Albert' }
    // notice no city, state provided in data object
  },
  { key: 2,
    name: { first: 'Barney', last:  'Rubble' },
    city: 'Bedrock', state: 'Stoneridge'
  },
  { key: 3,
    name: { first: 'Cliff',  last:  'Claven' },
    city: 'Boston',  state: 'MA'
  }
  ];
   * </code></pre>
   */

/**
   * @cfg {Function} sortType
   * (Optional) A function which converts a Field's value to a comparable value in order to ensure
   * correct sort ordering. Predefined functions are provided in {@link Ext.data.SortTypes}. A custom
   * sort example:<pre><code>
  // current sort     after sort we want
  // +-+------+          +-+------+
  // |1|First |          |1|First |
  // |2|Last  |          |3|Second|
  // |3|Second|          |2|Last  |
  // +-+------+          +-+------+
  sortType: function(value) {
  switch (value.toLowerCase()) // native toLowerCase():
  {
    case 'first': return 1;
    case 'second': return 2;
    default: return 3;
  }
  }
   * </code></pre>
   */

/**
   * @cfg {Mixed} defaultValue
   * (Optional) The default value used <b>when a Record is being created by a {@link Ext.data.Reader Reader}</b>
   * when the item referenced by the <tt>{@link Ext.data.Field#mapping mapping}</tt> does not exist in the data
   * object (i.e. undefined). (defaults to "")
   */

/**
   * @cfg {Number} prio (defaults to 7)
   */

/**
   * @cfg {Object} listeners (optional) <p>A config object containing one or more event handlers to be added to this
   * object during initialization.  This should be a valid listeners config object as specified in the
   * {@link #addListener} example for attaching multiple handlers at once.</p>
   * <br><p><b><u>DOM events from ExtJs {@link Ext.Component Components}</u></b></p>
   * <br><p>While <i>some</i> ExtJs Component classes export selected DOM events (e.g. "click", "mouseover" etc), this
   * is usually only done when extra value can be added. For example the {@link Ext.DataView DataView}'s
   * <b><code>{@link Ext.DataView#click click}</code></b> event passing the node clicked on. To access DOM
   * events directly from a Component's HTMLElement, listeners must be added to the <i>{@link Ext.Component#getEl Element}</i> after the Component
   * has been rendered. A plugin can simplify this step:<pre><code>
  // Plugin is configured with a listeners config object.
  // The Component is appended to the argument list of all handler functions.
  Ext.DomObserver = Ext.extend(Object, {
  constructor: function(config) {
      this.listeners = config.listeners ? config.listeners : config;
  },
   // Component passes itself into plugin&#39;s init method
  init: function(c) {
      var p, l = this.listeners;
      for (p in l) {
          if (Ext.isFunction(l[p])) {
              l[p] = this.createHandler(l[p], c);
          } else {
              l[p].fn = this.createHandler(l[p].fn, c);
          }
      }
       // Add the listeners to the Element immediately following the render call
      c.render = c.render.{@link Function#createSequence createSequence}(function() {
          var e = c.getEl();
          if (e) {
              e.on(l);
          }
      });
  },
   createHandler: function(fn, c) {
      return function(e) {
          fn.call(this, e, c);
      };
  }
  });
  var combo = new Ext.form.ComboBox({
   // Collapse combo when its element is clicked on
  plugins: [ new Ext.DomObserver({
      click: function(evt, comp) {
          comp.collapse();
      }
  })],
  store: myStore,
  typeAhead: true,
  mode: 'local',
  triggerAction: 'all'
  });
   * </code></pre></p>
   */

/**
   * @cfg {Object} raw The raw response returned from server-code
   */

/**
   * @cfg {String/Number} mapping
   * <p>(Optional) A path expression for use by the {@link Ext.data.DataReader} implementation
   * that is creating the {@link Ext.data.Record Record} to extract the Field value from the data object.
   * If the path expression is the same as the field name, the mapping may be omitted.</p>
   * <p>The form of the mapping expression depends on the Reader being used.</p>
   * <div class="mdetail-params"><ul>
   * <li>{@link Ext.data.JsonReader}<div class="sub-desc">The mapping is a string containing the javascript
   * expression to reference the data from an element of the data item's {@link Ext.data.JsonReader#root root} Array. Defaults to the field name.</div></li>
   * <li>{@link Ext.data.XmlReader}<div class="sub-desc">The mapping is an {@link Ext.DomQuery} path to the data
   * item relative to the DOM element that represents the {@link Ext.data.XmlReader#record record}. Defaults to the field name.</div></li>
   * <li>{@link Ext.data.ArrayReader}<div class="sub-desc">The mapping is a number indicating the Array index
   * of the field's value. Defaults to the field specification's Array position.</div></li>
   * </ul></div>
   * <p>If a more complex value extraction strategy is required, then configure the Field with a {@link #convert}
   * function. This is passed the whole row object, and may interrogate it in whatever way is necessary in order to
   * return the desired data.</p>
   */

/**
   * @cfg {String} action {@link Ext.data.Api#actions}
   */

/**
   * @cfg {String} appName
   * internal/untranslated app name (required)
   */

/**
   * @cfg {String} containerName
   * untranslated container name
   */

/**
   * @cfg {String} containerProperty
   * name of the container property
   */

/**
   * @cfg {String} dateFormat
   * (Optional) A format string for the {@link Date#parseDate parseDate} function, or "timestamp" if the
   * value provided by the Reader is a UNIX timestamp, or "time" if the value provided by the Reader is a
   * javascript millisecond timestamp.
   */

/**
   * @cfg {String} grantsPath
   * path (see _.get() to find grants
   */

/**
   * @cfg {String} idProperty
   * property of the id of the record
   */

/**
   * @cfg {String} idProperty [id] Name of the property within a row object
   * that contains a record identifier value.  Defaults to <tt>id</tt>
   */

/**
   * @cfg {String} message
   */

/**
   * @cfg {String} messageProperty [undefined] Optional name of a property within a server-response that represents a user-feedback message.
   */

/**
   * @cfg {String} modelName
   * name of the model/record  (required)
   */

/**
   * @cfg {String} name
   * The name by which the field is referenced within the Record. This is referenced by, for example,
   * the <tt>dataIndex</tt> property in column definition objects passed to {@link Ext.grid.ColumnModel}.
   * <p>Note: In the simplest case, if no properties other than <tt>name</tt> are required, a field
   * definition may consist of just a String for the field name.</p>
   */

/**
   * @cfg {String} recordName
   * untranslated record/item name
   */

/**
   * @cfg {String} recordName
   * untranslated records/items (plural) name
   */

/**
   * @cfg {String} root [undefined] <b>Required</b>.  The name of the property
   * which contains the Array of row objects.  Defaults to <tt>undefined</tt>.
   * An exception will be thrown if the root property is undefined. The data
   * packet value for this property should be an empty array to clear the data
   * or show no data.
   */

/**
   * @cfg {String} sortDir
   * (Optional) Initial direction to sort (<tt>"ASC"</tt> or  <tt>"DESC"</tt>).  Defaults to
   * <tt>"ASC"</tt>.
   */

/**
   * @cfg {String} successProperty [success] Name of the property from which to
   * retrieve the success attribute. Defaults to <tt>success</tt>.  See
   * {@link Ext.data.DataProxy}.{@link Ext.data.DataProxy#exception exception}
   * for additional information.
   */

/**
   * @cfg {String} titleProperty
   * property of the title attibute, used in generic getTitle function  (required)
   */

/**
   * @cfg {String} totalProperty [total] Name of the property from which to
   * retrieve the total number of records in the dataset. This is only needed
   * if the whole dataset is not passed in one go, but is being paged from
   * the remote server.  Defaults to <tt>total</tt>.
   */

/**
   * @cfg {String} type
   * (Optional) The data type for conversion to displayable value if <tt>{@link Ext.data.Field#convert convert}</tt>
   * has not been specified. Possible values are
   * <div class="mdetail-params"><ul>
   * <li>auto (Default, implies no conversion)</li>
   * <li>string</li>
   * <li>int</li>
   * <li>float</li>
   * <li>boolean</li>
   * <li>date</li></ul></div>
   */

/**
   * @cfg {string} containerName
   * untranslated name of container (plural)
   */

/**
   * @cfg: {bool} copyNoAppendTitle
   * don't append "(copy)" string to title when record is copied
   */

/**
   * @deprecated use fromFormat instead
   */

/**
   * @deprecated use fromFormatExplain instead
   */

/**
   * @event add
   * Fires when an item is added to the collection.
   * @param {Number} index The index at which the item was added.
   * @param {Object} o The item added.
   * @param {String} key The key associated with the added item.
   */

/**
   * @event clear
   * Fires when the collection is cleared.
   */

/**
   * @event remove
   * Fires when an item is removed from the collection.
   * @param {Object} o The item being removed.
   * @param {String} key (optional) The key associated with the removed item.
   */

/**
   * @event replace
   * Fires when an item is replaced in the collection.
   * @param {String} key he key associated with the new added.
   * @param {Object} old The item being replaced.
   * @param {Object} new The new item.
   */

/**
   * @ignore
   * TODO This isn't used anywhere??  Don't we want to use this where possible instead of complex #createAccessor?
   */

/**
   * @ignore
   */

/**
   * @internal
   */

/**
   * @param key
   * @param {Object} o The item to add.
   * @param suppressEvent
   */

/**
   * @param {string} name - Zone name
   * @return {IANAZone}
   */

/**
   * @private
   * @param {String} property Property to sort by ('key', 'value', or 'index')
   * @param {String} dir (optional) Direction to sort 'ASC' or 'DESC'. Defaults to 'ASC'.
   * @param {Function} fn (optional) Comparison function that defines the sort order.
   * Defaults to sorting by numeric value.
   */

/**
   * @private
   */

/**
   * A faster alternative to `Function#apply`, this function invokes `func`
   * with the `this` binding of `thisArg` and the arguments of `args`.
   *
   * @private
   * @param {Function} func The function to invoke.
   * @param {*} thisArg The `this` binding of `func`.
   * @param {Array} args The arguments to invoke `func` with.
   * @returns {*} Returns the result of `func`.
   */

/**
   * A specialized version of `_.every` for arrays without support for
   * iteratee shorthands.
   *
   * @private
   * @param {Array} [array] The array to iterate over.
   * @param {Function} predicate The function invoked per iteration.
   * @returns {boolean} Returns `true` if all elements pass the predicate check,
   *  else `false`.
   */

/**
   * A specialized version of `_.filter` for arrays without support for
   * iteratee shorthands.
   *
   * @private
   * @param {Array} [array] The array to iterate over.
   * @param {Function} predicate The function invoked per iteration.
   * @returns {Array} Returns the new filtered array.
   */

/**
   * A specialized version of `_.forEachRight` 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 `array`.
   */

/**
   * A specialized version of `_.forEach` 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 `array`.
   */

/**
   * A specialized version of `_.includes` for arrays without support for
   * specifying an index to search from.
   *
   * @private
   * @param {Array} [array] The array to inspect.
   * @param {*} target The value to search for.
   * @returns {boolean} Returns `true` if `target` is found, else `false`.
   */

/**
   * A specialized version of `_.indexOf` which performs strict equality
   * comparisons of values, i.e. `===`.
   *
   * @private
   * @param {Array} array The array to inspect.
   * @param {*} value The value to search for.
   * @param {number} fromIndex The index to search from.
   * @returns {number} Returns the index of the matched value, else `-1`.
   */

/**
   * A specialized version of `_.lastIndexOf` which performs strict equality
   * comparisons of values, i.e. `===`.
   *
   * @private
   * @param {Array} array The array to inspect.
   * @param {*} value The value to search for.
   * @param {number} fromIndex The index to search from.
   * @returns {number} Returns the index of the matched value, else `-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.
   */

/**
   * A specialized version of `_.reduceRight` 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 last element of `array` as
   *  the initial value.
   * @returns {*} Returns the accumulated value.
   */

/**
   * 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.
   */

/**
   * A specialized version of `_.some` for arrays without support for iteratee
   * shorthands.
   *
   * @private
   * @param {Array} [array] The array to iterate over.
   * @param {Function} predicate The function invoked per iteration.
   * @returns {boolean} Returns `true` if any element passes the predicate check,
   *  else `false`.
   */

/**
   * A specialized version of `baseAggregator` for arrays.
   *
   * @private
   * @param {Array} [array] The array to iterate over.
   * @param {Function} setter The function to set `accumulator` values.
   * @param {Function} iteratee The iteratee to transform keys.
   * @param {Object} accumulator The initial aggregated object.
   * @returns {Function} Returns `accumulator`.
   */

/**
   * A timeout in milliseconds to abort a request. If set to 0 (default) a
   * timeout is not created.
   */

/**
   * Abstract method created in extension's buildExtractors impl.
   */

/**
   * Abstract method overridden in DataReader extensions such as {@link Ext.data.JsonReader} and {@link Ext.data.XmlReader}
   */

/**
   * Abstract method, overridden in DataReader extensions such as {@link Ext.data.JsonReader} and {@link Ext.data.XmlReader}
   */

/**
   * Add a new interceptor to the stack
   *
   * @param {Function} fulfilled The function to handle `then` for a `Promise`
   * @param {Function} rejected The function to handle `reject` for a `Promise`
   *
   * @return {Number} An ID used to remove interceptor later
   */

/**
   * Add a period of time to this DateTime and return the resulting DateTime
   *
   * Adding hours, minutes, seconds, or milliseconds increases the timestamp by the right number of milliseconds. Adding days, months, or years shifts the calendar, accounting for DSTs and leap years along the way. Thus, `dt.plus({ hours: 24 })` may result in a different time than `dt.plus({ days: 1 })` if there's a DST shift in between.
   * @param {Duration|Object|number} duration - The amount to add. Either a Luxon Duration, a number of milliseconds, the object argument to Duration.fromObject()
   * @example DateTime.local().plus(123) //~> in 123 milliseconds
   * @example DateTime.local().plus({ minutes: 15 }) //~> in 15 minutes
   * @example DateTime.local().plus({ days: 1 }) //~> this time tomorrow
   * @example DateTime.local().plus({ days: -1 }) //~> this time yesterday
   * @example DateTime.local().plus({ hours: 3, minutes: 13 }) //~> in 3 hr, 13 min
   * @example DateTime.local().plus(Duration.fromObject({ hours: 3, minutes: 13 })) //~> in 3 hr, 13 min
   * @return {DateTime}
   */

/**
   * Adds all elements of an Array or an Object to the collection.
   * @param {Object/Array} objs An Object containing properties which will be added
   * to the collection, or an Array of values, each of which are added to the collection.
   * Functions references will be added to the collection if <code>{@link #allowFunctions}</code>
   * has been set to <tt>true</tt>.
   * @param suppressEvent
   */

/**
   * Adds an item to the collection. Fires the {@link #add} event when complete.
   * @param {String} key <p>The key to associate with the item, or the new item.</p>
   * <p>If a {@link #getKey} implementation was specified for this MixedCollection,
   * or if the key of the stored items is in a property called <tt><b>id</b></tt>,
   * the MixedCollection will be able to <i>derive</i> the key for the new item.
   * In this case just pass the new item in this parameter.</p>
   * @param {Object} o The item to add.
   * @param suppressEvent
   * @return {Object} The item added.
   */

/**
   * Adds the specified events to the list of events which this Observable may fire.
   * @param {Object|String} o Either an object with event names as properties with a value of <code>true</code>
   * or the first event name string if multiple event names are being passed as separate parameters.
   * @param {string} Optional. Event name if multiple event names are being passed as separate parameters.
   * Usage:<pre><code>
  this.addEvents('storeloaded', 'storecleared');
  </code></pre>
   */

/**
   * Allows you to define a tokenized string and pass an arbitrary number of arguments to replace the tokens.  Each
   * token must be unique, and must increment in the format {0}, {1}, etc.  Example usage:
   * <pre><code>
  var cls = 'my-class', text = 'Some text';
  var s = String.format('&lt;div class="{0}">{1}&lt;/div>', cls, text);
  // s now contains the string: '&lt;div class="my-class">Some text&lt;/div>'
   * </code></pre>
   * @param {String} string The tokenized string to be formatted
   * @param {String} value1 The value to replace token {0}
   * @param {String} value2 Etc...
   * @return {String} The formatted string
   * @static
   */

/**
   * An object hash representing the data for this Record. Every field name in the Record definition
   * is represented by a property of that name in this object. Note that unless you specified a field
   * with {@link Ext.data.Field#name name} "id" in the Record definition, this will <b>not</b> contain
   * an <tt>id</tt> property.
   * @property data
   * @type {Object}
   */

/**
   * Appends an event handler to this object.
   * @param {String}   eventName The name of the event to listen for.
   * @param {Function} handler The method the event invokes.
   * @param {Object}   scope (optional) The scope (<code><b>this</b></code> reference) in which the handler function is executed.
   * <b>If omitted, defaults to the object which fired the event.</b>
   * @param {Object}   options (optional) An object containing handler configuration.
   * properties. This may contain any of the following properties:<ul>
   * <li><b>scope</b> : Object<div class="sub-desc">The scope (<code><b>this</b></code> reference) in which the handler function is executed.
   * <b>If omitted, defaults to the object which fired the event.</b></div></li>
   * <li><b>delay</b> : Number<div class="sub-desc">The number of milliseconds to delay the invocation of the handler after the event fires.</div></li>
   * <li><b>single</b> : Boolean<div class="sub-desc">True to add a handler to handle just the next firing of the event, and then remove itself.</div></li>
   * <li><b>buffer</b> : Number<div class="sub-desc">Causes the handler to be scheduled to run in an {@link Ext.util.DelayedTask} delayed
   * by the specified number of milliseconds. If the event fires again within that time, the original
   * handler is <em>not</em> invoked, but the new handler is scheduled in its place.</div></li>
   * <li><b>target</b> : Observable<div class="sub-desc">Only call the handler if the event was fired on the target Observable, <i>not</i>
   * if the event was bubbled up from a child Observable.</div></li>
   * </ul><br>
   * <p>
   * <b>Combining Options</b><br>
   * Using the options argument, it is possible to combine different types of listeners:<br>
   * <br>
   * A delayed, one-time listener.
   * <pre><code>
  myDataView.on('click', this.onClick, this, {
  single: true,
  delay: 100
  });</code></pre>
   * <p>
   * <b>Attaching multiple handlers in 1 call</b><br>
   * The method also allows for a single argument to be passed which is a config object containing properties
   * which specify multiple handlers.
   * <p>
   * <pre><code>
  myGridPanel.on({
  'click' : {
  fn: this.onClick,
  scope: this,
  delay: 100
  },
  'mouseover' : {
  fn: this.onMouseOver,
  scope: this
  },
  'mouseout' : {
  fn: this.onMouseOut,
  scope: this
  }
  });</code></pre>
  * <p>
  * Or a shorthand syntax:<br>
  * <pre><code>
  myGridPanel.on({
  'click' : this.onClick,
  'mouseover' : this.onMouseOver,
  'mouseout' : this.onMouseOut,
  scope: this
  });</code></pre>
   */

/**
   * Appends the elements of `values` to `array`.
   *
   * @private
   * @param {Array} array The array to modify.
   * @param {Array} values The values to append.
   * @returns {Array} Returns `array`.
   */

/**
   * Begin an edit. While in edit mode, no events (e.g.. the <code>update</code> event)
   * are relayed to the containing store.
   * See also: <code>{@link #endEdit}</code> and <code>{@link #cancelEdit}</code>.
   */

/**
   * By default returns <tt>false</tt> if any {@link Ext.data.Field field} within the
   * record configured with <tt>{@link Ext.data.Field#allowBlank} = false</tt> returns
   * <tt>true</tt> from an {@link Ext}.{@link Ext#isEmpty isempty} test.
   * @return {Boolean}
   */

/**
   * Calls this function after the number of millseconds specified, optionally in a specific scope. Example usage:
   * <pre><code>
  var sayHi = function(name){
  alert('Hi, ' + name);
  }
  // executes immediately:
  sayHi('Fred');
  // executes after 2 seconds:
  sayHi.defer(2000, this, ['Fred']);
  // this syntax is sometimes useful for deferring
  // execution of an anonymous function:
  (function(){
  alert('Anonymous');
  }).defer(100);
  </code></pre>
   * @param {Number} millis The number of milliseconds for the setTimeout call (if less than or equal to 0 the function is executed immediately)
   * @param {Object} scope (optional) The scope (<code><b>this</b></code> reference) in which the function is executed.
   * <b>If omitted, defaults to the browser window.</b>
   * @param {Array} args (optional) Overrides arguments for the call. (Defaults to the arguments passed by the caller)
   * @param {Boolean/Number} appendArgs (optional) if True args are appended to call args instead of overriding,
   * if a number the args are inserted at the specified position
   * @return {Number} The timeout id that can be used with clearTimeout
   */

/**
   * Cancel the last queued timeout
   */

/**
   * Cancels all changes made in the current edit operation.
   */

/**
   * Cancels any pending timeout and queues a new one
   * @param {Number} delay The milliseconds to delay
   * @param {Function} newFn (optional) Overrides function passed to constructor
   * @param {Object} newScope (optional) Overrides scope passed to constructor. Remember that if no scope
   * is specified, <code>this</code> will refer to the browser window.
   * @param {Array} newArgs (optional) Overrides args passed to constructor
   */

/**
   * Case insensitive string
   * @param {Mixed} s The value being converted
   * @return {String} The comparison value
   */

/**
   * Check if an object is a DateTime. Works across context boundaries
   * @param {object} o
   * @return {boolean}
   */

/**
   * Check if an object is a Duration. Works across context boundaries
   * @param {object} o
   * @return {boolean}
   */

/**
   * Check if an object is an Interval. Works across context boundaries
   * @param {object} o
   * @return {boolean}
   */

/**
   * 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`.
   */

/**
   * 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`.
   */

/**
   * Checks if a `cache` value for `key` exists.
   *
   * @private
   * @param {Object} cache The cache to query.
   * @param {string} key The key of the entry to check.
   * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.
   */

/**
   * Checks to see if this object has any listeners for a specified event
   * @param {String} eventName The name of the event to check for
   * @return {Boolean} True if the event is being listened for, else false
   */

/**
   * Checks whether or not the current number is within a desired range.  If the number is already within the
   * range it is returned, otherwise the min or max value is returned depending on which side of the range is
   * exceeded.  Note that this method returns the constrained value but does not change the current number.
   * @param {Number} min The minimum number in the range
   * @param {Number} max The maximum number in the range
   * @return {Number} The constrained value if outside the range, otherwise the current value
   */

/**
   * Checks whether or not the specified object exists in the array.
   * @param {Object} o The object to check for
   * @param {Number} from (Optional) The index at which to begin the search
   * @return {Number} The index of o in the array (or -1 if it is not found)
   */

/**
   * Clear all interceptors from the stack
   *
   * @returns {void}
   */

/**
   * Confirm application restart
   *
   * @param Boolean closewindow
   */

/**
   * Convert this Duration into its representation in a different set of units.
   * @example Duration.fromObject({ hours: 1, seconds: 30 }).shiftTo('minutes', 'milliseconds').toObject() //=> { minutes: 60, milliseconds: 30000 }
   * @return {Duration}
   */

/**
   * Converts `iterator` to an array.
   *
   * @private
   * @param {Object} iterator The iterator to convert.
   * @returns {Array} Returns the converted array.
   */

/**
   * Converts `map` to its key-value pairs.
   *
   * @private
   * @param {Object} map The map to convert.
   * @returns {Array} Returns the key-value pairs.
   */

/**
   * Converts `set` to an array of its values.
   *
   * @private
   * @param {Object} set The set to convert.
   * @returns {Array} Returns the values.
   */

/**
   * Converts `set` to its value-value pairs.
   *
   * @private
   * @param {Object} set The set to convert.
   * @returns {Array} Returns the value-value pairs.
   */

/**
   * Converts `string` to an array.
   *
   * @private
   * @param {string} string The string to convert.
   * @returns {Array} Returns the converted array.
   */

/**
   * Converts a Unicode `string` to an array.
   *
   * @private
   * @param {string} string The string to convert.
   * @returns {Array} Returns the converted array.
   */

/**
   * Converts an ASCII `string` to an array.
   *
   * @private
   * @param {string} string The string to convert.
   * @returns {Array} Returns the converted array.
   */

/**
   * Converts the input into a {@link Zone} instance.
   *
   * * If `input` is already a Zone instance, it is returned unchanged.
   * * If `input` is a string containing a valid time zone name, a Zone instance
   *   with that name is returned.
   * * If `input` is a string that doesn't refer to a known time zone, a Zone
   *   instance with {@link Zone.isValid} == false is returned.
   * * If `input is a number, a Zone instance with the specified fixed offset
   *   in minutes is returned.
   * * If `input` is `null` or `undefined`, the default zone is returned.
   * @param {string|Zone|number} [input] - the value to be converted
   * @return {Zone}
   */

/**
   * Create Duration from a number of milliseconds.
   * @param {number} count of milliseconds
   * @param {Object} opts - options for parsing
   * @param {string} [opts.locale='en-US'] - the locale to use
   * @param {string} opts.numberingSystem - the numbering system to use
   * @param {string} [opts.conversionAccuracy='casual'] - the conversion system to use
   * @return {Duration}
   */

/**
   * Create a DateTime from a Javascript Date object. Uses the default zone.
   * @param {Date} date - a Javascript Date object
   * @param {Object} options - configuration options for the DateTime
   * @param {string|Zone} [options.zone='local'] - the zone to place the DateTime into
   * @return {DateTime}
   */

/**
   * Create a DateTime from a Javascript object with keys like 'year' and 'hour' with reasonable defaults.
   * @param {Object} obj - the object to create the DateTime from
   * @param {number} obj.year - a year, such as 1987
   * @param {number} obj.month - a month, 1-12
   * @param {number} obj.day - a day of the month, 1-31, depending on the month
   * @param {number} obj.ordinal - day of the year, 1-365 or 366
   * @param {number} obj.weekYear - an ISO week year
   * @param {number} obj.weekNumber - an ISO week number, between 1 and 52 or 53, depending on the year
   * @param {number} obj.weekday - an ISO weekday, 1-7, where 1 is Monday and 7 is Sunday
   * @param {number} obj.hour - hour of the day, 0-23
   * @param {number} obj.minute - minute of the hour, 0-59
   * @param {number} obj.second - second of the minute, 0-59
   * @param {number} obj.millisecond - millisecond of the second, 0-999
   * @param {string|Zone} [obj.zone='local'] - interpret the numbers in the context of a particular zone. Can take any value taken as the first argument to setZone()
   * @param {string} [obj.locale='system's locale'] - a locale to set on the resulting DateTime instance
   * @param {string} obj.outputCalendar - the output calendar to set on the resulting DateTime instance
   * @param {string} obj.numberingSystem - the numbering system to set on the resulting DateTime instance
   * @example DateTime.fromObject({ year: 1982, month: 5, day: 25}).toISODate() //=> '1982-05-25'
   * @example DateTime.fromObject({ year: 1982 }).toISODate() //=> '1982-01-01'
   * @example DateTime.fromObject({ hour: 10, minute: 26, second: 6 }) //~> today at 10:26:06
   * @example DateTime.fromObject({ hour: 10, minute: 26, second: 6, zone: 'utc' }),
   * @example DateTime.fromObject({ hour: 10, minute: 26, second: 6, zone: 'local' })
   * @example DateTime.fromObject({ hour: 10, minute: 26, second: 6, zone: 'America/New_York' })
   * @example DateTime.fromObject({ weekYear: 2016, weekNumber: 2, weekday: 3 }).toISODate() //=> '2016-01-13'
   * @return {DateTime}
   */

/**
   * Create a DateTime from a SQL date, time, or datetime
   * Defaults to en-US if no locale has been specified, regardless of the system's locale
   * @param {string} text - the string to parse
   * @param {Object} opts - options to affect the creation
   * @param {string|Zone} [opts.zone='local'] - use this zone if no offset is specified in the input string itself. Will also convert the DateTime to this zone
   * @param {boolean} [opts.setZone=false] - override the zone with a zone specified in the string itself, if it specifies one
   * @param {string} [opts.locale='en-US'] - a locale string to use when parsing. Will also set the DateTime to this locale
   * @param {string} opts.numberingSystem - the numbering system to use when parsing. Will also set the resulting DateTime to this numbering system
   * @param {string} opts.outputCalendar - the output calendar to set on the resulting DateTime instance
   * @example DateTime.fromSQL('2017-05-15')
   * @example DateTime.fromSQL('2017-05-15 09:12:34')
   * @example DateTime.fromSQL('2017-05-15 09:12:34.342')
   * @example DateTime.fromSQL('2017-05-15 09:12:34.342+06:00')
   * @example DateTime.fromSQL('2017-05-15 09:12:34.342 America/Los_Angeles')
   * @example DateTime.fromSQL('2017-05-15 09:12:34.342 America/Los_Angeles', { setZone: true })
   * @example DateTime.fromSQL('2017-05-15 09:12:34.342', { zone: 'America/Los_Angeles' })
   * @example DateTime.fromSQL('09:12:34.342')
   * @return {DateTime}
   */

/**
   * Create a DateTime from a number of milliseconds since the epoch (meaning since 1 January 1970 00:00:00 UTC). Uses the default zone.
   * @param {number} milliseconds - a number of milliseconds since 1970 UTC
   * @param {Object} options - configuration options for the DateTime
   * @param {string|Zone} [options.zone='local'] - the zone to place the DateTime into
   * @param {string} [options.locale] - a locale to set on the resulting DateTime instance
   * @param {string} options.outputCalendar - the output calendar to set on the resulting DateTime instance
   * @param {string} options.numberingSystem - the numbering system to set on the resulting DateTime instance
   * @return {DateTime}
   */

/**
   * Create a DateTime from a number of seconds since the epoch (meaning since 1 January 1970 00:00:00 UTC). Uses the default zone.
   * @param {number} seconds - a number of seconds since 1970 UTC
   * @param {Object} options - configuration options for the DateTime
   * @param {string|Zone} [options.zone='local'] - the zone to place the DateTime into
   * @param {string} [options.locale] - a locale to set on the resulting DateTime instance
   * @param {string} options.outputCalendar - the output calendar to set on the resulting DateTime instance
   * @param {string} options.numberingSystem - the numbering system to set on the resulting DateTime instance
   * @return {DateTime}
   */

/**
   * Create a DateTime from an HTTP header date
   * @see https://www.w3.org/Protocols/rfc2616/rfc2616-sec3.html#sec3.3.1
   * @param {string} text - the HTTP header date
   * @param {Object} opts - options to affect the creation
   * @param {string|Zone} [opts.zone='local'] - convert the time to this zone. Since HTTP dates are always in UTC, this has no effect on the interpretation of string, merely the zone the resulting DateTime is expressed in.
   * @param {boolean} [opts.setZone=false] - override the zone with the fixed-offset zone specified in the string. For HTTP dates, this is always UTC, so this option is equivalent to setting the `zone` option to 'utc', but this option is included for consistency with similar methods.
   * @param {string} [opts.locale='system's locale'] - a locale to set on the resulting DateTime instance
   * @param {string} opts.outputCalendar - the output calendar to set on the resulting DateTime instance
   * @param {string} opts.numberingSystem - the numbering system to set on the resulting DateTime instance
   * @example DateTime.fromHTTP('Sun, 06 Nov 1994 08:49:37 GMT')
   * @example DateTime.fromHTTP('Sunday, 06-Nov-94 08:49:37 GMT')
   * @example DateTime.fromHTTP('Sun Nov  6 08:49:37 1994')
   * @return {DateTime}
   */

/**
   * Create a DateTime from an ISO 8601 string
   * @param {string} text - the ISO string
   * @param {Object} opts - options to affect the creation
   * @param {string|Zone} [opts.zone='local'] - use this zone if no offset is specified in the input string itself. Will also convert the time to this zone
   * @param {boolean} [opts.setZone=false] - override the zone with a fixed-offset zone specified in the string itself, if it specifies one
   * @param {string} [opts.locale='system's locale'] - a locale to set on the resulting DateTime instance
   * @param {string} opts.outputCalendar - the output calendar to set on the resulting DateTime instance
   * @param {string} opts.numberingSystem - the numbering system to set on the resulting DateTime instance
   * @example DateTime.fromISO('2016-05-25T09:08:34.123')
   * @example DateTime.fromISO('2016-05-25T09:08:34.123+06:00')
   * @example DateTime.fromISO('2016-05-25T09:08:34.123+06:00', {setZone: true})
   * @example DateTime.fromISO('2016-05-25T09:08:34.123', {zone: 'utc'})
   * @example DateTime.fromISO('2016-W05-4')
   * @return {DateTime}
   */

/**
   * Create a DateTime from an RFC 2822 string
   * @param {string} text - the RFC 2822 string
   * @param {Object} opts - options to affect the creation
   * @param {string|Zone} [opts.zone='local'] - convert the time to this zone. Since the offset is always specified in the string itself, this has no effect on the interpretation of string, merely the zone the resulting DateTime is expressed in.
   * @param {boolean} [opts.setZone=false] - override the zone with a fixed-offset zone specified in the string itself, if it specifies one
   * @param {string} [opts.locale='system's locale'] - a locale to set on the resulting DateTime instance
   * @param {string} opts.outputCalendar - the output calendar to set on the resulting DateTime instance
   * @param {string} opts.numberingSystem - the numbering system to set on the resulting DateTime instance
   * @example DateTime.fromRFC2822('25 Nov 2016 13:23:12 GMT')
   * @example DateTime.fromRFC2822('Fri, 25 Nov 2016 13:23:12 +0600')
   * @example DateTime.fromRFC2822('25 Nov 2016 13:23 Z')
   * @return {DateTime}
   */

/**
   * Create a DateTime from an input string and format string.
   * Defaults to en-US if no locale has been specified, regardless of the system's locale.
   * @see https://moment.github.io/luxon/docs/manual/parsing.html#table-of-tokens
   * @param {string} text - the string to parse
   * @param {string} fmt - the format the string is expected to be in (see the link below for the formats)
   * @param {Object} opts - options to affect the creation
   * @param {string|Zone} [opts.zone='local'] - use this zone if no offset is specified in the input string itself. Will also convert the DateTime to this zone
   * @param {boolean} [opts.setZone=false] - override the zone with a zone specified in the string itself, if it specifies one
   * @param {string} [opts.locale='en-US'] - a locale string to use when parsing. Will also set the DateTime to this locale
   * @param {string} opts.numberingSystem - the numbering system to use when parsing. Will also set the resulting DateTime to this numbering system
   * @param {string} opts.outputCalendar - the output calendar to set on the resulting DateTime instance
   * @return {DateTime}
   */

/**
   * Create a DateTime in UTC
   * @param {number} [year] - The calendar year. If omitted (as in, call `utc()` with no arguments), the current time will be used
   * @param {number} [month=1] - The month, 1-indexed
   * @param {number} [day=1] - The day of the month
   * @param {number} [hour=0] - The hour of the day, in 24-hour time
   * @param {number} [minute=0] - The minute of the hour, meaning a number between 0 and 59
   * @param {number} [second=0] - The second of the minute, meaning a number between 0 and 59
   * @param {number} [millisecond=0] - The millisecond of the second, meaning a number between 0 and 999
   * @example DateTime.utc()                            //~> now
   * @example DateTime.utc(2017)                        //~> 2017-01-01T00:00:00Z
   * @example DateTime.utc(2017, 3)                     //~> 2017-03-01T00:00:00Z
   * @example DateTime.utc(2017, 3, 12)                 //~> 2017-03-12T00:00:00Z
   * @example DateTime.utc(2017, 3, 12, 5)              //~> 2017-03-12T05:00:00Z
   * @example DateTime.utc(2017, 3, 12, 5, 45)          //~> 2017-03-12T05:45:00Z
   * @example DateTime.utc(2017, 3, 12, 5, 45, 10)      //~> 2017-03-12T05:45:10Z
   * @example DateTime.utc(2017, 3, 12, 5, 45, 10, 765) //~> 2017-03-12T05:45:10.765Z
   * @return {DateTime}
   */

/**
   * Create a Duration from a Javascript object with keys like 'years' and 'hours.
   * If this object is empty then a zero milliseconds duration is returned.
   * @param {Object} obj - the object to create the DateTime from
   * @param {number} obj.years
   * @param {number} obj.quarters
   * @param {number} obj.months
   * @param {number} obj.weeks
   * @param {number} obj.days
   * @param {number} obj.hours
   * @param {number} obj.minutes
   * @param {number} obj.seconds
   * @param {number} obj.milliseconds
   * @param {string} [obj.locale='en-US'] - the locale to use
   * @param {string} obj.numberingSystem - the numbering system to use
   * @param {string} [obj.conversionAccuracy='casual'] - the conversion system to use
   * @return {Duration}
   */

/**
   * Create a Duration from an ISO 8601 duration string.
   * @param {string} text - text to parse
   * @param {Object} opts - options for parsing
   * @param {string} [opts.locale='en-US'] - the locale to use
   * @param {string} opts.numberingSystem - the numbering system to use
   * @param {string} [opts.conversionAccuracy='casual'] - the conversion system to use
   * @see https://en.wikipedia.org/wiki/ISO_8601#Durations
   * @example Duration.fromISO('P3Y6M1W4DT12H30M5S').toObject() //=> { years: 3, months: 6, weeks: 1, days: 4, hours: 12, minutes: 30, seconds: 5 }
   * @example Duration.fromISO('PT23H').toObject() //=> { hours: 23 }
   * @example Duration.fromISO('P5Y3M').toObject() //=> { years: 5, months: 3 }
   * @return {Duration}
   */

/**
   * Create a combined function call sequence of the original function + the passed function.
   * The resulting function returns the results of the original function.
   * The passed fcn is called with the parameters of the original function. Example usage:
   * <pre><code>
  var sayHi = function(name){
  alert('Hi, ' + name);
  }
  sayHi('Fred'); // alerts "Hi, Fred"
  var sayGoodbye = sayHi.createSequence(function(name){
  alert('Bye, ' + name);
  });
  sayGoodbye('Fred'); // both alerts show
  </code></pre>
   * @param {Function} fcn The function to sequence
   * @param {Object} scope (optional) The scope (<code><b>this</b></code> reference) in which the passed function is executed.
   * <b>If omitted, defaults to the scope in which the original function is called or the browser window.</b>
   * @return {Function} The new function
   */

/**
   * Create a data block containing Ext.data.Records from a JSON object.
   * @param {Object} o An object which contains an Array of row objects in the property specified
   * in the config as 'root, and optionally a property, specified in the config as 'totalProperty'
   * which contains the total size of the dataset.
   * @return {Object} data A data block which is used by an Ext.data.Store object as
   * a cache of Ext.data.Records.
   */

/**
   * Create a local DateTime
   * @param {number} [year] - The calendar year. If omitted (as in, call `local()` with no arguments), the current time will be used
   * @param {number} [month=1] - The month, 1-indexed
   * @param {number} [day=1] - The day of the month
   * @param {number} [hour=0] - The hour of the day, in 24-hour time
   * @param {number} [minute=0] - The minute of the hour, meaning a number between 0 and 59
   * @param {number} [second=0] - The second of the minute, meaning a number between 0 and 59
   * @param {number} [millisecond=0] - The millisecond of the second, meaning a number between 0 and 999
   * @example DateTime.local()                            //~> now
   * @example DateTime.local(2017)                        //~> 2017-01-01T00:00:00
   * @example DateTime.local(2017, 3)                     //~> 2017-03-01T00:00:00
   * @example DateTime.local(2017, 3, 12)                 //~> 2017-03-12T00:00:00
   * @example DateTime.local(2017, 3, 12, 5)              //~> 2017-03-12T05:00:00
   * @example DateTime.local(2017, 3, 12, 5, 45)          //~> 2017-03-12T05:45:00
   * @example DateTime.local(2017, 3, 12, 5, 45, 10)      //~> 2017-03-12T05:45:10
   * @example DateTime.local(2017, 3, 12, 5, 45, 10, 765) //~> 2017-03-12T05:45:10.765
   * @return {DateTime}
   */

/**
   * Create a new pristine `lodash` function using the `context` object.
   *
   * @static
   * @memberOf _
   * @since 1.1.0
   * @category Util
   * @param {Object} [context=root] The context object.
   * @returns {Function} Returns a new `lodash` function.
   * @example
   *
   * _.mixin({ 'foo': _.constant('foo') });
   *
   * var lodash = _.runInContext();
   * lodash.mixin({ 'bar': lodash.constant('bar') });
   *
   * _.isFunction(_.foo);
   * // => true
   * _.isFunction(_.bar);
   * // => false
   *
   * lodash.isFunction(lodash.foo);
   * // => false
   * lodash.isFunction(lodash.bar);
   * // => true
   *
   * // Create a suped-up `defer` in Node.js.
   * var defer = _.runInContext({ 'setTimeout': setImmediate }).defer;
   */

/**
   * Create an Interval from a start DateTime and a Duration to extend to.
   * @param {DateTime|Date|Object} start
   * @param {Duration|Object|number} duration - the length of the Interval.
   * @return {Interval}
   */

/**
   * Create an Interval from a start DateTime and an end DateTime. Inclusive of the start but not the end.
   * @param {DateTime|Date|Object} start
   * @param {DateTime|Date|Object} end
   * @return {Interval}
   */

/**
   * Create an Interval from an ISO 8601 string.
   * Accepts `<start>/<end>`, `<start>/<duration>`, and `<duration>/<end>` formats.
   * @param {string} text - the ISO string to parse
   * @param {Object} [opts] - options to pass {@link DateTime.fromISO} and optionally {@link Duration.fromISO}
   * @see https://en.wikipedia.org/wiki/ISO_8601#Time_intervals
   * @return {Interval}
   */

/**
   * Create an Interval from an end DateTime and a Duration to extend backwards to.
   * @param {DateTime|Date|Object} end
   * @param {Duration|Object|number} duration - the length of the Interval.
   * @return {Interval}
   */

/**
   * Create an invalid DateTime.
   * @param {string} reason - simple string of why this DateTime is invalid. Should not contain parameters or anything else data-dependent
   * @param {string} [explanation=null] - longer explanation, may include parameters and other useful debugging information
   * @return {DateTime}
   */

/**
   * Create an invalid Duration.
   * @param {string} reason - simple string of why this datetime is invalid. Should not contain parameters or anything else data-dependent
   * @param {string} [explanation=null] - longer explanation, may include parameters and other useful debugging information
   * @return {Duration}
   */

/**
   * Create an invalid Interval.
   * @param {string} reason - simple string of why this Interval is invalid. Should not contain parameters or anything else data-dependent
   * @param {string} [explanation=null] - longer explanation, may include parameters and other useful debugging information
   * @return {Interval}
   */

/**
   * Creates a copy (clone) of this Record.
   * @param {String} id (optional) A new Record id, defaults to the id
   * of the record being copied. See {@link #id}.
   * To generate a phantom record with a new id use:
   var rec = record.copy(); // clone the record
   Ext.data.Record.id(rec); // automatically generate a unique sequential id
   *
   * @return {Record}
   */

/**
   * Creates a delegate (callback) that sets the scope to obj.
   * Call directly on any function. Example: <code>this.myFunction.createDelegate(this, [arg1, arg2])</code>
   * Will create a function that is automatically scoped to obj so that the <tt>this</tt> variable inside the
   * callback points to obj. Example usage:
   * <pre><code>
  var sayHi = function(name){
  // Note this use of "this.text" here.  This function expects to
  // execute within a scope that contains a text property.  In this
  // example, the "this" variable is pointing to the btn object that
  // was passed in createDelegate below.
  alert('Hi, ' + name + '. You clicked the "' + this.text + '" button.');
  }
  var btn = new Ext.Button({
  text: 'Say Hi',
  renderTo: Ext.getBody()
  });
  // This callback will execute in the scope of the
  // button instance. Clicking the button alerts
  // "Hi, Fred. You clicked the "Say Hi" button."
  btn.on('click', sayHi.createDelegate(btn, ['Fred']));
  </code></pre>
   * @param {Object} scope (optional) The scope (<code><b>this</b></code> reference) in which the function is executed.
   * <b>If omitted, defaults to the browser window.</b>
   * @param {Array} args (optional) Overrides arguments for the call. (Defaults to the arguments passed by the caller)
   * @param {Boolean/Number} appendArgs (optional) if True args are appended to call args instead of overriding,
   * if a number the args are inserted at the specified position
   * @return {Function} The new function
   */

/**
   * Creates a shallow copy of this collection
   * @return {MixedCollection}
   */

/**
   * 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.
   */

/**
   * Creates namespaces to be used for scoping variables and classes so that they are not global.
   * Specifying the last node of a namespace implicitly creates all other nodes. Usage:
   * <pre><code>
  Ext.namespace('Company', 'Company.data');
  Ext.namespace('Company.data'); // equivalent and preferable to above syntax
  Company.Widget = function() { ... }
  Company.data.CustomStore = function(config) { ... }
  </code></pre>
   * @param {String} namespace1
   * @param {String} namespace2
   * @param {String} etc
   * @return {Object} The namespace object. (If multiple arguments are passed, this will be the last namespace created)
   * @method ns
   */

/**
   * Date sorting
   * @param {Mixed} s The value being converted
   * @return {Number} The comparison value
   */

/**
   * Decode a json response from server.
   * @param {String} action [Ext.data.Api.actions.create|read|update|destroy]
   * @param {Object} response
   * TODO: refactor code between JsonReader#readRecords, #readResponse into 1 method.
   * there's ugly duplication going on due to maintaining backwards compat. with 2.0.  It's time to do this.
   */

/**
   * Default sort that does nothing
   * @param {Mixed} s The value being converted
   * @return {Mixed} The comparison value
   */

/**
   * Default visitor.
   *
   * @param {*} value
   * @param {String|Number} key
   * @param {Array<String|Number>} path
   * @this {FormData}
   *
   * @returns {boolean} return true to visit the each prop of the value recursively
   */

/**
   * Dispatch a request
   *
   * @param {String|Object} configOrUrl The config specific for this request (merged with this.defaults)
   * @param {?Object} config
   *
   * @returns {Promise} The Promise to be fulfilled
   */

/**
   * End an edit. If any data was modified, the containing store is notified
   * (ie, the store's <code>update</code> event will fire).
   */

/**
   * Equality check
   * Two DateTimes are equal iff they represent the same millisecond, have the same zone and location, and are both valid.
   * To compare just the millisecond values, use `+dt1 === +dt2`.
   * @param {DateTime} other - the other DateTime
   * @return {boolean}
   */

/**
   * Equality check
   * Two Durations are equal iff they have the same units and the same values for each unit.
   * @param {Duration} other
   * @return {boolean}
   */

/**
   * Escapes the passed string for ' and \
   * @param {String} string The string to escape
   * @return {String} The escaped string
   * @static
   */

/**
   * Executes the specified function once for every item in the collection, passing the following arguments:
   * <div class="mdetail-params"><ul>
   * <li><b>item</b> : Mixed<p class="sub-desc">The collection item</p></li>
   * <li><b>index</b> : Number<p class="sub-desc">The item's index</p></li>
   * <li><b>length</b> : Number<p class="sub-desc">The total number of items in the collection</p></li>
   * </ul></div>
   * The function should return a boolean value. Returning false from the function will stop the iteration.
   * @param {Function} fn The function to execute for each item.
   * @param {Object} scope (optional) The scope (<code>this</code> reference) in which the function is executed. Defaults to the current item in the iteration.
   */

/**
   * Executes the specified function once for every key in the collection, passing each
   * key, and its associated item as the first two parameters.
   * @param {Function} fn The function to execute for each item.
   * @param {Object} scope (optional) The scope (<code>this</code> reference) in which the function is executed. Defaults to the browser window.
   */

/**
   * Explain how a string would be parsed by fromFormat()
   * @param {string} text - the string to parse
   * @param {string} fmt - the format the string is expected to be in (see description)
   * @param {Object} options - options taken by fromFormat()
   * @return {Object}
   */

/**
   * Filter by a function. Returns a <i>new</i> collection that has been filtered.
   * The passed function will be called with each object in the collection.
   * If the function returns true, the value is included otherwise it is filtered.
   * @param {Function} fn The function to be called, it will receive the args o (the object), k (the key)
   * @param {Object} scope (optional) The scope (<code>this</code> reference) in which the function is executed. Defaults to this MixedCollection.
   * @return {MixedCollection} The new filtered collection
   */

/**
   * Filter the <i>objects</i> in this collection by a specific property.
   * Returns a new collection that has been filtered.
   * @param {String} property A property on your objects
   * @param {String/RegExp} value Either string that the property values
   * should start with or a RegExp to test against the property
   * @param {Boolean} anyMatch (optional) True to match any part of the string, not just the beginning
   * @param {Boolean} caseSensitive (optional) True for case sensitive comparison (defaults to False).
   * @return {MixedCollection} The new filtered collection
   */

/**
   * Find the index of the first matching object in this collection by a function.
   * If the function returns <i>true</i> it is considered a match.
   * @param {Function} fn The function to be called, it will receive the args o (the object), k (the key).
   * @param {Object} scope (optional) The scope (<code>this</code> reference) in which the function is executed. Defaults to this MixedCollection.
   * @param {Number} start (optional) The index to start searching at (defaults to 0).
   * @return {Number} The matched index or -1
   */

/**
   * Finds the index of the first matching object in this collection by a specific property/value.
   * @param {String} property The name of a property on your objects.
   * @param {String/RegExp} value A string that the property values
   * should start with or a RegExp to test against the property.
   * @param {Number} start (optional) The index to start searching at (defaults to 0).
   * @param {Boolean} anyMatch (optional) True to match any part of the string, not just the beginning.
   * @param {Boolean} caseSensitive (optional) True for case sensitive comparison.
   * @return {Number} The matched index or -1
   */

/**
   * Float sorting
   * @param {Mixed} s The value being converted
   * @return {Float} The comparison value
   */

/**
   * Get  the locale of a Duration, such 'en-GB'
   * @type {string}
   */

/**
   * Get an instance of FixedOffsetZone from a UTC offset string, like "UTC+6"
   * @param {string} s - The offset string to parse
   * @example FixedOffsetZone.parseSpecifier("UTC+6")
   * @example FixedOffsetZone.parseSpecifier("UTC+06")
   * @example FixedOffsetZone.parseSpecifier("UTC-6:00")
   * @return {FixedOffsetZone}
   */

/**
   * Get an instance with a specified offset
   * @param {number} offset - The offset in minutes
   * @return {FixedOffsetZone}
   */

/**
   * Get the value of the {@link Ext.data.Field#name named field}.
   * @param {String} name The {@link Ext.data.Field#name name of the field} to get the value of.
   * @return {Object} The value of the field.
   */

/**
   * Get the value of the {@link Field#name named field}.
   * @param {String} name The {@link Field#name name of the field} to get the value of.
   * @return {Object} The value of the field.
   */

/**
   * Get the value of unit.
   * @param {string} unit - a unit such as 'minute' or 'day'
   * @example DateTime.local(2017, 7, 4).get('month'); //=> 7
   * @example DateTime.local(2017, 7, 4).get('day'); //=> 4
   * @return {number}
   */

/**
   * Get the value of unit.
   * @param {string} unit - a unit such as 'minute' or 'day'
   * @example Duration.fromObject({years: 2, days: 3}).years //=> 2
   * @example Duration.fromObject({years: 2, days: 3}).months //=> 0
   * @example Duration.fromObject({years: 2, days: 3}).days //=> 3
   * @return {number}
   */

/**
   * Get the years.
   * @type {number}
   */

/**
   * Gets a hash of only the fields that have been modified since this Record was created or commited.
   * @return Object
   */

/**
   * Gets the number of `placeholder` occurrences in `array`.
   *
   * @private
   * @param {Array} array The array to inspect.
   * @param {*} placeholder The placeholder to search for.
   * @returns {number} Returns the placeholder count.
   */

/**
   * Gets the number of symbols in `string`.
   *
   * @private
   * @param {string} string The string to inspect.
   * @returns {number} Returns the string size.
   */

/**
   * Gets the size of a Unicode `string`.
   *
   * @private
   * @param {string} string The string inspect.
   * @returns {number} Returns the string size.
   */

/**
   * Gets the size of an ASCII `string`.
   *
   * @private
   * @param {string} string The string inspect.
   * @returns {number} Returns the string size.
   */

/**
   * Gets the value at `key` of `object`.
   *
   * @private
   * @param {Object} [object] The object to query.
   * @param {string} key The key of the property to get.
   * @returns {*} Returns the property value.
   */

/**
   * HTML-encodes a string twice
   * @param {String} value
   * @return {String}
   */

/**
   * Inserts an item at the specified index in the collection. Fires the {@link #add} event when complete.
   * @param {Number} index The index to insert the item at.
   * @param {String} key The key to associate with the new item, or the item itself.
   * @param {Object} o (optional) If the second parameter was a key, the new item.
   * @return {Object} The item inserted.
   */

/**
   * Integer sorting
   * @param {Mixed} s The value being converted
   * @return {Number} The comparison value
   */

/**
   * Iterate over all the registered interceptors
   *
   * This method is particularly useful for skipping over any
   * interceptors that may have become `null` calling `eject`.
   *
   * @param {Function} fn The function to call for each interceptor
   *
   * @returns {void}
   */

/**
   * Make this Duration longer by the specified amount. Return a newly-constructed Duration.
   * @param {Duration|Object|number} duration - The amount to add. Either a Luxon Duration, a number of milliseconds, the object argument to Duration.fromObject()
   * @return {Duration}
   */

/**
   * Make this Duration shorter by the specified amount. Return a newly-constructed Duration.
   * @param {Duration|Object|number} duration - The amount to subtract. Either a Luxon Duration, a number of milliseconds, the object argument to Duration.fromObject()
   * @return {Duration}
   */

/**
   * Math.trunc polyfill
   *
   * https://developer.mozilla.org/de/docs/Web/JavaScript/Reference/Global_Objects/Math/trunc
   *
   * @param x
   * @return {*}
   */

/**
   * Merge an array of Intervals into a equivalent minimal set of Intervals.
   * Combines overlapping and adjacent Intervals.
   * @param {[Interval]} intervals
   * @return {[Interval]}
   */

/**
   * Pads the left side of a string with a specified character.  This is especially useful
   * for normalizing number and date strings.  Example usage:
   * <pre><code>
  var s = String.leftPad('123', 5, '0');
  // s now contains the string: '00123'
   * </code></pre>
   * @param {String} string The original string
   * @param {Number} size The total length of the output string
   * @param {String} char (optional) The character with which to pad the original string (defaults to empty string " ")
   * @return {String} The padded string
   * @static
   */

/**
   * Readonly flag - true if this Record has been modified.
   * @type Boolean
   */

/**
   * Reduce this Duration to its canonical representation in its current units.
   * @example Duration.fromObject({ years: 2, days: 5000 }).normalize().toObject() //=> { years: 15, days: 255 }
   * @example Duration.fromObject({ hours: 12, minutes: -45 }).normalize().toObject() //=> { hours: 11, minutes: 15 }
   * @return {Duration}
   */

/**
   * Remove an interceptor from the stack
   *
   * @param {Number} id The ID that was returned by `use`
   *
   * @returns {Boolean} `true` if the interceptor was removed, `false` otherwise
   */

/**
   * Remove an item from a specified index in the collection. Fires the {@link #remove} event when complete.
   * @param {Number} index The index within the collection of the item to remove.
   * @return {Object} The item removed or false if no item was removed.
   */

/**
   * Remove an item from the collection.
   * @param {Object} o The item to remove.
   * @return {Object} The item removed or false if no item was removed.
   */

/**
   * Removed an item associated with the passed key fom the collection.
   * @param {String} key The key of the item to remove.
   * @return {Object} The item removed or false if no item was removed.
   */

/**
   * Removes all items from the collection.  Fires the {@link #clear} event when complete.
   */

/**
   * Removes all listeners for this object
   */

/**
   * Removes an event handler.
   * @param {String}   eventName The type of event the handler was associated with.
   * @param {Function} handler   The handler to remove. <b>This must be a reference to the function passed into the {@link #addListener} call.</b>
   * @param {Object}   scope     (optional) The scope originally specified for the handler.
   */

/**
   * Removes the specified object from the array.  If the object is not found nothing happens.
   * @param {Object} o The object to remove
   * @return {Array} this array
   */

/**
   * Renders a float or integer as percent
   *
   * @param {Number} v The number to format.
   * @see Ext.util.Format.number
   *
   * @return {String} The formatted number.
   */

/**
   * Replaces all `placeholder` elements in `array` with an internal placeholder
   * and returns an array of their indexes.
   *
   * @private
   * @param {Array} array The array to modify.
   * @param {*} placeholder The placeholder to replace.
   * @returns {Array} Returns the new array of placeholder indexes.
   */

/**
   * Replaces an item in the collection. Fires the {@link #replace} event when complete.
   * @param {String} key <p>The key associated with the item to replace, or the replacement item.</p>
   * <p>If you supplied a {@link #getKey} implementation for this MixedCollection, or if the key
   * of your stored items is in a property called <tt><b>id</b></tt>, then the MixedCollection
   * will be able to <i>derive</i> the key of the replacement item. If you want to replace an item
   * with one having the same key value, then just pass the replacement item in this parameter.</p>
   * @param o {Object} o (optional) If the first parameter passed was a key, the item to associate
   * with that key.
   * @return {Object}  The new item.
   */

/**
   * Reset Luxon's global caches. Should only be necessary in testing scenarios.
   * @return {void}
   */

/**
   * Reset local caches. Should only be necessary in testing scenarios.
   * @return {void}
   */

/**
   * Resume firing events. (see {@link #suspendEvents})
   * If events were suspended using the <tt><b>queueSuspended</b></tt> parameter, then all
   * events fired during event suspension will be sent to any listeners now.
   */

/**
   * Return a Duration representing the time spanned by this interval.
   * @param {string|string[]} [unit=['milliseconds']] - the unit or units (such as 'hours' or 'days') to include in the duration.
   * @param {Object} opts - options that affect the creation of the Duration
   * @param {string} [opts.conversionAccuracy='casual'] - the conversion system to use
   * @example Interval.fromDateTimes(dt1, dt2).toDuration().toObject() //=> { milliseconds: 88489257 }
   * @example Interval.fromDateTimes(dt1, dt2).toDuration('days').toObject() //=> { days: 1.0241812152777778 }
   * @example Interval.fromDateTimes(dt1, dt2).toDuration(['hours', 'minutes']).toObject() //=> { hours: 24, minutes: 34.82095 }
   * @example Interval.fromDateTimes(dt1, dt2).toDuration(['hours', 'minutes', 'seconds']).toObject() //=> { hours: 24, minutes: 34, seconds: 49.257 }
   * @example Interval.fromDateTimes(dt1, dt2).toDuration('seconds').toObject() //=> { seconds: 88489.257 }
   * @return {Duration}
   */

/**
   * Return an Interval representing the intersection of this Interval and the specified Interval.
   * Specifically, the resulting Interval has the maximum start time and the minimum end time of the two Intervals.
   * Returns null if the intersection is empty, meaning, the intervals don't intersect.
   * @param {Interval} other
   * @return {Interval}
   */

/**
   * Return an Interval representing the span of time in this Interval that doesn't overlap with any of the specified Intervals.
   * @param {...Interval} intervals
   * @return {[Interval]}
   */

/**
   * Return an Interval representing the union of this Interval and the specified Interval.
   * Specifically, the resulting Interval has the minimum start time and the maximum end time of the two Intervals.
   * @param {Interval} other
   * @return {Interval}
   */

/**
   * Return an Interval spanning between this DateTime and another DateTime
   * @param {DateTime} otherDateTime - the other end point of the Interval
   * @return {Interval}
   */

/**
   * Return an array of Intervals representing the spans of time that only appear in one of the specified Intervals.
   * @param {[Interval]} intervals
   * @return {[Interval]}
   */

/**
   * Return an array of eras, such as ['BC', 'AD']. The locale can be specified, but the calendar system is always Gregorian.
   * @param {string} [length='short'] - the length of the era representation, such as "short" or "long".
   * @param {Object} opts - options
   * @param {string} [opts.locale] - the locale code
   * @example Info.eras() //=> [ 'BC', 'AD' ]
   * @example Info.eras('long') //=> [ 'Before Christ', 'Anno Domini' ]
   * @example Info.eras('long', { locale: 'fr' }) //=> [ 'avant Jésus-Christ', 'après Jésus-Christ' ]
   * @return {[string]}
   */

/**
   * Return an array of format month names.
   * Format months differ from standalone months in that they're meant to appear next to the day of the month. In some languages, that
   * changes the string.
   * See {@link months}
   * @param {string} [length='long'] - the length of the month representation, such as "numeric", "2-digit", "narrow", "short", "long"
   * @param {Object} opts - options
   * @param {string} [opts.locale] - the locale code
   * @param {string} [opts.numberingSystem=null] - the numbering system
   * @param {string} [opts.outputCalendar='gregory'] - the calendar
   * @return {[string]}
   */

/**
   * Return an array of format week names.
   * Format weekdays differ from standalone weekdays in that they're meant to appear next to more date information. In some languages, that
   * changes the string.
   * See {@link weekdays}
   * @param {string} [length='long'] - the length of the month representation, such as "narrow", "short", "long".
   * @param {Object} opts - options
   * @param {string} [opts.locale=null] - the locale code
   * @param {string} [opts.numberingSystem=null] - the numbering system
   * @return {[string]}
   */

/**
   * Return an array of meridiems.
   * @param {Object} opts - options
   * @param {string} [opts.locale] - the locale code
   * @example Info.meridiems() //=> [ 'AM', 'PM' ]
   * @example Info.meridiems({ locale: 'my' }) //=> [ 'နံနက်', 'ညနေ' ]
   * @return {[string]}
   */

/**
   * Return an array of standalone month names.
   * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/DateTimeFormat
   * @param {string} [length='long'] - the length of the month representation, such as "numeric", "2-digit", "narrow", "short", "long"
   * @param {Object} opts - options
   * @param {string} [opts.locale] - the locale code
   * @param {string} [opts.numberingSystem=null] - the numbering system
   * @param {string} [opts.outputCalendar='gregory'] - the calendar
   * @example Info.months()[0] //=> 'January'
   * @example Info.months('short')[0] //=> 'Jan'
   * @example Info.months('numeric')[0] //=> '1'
   * @example Info.months('short', { locale: 'fr-CA' } )[0] //=> 'janv.'
   * @example Info.months('numeric', { locale: 'ar' })[0] //=> '١'
   * @example Info.months('long', { outputCalendar: 'islamic' })[0] //=> 'Rabiʻ I'
   * @return {[string]}
   */

/**
   * Return an array of standalone week names.
   * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/DateTimeFormat
   * @param {string} [length='long'] - the length of the month representation, such as "narrow", "short", "long".
   * @param {Object} opts - options
   * @param {string} [opts.locale] - the locale code
   * @param {string} [opts.numberingSystem=null] - the numbering system
   * @example Info.weekdays()[0] //=> 'Monday'
   * @example Info.weekdays('short')[0] //=> 'Mon'
   * @example Info.weekdays('short', { locale: 'fr-CA' })[0] //=> 'lun.'
   * @example Info.weekdays('short', { locale: 'ar' })[0] //=> 'الاثنين'
   * @return {[string]}
   */

/**
   * Return the difference between this DateTime and right now.
   * See {@link diff}
   * @param {string|string[]} [unit=['milliseconds']] - the unit or units units (such as 'hours' or 'days') to include in the duration
   * @param {Object} opts - options that affect the creation of the Duration
   * @param {string} [opts.conversionAccuracy='casual'] - the conversion system to use
   * @return {Duration}
   */

/**
   * Return the difference between two DateTimes as a Duration.
   * @param {DateTime} otherDateTime - the DateTime to compare this one to
   * @param {string|string[]} [unit=['milliseconds']] - the unit or array of units (such as 'hours' or 'days') to include in the duration.
   * @param {Object} opts - options that affect the creation of the Duration
   * @param {string} [opts.conversionAccuracy='casual'] - the conversion system to use
   * @example
   * var i1 = DateTime.fromISO('1982-05-25T09:45'),
   *     i2 = DateTime.fromISO('1983-10-14T10:30');
   * i2.diff(i1).toObject() //=> { milliseconds: 43807500000 }
   * i2.diff(i1, 'hours').toObject() //=> { hours: 12168.75 }
   * i2.diff(i1, ['months', 'days']).toObject() //=> { months: 16, days: 19.03125 }
   * i2.diff(i1, ['months', 'days', 'hours']).toObject() //=> { months: 16, days: 19, hours: 0.75 }
   * @return {Duration}
   */

/**
   * Return the length of the duration in the specified unit.
   * @param {string} unit - a unit such as 'minutes' or 'days'
   * @example Duration.fromObject({years: 1}).as('days') //=> 365
   * @example Duration.fromObject({years: 1}).as('months') //=> 12
   * @example Duration.fromObject({hours: 60}).as('days') //=> 2.5
   * @return {number}
   */

/**
   * Return the max of several date times
   * @param {...DateTime} dateTimes - the DateTimes from which to choose the maximum
   * @return {DateTime} the max DateTime, or undefined if called with no argument
   */

/**
   * Return the min of several date times
   * @param {...DateTime} dateTimes - the DateTimes from which to choose the minimum
   * @return {DateTime} the min DateTime, or undefined if called with no argument
   */

/**
   * Return the negative of this Duration.
   * @example Duration.fromObject({ hours: 1, seconds: 30 }).negate().toObject() //=> { hours: -1, seconds: -30 }
   * @return {Duration}
   */

/**
   * Return the offset in minutes for this zone at the specified timestamp.
   * @abstract
   * @param {number} ts - Epoch milliseconds for which to compute the offset
   * @return {number}
   */

/**
   * Return the set of available features in this environment.
   * Some features of Luxon are not available in all environments. For example, on older browsers, timezone support is not available. Use this function to figure out if that's the case.
   * Keys:
   * * `zones`: whether this environment supports IANA timezones
   * * `intlTokens`: whether this environment supports internationalized token-based formatting/parsing
   * * `intl`: whether this environment supports general internationalization
   * * `relative`: whether this environment supports relative time formatting
   * @example Info.features() //=> { intl: true, intlTokens: false, zones: true, relative: false }
   * @return {Object}
   */

/**
   * Return whether the specified zone contains a DST.
   * @param {string|Zone} [zone='local'] - Zone to check. Defaults to the environment's local zone.
   * @return {boolean}
   */

/**
   * Return whether the specified zone is a valid IANA specifier.
   * @param {string} zone - Zone to check
   * @return {boolean}
   */

/**
   * Return whether this DateTime is in the same unit of time as another DateTime
   * @param {DateTime} otherDateTime - the other DateTime
   * @param {string} unit - the unit of time to check sameness on
   * @example DateTime.local().hasSame(otherDT, 'day'); //~> true if both the same calendar day
   * @return {boolean}
   */

/**
   * Return whether this Interval contains the specified DateTime.
   * @param {DateTime} dateTime
   * @return {boolean}
   */

/**
   * Return whether this Interval engulfs the start and end of the specified Interval.
   * @param {Interval} other
   * @return {boolean}
   */

/**
   * Return whether this Interval has the same start and end DateTimes.
   * @return {boolean}
   */

/**
   * Return whether this Interval has the same start and end as the specified Interval.
   * @param {Interval} other
   * @return {boolean}
   */

/**
   * Return whether this Interval overlaps with the specified Interval
   * @param {Interval} other
   * @return {boolean}
   */

/**
   * Return whether this Interval's end is adjacent to the specified Interval's start.
   * @param {Interval} other
   * @return {boolean}
   */

/**
   * Return whether this Interval's end is before the specified DateTime.
   * @param {DateTime} dateTime
   * @return {boolean}
   */

/**
   * Return whether this Interval's start is adjacent to the specified Interval's end.
   * @param {Interval} other
   * @return {boolean}
   */

/**
   * Return whether this Interval's start is after the specified DateTime.
   * @param {DateTime} dateTime
   * @return {boolean}
   */

/**
   * Return whether this Zone is equal to another zone
   * @abstract
   * @param {Zone} otherZone - the zone to compare
   * @return {boolean}
   */

/**
   * Return whether this Zone is valid.
   * @abstract
   * @type {boolean}
   */

/**
   * Returns <tt>true</tt> if the passed field name has been <code>{@link #modified}</code>
   * since the load or last commit.
   * @param {String} fieldName {@link Ext.data.Field.{@link Ext.data.Field#name}
   * @return {Boolean}
   */

/**
   * Returns a BSON serializable equivalent to this DateTime.
   * @return {Date}
   */

/**
   * Returns a Javascript Date equivalent to this DateTime.
   * @return {Date}
   */

/**
   * Returns a Javascript object with this DateTime's year, month, day, and so on.
   * @param opts - options for generating the object
   * @param {boolean} [opts.includeConfig=false] - include configuration attributes in the output
   * @example DateTime.local().toObject() //=> { year: 2017, month: 4, day: 22, hour: 20, minute: 49, second: 42, millisecond: 268 }
   * @return {Object}
   */

/**
   * Returns a Javascript object with this Duration's values.
   * @param opts - options for generating the object
   * @param {boolean} [opts.includeConfig=false] - include configuration attributes in the output
   * @example Duration.fromObject({ years: 1, days: 6, seconds: 2 }).toObject() //=> { years: 1, days: 6, seconds: 2 }
   * @return {Object}
   */

/**
   * Returns a localized string representing this date. Accepts the same options as the Intl.DateTimeFormat constructor and any presets defined by Luxon, such as `DateTime.DATE_FULL` or `DateTime.TIME_SIMPLE`.
   * The exact behavior of this method is browser-specific, but in general it will return an appropriate representation
   * of the DateTime in the assigned locale.
   * Defaults to the system's locale if no locale has been specified
   * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/DateTimeFormat
   * @param opts {Object} - Intl.DateTimeFormat constructor options and configuration options
   * @example DateTime.local().toLocaleString(); //=> 4/20/2017
   * @example DateTime.local().setLocale('en-gb').toLocaleString(); //=> '20/04/2017'
   * @example DateTime.local().toLocaleString({ locale: 'en-gb' }); //=> '20/04/2017'
   * @example DateTime.local().toLocaleString(DateTime.DATE_FULL); //=> 'April 20, 2017'
   * @example DateTime.local().toLocaleString(DateTime.TIME_SIMPLE); //=> '11:32 AM'
   * @example DateTime.local().toLocaleString(DateTime.DATETIME_SHORT); //=> '4/20/2017, 11:32 AM'
   * @example DateTime.local().toLocaleString({ weekday: 'long', month: 'long', day: '2-digit' }); //=> 'Thursday, April 20'
   * @example DateTime.local().toLocaleString({ weekday: 'short', month: 'short', day: '2-digit', hour: '2-digit', minute: '2-digit' }); //=> 'Thu, Apr 20, 11:27 AM'
   * @example DateTime.local().toLocaleString({ hour: '2-digit', minute: '2-digit', hour12: false }); //=> '11:32'
   * @return {string}
   */

/**
   * Returns a range of items in this collection
   * @param {Number} startIndex (optional) The starting index. Defaults to 0.
   * @param {Number} endIndex (optional) The ending index. Defaults to the last item.
   * @return {Array} An array of items
   */

/**
   * Returns a string representation of a this time relative to now, such as "in two days". Can only internationalize if your
   * platform supports Intl.RelativeTimeFormat. Rounds down by default.
   * @param {Object} options - options that affect the output
   * @param {DateTime} [options.base=DateTime.local()] - the DateTime to use as the basis to which this time is compared. Defaults to now.
   * @param {string} [options.style="long"] - the style of units, must be "long", "short", or "narrow"
   * @param {string} options.unit - use a specific unit; if omitted, the method will pick the unit. Use one of "years", "quarters", "months", "weeks", "days", "hours", "minutes", or "seconds"
   * @param {boolean} [options.round=true] - whether to round the numbers in the output.
   * @param {boolean} [options.padding=0] - padding in milliseconds. This allows you to round up the result if it fits inside the threshold. Don't use in combination with {round: false} because the decimal output will include the padding.
   * @param {string} options.locale - override the locale of this DateTime
   * @param {string} options.numberingSystem - override the numberingSystem of this DateTime. The Intl system may choose not to honor this
   * @example DateTime.local().plus({ days: 1 }).toRelative() //=> "in 1 day"
   * @example DateTime.local().setLocale("es").toRelative({ days: 1 }) //=> "dentro de 1 día"
   * @example DateTime.local().plus({ days: 1 }).toRelative({ locale: "fr" }) //=> "dans 23 heures"
   * @example DateTime.local().minus({ days: 2 }).toRelative() //=> "2 days ago"
   * @example DateTime.local().minus({ days: 2 }).toRelative({ unit: "hours" }) //=> "48 hours ago"
   * @example DateTime.local().minus({ hours: 36 }).toRelative({ round: false }) //=> "1.5 days ago"
   */

/**
   * Returns a string representation of this DateTime appropriate for debugging
   * @return {string}
   */

/**
   * Returns a string representation of this DateTime appropriate for use in HTTP headers.
   * Specifically, the string conforms to RFC 1123.
   * @see https://www.w3.org/Protocols/rfc2616/rfc2616-sec3.html#sec3.3.1
   * @example DateTime.utc(2014, 7, 13).toHTTP() //=> 'Sun, 13 Jul 2014 00:00:00 GMT'
   * @example DateTime.utc(2014, 7, 13, 19).toHTTP() //=> 'Sun, 13 Jul 2014 19:00:00 GMT'
   * @return {string}
   */

/**
   * Returns a string representation of this DateTime appropriate for use in SQL Date
   * @example DateTime.utc(2014, 7, 13).toSQLDate() //=> '2014-07-13'
   * @return {string}
   */

/**
   * Returns a string representation of this DateTime appropriate for use in SQL DateTime
   * @param {Object} opts - options
   * @param {boolean} [opts.includeZone=false] - include the zone, such as 'America/New_York'. Overrides includeOffset.
   * @param {boolean} [opts.includeOffset=true] - include the offset, such as 'Z' or '-04:00'
   * @example DateTime.utc(2014, 7, 13).toSQL() //=> '2014-07-13 00:00:00.000 Z'
   * @example DateTime.local(2014, 7, 13).toSQL() //=> '2014-07-13 00:00:00.000 -04:00'
   * @example DateTime.local(2014, 7, 13).toSQL({ includeOffset: false }) //=> '2014-07-13 00:00:00.000'
   * @example DateTime.local(2014, 7, 13).toSQL({ includeZone: true }) //=> '2014-07-13 00:00:00.000 America/New_York'
   * @return {string}
   */

/**
   * Returns a string representation of this DateTime appropriate for use in SQL Time
   * @param {Object} opts - options
   * @param {boolean} [opts.includeZone=false] - include the zone, such as 'America/New_York'. Overrides includeOffset.
   * @param {boolean} [opts.includeOffset=true] - include the offset, such as 'Z' or '-04:00'
   * @example DateTime.utc().toSQL() //=> '05:15:16.345'
   * @example DateTime.local().toSQL() //=> '05:15:16.345 -04:00'
   * @example DateTime.local().toSQL({ includeOffset: false }) //=> '05:15:16.345'
   * @example DateTime.local().toSQL({ includeZone: false }) //=> '05:15:16.345 America/New_York'
   * @return {string}
   */

/**
   * Returns a string representation of this DateTime formatted according to the specified format string.
   * **You may not want this.** See {@link toLocaleString} for a more flexible formatting tool. For a table of tokens and their interpretations, see [here](https://moment.github.io/luxon/docs/manual/formatting.html#table-of-tokens).
   * Defaults to en-US if no locale has been specified, regardless of the system's locale.
   * @see https://moment.github.io/luxon/docs/manual/formatting.html#table-of-tokens
   * @param {string} fmt - the format string
   * @param {Object} opts - opts to override the configuration options
   * @example DateTime.local().toFormat('yyyy LLL dd') //=> '2017 Apr 22'
   * @example DateTime.local().setLocale('fr').toFormat('yyyy LLL dd') //=> '2017 avr. 22'
   * @example DateTime.local().toFormat('yyyy LLL dd', { locale: "fr" }) //=> '2017 avr. 22'
   * @example DateTime.local().toFormat("HH 'hours and' mm 'minutes'") //=> '20 hours and 55 minutes'
   * @return {string}
   */

/**
   * Returns a string representation of this Duration formatted according to the specified format string. You may use these tokens:
   * * `S` for milliseconds
   * * `s` for seconds
   * * `m` for minutes
   * * `h` for hours
   * * `d` for days
   * * `M` for months
   * * `y` for years
   * Notes:
   * * Add padding by repeating the token, e.g. "yy" pads the years to two digits, "hhhh" pads the hours out to four digits
   * * The duration will be converted to the set of units in the format string using {@link Duration.shiftTo} and the Durations's conversion accuracy setting.
   * @param {string} fmt - the format string
   * @param {Object} opts - options
   * @param {boolean} [opts.floor=true] - floor numerical values
   * @example Duration.fromObject({ years: 1, days: 6, seconds: 2 }).toFormat("y d s") //=> "1 6 2"
   * @example Duration.fromObject({ years: 1, days: 6, seconds: 2 }).toFormat("yy dd sss") //=> "01 06 002"
   * @example Duration.fromObject({ years: 1, days: 6, seconds: 2 }).toFormat("M S") //=> "12 518402000"
   * @return {string}
   */

/**
   * Returns a string representation of this Interval appropriate for debugging.
   * @return {string}
   */

/**
   * Returns a string representation of this Interval formatted according to the specified format string.
   * @param {string} dateFormat - the format string. This string formats the start and end time. See {@link DateTime.toFormat} for details.
   * @param {Object} opts - options
   * @param {string} [opts.separator =  ' – '] - a separator to place between the start and end representations
   * @return {string}
   */

/**
   * Returns a string representation of this date relative to today, such as "yesterday" or "next month".
   * Only internationalizes on platforms that supports Intl.RelativeTimeFormat.
   * @param {Object} options - options that affect the output
   * @param {DateTime} [options.base=DateTime.local()] - the DateTime to use as the basis to which this time is compared. Defaults to now.
   * @param {string} options.locale - override the locale of this DateTime
   * @param {string} options.unit - use a specific unit; if omitted, the method will pick the unit. Use one of "years", "quarters", "months", "weeks", or "days"
   * @param {string} options.numberingSystem - override the numberingSystem of this DateTime. The Intl system may choose not to honor this
   * @example DateTime.local().plus({ days: 1 }).toRelativeCalendar() //=> "tomorrow"
   * @example DateTime.local().setLocale("es").plus({ days: 1 }).toRelative() //=> ""mañana"
   * @example DateTime.local().plus({ days: 1 }).toRelativeCalendar({ locale: "fr" }) //=> "demain"
   * @example DateTime.local().minus({ days: 2 }).toRelativeCalendar() //=> "2 days ago"
   */

/**
   * Returns a username or groupname with according icon in front
   */

/**
   * Returns account type icon
   *
   * @return String
   */

/**
   * Returns an ISO 8601 representation of this DateTime appropriate for use in JSON.
   * @return {string}
   */

/**
   * Returns an ISO 8601 representation of this Duration appropriate for use in JSON.
   * @return {string}
   */

/**
   * Returns an ISO 8601 representation of this Duration appropriate for use in debugging.
   * @return {string}
   */

/**
   * Returns an ISO 8601-compliant string representation of date of this Interval.
   * The time components are ignored.
   * @see https://en.wikipedia.org/wiki/ISO_8601#Time_intervals
   * @return {string}
   */

/**
   * Returns an ISO 8601-compliant string representation of this DateTime
   * @param {Object} opts - options
   * @param {boolean} [opts.suppressMilliseconds=false] - exclude milliseconds from the format if they're 0
   * @param {boolean} [opts.suppressSeconds=false] - exclude seconds from the format if they're 0
   * @param {boolean} [opts.includeOffset=true] - include the offset, such as 'Z' or '-04:00'
   * @param {string} [opts.format='extended'] - choose between the basic and extended format
   * @example DateTime.utc(1982, 5, 25).toISO() //=> '1982-05-25T00:00:00.000Z'
   * @example DateTime.local().toISO() //=> '2017-04-22T20:47:05.335-04:00'
   * @example DateTime.local().toISO({ includeOffset: false }) //=> '2017-04-22T20:47:05.335'
   * @example DateTime.local().toISO({ format: 'basic' }) //=> '20170422T204705.335-0400'
   * @return {string}
   */

/**
   * Returns an ISO 8601-compliant string representation of this DateTime's date component
   * @param {Object} opts - options
   * @param {string} [opts.format='extended'] - choose between the basic and extended format
   * @example DateTime.utc(1982, 5, 25).toISODate() //=> '1982-05-25'
   * @example DateTime.utc(1982, 5, 25).toISODate({ format: 'basic' }) //=> '19820525'
   * @return {string}
   */

/**
   * Returns an ISO 8601-compliant string representation of this DateTime's time component
   * @param {Object} opts - options
   * @param {boolean} [opts.suppressMilliseconds=false] - exclude milliseconds from the format if they're 0
   * @param {boolean} [opts.suppressSeconds=false] - exclude seconds from the format if they're 0
   * @param {boolean} [opts.includeOffset=true] - include the offset, such as 'Z' or '-04:00'
   * @param {string} [opts.format='extended'] - choose between the basic and extended format
   * @example DateTime.utc().set({ hour: 7, minute: 34 }).toISOTime() //=> '07:34:19.361Z'
   * @example DateTime.utc().set({ hour: 7, minute: 34, seconds: 0, milliseconds: 0 }).toISOTime({ suppressSeconds: true }) //=> '07:34Z'
   * @example DateTime.utc().set({ hour: 7, minute: 34 }).toISOTime({ format: 'basic' }) //=> '073419.361Z'
   * @return {string}
   */

/**
   * Returns an ISO 8601-compliant string representation of this DateTime's week date
   * @example DateTime.utc(1982, 5, 25).toISOWeekDate() //=> '1982-W21-2'
   * @return {string}
   */

/**
   * Returns an ISO 8601-compliant string representation of this Duration.
   * @see https://en.wikipedia.org/wiki/ISO_8601#Durations
   * @example Duration.fromObject({ years: 3, seconds: 45 }).toISO() //=> 'P3YT45S'
   * @example Duration.fromObject({ months: 4, seconds: 45 }).toISO() //=> 'P4MT45S'
   * @example Duration.fromObject({ months: 5 }).toISO() //=> 'P5M'
   * @example Duration.fromObject({ minutes: 5 }).toISO() //=> 'PT5M'
   * @example Duration.fromObject({ milliseconds: 6 }).toISO() //=> 'PT0.006S'
   * @return {string}
   */

/**
   * Returns an ISO 8601-compliant string representation of this Interval.
   * @see https://en.wikipedia.org/wiki/ISO_8601#Time_intervals
   * @param {Object} opts - The same options as {@link DateTime.toISO}
   * @return {string}
   */

/**
   * Returns an ISO 8601-compliant string representation of time of this Interval.
   * The date components are ignored.
   * @see https://en.wikipedia.org/wiki/ISO_8601#Time_intervals
   * @param {Object} opts - The same options as {@link DateTime.toISO}
   * @return {string}
   */

/**
   * Returns an RFC 2822-compatible string representation of this DateTime, always in UTC
   * @example DateTime.utc(2014, 7, 13).toRFC2822() //=> 'Sun, 13 Jul 2014 00:00:00 +0000'
   * @example DateTime.local(2014, 7, 13).toRFC2822() //=> 'Sun, 13 Jul 2014 00:00:00 -0400'
   * @return {string}
   */

/**
   * Returns an array of format "parts", meaning individual tokens along with metadata. This is allows callers to post-process individual sections of the formatted output.
   * Defaults to the system's locale if no locale has been specified
   * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/DateTimeFormat/formatToParts
   * @param opts {Object} - Intl.DateTimeFormat constructor options, same as `toLocaleString`.
   * @example DateTime.local().toLocaleParts(); //=> [
   *                                   //=>   { type: 'day', value: '25' },
   *                                   //=>   { type: 'literal', value: '/' },
   *                                   //=>   { type: 'month', value: '05' },
   *                                   //=>   { type: 'literal', value: '/' },
   *                                   //=>   { type: 'year', value: '1982' }
   *                                   //=> ]
   */

/**
   * Returns an milliseconds value of this Duration.
   * @return {number}
   */

/**
   * Returns an object that contains a new `CancelToken` and a function that, when called,
   * cancels the `CancelToken`.
   */

/**
   * Returns dropdown hint icon for editor grid columns with comboboxes
   *
   * @return String
   */

/**
   * Returns emails from string or recipient token
   * @param emails
   */

/**
   * Returns index within the collection of the passed Object.
   * @param {Object} o The item to find the index of.
   * @return {Number} index of the item. Returns -1 if not found.
   */

/**
   * Returns index within the collection of the passed key.
   * @param {String} key The key to find the index of.
   * @return {Number} index of the key.
   */

/**
   * Returns localised date and time string
   *
   * @param {mixed} $_iso8601
   * @param metadata
   * @see date
   * @return {String} localised date and time
   */

/**
   * Returns localised date string
   *
   * @param {mixed} date
   * @param metadata
   * @param formatArray
   * @see Ext.util.Format.date
   * @return {String} localised date
   */

/**
   * Returns localised number string with two digits if no format is given
   *
   * @param {Number} v The number to format.
   * @param {String} format The way you would like to format this text.
   * @see Ext.util.Format.number
   *
   * @return {String} The formatted number.
   */

/**
   * Returns localised time string
   *
   * @param {mixed} date
   * @param metadata
   * @see Ext.util.Format.date
   * @return {String} localised time
   */

/**
   * Returns prettyfied minutes
   *
   * @param  {Number} minutes
   * @param  format -> {0} will be replaced by Hours, {1} with minutes
   * @param  {String} leadingZeros add leading zeros for given item {i|H}
   * @return {String}
   */

/**
   * Returns prettyfied seconds
   *
   * @param  {Number} seconds
   * @return {String}
   */

/**
   * Returns rendered containers
   *
   * @TODO show qtip with grants
   *
   * @param {mixed} container
   * @return {String}
   */

/**
   * Returns rendered relations
   *
   * @param {mixed} container
   * @return {String}
   *
   * TODO use/invent renderer registry to show more information on relations
   */

/**
   * Returns rendered tags for grids
   *
   * @param {mixed} tags
   * @return {String} tags as colored squares with qtips
   *
   * TODO add style for tag divs
   */

/**
   * Returns the count of minutes, hours, days, months, or years included in the Interval, even in part.
   * Unlike {@link length} this counts sections of the calendar, not periods of time, e.g. specifying 'day'
   * asks 'what dates are included in this interval?', not 'how many days long is this interval?'
   * @param {string} [unit='milliseconds'] - the unit of time to count.
   * @return {number}
   */

/**
   * Returns the epoch milliseconds of this DateTime.
   * @return {number}
   */

/**
   * Returns the epoch milliseconds of this DateTime. Alias of {@link toMillis}
   * @return {number}
   */

/**
   * Returns the epoch seconds of this DateTime.
   * @return {number}
   */

/**
   * Returns the first item in the collection which elicits a true return value from the
   * passed selection function.
   * @param {Function} fn The selection function to execute for each item.
   * @param {Object} scope (optional) The scope (<code>this</code> reference) in which the function is executed. Defaults to the browser window.
   * @return {Object} The first item in the collection which returned true from the selection function.
   */

/**
   * Returns the first item in the collection.
   * @return {Object} the first item in the collection..
   */

/**
   * Returns the formated username
   *
   * @param {object} account object
   * @return {string} formated user display name
   */

/**
   * Returns the item associated with the passed key OR index.
   * Key has priority over index.  This is the equivalent
   * of calling {@link #key} first, then if nothing matched calling {@link #itemAt}.
   * @param {String/Number} key The key or index of the item.
   * @return {Object} If the item is found, returns the item.  If the item was not found, returns <tt>undefined</tt>.
   * If an item was found, but is a Class, returns <tt>null</tt>.
   */

/**
   * Returns the item associated with the passed key.
   * @param {String/Number} key The key of the item.
   * @return {Object} The item associated with the passed key.
   */

/**
   * Returns the item at the specified index.
   * @param {Number} index The index of the item.
   * @return {Object} The item at the specified index.
   */

/**
   * Returns the last item in the collection.
   * @return {Object} the last item in the collection..
   */

/**
   * Returns the length of the Interval in the specified unit.
   * @param {string} unit - the unit (such as 'hours' or 'days') to return the length in.
   * @return {number}
   */

/**
   * Returns the number of items in the collection.
   * @return {Number} the number of items in the collection.
   */

/**
   * Returns the offset's common name (such as EST) at the specified timestamp
   * @abstract
   * @param {number} ts - Epoch milliseconds for which to get the name
   * @param {Object} opts - Options to affect the format
   * @param {string} opts.format - What style of offset to return. Accepts 'long' or 'short'.
   * @param {string} opts.locale - What locale to return the offset name in.
   * @return {string}
   */

/**
   * Returns the offset's value as a string
   * @abstract
   * @param {number} ts - Epoch milliseconds for which to get the offset
   * @param {string} format - What style of offset to return.
   *                          Accepts 'narrow', 'short', or 'techie'. Returning '+6', '+06:00', or '+0600' respectively
   * @return {string}
   */

/**
   * Returns the resolved Intl options for this DateTime.
   * This is useful in understanding the behavior of formatting methods
   * @param {Object} opts - the same options as toLocaleString
   * @return {Object}
   */

/**
   * Returns the start of the Interval
   * @type {DateTime}
   */

/**
   * Returns true if the collection contains the passed Object as a key.
   * @param {String} key The key to look for in the collection.
   * @return {Boolean} True if the collection contains the Object as a key.
   */

/**
   * Returns true if the collection contains the passed Object as an item.
   * @param {Object} o  The Object to look for in the collection.
   * @return {Boolean} True if the collection contains the Object as an item.
   */

/**
   * Returns true if the supplied data-hash <b>looks</b> and quacks like data.  Checks to see if it has a key
   * corresponding to idProperty defined in your DataReader config containing non-empty pk.
   * @param {Object} data
   * @return {Boolean}
   */

/**
   * Returns whether the DateTime is valid. Invalid DateTimes occur when:
   * * The DateTime was created from invalid calendar information, such as the 13th month or February 30
   * * The DateTime was created by an operation on another invalid date
   * @type {boolean}
   */

/**
   * Returns whether the provided string identifies a real zone
   * @param {string} zone - The string to check
   * @example IANAZone.isValidZone("America/New_York") //=> true
   * @example IANAZone.isValidZone("Fantasia/Castle") //=> false
   * @example IANAZone.isValidZone("Sport~~blorp") //=> false
   * @return {boolean}
   */

/**
   * Returns whether the provided string is a valid specifier. This only checks the string's format, not that the specifier identifies a known zone; see isValidZone for that.
   * @param {string} s - The string to check validity on
   * @example IANAZone.isValidSpecifier("America/New_York") //=> true
   * @example IANAZone.isValidSpecifier("Fantasia/Castle") //=> true
   * @example IANAZone.isValidSpecifier("Sport~~blorp") //=> false
   * @return {boolean}
   */

/**
   * Returns whether this Interval's start and end are both in the same unit of time
   * @param {string} unit - the unit of time to check sameness on
   * @return {boolean}
   */

/**
   * Run mapFn on the interval start and end, returning a new Interval from the resulting DateTimes
   * @param {function} mapFn
   * @return {Interval}
   * @example Interval.fromDateTimes(dt1, dt2).mapEndpoints(endpoint => endpoint.toUTC())
   * @example Interval.fromDateTimes(dt1, dt2).mapEndpoints(endpoint => endpoint.plus({ hours: 2 }))
   */

/**
   * Scale this Duration by the specified amount. Return a newly-constructed Duration.
   * @param {function} fn - The function to apply to each unit. Arity is 1 or 2: the value of the unit and, optionally, the unit name. Must return a number.
   * @example Duration.fromObject({ hours: 1, minutes: 30 }).mapUnit(x => x * 2) //=> { hours: 2, minutes: 60 }
   * @example Duration.fromObject({ hours: 1, minutes: 30 }).mapUnit((x, u) => u === "hour" ? x * 2 : x) //=> { hours: 2, minutes: 30 }
   * @return {Duration}
   */

/**
   * Set the value of the {@link Field#name named field}.
   * @param {String} name The {@link Field#name name of the field} to get the value of.
   * @return {Object} this.
   */

/**
   * Set the {@link Ext.data.Field#name named field} to the specified value.  For example:
   * <pre><code>
  // record has a field named 'firstname'
  var Employee = Record.{@link #create}([
  {name: 'firstname'},
  ...
  ]);
  // update the 2nd record in the store:
  var rec = myStore.{@link Ext.data.Store#getAt getAt}(1);
  // set the value (shows dirty flag):
  rec.set('firstname', 'Betty');
  // commit the change (removes dirty flag):
  rec.{@link #commit}();
  // update the record in the store, bypass setting dirty flag,
  // and do not store the change in the {@link Ext.data.Store#getModifiedRecords modified records}
  rec.{@link #data}['firstname'] = 'Wilma'; // updates record, but not the view
  rec.{@link #commit}(); // updates the view
   * </code></pre>
   * <b>Notes</b>:<div class="mdetail-params"><ul>
   * <li>If the store has a writer and <code>autoSave=true</code>, each set()
   * will execute an XHR to the server.</li>
   * <li>Use <code>{@link #beginEdit}</code> to prevent the store's <code>update</code>
   * event firing while using set().</li>
   * <li>Use <code>{@link #endEdit}</code> to have the store's <code>update</code>
   * event fire.</li>
   * </ul></div>
   * @param {String} name The {@link Ext.data.Field#name name of the field} to set.
   * @param {String/Object/Array} value The value to set the field to.
   * @return {Object} this.
   */

/**
   * Sorts this collection by <b>item</b> value with the passed comparison function.
   * @param {String} direction (optional) 'ASC' or 'DESC'. Defaults to 'ASC'.
   * @param {Function} fn (optional) Comparison function that defines the sort order.
   * Defaults to sorting by numeric value.
   */

/**
   * Sorts this collection by <b>key</b>s.
   * @param {String} direction (optional) 'ASC' or 'DESC'. Defaults to 'ASC'.
   * @param {Function} fn (optional) Comparison function that defines the sort order.
   * Defaults to sorting by case insensitive string.
   */

/**
   * Split this Interval at each of the specified DateTimes
   * @param {...[DateTime]} dateTimes - the unit of time to count.
   * @return {[Interval]}
   */

/**
   * Split this Interval into smaller Intervals, each of the specified length.
   * Left over time is grouped into a smaller interval
   * @param {Duration|Object|number} duration - The length of each resulting interval.
   * @return {[Interval]}
   */

/**
   * Split this Interval into the specified number of smaller intervals.
   * @param {number} numberOfParts - The number of Intervals to divide the Interval into.
   * @return {[Interval]}
   */

/**
   * Splits a Unicode `string` into an array of its words.
   *
   * @private
   * @param {string} The string to inspect.
   * @returns {Array} Returns the words of `string`.
   */

/**
   * Splits an ASCII `string` into an array of its words.
   *
   * @private
   * @param {string} The string to inspect.
   * @returns {Array} Returns the words of `string`.
   */

/**
   * Strips all HTML tags to sort on text only
   * @param {Mixed} s The value being converted
   * @return {String} The comparison value
   */

/**
   * Strips all HTML tags to sort on text only - Case insensitive
   * @param {Mixed} s The value being converted
   * @return {String} The comparison value
   */

/**
   * Subscribe to the cancel signal
   */

/**
   * Subtract a period of time to this DateTime and return the resulting DateTime
   * See {@link plus}
   * @param {Duration|Object|number} duration - The amount to subtract. Either a Luxon Duration, a number of milliseconds, the object argument to Duration.fromObject()
   @return {DateTime}
  */

/**
   * Suspend the firing of all events. (see {@link #resumeEvents})
   * @param {Boolean} queueSuspended Pass as true to queue up suspended events to be fired
   * after the {@link #resumeEvents} call instead of discarding all suspended events;
   */

/**
   * The base implementation of `_.findIndex` and `_.findLastIndex` without
   * support for iteratee shorthands.
   *
   * @private
   * @param {Array} array The array to inspect.
   * @param {Function} predicate The function invoked per iteration.
   * @param {number} fromIndex The index to search from.
   * @param {boolean} [fromRight] Specify iterating from right to left.
   * @returns {number} Returns the index of the matched value, else `-1`.
   */

/**
   * The base implementation of `_.indexOf` without `fromIndex` bounds checks.
   *
   * @private
   * @param {Array} array The array to inspect.
   * @param {*} value The value to search for.
   * @param {number} fromIndex The index to search from.
   * @returns {number} Returns the index of the matched value, else `-1`.
   */

/**
   * The base implementation of `_.isNaN` without support for number objects.
   *
   * @private
   * @param {*} value The value to check.
   * @returns {boolean} Returns `true` if `value` is `NaN`, else `false`.
   */

/**
   * The base implementation of `_.mean` and `_.meanBy` without support for
   * iteratee shorthands.
   *
   * @private
   * @param {Array} array The array to iterate over.
   * @param {Function} iteratee The function invoked per iteration.
   * @returns {number} Returns the mean.
   */

/**
   * 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.
   */

/**
   * 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.
   */

/**
   * The base implementation of `_.reduce` and `_.reduceRight`, without support
   * for iteratee shorthands, which iterates over `collection` using `eachFunc`.
   *
   * @private
   * @param {Array|Object} collection The collection to iterate over.
   * @param {Function} iteratee The function invoked per iteration.
   * @param {*} accumulator The initial value.
   * @param {boolean} initAccum Specify using the first or last element of
   *  `collection` as the initial value.
   * @param {Function} eachFunc The function to iterate over `collection`.
   * @returns {*} Returns the accumulated value.
   */

/**
   * The base implementation of `_.sortBy` which uses `comparer` to define the
   * sort order of `array` and replaces criteria objects with their corresponding
   * values.
   *
   * @private
   * @param {Array} array The array to sort.
   * @param {Function} comparer The function to define sort order.
   * @returns {Array} Returns `array`.
   */

/**
   * The base implementation of `_.sum` and `_.sumBy` without support for
   * iteratee shorthands.
   *
   * @private
   * @param {Array} array The array to iterate over.
   * @param {Function} iteratee The function invoked per iteration.
   * @returns {number} Returns the sum.
   */

/**
   * The base implementation of `_.times` without support for iteratee shorthands
   * or max array length checks.
   *
   * @private
   * @param {number} n The number of times to invoke `iteratee`.
   * @param {Function} iteratee The function invoked per iteration.
   * @returns {Array} Returns the array of results.
   */

/**
   * The base implementation of `_.toPairs` and `_.toPairsIn` which creates an array
   * of key-value pairs for `object` corresponding to the property names of `props`.
   *
   * @private
   * @param {Object} object The object to query.
   * @param {Array} props The property names to get values for.
   * @returns {Object} Returns the key-value pairs.
   */

/**
   * The base implementation of `_.trim`.
   *
   * @private
   * @param {string} string The string to trim.
   * @returns {string} Returns the trimmed string.
   */

/**
   * The base implementation of `_.unary` without support for storing metadata.
   *
   * @private
   * @param {Function} func The function to cap arguments for.
   * @returns {Function} Returns the new capped function.
   */

/**
   * The base implementation of `_.values` and `_.valuesIn` which creates an
   * array of `object` property values corresponding to the property names
   * of `props`.
   *
   * @private
   * @param {Object} object The object to query.
   * @param {Array} props The property names to get values for.
   * @returns {Object} Returns the array of property values.
   */

/**
   * The base implementation of methods like `_.findKey` and `_.findLastKey`,
   * without support for iteratee shorthands, which iterates over `collection`
   * using `eachFunc`.
   *
   * @private
   * @param {Array|Object} collection The collection to inspect.
   * @param {Function} predicate The function invoked per iteration.
   * @param {Function} eachFunc The function to iterate over `collection`.
   * @returns {*} Returns the found element or its key, else `undefined`.
   */

/**
   * The regular expression used to strip tags
   * @type {RegExp}
   * @property
   */

/**
   * The unique ID of the Record {@link #Record as specified at construction time}.
   * @property id
   * @type {Object}
   */

/**
   * The version of the framework
   * @type String
   */

/**
   * This DataReader's configured metadata as passed to the constructor.
   * @type Mixed
   * @property meta
   */

/**
   * This JsonReader's metadata as passed to the constructor, or as passed in
   * the last data packet's <b><tt>metaData</tt></b> property.
   * @type Mixed
   * @property meta
   */

/**
   * This function is like `arrayIncludes` except that it accepts a comparator.
   *
   * @private
   * @param {Array} [array] The array to inspect.
   * @param {*} target The value to search for.
   * @param {Function} comparator The comparator invoked per element.
   * @returns {boolean} Returns `true` if `target` is found, else `false`.
   */

/**
   * This function is like `baseIndexOf` except that it accepts a comparator.
   *
   * @private
   * @param {Array} array The array to inspect.
   * @param {*} value The value to search for.
   * @param {number} fromIndex The index to search from.
   * @param {Function} comparator The comparator invoked per element.
   * @returns {number} Returns the index of the matched value, else `-1`.
   */

/**
   * This method is only used by a DataProxy which has retrieved data from a remote server.
   * @param {Object} response The XHR object which contains the JSON data in its responseText.
   * @return {Object} data A data block which is used by an Ext.data.Store object as
   * a cache of Ext.data.Records.
   */

/**
   * This object contains a key and value storing the original values of all modified
   * fields or is null if no fields have been modified.
   * @property modified
   * @type {Object}
   */

/**
   * This should only be called on non-detached scopes
   * @internal
   */

/**
   * Throws a `CanceledError` if cancellation has been requested.
   */

/**
   * Unsubscribe from the cancel signal
   */

/**
   * 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.
   */

/**
   * Used by `_.escape` to convert characters to HTML entities.
   *
   * @private
   * @param {string} chr The matched character to escape.
   * @returns {string} Returns the escaped character.
   */

/**
   * Used by `_.template` to escape characters for inclusion in compiled string literals.
   *
   * @private
   * @param {string} chr The matched character to escape.
   * @returns {string} Returns the escaped character.
   */

/**
   * 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.
   */

/**
   * Used by `_.trim` and `_.trimEnd` to get the index of the last string symbol
   * that is not found in the character symbols.
   *
   * @private
   * @param {Array} strSymbols The string symbols to inspect.
   * @param {Array} chrSymbols The character symbols to find.
   * @returns {number} Returns the index of the last unmatched string symbol.
   */

/**
   * Used by `_.trim` and `_.trimStart` to get the index of the first string symbol
   * that is not found in the character symbols.
   *
   * @private
   * @param {Array} strSymbols The string symbols to inspect.
   * @param {Array} chrSymbols The character symbols to find.
   * @returns {number} Returns the index of the first unmatched string symbol.
   */

/**
   * Used by `_.unescape` to convert HTML entities to characters.
   *
   * @private
   * @param {string} chr The matched character to unescape.
   * @returns {string} Returns the unescaped character.
   */

/**
   * Used for un-phantoming a record after a successful database insert.  Sets the records pk along with new data from server.
   * You <b>must</b> return at least the database pk using the idProperty defined in your DataReader configuration.  The incoming
   * data from server will be merged with the data in the local record.
   * In addition, you <b>must</b> return record-data from the server in the same order received.
   * Will perform a commit as well, un-marking dirty-fields.  Store's "update" event will be suppressed.
   * @param {Record/Record[]} record The phantom record to be realized.
   * @param {Object/Object[]} data The new record data to apply.  Must include the primary-key from database defined in idProperty field.
   */

/**
   * Used for updating a non-phantom or "real" record's data with fresh data from server after remote-save.
   * If returning data from multiple-records after a batch-update, you <b>must</b> return record-data from the server in
   * the same order received.  Will perform a commit as well, un-marking dirty-fields.  Store's "update" event will be
   * suppressed as the record receives fresh new data-hash
   * @param {Record/Record[]} rs
   * @param {Object/Object[]} data
   */

/**
   * Usually called by the {@link Ext.data.Store} which owns the Record.
   * Commits all changes made to the Record since either creation, or the last commit operation.
   * <p>Developers should subscribe to the {@link Ext.data.Store#update} event
   * to have their code notified of commit operations.</p>
   * @param {Boolean} silent (optional) True to skip notification of the owning
   * store of the change (defaults to false)
   */

/**
   * Usually called by the {@link Ext.data.Store} which owns the Record.
   * Rejects all changes made to the Record since either creation, or the last commit operation.
   * Modified fields are reverted to their original values.
   * <p>Developers should subscribe to the {@link Ext.data.Store#update} event
   * to have their code notified of reject operations.</p>
   * @param {Boolean} silent (optional) True to skip notification of the owning
   * store of the change (defaults to false)
   */

/**
   * apply Ext.encode as toString functino to given object
   *
   * @param {mixed} o
   */

/**
   * assert that given object is comparable
   *
   * @param {mixed} o
   * @param {bool} clone
   * @return {mixed} o
   */

/**
   * check if user has right to view/manage this application/resource
   *
   * @param   {String}      right (view, admin, manage)
   * @param   {String}      application
   * @param   {String}      resource (for example roles, accounts, ...)
   * @returns {Boolean}
   */

/**
   * check valid email domain (if email domain is set in config)
   *
   * @param {String} email
   */

/**
   * check whether given value can be interpreted as true
   *
   * @param {String|Integer|Boolean} value
   * @return {Boolean}
   */

/**
   * check whether object is empty (has no property)
   *
   * @param {Object} obj
   * @return {Boolean}
   */

/**
   * clone function
   *
   * @param {Object/Array} o Object or array to clone
   * @return {Object/Array} Deep clone of an object or an array
   */

/**
   * color renderer
   *
   * @param color
   */

/**
   * converts data to String
   * 
   * @return {String}
   */

/**
   * currency renderer
   *
   * @param currency
   */

/**
   * default filter
   * @type {string}
   */

/**
   * default implementation to replace proxy in dom
   *
   * @param html
   * @private
   */

/**
   * find contacts by email string
   *
   * return recipients token
   *
   * @param addresses
   */

/**
   * find record from target
   *
   * @param target
   */

/**
   * foreign record renderer
   *
   * @param record
   * @param metadata
   *
   * TODO use title fn? allow to configure displayed field(s)?
   */

/**
   * format byte values
   * @param {String} value
   * @param {String} forceUnit
   * @param {Integer} decimals
   * @param {Boolean} useDecimalValues
   */

/**
   * get a Promise which resolves with the final content
   * @returns {Promise<String>}
   */

/**
   * getMessage
   * @return {String}
   */

/**
   * getName
   * @return {String}
   */

/**
   * i18n renderer
   *
   * NOTE: needs to be bound to i18n object!
   *
   * renderer: Tine.Tinebase.common.i18nRenderer.createDelegate(this.app.i18n)
   * @param original
   */

/**
   * linkify text
   *
   * @param {String} text
   * @param {Ext.Element|Function} cb
   */

/**
   * markdown renderer - fulltext, special type
   * @param {String} v The string to format.
   * @param {Object} metaData Grid metadata object
   * @param {Object} record Grid record
   * @return {String} The formatted string.
   */

/**
   * possible log levels
   * @type Object
   */

/**
   * register a custom replacer method for this proxy
   * NOTE: replacer needs to return bool true to mark a successfully replacement
   * @param {Function} fn
   */

/**
   * reload client
   *
   * @param {Object} options
   *      {Boolean} keepRegistry
   *      {Boolean} clearCache
   *      {Boolean} redirectAlways
   *      {String} redirectUrl
   */

/**
   * render single tag
   *
   * @param {Tine.Tinebase.Model.Tag} tag
   */

/**
   * renders bytes for filesize
   * @param {Integer} value
   * @param {Object} metadata
   * @param {Tine.Tinebase.data.Record} record
   * @param {Integer} decimals
   * @param {Boolean} useDecimalValues
   * @return {String}
   */

/**
   * replace proxy by given html
   * @param html
   * @returns {Promise<boolean|void>}
   */

/**
   * resolve inner component definition (handle possible async component)
   */

/**
   * return yes or no in the selected language for a boolean value
   *
   * @param {string} value
   * @return {string}
   */

/**
   * returns current logging priority
   * 
   * @return {}
   */

/**
   * returns extracted, type-cast rows of data.  Iterates to call #extractValues for each row
   * @param {Object[]/Object} data-root from server response
   * @param {Boolean} returnRecords [false] Set true to return instances of Ext.data.Record
   * @private
   */

/**
   * returns random integer number
   * @param {Integer} min
   * @param {Integer} max
   * @return {Integer}
   */

/**
   * returns the id of the record
   */

/**
   * returns the php class name of the record itself or by the application(name) and model(name)
   * @param {mixed} app       the application instance or the application name or the record class
   * @param {mixed} model     the model name
   * @return {String} php class name
   */

/**
   * returns title of this record
   * 
   * @return {String}
   */

/**
   * returns true if given record obsoletes this one
   * 
   * - returns false if record has no modlog properties to make 
   *   handling of updated records work in the grid panel
   * @see 0009464: user grid does not refresh after ctx menu action
   * 
   * @param {Record} record
   * @return {Boolean}
   */

/**
   * set logging priority
   * 
   * @namespace Ext.ux.log
   * @param {Number} prio
   */

/**
   * set the render/producer function this HTMLProxy proxies
   *
   * @param renderPromise
   * @returns {Promise}
   */

/**
   * sets the id of the record
   *
   * @param {String} id
   */

/**
   * sets the id of the record
   */

/**
   * simple html to text conversion
   *
   * @param html
   * @returns {String}
   */

/**
   * sorts account/user objects
   *
   * @param {Object|String} user_id
   * @return {String}
   */

/**
   * sorts records
   *
   * @param {Object} record
   * @return {String}
   */

/**
   * template fn called when record is instanciated
   */

/**
   * toJson
   * @return {String}
   */

/**
   * type-casts a single row of raw-data from server
   * @param {Object} data
   * @param {Array} items
   * @param {Integer} len
   * @private
   */

/**
   * update complete record with data from given record
   *
   * @param record
   */

/**
   * {@link toLocaleString} format like 10/14/1983
   * @type {Object}
   */

/**
  * Creates a callback that passes arguments[0], arguments[1], arguments[2], ...
  * Call directly on any function. Example: <code>myFunction.createCallback(arg1, arg2)</code>
  * Will create a function that is bound to those 2 args. <b>If a specific scope is required in the
  * callback, use {@link #createDelegate} instead.</b> The function returned by createCallback always
  * executes in the window scope.
  * <p>This method is required when you want to pass arguments to a callback function.  If no arguments
  * are needed, you can simply pass a reference to the function as a callback (e.g., callback: myFn).
  * However, if you tried to pass a function with arguments (e.g., callback: myFn(arg1, arg2)) the function
  * would simply execute immediately when the code is parsed. Example usage:
  * <pre><code>
  var sayHi = function(name){
  alert('Hi, ' + name);
  }
  // clicking the button alerts "Hi, Fred"
  new Ext.Button({
  text: 'Say Hi',
  renderTo: Ext.getBody(),
  handler: sayHi.createCallback('Fred')
  });
  </code></pre>
  * @return {Function} The new function
  */

/**
  * Creates an interceptor function. The passed function is called before the original one. If it returns false,
  * the original one is not called. The resulting function returns the results of the original function.
  * The passed function is called with the parameters of the original function. Example usage:
  * <pre><code>
  var sayHi = function(name){
  alert('Hi, ' + name);
  }
  sayHi('Fred'); // alerts "Hi, Fred"
  // create a new function that validates input without
  // directly modifying the original function:
  var sayHiToFriend = sayHi.createInterceptor(function(name){
  return name == 'Brian';
  });
  sayHiToFriend('Fred');  // no alert
  sayHiToFriend('Brian'); // alerts "Hi, Brian"
  </code></pre>
  * @param {Function} fcn The function to call before the original
  * @param {Object} scope (optional) The scope (<code><b>this</b></code> reference) in which the passed function is executed.
  * <b>If omitted, defaults to the scope in which the original function is called or the browser window.</b>
  * @return {Function} The new function
  */

/**
 *
 * @param value
 * @returns {boolean}
 */

/**
 * @author Eric MORAND <eric.morand@gmail.com>
 */

/**
 * @class
 */

/**
 * @class Array
 */

/**
 * @class DataReader.Error
 * @extends Ext.Error
 * General error class for DataReader
 */

/**
 * @class Ext
 * Ext core utilities and functions.
 * @singleton
 */

/**
 * @class Ext
 */

/**
 * @class Ext.Error
 * @extends Error
 * <p>A base error class. Future implementations are intended to provide more
 * robust error handling throughout the framework (<b>in the debug build only</b>)
 * to check for common errors and problems. The messages issued by this class
 * will aid error checking. Error checks will be automatically removed in the
 * production build so that performance is not negatively impacted.</p>
 * <p>Some sample messages currently implemented:</p><pre>
"DataProxy attempted to execute an API-action but found an undefined
url / function. Please review your Proxy url/api-configuration."
 * </pre><pre>
"Could not locate your "root" property in your server response.
Please review your JsonReader config to ensure the config-property
"root" matches the property your server-response.  See the JsonReader
docs for additional assistance."
 * </pre>
 * <p>An example of the code used for generating error messages:</p><pre><code>
try {
    generateError({
        foo: 'bar'
    });
}
catch (e) {
    console.error(e);
}
function generateError(data) {
    throw new Ext.Error('foo-error', data);
}
 * </code></pre>
 * @param {String} message
 */

/**
 * @class Ext.data.Response
 * A generic response class to normalize response-handling internally to the framework.
 */

/**
 * @class Ext.data.SortTypes
 * @singleton
 * Defines the default sorting (casting?) comparison functions used when sorting data.
 */

/**
 * @class Ext.util.Format
 * Reusable data formatting functions
 * @singleton
 */

/**
 * @class Function
 * These functions are available on every Function object (any JavaScript function).
 */

/**
 * @class JsonReader.Error
 * Error class for JsonReader
 */

/**
 * @class Number
 */

/**
 * @class String
 * These functions are available as static methods on the JavaScript String object.
 */

/**
 * @class String
 * These functions are available on every String object.
 */

/**
 * @constuctor
 */

/**
 * @license
 * Lodash <https://lodash.com/>
 * Copyright OpenJS Foundation and other contributors <https://openjsf.org/>
 * Released under MIT license <https://lodash.com/license>
 * Based on Underscore.js 1.8.3 <http://underscorejs.org/LICENSE>
 * Copyright Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors
 */

/**
 * @license     http://creativecommons.org/licenses/publicdomain Public Domain
 * @author      Koji Horaguchi <horaguchi@horaguchi.net>
 */

/**
 * @namespace Tine.Tinebase.data
 * @class     Record
 * @extends   Ext.data.Record
 * 
 * Baseclass of Tine 2.0 models
 */

/**
 * @param {"luxon".luxon.Duration} duration
 * @param {string} format
 *
 * @returns {string} The formatted interval.
 */

/**
 * @param {string} input
 * @returns {RegExp}
 */

/**
 * @private
 */

/**
 * @type {Array}
 *
 * modlog Fields
 */

/**
 * @type {Array}
 * generic Record fields
 */

/**
 * A BasicSourceMapConsumer instance represents a parsed source map which we can
 * query for information about the original file positions by giving it a file
 * position in the generated source.
 *
 * The first parameter is the raw source map (either as a JSON string, or
 * already parsed to an object). According to the spec, source maps have the
 * following attributes:
 *
 *   - version: Which version of the source map spec this map is following.
 *   - sources: An array of URLs to the original source files.
 *   - names: An array of identifiers which can be referrenced by individual mappings.
 *   - sourceRoot: Optional. The URL root from which all sources are relative.
 *   - sourcesContent: Optional. An array of contents of the original source files.
 *   - mappings: A string of base64 VLQs which contain the actual mappings.
 *   - file: Optional. The generated file this source map is associated with.
 *
 * Here is an example source map, taken from the source map spec[0]:
 *
 *     {
 *       version : 3,
 *       file: "out.js",
 *       sourceRoot : "",
 *       sources: ["foo.js", "bar.js"],
 *       names: ["src", "maps", "are", "fun"],
 *       mappings: "AA,AB;;ABCDE;"
 *     }
 *
 * The second parameter, if given, is a string whose value is the URL
 * at which the source map was found.  This URL is used to compute the
 * sources array.
 *
 * [0]: https://docs.google.com/document/d/1U1RGAehQwRypUTovF1KRlpiOFze0b-_2gc6fAH0KY0k/edit?pli=1#
 */

/**
 * A DateTime is an immutable data structure representing a specific date and time and accompanying methods. It contains class and instance methods for creating, parsing, interrogating, transforming, and formatting them.
 *
 * A DateTime comprises of:
 * * A timestamp. Each DateTime instance refers to a specific millisecond of the Unix epoch.
 * * A time zone. Each instance is considered in the context of a specific zone (by default the local system's zone).
 * * Configuration properties that effect how output strings are formatted, such as `locale`, `numberingSystem`, and `outputCalendar`.
 *
 * Here is a brief overview of the most commonly used functionality it provides:
 *
 * * **Creation**: To create a DateTime from its components, use one of its factory class methods: {@link local}, {@link utc}, and (most flexibly) {@link fromObject}. To create one from a standard string format, use {@link fromISO}, {@link fromHTTP}, and {@link fromRFC2822}. To create one from a custom string format, use {@link fromFormat}. To create one from a native JS date, use {@link fromJSDate}.
 * * **Gregorian calendar and time**: To examine the Gregorian properties of a DateTime individually (i.e as opposed to collectively through {@link toObject}), use the {@link year}, {@link month},
 * {@link day}, {@link hour}, {@link minute}, {@link second}, {@link millisecond} accessors.
 * * **Week calendar**: For ISO week calendar attributes, see the {@link weekYear}, {@link weekNumber}, and {@link weekday} accessors.
 * * **Configuration** See the {@link locale} and {@link numberingSystem} accessors.
 * * **Transformation**: To transform the DateTime into other DateTimes, use {@link set}, {@link reconfigure}, {@link setZone}, {@link setLocale}, {@link plus}, {@link minus}, {@link endOf}, {@link startOf}, {@link toUTC}, and {@link toLocal}.
 * * **Output**: To convert the DateTime to other representations, use the {@link toRelative}, {@link toRelativeCalendar}, {@link toJSON}, {@link toISO}, {@link toHTTP}, {@link toObject}, {@link toRFC2822}, {@link toString}, {@link toLocaleString}, {@link toFormat}, {@link toMillis} and {@link toJSDate}.
 *
 * There's plenty others documented below. In addition, for more information on subtler topics like internationalization, time zones, alternative calendars, validity, and so on, see the external documentation.
 */

/**
 * A Duration object represents a period of time, like "2 months" or "1 day, 1 hour". Conceptually, it's just a map of units to their quantities, accompanied by some additional configuration and methods for creating, parsing, interrogating, transforming, and formatting them. They can be used on their own or in conjunction with other Luxon types; for example, you can use {@link DateTime.plus} to add a Duration object to a DateTime, producing another DateTime.
 *
 * Here is a brief overview of commonly used methods and getters in Duration:
 *
 * * **Creation** To create a Duration, use {@link Duration.fromMillis}, {@link Duration.fromObject}, or {@link Duration.fromISO}.
 * * **Unit values** See the {@link Duration.years}, {@link Duration.months}, {@link Duration.weeks}, {@link Duration.days}, {@link Duration.hours}, {@link Duration.minutes}, {@link Duration.seconds}, {@link Duration.milliseconds} accessors.
 * * **Configuration** See  {@link Duration.locale} and {@link Duration.numberingSystem} accessors.
 * * **Transformation** To create new Durations out of old ones use {@link Duration.plus}, {@link Duration.minus}, {@link Duration.normalize}, {@link Duration.set}, {@link Duration.reconfigure}, {@link Duration.shiftTo}, and {@link Duration.negate}.
 * * **Output** To convert the Duration into other representations, see {@link Duration.as}, {@link Duration.toISO}, {@link Duration.toFormat}, and {@link Duration.toJSON}
 *
 * There's are more methods documented below. In addition, for more information on subtler topics like internationalization and validity, see the external documentation.
 */

/**
 * A JavaScript implementation of the Secure Hash Algorithm, SHA-256, as defined
 * in FIPS 180-2
 * Version 2.2-beta Copyright Angel Marin, Paul Johnston 2000 - 2009.
 * Other contributors: Greg Holt, Andrew Kepert, Ydnar, Lostinet
 *
 */

/**
 * A `CancelToken` is an object that can be used to request cancellation of an operation.
 *
 * @param {Function} executor The executor function.
 *
 * @returns {CancelToken}
 */

/**
 * A `CanceledError` is an object that is thrown when an operation is canceled.
 *
 * @param {string=} message The message.
 * @param {Object=} config The config.
 * @param {Object=} request The request.
 *
 * @returns {CanceledError} The created error.
 */

/**
 * A data structure to provide a sorted view of accumulated mappings in a
 * performance conscious manner. It trades a neglibable overhead in general
 * case for a large speedup in case of mappings being added in order.
 */

/**
 * A data structure which is a combination of an array and a set. Adding a new
 * member is O(1), testing for membership is O(1), and finding the index of an
 * element is O(1). Removing elements from the set is not supported. Only
 * strings are supported for membership.
 */

/**
 * A mapping can have one of the three levels of data:
 *
 *   1. Just the generated position.
 *   2. The Generated position, original position, and original source.
 *   3. Generated and original position, original source, as well as a name
 *      token.
 *
 * To maintain consistency, we validate that any new mapping being added falls
 * in to one of these categories.
 */

/**
 * A specialized version of `_.filter` for arrays without support for
 * iteratee shorthands.
 *
 * @private
 * @param {Array} [array] The array to iterate over.
 * @param {Function} predicate The function invoked per iteration.
 * @returns {Array} Returns the new filtered array.
 */

/**
 * A specialized version of `_.forEach` 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 `array`.
 */

/**
 * A specialized version of `baseGetTag` which ignores `Symbol.toStringTag` values.
 *
 * @private
 * @param {*} value The value to query.
 * @returns {string} Returns the raw `toStringTag`.
 */

/**
 * A zone identified by an IANA identifier, like America/New_York
 * @implements {Zone}
 */

/**
 * Abstract class for all nodes that represents an expression.
 */

/**
 * Accepts varargs expecting each argument to be an object, then
 * immutably merges the properties of each object and returns result.
 *
 * When multiple objects contain the same key the later object in
 * the arguments list will take precedence.
 *
 * Example:
 *
 * ```js
 * var result = merge({foo: 123}, {foo: 456});
 * console.log(result.foo); // outputs 456
 * ```
 *
 * @param {Object} obj1 Object to merge
 *
 * @returns {Object} Result of all merge properties
 */

/**
 * Adapted from https://github.com/kvz/locutus/blob/master/src/php/var/var_dump.js
 */

/**
 * Add a chunk of generated JS to the beginning of this source node.
 *
 * @param aChunk A string snippet of generated JS code, another instance of
 *        SourceNode, or an array where each member is one of those things.
 */

/**
 * Add a chunk of generated JS to this source node.
 *
 * @param aChunk A string snippet of generated JS code, another instance of
 *        SourceNode, or an array where each member is one of those things.
 */

/**
 * Add a single mapping from original source line and column to the generated
 * source's line and column for this source map being created. The mapping
 * object should have the following properties:
 *
 *   - generated: An object with the generated line and column positions.
 *   - original: An object with the original line and column positions.
 *   - source: The original source file (relative to the sourceRoot).
 *   - name: An optional original token name for this mapping.
 */

/**
 * Add the given source mapping.
 *
 * @param Object aMapping
 */

/**
 * Add the given string to this set.
 *
 * @param String aStr
 */

/**
 * Adjusts colors of html element
 * @param {Element} element
 */

/**
 * Allows differentiating lazy components from functional components and vue-class-component
 * @internal
 *
 * @param component
 */

/**
 * Allows overriding the router view depth to control which component in
 * `matched` is rendered. rvd stands for Router View Depth
 *
 * @internal
 */

/**
 * An IndexedSourceMapConsumer instance represents a parsed source map which
 * we can query for information. It differs from BasicSourceMapConsumer in
 * that it takes "indexed" source maps (i.e. ones with a "sections" field) as
 * input.
 *
 * The first parameter is a raw source map (either as a JSON string, or already
 * parsed to an object). According to the spec for indexed source maps, they
 * have the following attributes:
 *
 *   - version: Which version of the source map spec this map is following.
 *   - file: Optional. The generated file this source map is associated with.
 *   - sections: A list of section definitions.
 *
 * Each value under the "sections" field has two fields:
 *   - offset: The offset into the original specified at which this section
 *       begins to apply, defined as an object with a "line" and "column"
 *       field.
 *   - map: A source map definition. This source map could also be indexed,
 *       but doesn't have to be.
 *
 * Instead of the "map" field, it's also possible to have a "url" field
 * specifying a URL to retrieve a source map from, but that's currently
 * unsupported.
 *
 * Here's an example source map, taken from the source map spec[0], but
 * modified to omit a section which uses the "url" field.
 *
 *  {
 *    version : 3,
 *    file: "app.js",
 *    sections: [{
 *      offset: {line:100, column:10},
 *      map: {
 *        version : 3,
 *        file: "section.js",
 *        sources: ["foo.js", "bar.js"],
 *        names: ["src", "maps", "are", "fun"],
 *        mappings: "AAAA,E;;ABCDE;"
 *      }
 *    }],
 *  }
 *
 * The second parameter, if given, is a string whose value is the URL
 * at which the source map was found.  This URL is used to compute the
 * sources array.
 *
 * [0]: https://docs.google.com/document/d/1U1RGAehQwRypUTovF1KRlpiOFze0b-_2gc6fAH0KY0k/edit#heading=h.535es3xeprgt
 */

/**
 * An Interval object represents a half-open interval of time, where each endpoint is a {@link DateTime}. Conceptually, it's a container for those two endpoints, accompanied by methods for creating, parsing, interrogating, comparing, transforming, and formatting them.
 *
 * Here is a brief overview of the most commonly used methods and getters in Interval:
 *
 * * **Creation** To create an Interval, use {@link fromDateTimes}, {@link after}, {@link before}, or {@link fromISO}.
 * * **Accessors** Use {@link start} and {@link end} to get the start and end.
 * * **Interrogation** To analyze the Interval, use {@link count}, {@link length}, {@link hasSame}, {@link contains}, {@link isAfter}, or {@link isBefore}.
 * * **Transformation** To create other Intervals out of this one, use {@link set}, {@link splitAt}, {@link splitBy}, {@link divideEqually}, {@link merge}, {@link xor}, {@link union}, {@link intersection}, or {@link difference}.
 * * **Comparison** To compare this Interval to another one, use {@link equals}, {@link overlaps}, {@link abutsStart}, {@link abutsEnd}, {@link engulfs}
 * * **Output** To convert the Interval into other representations, see {@link toString}, {@link toISO}, {@link toISODate}, {@link toISOTime}, {@link toFormat}, and {@link toDuration}.
 */

/**
 * An instance of the SourceMapGenerator represents a source map which is
 * being built incrementally. You may pass an object with the following
 * properties:
 *
 *   - file: The filename of the generated source.
 *   - sourceRoot: A root for all relative URLs in this source map.
 */

/**
 * Appends an event handler to this object (shorthand for {@link #addListener}.)
 * @param {String}   eventName     The type of event to listen for
 * @param {Function} handler       The method the event invokes
 * @param {Object}   scope         (optional) The scope (<code><b>this</b></code> reference) in which the handler function is executed.
 * <b>If omitted, defaults to the object which fired the event.</b>
 * @param {Object}   options       (optional) An object containing handler configuration.
 * @method
 */

/**
 * Appends the elements of `values` to `array`.
 *
 * @private
 * @param {Array} array The array to modify.
 * @param {Array} values The values to append.
 * @returns {Array} Returns `array`.
 */

/**
 * Applies filters on a section of a template.
 *
 *   {% apply upper %}
 *      This text becomes uppercase
 *   {% endapply %}
 */

/**
 * Applies the mappings of a sub-source-map for a specific source file to the
 * source map being generated. Each mapping to the supplied source file is
 * rewritten using the supplied source map. Note: The resolution for the
 * resulting mappings is the minimium of this map and the supplied map.
 *
 * @param aSourceMapConsumer The source map to be applied.
 * @param aSourceFile Optional. The filename of the source file.
 *        If omitted, SourceMapConsumer's file property will be used.
 * @param aSourceMapPath Optional. The dirname of the path to the source map
 *        to be applied. If relative, it is relative to the SourceMapConsumer.
 *        This parameter is needed when the two source maps aren't in the same
 *        directory, and the source map to be applied contains relative source
 *        paths. If so, those relative source paths need to be rewritten
 *        relative to the SourceMapGenerator.
 */

/**
 * Assert object's properties type
 *
 * @param {object} options
 * @param {object} schema
 * @param {boolean?} allowUnknown
 *
 * @returns {object}
 */

/**
 * Assigns `value` to `key` of `object` if the existing value is not equivalent
 * using [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero)
 * for equality comparisons.
 *
 * @private
 * @param {Object} object The object to modify.
 * @param {string} key The key of the property to assign.
 * @param {*} value The value to assign.
 */

/**
 * Base class for all token parsers.
 *
 * @author Eric MORAND <eric.morand@gmail.com>
 */

/**
 * Batches item.
 *
 * @param {any[]} items An array of items
 * @param {number} size  The size of the batch
 * @param {any} fill A value used to fill missing items
 * @param {boolean} preserveKeys
 *
 * @returns Promise<Map<any, any>[]>
 */

/**
 * Because behavior goes wacky when you set `__proto__` on objects, we
 * have to prefix all the strings in our set with an arbitrary character.
 *
 * See https://github.com/mozilla/source-map/pull/31 and
 * https://github.com/mozilla/source-map/issues/30
 *
 * @param String aStr
 */

/**
 * Build a URL by appending params to the end
 *
 * @param {string} url The base of the url (e.g., http://www.google.com)
 * @param {object} [params] The params to be appended
 * @param {?object} options
 *
 * @returns {string} The formatted url
 */

/**
 * Calculate data maxRate
 * @param {Number} [samplesCount= 10]
 * @param {Number} [min= 1000]
 * @returns {Function}
 */

/**
 * Call String.prototype.replace on the very right-most source snippet. Useful
 * for trimming whitespace from the end of a source node, etc.
 *
 * @param aPattern The pattern to replace.
 * @param aReplacement The thing to replace the pattern with.
 */

/**
 * Check if two `RouteRecords` are equal. Takes into account aliases: they are
 * considered equal to the `RouteRecord` they are aliasing.
 *
 * @param a - first {@link RouteRecord}
 * @param b - second {@link RouteRecord}
 */

/**
 * Check if two arrays are the same or if an array with one single entry is the
 * same as another primitive value. Used to check query and parameters
 *
 * @param a - array of values
 * @param b - array of values or a single value
 */

/**
 * Check that an obejct is traversable in the sense of PHP,
 * i.e. implements PHP Traversable interface
 *
 * @param value
 * @returns {boolean}
 */

/**
 * Check whether a string consists of numerical character(s) only.
 *
 * @param {string} value
 * @return boolean
 */

/**
 * Check whether a string consists of whitespace character(s) only.
 *
 * @param {string} value
 * @return boolean
 */

/**
 * Checks `localStorage` for boolean values for the given `name`.
 *
 * @param {String} name
 * @returns {Boolean}
 * @api private
 */

/**
 * Checks if `func` has its source masked.
 *
 * @private
 * @param {Function} func The function to check.
 * @returns {boolean} Returns `true` if `func` is masked, else `false`.
 */

/**
 * Checks if `value` is a valid array-like index.
 *
 * @private
 * @param {*} value The value to check.
 * @param {number} [length=MAX_SAFE_INTEGER] The upper bounds of a valid index.
 * @returns {boolean} Returns `true` if `value` is a valid index, else `false`.
 */

/**
 * Checks if `value` is a valid array-like length.
 *
 * **Note:** This method is loosely based on
 * [`ToLength`](http://ecma-international.org/ecma-262/7.0/#sec-tolength).
 *
 * @static
 * @memberOf _
 * @since 4.0.0
 * @category Lang
 * @param {*} value The value to check.
 * @returns {boolean} Returns `true` if `value` is a valid length, else `false`.
 * @example
 *
 * _.isLength(3);
 * // => true
 *
 * _.isLength(Number.MIN_VALUE);
 * // => false
 *
 * _.isLength(Infinity);
 * // => false
 *
 * _.isLength('3');
 * // => false
 */

/**
 * Checks if `value` is array-like. A value is considered array-like if it's
 * not a function and has a `value.length` that's an integer greater than or
 * equal to `0` and less than or equal to `Number.MAX_SAFE_INTEGER`.
 *
 * @static
 * @memberOf _
 * @since 4.0.0
 * @category Lang
 * @param {*} value The value to check.
 * @returns {boolean} Returns `true` if `value` is array-like, else `false`.
 * @example
 *
 * _.isArrayLike([1, 2, 3]);
 * // => true
 *
 * _.isArrayLike(document.body.children);
 * // => true
 *
 * _.isArrayLike('abc');
 * // => true
 *
 * _.isArrayLike(_.noop);
 * // => false
 */

/**
 * Checks if `value` is classified as a `Function` object.
 *
 * @static
 * @memberOf _
 * @since 0.1.0
 * @category Lang
 * @param {*} value The value to check.
 * @returns {boolean} Returns `true` if `value` is a function, else `false`.
 * @example
 *
 * _.isFunction(_);
 * // => true
 *
 * _.isFunction(/abc/);
 * // => false
 */

/**
 * 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
 */

/**
 * Checks if `value` is likely a prototype object.
 *
 * @private
 * @param {*} value The value to check.
 * @returns {boolean} Returns `true` if `value` is a prototype, else `false`.
 */

/**
 * 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
 */

/**
 * Checks if `value` is suitable for use as unique object key.
 *
 * @private
 * @param {*} value The value to check.
 * @returns {boolean} Returns `true` if `value` is suitable, else `false`.
 */

/**
 * 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
 */

/**
 * Checks if a hash value for `key` exists.
 *
 * @private
 * @name has
 * @memberOf Hash
 * @param {string} key The key of the entry to check.
 * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.
 */

/**
 * Checks if a list cache value for `key` exists.
 *
 * @private
 * @name has
 * @memberOf ListCache
 * @param {string} key The key of the entry to check.
 * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.
 */

/**
 * Checks if a map value for `key` exists.
 *
 * @private
 * @name has
 * @memberOf MapCache
 * @param {string} key The key of the entry to check.
 * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.
 */

/**
 * Checks if a record or any of its parent is an alias
 * @param record
 */

/**
 * Checks if a stack value for `key` exists.
 *
 * @private
 * @name has
 * @memberOf Stack
 * @param {string} key The key of the entry to check.
 * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.
 */

/**
 * Checks if a variable is defined in the active context.
 *
 * <pre>
 * {# defined works with variable names and variable attributes #}
 * {% if foo is defined %}
 *     {# ... #}
 * {% endif %}
 * </pre>
 */

/**
 * Checks if a variable is empty.
 *
 * <pre>
 * {# evaluates to true if the foo variable is null, false, or the empty string #}
 * {% if foo is empty %}
 *     {# ... #}
 * {% endif %}
 * </pre>
 *
 * @param value A variable
 *
 * @returns {boolean} true if the value is empty, false otherwise
 */

/**
 * Checks if a variable is traversable.
 *
 * <pre>
 * {# evaluates to true if the foo variable is an array or a traversable object #}
 * {% if foo is iterable %}
 *     {# ... #}
 * {% endif %}
 * </pre>
 *
 * @param value A variable
 *
 * @return {Promise<boolean>} true if the value is traversable
 */

/**
 * Checks if casting an expression to toString() is allowed by the sandbox.
 *
 * For instance, when there is a simple Print statement, like {{ article }},
 * and if the sandbox is enabled, we need to check that the toString()
 * method is allowed if 'article' is an object. The same goes for {{ article|upper }}
 * or {{ random(article) }}.
 */

/**
 * Checks if two RouteLocation are equal. This means that both locations are
 * pointing towards the same {@link RouteRecord} and that all `params`, `query`
 * parameters and `hash` are the same
 *
 * @param a - first {@link RouteLocation}
 * @param b - second {@link RouteLocation}
 */

/**
 * Clone a map.
 *
 * @param {Map<K, V>} map
 * @returns {Map<K, V>}
 */

/**
 * Clones (copies) an Object using deep copying.
 *
 * This function supports circular references by default, but if you are certain
 * there are no circular references in your object, you can save some CPU time
 * by calling clone(obj, false).
 *
 * Caution: if `circular` is false and `parent` contains circular references,
 * your program may enter an infinite loop and crash.
 *
 * @param `parent` - the object to be cloned
 * @param `circular` - set to true if the object to be cloned may contain
 *    circular references. (optional - true by default)
 * @param `depth` - set to a number if the object is only to be cloned to
 *    a particular depth. (optional - defaults to Infinity)
 * @param `prototype` - sets the prototype to be used when cloning an object.
 *    (optional - defaults to parent prototype).
*/

/**
 * Comparator between two mappings where the original positions are compared.
 *
 * Optionally pass in `true` as `onlyCompareGenerated` to consider two
 * mappings with the same original source/line/column, but different generated
 * line and column the same. Useful when searching for a mapping with a
 * stubbed out mapping.
 */

/**
 * Comparator between two mappings with deflated source and name indices where
 * the generated positions are compared.
 *
 * Optionally pass in `true` as `onlyCompareGenerated` to consider two
 * mappings with the same generated line and column, but different
 * source/name/original line and column the same. Useful when searching for a
 * mapping with a stubbed out mapping.
 */

/**
 * Comparator between two mappings with inflated source and name strings where
 * the generated positions are compared.
 */

/**
 * Compare a DateTime to something else by conforming to PHP loose comparisons rules
 * ┌─────────┬───────┬───────┬───────┬───────┬───────┬───────┬───────┬───────┬───────┬───────┬─────────┬───────┬───────┬───────┬───────┐
 * │         │ TRUE  │ FALSE │   1   │   0   │  -1   │  "1"  │  "0"  │ "-1"  │ NULL  │ []    │ ["php"] | "php" │  ""   │  NOW  | LATER |
 * ├─────────┼───────┼───────┼───────┼───────┼───────┼───────┼───────┼───────┼───────┼───────┼─────────┼───────┼───────┼───────┼───────┤
 * │  NOW    │ FALSE │ FALSE │ FALSE │ FALSE │ FALSE │ FALSE │ FALSE │ FALSE │ FALSE │ FALSE │ FALSE   │ FALSE │ FALSE │ TRUE  │ FALSE │
 * │  LATER  │ FALSE │ FALSE │ FALSE │ FALSE │ FALSE │ FALSE │ FALSE │ FALSE │ FALSE │ FALSE │ FALSE   │ FALSE │ FALSE │ FALSE │ TRUE  │
 * └─────────┴───────┴───────┴───────┴───────┴───────┴───────┴───────┴───────┴───────┴───────┴─────────┴───────┴───────┴───────┴───────┘
 */

/**
 * Compare a Map to something else by conforming to PHP loose comparisons rules
 * ┌─────────┬───────┬───────┬───────┬───────┬───────┬───────┬───────┬───────┬───────┬───────┬─────────┬───────┬───────┐
 * │         │ TRUE  │ FALSE │   1   │   0   │  -1   │  "1"  │  "0"  │ "-1"  │ NULL  │ []    │ ["php"] | "php" │  ""   │
 * ├─────────┼───────┼───────┼───────┼───────┼───────┼───────┼───────┼───────┼───────┼───────┼─────────┼───────┼───────┤
 * │ []      │ FALSE │ TRUE  │ FALSE │ FALSE │ FALSE │ FALSE │ FALSE │ FALSE │ TRUE  │ TRUE  │ FALSE   │ FALSE │ FALSE |
 * │ ["php"] │ TRUE  │ FALSE │ FALSE │ FALSE │ FALSE │ FALSE │ FALSE │ FALSE │ FALSE │ FALSE │ TRUE    │ FALSE │ FALSE |
 * └─────────┴───────┴───────┴───────┴───────┴───────┴───────┴───────┴───────┴───────┴───────┴─────────┴───────┴───────┘
 */

/**
 * Compare a boolean to something else by conforming to PHP loose comparisons rules
 * ┌─────────┬───────┬───────┬───────┬───────┬───────┬───────┬───────┬───────┬───────┬─────────┬───────┬───────┐
 * │         │ TRUE  │ FALSE │   1   │   0   │  -1   │  "1"  │  "0"  │ "-1"  │ NULL  │ array() │ "php" │  ""   │
 * ├─────────┼───────┼───────┼───────┼───────┼───────┼───────┼───────┼───────┼───────┼─────── ─┼───────┼───────┤
 * │ TRUE    │ TRUE  │ FALSE │ TRUE  │ FALSE │ TRUE  │ TRUE  │ FALSE │ TRUE  │ FALSE │ FALSE   │ TRUE  │ FALSE │
 * │ FALSE   │ FALSE │ TRUE  │ FALSE │ TRUE  │ FALSE │ FALSE │ TRUE  │ FALSE │ TRUE  │ TRUE    │ FALSE │ TRUE  │
 * └─────────┴───────┴───────┴───────┴───────┴───────┴───────┴───────┴───────┴───────┴─────────┴───────┴───────┘
 */

/**
 * Compare a number to something else by conforming to PHP loose comparisons rules
 * ┌─────────┬───────┬───────┬───────┬───────┬───────┬───────┬───────┬───────┬───────┬─────────┬───────┬───────┐
 * │         │ TRUE  │ FALSE │   1   │   0   │  -1   │  "1"  │  "0"  │ "-1"  │ NULL  │ array() │ "php" │  ""   │
 * ├─────────┼───────┼───────┼───────┼───────┼───────┼───────┼───────┼───────┼───────┼─────── ─┼───────┼───────┤
 * │ 1       │ TRUE  │ FALSE │ TRUE  │ FALSE │ FALSE │ TRUE  │ FALSE │ FALSE │ FALSE │ FALSE   │ FALSE │ FALSE │
 * │ 0       │ FALSE │ TRUE  │ FALSE │ TRUE  │ FALSE │ FALSE │ TRUE  │ FALSE │ TRUE  │ FALSE   │ TRUE  │ TRUE  │
 * │ -1      │ TRUE  │ FALSE │ FALSE │ FALSE │ TRUE  │ FALSE │ FALSE │ TRUE  │ FALSE │ FALSE   │ FALSE │ FALSE │
 * └─────────┴───────┴───────┴───────┴───────┴───────┴───────┴───────┴───────┴───────┴─────────┴───────┴───────┘
 */

/**
 * Compare a string to something else by conforming to PHP loose comparisons rules
 * ┌─────────┬───────┬───────┬───────┬───────┬───────┬───────┬───────┬───────┬───────┬─────────┬───────┬───────┐
 * │         │ TRUE  │ FALSE │   1   │   0   │  -1   │  "1"  │  "0"  │ "-1"  │ NULL  │ array() │ "php" │  ""   │
 * ├─────────┼───────┼───────┼───────┼───────┼───────┼───────┼───────┼───────┼───────┼─────── ─┼───────┼───────┤
 * │ "1"     │ TRUE  │ FALSE │ TRUE  │ FALSE │ FALSE │ TRUE  │ FALSE │ FALSE │ FALSE │ FALSE   │ FALSE │ FALSE │
 * │ "0"     │ FALSE │ TRUE  │ FALSE │ TRUE  │ FALSE │ FALSE │ TRUE  │ FALSE │ FALSE │ FALSE   │ FALSE │ FALSE │
 * │ "-1"    │ TRUE  │ FALSE │ FALSE │ FALSE │ TRUE  │ FALSE │ FALSE │ TRUE  │ FALSE │ FALSE   │ FALSE │ FALSE │
 * │ ""      │ FALSE │ TRUE  │ FALSE │ TRUE  │ FALSE │ FALSE │ FALSE │ FALSE │ TRUE  │ FALSE   │ FALSE │ TRUE  │
 * │ "php"   │ TRUE  │ FALSE │ FALSE │ TRUE  │ FALSE │ FALSE │ FALSE │ FALSE │ FALSE │ FALSE   │ TRUE  │ FALSE │
 * └─────────┴───────┴───────┴───────┴───────┴───────┴───────┴───────┴───────┴───────┴─────────┴───────┴───────┘
 */

/**
 * Compare by conforming to PHP loose comparisons rules
 *
 * @see http://php.net/manual/en/types.comparisons.php
 * @see https://stackoverflow.com/questions/47969711/php-algorithm-loose-equality-comparison
 */

/**
 * Compare function that can be used with `sort` to sort an array of PathParser
 *
 * @param a - first PathParser
 * @param b - second PathParser
 * @returns 0 if both are equal, < 0 if a should be sorted first, > 0 if b
 */

/**
 * Compare null to something else by conforming to PHP loose comparisons rules
 * ┌─────────┬───────┬───────┬───────┬───────┬───────┬───────┬───────┬───────┬───────┬───────┬─────────┬───────┬───────┐
 * │         │ TRUE  │ FALSE │   1   │   0   │  -1   │  "1"  │  "0"  │ "-1"  │ NULL  │ []    │ ["php"] | "php" │  ""   │
 * ├─────────┼───────┼───────┼───────┼───────┼───────┼───────┼───────┼───────┼───────┼───────┼─────────┼───────┼───────┤
 * │ NULL    │ FALSE │ TRUE  │ FALSE │ TRUE  │ FALSE │ FALSE │ FALSE │ FALSE │ TRUE  │ TRUE  │ FALSE   │ FALSE │ TRUE  |
 * └─────────┴───────┴───────┴───────┴───────┴───────┴───────┴───────┴───────┴───────┴───────┴─────────┴───────┴───────┘
 */

/**
 * Compares an array of numbers as used in PathParser.score and returns a
 * number. This function can be used to `sort` an array
 *
 * @param a - first array of numbers
 * @param b - second array of numbers
 * @returns 0 if both are equal, < 0 if a should be sorted first, > 0 if b
 * should be sorted first
 */

/**
 * Component to display the current route the user is at.
 */

/**
 * Component to render a link that triggers a navigation on click.
 */

/**
 * Compute the URL of a source given the the source root, the source's
 * URL, and the source map's URL.
 */

/**
 * Compute the last column for each generated mapping. The last column is
 * inclusive.
 */

/**
 * Config-specific merge-function which creates a new config-object
 * by merging two configuration objects together.
 *
 * @param {Object} config1
 * @param {Object} config2
 *
 * @returns {Object} New object resulting from merging config2 to config1
 */

/**
 * Convert a data object to FormData
 *
 * @param {Object} obj
 * @param {?Object} [formData]
 * @param {?Object} [options]
 * @param {Function} [options.visitor]
 * @param {Boolean} [options.metaTokens = true]
 * @param {Boolean} [options.dots = false]
 * @param {?Boolean} [options.indexes = false]
 *
 * @returns {Object}
 **/

/**
 * Convert an array to an object.
 *
 * @param {Array<any>} arr - The array to convert to an object.
 *
 * @returns An object with the same keys and values as the array.
 */

/**
 * Converts `func` to its source code.
 *
 * @private
 * @param {Function} func The function to convert.
 * @returns {string} Returns the source code.
 */

/**
 * Converts `value` to a string using `Object.prototype.toString`.
 *
 * @private
 * @param {*} value The value to convert.
 * @returns {string} Returns the converted string.
 */

/**
 * Converts a date to the given format.
 *
 * <pre>
 *   {{ post.published_at|date("m/d/Y") }}
 * </pre>
 *
 * @param {TwingTemplate} template
 * @param {DateTime|Duration|string} date A date
 * @param {string|null} format The target format, null to use the default
 * @param {string|null|boolean} timezone The target timezone, null to use the default, false to leave unchanged
 *
 * @return {Promise<string>} The formatted date
 */

/**
 * Converts a string to lowercase.
 *
 * @param {TwingEnvironment} env
 * @param {string | TwingMarkup} string A string
 *
 * @returns {Promise<string>} The lowercased string
 */

/**
 * Converts a string to uppercase.
 *
 * @param {string | TwingMarkup} string A string
 *
 * @returns {Promise<string>} The uppercased string
 */

/**
 * Converts an input to a DateTime instance.
 *
 * <pre>
 *    {% if date(user.created_at) < date('+2days') %}
 *      {# do something #}
 *    {% endif %}
 * </pre>
 *
 * @param {TwingTemplate} template
 * @param {Date | DateTime | Duration | number | string} date A date or null to use the current time
 * @param {string | null | boolean} timezone The target timezone, null to use the default, false to leave unchanged
 *
 * @returns {Promise<DateTime | Duration>}
 */

/**
 * Converts from a two-complement value to a value where the sign bit is
 * placed in the least significant bit.  For example, as decimals:
 *   1 becomes 2 (10 binary), -1 becomes 3 (11 binary)
 *   2 becomes 4 (100 binary), -2 becomes 5 (101 binary)
 */

/**
 * Converts input to Map.
 *
 * @param {*} thing
 * @returns {Map<any, any>}
 */

/**
 * Converts to a two-complement value from a value where the sign bit is
 * placed in the least significant bit.  For example, as decimals:
 *   2 (10 binary) becomes 1, 3 (11 binary) becomes -1
 *   4 (100 binary) becomes 2, 5 (101 binary) becomes -2
 */

/**
 * Copies a route location and removes any problematic properties that cannot be shown in devtools (e.g. Vue instances).
 *
 * @param routeLocation - routeLocation to format
 * @param tooltip - optional tooltip
 * @returns a copy of the routeLocation
 */

/**
 * Copies all the properties of config to obj.
 * @param {Object} obj The receiver of the properties
 * @param {Object} config The source of the properties
 * @param {Object} defaults A different object that will also be applied for default values
 * @return {Object} returns obj
 * @member Ext apply
 */

/**
 * Copies own and inherited symbols of `source` to `object`.
 *
 * @private
 * @param {Object} source The object to copy symbols from.
 * @param {Object} [object={}] The object to copy symbols to.
 * @returns {Object} Returns `object`.
 */

/**
 * Copies own symbols of `source` to `object`.
 *
 * @private
 * @param {Object} source The object to copy symbols from.
 * @param {Object} [object={}] The object to copy symbols to.
 * @returns {Object} Returns `object`.
 */

/**
 * Copies properties of `source` to `object`.
 *
 * @private
 * @param {Object} source The object to copy properties from.
 * @param {Array} props The property identifiers to copy.
 * @param {Object} [object={}] The object to copy properties to.
 * @param {Function} [customizer] The function to customize copied values.
 * @returns {Object} Returns `object`.
 */

/**
 * Copies the values of `source` to `array`.
 *
 * @private
 * @param {Array} source The array to copy values from.
 * @param {Array} [array=[]] The array to copy values to.
 * @returns {Array} Returns `array`.
 */

/**
 * Count all elements in an object.
 *
 * @param {*} countable
 * @returns {number}
 */

/**
 * Create a BasicSourceMapConsumer from a SourceMapGenerator.
 *
 * @param SourceMapGenerator aSourceMap
 *        The source map that will be consumed.
 * @param String aSourceMapURL
 *        The URL at which the source map can be found (optional)
 * @returns BasicSourceMapConsumer
 */

/**
 * Create a list of callbacks that can be reset. Used to create before and after navigation guards list
 */

/**
 * Create a new instance of Axios
 *
 * @param {Object} instanceConfig The default config for the instance
 *
 * @return {Axios} A new instance of Axios
 */

/**
 * Create an Error with the specified message, config, error code, request and response.
 *
 * @param {string} message The error message.
 * @param {string} [code] The error code (for example, 'ECONNABORTED').
 * @param {Object} [config] The config.
 * @param {Object} [request] The request.
 * @param {Object} [response] The response.
 *
 * @returns {Error} The created error.
 */

/**
 * Create an instance of Axios
 *
 * @param {Object} defaultConfig The default config for the instance
 *
 * @returns {Axios} A new instance of Axios
 */

/**
 * Creates a Router Matcher.
 *
 * @internal
 * @param routes - array of initial routes
 * @param globalOptions - global route options
 */

/**
 * Creates a Router instance that can be used by a Vue app.
 *
 * @param options - {@link RouterOptions}
 */

/**
 * Creates a SourceNode from generated code and a SourceMapConsumer.
 *
 * @param aGeneratedCode The generated code
 * @param aSourceMapConsumer The SourceMap for the generated code
 * @param aRelativePath Optional. The path that relative sources in the
 *        SourceMapConsumer should be relative to.
 */

/**
 * Creates a clone of  `buffer`.
 *
 * @private
 * @param {Buffer} buffer The buffer to clone.
 * @param {boolean} [isDeep] Specify a deep clone.
 * @returns {Buffer} Returns the cloned buffer.
 */

/**
 * Creates a clone of `arrayBuffer`.
 *
 * @private
 * @param {ArrayBuffer} arrayBuffer The array buffer to clone.
 * @returns {ArrayBuffer} Returns the cloned array buffer.
 */

/**
 * Creates a clone of `dataView`.
 *
 * @private
 * @param {Object} dataView The data view to clone.
 * @param {boolean} [isDeep] Specify a deep clone.
 * @returns {Object} Returns the cloned data view.
 */

/**
 * Creates a clone of `regexp`.
 *
 * @private
 * @param {Object} regexp The regexp to clone.
 * @returns {Object} Returns the cloned regexp.
 */

/**
 * Creates a clone of `typedArray`.
 *
 * @private
 * @param {Object} typedArray The typed array to clone.
 * @param {boolean} [isDeep] Specify a deep clone.
 * @returns {Object} Returns the cloned typed array.
 */

/**
 * Creates a clone of the `symbol` object.
 *
 * @private
 * @param {Object} symbol The symbol object to clone.
 * @returns {Object} Returns the cloned symbol object.
 */

/**
 * Creates a hash object.
 *
 * @private
 * @constructor
 * @param {Array} [entries] The key-value pairs to cache.
 */

/**
 * Creates a map cache object to store key-value pairs.
 *
 * @private
 * @constructor
 * @param {Array} [entries] The key-value pairs to cache.
 */

/**
 * Creates a new SourceMapGenerator based on a SourceMapConsumer
 *
 * @param aSourceMapConsumer The SourceMap.
 */

/**
 * Creates a new URL by combining the baseURL with the requestedURL,
 * only when the requestedURL is not already an absolute URL.
 * If the requestURL is absolute, this function returns the requestedURL untouched.
 *
 * @param {string} baseURL The base URL
 * @param {string} requestedURL Absolute or relative URL to combine
 *
 * @returns {string} The combined full path
 */

/**
 * Creates a new URL by combining the specified URLs
 *
 * @param {string} baseURL The base URL
 * @param {string} relativeURL The relative URL
 *
 * @returns {string} The combined URL
 */

/**
 * Creates a new filled Buffer instance.
 * alloc(size[, fill[, encoding]])
 **/

/**
 * Creates a normalized history location from a window.location object
 * @param location -
 */

/**
 * Creates a path parser from an array of Segments (a segment is an array of Tokens)
 *
 * @param segments - array of segments returned by tokenizePath
 * @param extraOptions - optional options for the regexp
 * @returns a PathParser
 */

/**
 * Creates a stack cache object to store key-value pairs.
 *
 * @private
 * @constructor
 * @param {Array} [entries] The key-value pairs to cache.
 */

/**
 * Creates a state object
 */

/**
 * 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.
 */

/**
 * Creates an HTML5 history. Most common history for single page applications.
 *
 * @param base -
 */

/**
 * Creates an array of own and inherited enumerable property names and
 * symbols of `object`.
 *
 * @private
 * @param {Object} object The object to query.
 * @returns {Array} Returns the array of property names and symbols.
 */

/**
 * Creates an array of own enumerable property names and symbols of `object`.
 *
 * @private
 * @param {Object} object The object to query.
 * @returns {Array} Returns the array of property names and symbols.
 */

/**
 * Creates an array of the enumerable property names of the array-like `value`.
 *
 * @private
 * @param {*} value The value to query.
 * @param {boolean} inherited Specify returning inherited property names.
 * @returns {Array} Returns the array of property names.
 */

/**
 * Creates an array of the own and inherited enumerable property names of `object`.
 *
 * **Note:** Non-object values are coerced to objects.
 *
 * @static
 * @memberOf _
 * @since 3.0.0
 * @category Object
 * @param {Object} object The object to query.
 * @returns {Array} Returns the array of property names.
 * @example
 *
 * function Foo() {
 *   this.a = 1;
 *   this.b = 2;
 * }
 *
 * Foo.prototype.c = 3;
 *
 * _.keysIn(new Foo);
 * // => ['a', 'b', 'c'] (iteration order is not guaranteed)
 */

/**
 * Creates an array of the own enumerable property names of `object`.
 *
 * **Note:** Non-object values are coerced to objects. See the
 * [ES spec](http://ecma-international.org/ecma-262/7.0/#sec-object.keys)
 * for more details.
 *
 * @static
 * @since 0.1.0
 * @memberOf _
 * @category Object
 * @param {Object} object The object to query.
 * @returns {Array} Returns the array of property names.
 * @example
 *
 * function Foo() {
 *   this.a = 1;
 *   this.b = 2;
 * }
 *
 * Foo.prototype.c = 3;
 *
 * _.keys(new Foo);
 * // => ['a', 'b'] (iteration order is not guaranteed)
 *
 * _.keys('hi');
 * // => ['0', '1']
 */

/**
 * Creates an in-memory based history. The main purpose of this history is to handle SSR. It starts in a special location that is nowhere.
 * It's up to the user to replace that location with the starter location by either calling `router.push` or `router.replace`.
 *
 * @param base - Base applied to all urls, defaults to '/'
 * @returns a history object that can be passed to the router constructor
 */

/**
 * Creates an list cache object.
 *
 * @private
 * @constructor
 * @param {Array} [entries] The key-value pairs to cache.
 */

/**
 * Cycles over a value.
 *
 * @param {Map<any, any> | any} value
 * @param {number} position The cycle position
 *
 * @returns {Promise<any>} The value at position
 */

/**
 * Decode a single base 64 character code digit to an integer. Returns -1 on
 * failure.
 */

/**
 * Decode text using `decodeURIComponent`. Returns the original text if it
 * fails.
 *
 * @param text - string to decode
 * @returns decoded string
 */

/**
 * Decodes the next base 64 VLQ value from the given string and returns the
 * value and the rest of the string via the out parameter.
 */

/**
 * Default base class for compiled templates.
 *
 * @author Eric MORAND <eric.morand@gmail.com>
 */

/**
 * Defines a macro.
 *
 * <pre>
 * {% macro input(name, value, type, size) %}
 *    <input type="{{ type|default('text') }}" name="{{ name }}" value="{{ value|e }}" size="{{ size|default(20) }}" />
 * {% endmacro %}
 * </pre>
 */

/**
 * Deprecates a section of a template.
 *
 * <pre>
 * {% deprecated 'The "base.twig" template is deprecated, use "layout.twig" instead.' %}
 *
 * {% extends 'layout.html.twig' %}
 * </pre>
 *
 * @author Eric MORAND <eric.morand@gmail.com>
 */

/**
 * Determine if a value is a Boolean
 *
 * @param {*} thing The value to test
 * @returns {boolean} True if value is a Boolean, otherwise false
 */

/**
 * Determine if a value is a Buffer
 *
 * @param {*} val The value to test
 *
 * @returns {boolean} True if value is a Buffer, otherwise false
 */

/**
 * Determine if a value is a Date
 *
 * @param {*} val The value to test
 *
 * @returns {boolean} True if value is a Date, otherwise false
 */

/**
 * Determine if a value is a FormData
 *
 * @param {*} thing The value to test
 *
 * @returns {boolean} True if value is an FormData, otherwise false
 */

/**
 * Determine if a value is a Function
 *
 * @param {*} val The value to test
 * @returns {boolean} True if value is a Function, otherwise false
 */

/**
 * Determine if a value is a String
 *
 * @param {*} val The value to test
 *
 * @returns {boolean} True if value is a String, otherwise false
 */

/**
 * Determine if a value is a plain Object
 *
 * @param {*} val The value to test
 *
 * @returns {boolean} True if value is a plain Object, otherwise false
 */

/**
 * Determine if a value is a view on an ArrayBuffer
 *
 * @param {*} val The value to test
 *
 * @returns {boolean} True if value is a view on an ArrayBuffer, otherwise false
 */

/**
 * Determine if a value is an Array
 *
 * @param {Object} val The value to test
 *
 * @returns {boolean} True if value is an Array, otherwise false
 */

/**
 * Determine if a value is an ArrayBuffer
 *
 * @param {*} val The value to test
 *
 * @returns {boolean} True if value is an ArrayBuffer, otherwise false
 */

/**
 * Determine whether mappingB is after mappingA with respect to generated
 * position.
 */

/**
 * Determines if the given thing is a array or js object.
 *
 * @param {string} thing - The object or array to be visited.
 *
 * @returns {boolean}
 */

/**
 * Determines whether the payload is an error thrown by Axios
 *
 * @param {*} payload The value to test
 *
 * @returns {boolean} True if the payload is an error thrown by Axios, otherwise false
 */

/**
 * Dispatch a request to the server using the configured adapter.
 *
 * @param {object} config The config that is to be used for the request
 *
 * @returns {Promise} The Promise to be fulfilled
 */

/**
 * Echos the value of a value. Trys to print the value out
 * in the best way possible given the different types.
 *
 * @param {Object} obj The object to print out.
 * @param {Object} opts Optional options object that alters the output.
 */

/**
 * Encode an integer in the range of 0 to 63 to a single base 64 digit.
 */

/**
 * Encode characters that need to be encoded on the hash section of the URL.
 *
 * @param text - string to encode
 * @returns encoded string
 */

/**
 * Encode characters that need to be encoded on the path section of the URL as a
 * param. This function encodes everything {@link encodePath} does plus the
 * slash (`/`) character. If `text` is `null` or `undefined`, returns an empty
 * string instead.
 *
 * @param text - string to encode
 * @returns encoded string
 */

/**
 * Encode characters that need to be encoded on the path section of the URL.
 *
 * @param text - string to encode
 * @returns encoded string
 */

/**
 * Encode characters that need to be encoded on the path, search and hash
 * sections of the URL.
 *
 * @internal
 * @param text - string to encode
 * @returns encoded string
 */

/**
 * Encode characters that need to be encoded query values on the query
 * section of the URL.
 *
 * @param text - string to encode
 * @returns encoded string
 */

/**
 * Encoding Rules ␣ = Space Path: ␣ " < > # ? { } Query: ␣ " < > # & = Hash: ␣ "
 * < > `
 *
 * On top of that, the RFC3986 (https://tools.ietf.org/html/rfc3986#section-2.2)
 * defines some extra characters to be encoded. Most browsers do not encode them
 * in encodeURI https://github.com/whatwg/url/issues/369, so it may be safer to
 * also encode `!'()*`. Leaving un-encoded only ASCII alphanumeric(`a-zA-Z0-9`)
 * plus `-._~`. This extra safety should be applied to query by patching the
 * string returned by encodeURIComponent encodeURI also encodes `[\]^`. `\`
 * should be encoded to avoid ambiguity. Browsers (IE, FF, C) transform a `\`
 * into a `/` if directly typed in. The _backtick_ (`````) should also be
 * encoded everywhere because some browsers like FF encode it when directly
 * written while others don't. Safari and IE don't encode ``"<>{}``` in hash.
 */

/**
 * Ensures a route is loaded, so it can be passed as o prop to `<RouterView>`.
 *
 * @param route - resolved route to load
 */

/**
 * Enumeration with all possible types for navigation failures. Can be passed to
 * {@link isNavigationFailure} to check for specific failures.
 */

/**
 * Equivalent to Buffer(num), by default creates a non-zero-filled Buffer instance.
 * */

/**
 * Equivalent to SlowBuffer(num), by default creates a non-zero-filled Buffer instance.
 */

/**
 * Escapes a string.
 *
 * @param {TwingTemplate} template
 * @param {*} string The value to be escaped
 * @param {string} strategy The escaping strategy
 * @param {string} charset The charset
 * @param {boolean} autoescape Whether the function is called by the auto-escaping feature (true) or by the developer (false)
 *
 * @returns {Promise<string>}
 */

/**
 * Exception thrown when a not allowed class property is used in a template.
 *
 * @author Eric MORAND <eric.morand@gmail.com>
 */

/**
 * Exception thrown when a not allowed filter is used in a template.
 *
 * @author Eric MORAND <eric.morand@gmail.com>
 */

/**
 * Exception thrown when a security error occurs at runtime.
 *
 * @author Eric MORAND <eric.morand@gmail.com>
 */

/**
 * Exception thrown when an error occurs during template loading.
 *
 * @author Eric MORAND <eric.morand@gmail.com>
 */

/**
 * Executes the provided function once for each element of an iterable.
 *
 * @param {*} it An iterable
 * @param {IterateCallback} cb Callback to execute for each element, taking a key and a value as arguments
 *
 * @return {void}
 */

/**
 * Expression is a string that does not get quoted in htmlEncode (@see Ext.util.Format.htmlEncode)
 */

/**
 * Extends object a by mutably adding to it the properties of object b.
 *
 * @param {Object} a The object to be extended
 * @param {Object} b The object to copy properties from
 * @param {Object} thisArg The object to bind function to
 *
 * @param {Boolean} [allOwnKeys]
 * @returns {Object} The resulting value of object a
 */

/**
 * Externalize the source map.
 */

/**
 * Extracted from tailwind palette
 */

/**
 * Fill map with value until map's size is size.
 *
 * @param {Map<*, *>} map
 * @param {number} size
 * @param {any} value
 */

/**
 * Filters a section of a template by applying filters.
 *
 * <pre>
 * {% filter upper %}
 *  This text becomes uppercase
 * {% endfilter %}
 * </pre>
 */

/**
 * Find the mapping that best matches the hypothetical "needle" mapping that
 * we are searching for in the given "haystack" of mappings.
 */

/**
 * For each entry in the object, call the function with the key and value.
 *
 * @param {Object<any, any>} obj - The object to iterate over.
 * @param {Function} fn - The function to call for each entry.
 *
 * @returns {void}
 */

/**
 * For the formats reference, @see https://secure.php.net/manual/en/function.date.php
 */

/**
 * Functionally equivalent to Buffer(arg, encoding) but throws a TypeError
 * if value is a number.
 * Buffer.from(str[, encoding])
 * Buffer.from(array)
 * Buffer.from(buffer)
 * Buffer.from(arrayBuffer[, byteOffset[, length]])
 **/

/**
 * Generate a constructor for a specific Record layout.
 * 
 * @param {Array} def see {@link Ext.data.Record#create}
 * @param {Object} meta information see {@link Record}
 * 
 * <br>usage:<br>
<b>IMPORTANT: the ngettext comments are required for the translation system!</b>
<pre><code>
var TopicRecord = Record.create([
    {name: 'summary', mapping: 'topic_title'},
    {name: 'details', mapping: 'username'}
], {
    appName: 'Tasks',
    modelName: 'Task',
    idProperty: 'id',
    titleProperty: 'summary',
    // ngettext('Task', 'Tasks', n);
    recordName: 'Task',
    recordsName: 'Tasks',
    containerProperty: 'container_id',
    // ngettext('to do list', 'to do lists', n);
    containerName: 'to do list',
    containesrName: 'to do lists'
});
</code></pre>
 * @static
 */

/**
 * Generate a constructor for a specific Record layout.
 * @param {Array} o An Array of <b>{@link Ext.data.Field Field}</b> definition objects.
 * The constructor generated by this method may be used to create new Record instances. The data
 * object must contain properties named after the {@link Ext.data.Field field}
 * <b><tt>{@link Ext.data.Field#name}s</tt></b>.  Example usage:<pre><code>
// create a Record constructor from a description of the fields
var TopicRecord = Record.create([ // creates a subclass of Record
    {{@link Ext.data.Field#name name}: 'title', {@link Ext.data.Field#mapping mapping}: 'topic_title'},
    {name: 'author', mapping: 'username', allowBlank: false},
    {name: 'totalPosts', mapping: 'topic_replies', type: 'int'},
    {name: 'lastPost', mapping: 'post_time', type: 'date'},
    {name: 'lastPoster', mapping: 'user2'},
    {name: 'excerpt', mapping: 'post_text', allowBlank: false},
    // In the simplest case, if no properties other than <tt>name</tt> are required,
    // a field definition may consist of just a String for the field name.
    'signature'
]);

// create Record instance
var myNewRecord = new TopicRecord(
    {
        title: 'Do my job please',
        author: 'noobie',
        totalPosts: 1,
        lastPost: new Date(),
        lastPoster: 'Animal',
        excerpt: 'No way dude!',
        signature: ''
    },
    id // optionally specify the id of the record otherwise {@link #Record.id one is auto-assigned}
);
myStore.{@link Ext.data.Store#add add}(myNewRecord);
</code></pre>
 * @method create
 * @return {function} A constructor which is used to create new Records according
 * to the definition. The constructor has the same signature as {@link #Record}.
 * @static
 */

/**
 * Generates a sequential id. This method is typically called when a record is {@link #create}d
 * and {@link #Record no id has been specified}. The returned id takes the form:
 * <tt>&#123;PREFIX}-&#123;AUTO_ID}</tt>.<div class="mdetail-params"><ul>
 * <li><b><tt>PREFIX</tt></b> : String<p class="sub-desc"><tt>Record.PREFIX</tt>
 * (defaults to <tt>'ext-record'</tt>)</p></li>
 * <li><b><tt>AUTO_ID</tt></b> : String<p class="sub-desc"><tt>Record.AUTO_ID</tt>
 * (defaults to <tt>1</tt> initially)</p></li>
 * </ul></div>
 * @param {Record} rec The record being created.  The record does not exist, it's a {@link #phantom}.
 * @return {String} auto-generated string id, <tt>"ext-record-i++'</tt>;
 */

/**
 * Get the original path value of a record by following its aliasOf
 * @param record
 */

/**
 * Gets the data for `map`.
 *
 * @private
 * @param {Object} map The map to query.
 * @param {string} key The reference key.
 * @returns {*} Returns the map data.
 */

/**
 * Gets the hash value for `key`.
 *
 * @private
 * @name get
 * @memberOf Hash
 * @param {string} key The key of the value to get.
 * @returns {*} Returns the entry value.
 */

/**
 * Gets the index at which the `key` is found in `array` of key-value pairs.
 *
 * @private
 * @param {Array} array The array to inspect.
 * @param {*} key The key to search for.
 * @returns {number} Returns the index of the matched value, else `-1`.
 */

/**
 * Gets the list cache value for `key`.
 *
 * @private
 * @name get
 * @memberOf ListCache
 * @param {string} key The key of the value to get.
 * @returns {*} Returns the entry value.
 */

/**
 * Gets the map value for `key`.
 *
 * @private
 * @name get
 * @memberOf MapCache
 * @param {string} key The key of the value to get.
 * @returns {*} Returns the entry value.
 */

/**
 * Gets the native function at `key` of `object`.
 *
 * @private
 * @param {Object} object The object to query.
 * @param {string} key The key of the method to get.
 * @returns {*} Returns the function if it's native, else `undefined`.
 */

/**
 * Gets the stack value for `key`.
 *
 * @private
 * @name get
 * @memberOf Stack
 * @param {string} key The key of the value to get.
 * @returns {*} Returns the entry value.
 */

/**
 * Gets the value at `key` of `object`.
 *
 * @private
 * @param {Object} [object] The object to query.
 * @param {string} key The key of the property to get.
 * @returns {*} Returns the property value.
 */

/**
 * HTMLProxy - html proxy snipped that will be replaced with the real content later
 *
 * useful in situations where you need to return html directly which gets produces async
 */

/**
 * If `Buffer.TYPED_ARRAY_SUPPORT`:
 *   === true    Use Uint8Array implementation (fastest)
 *   === false   Print warning and recommend using `buffer` v4.x which has an Object
 *               implementation (most compatible, even IE6)
 *
 * Browsers that support typed arrays are IE 10+, Firefox 4+, Chrome 7+, Safari 5.1+,
 * Opera 11.6+, iOS 4.2+.
 *
 * We report that the browser does not support typed arrays if the are not subclassable
 * using __proto__. Firefox 4-29 lacks support for adding new properties to `Uint8Array`
 * (See: https://bugzilla.mozilla.org/show_bug.cgi?id=695438). IE 10 lacks support
 * for __proto__ and has a buggy typed array implementation.
 */

/**
 * If the array is an array and none of its elements are visitable, then it's a flat array.
 *
 * @param {Array<any>} arr - The array to check
 *
 * @returns {boolean}
 */

/**
 * If the thing is a FormData object, return true, otherwise return false.
 *
 * @param {unknown} thing - The thing to check.
 *
 * @returns {boolean}
 */

/**
 * Implements a no-cache strategy.
 *
 * @author Eric MORAND <eric.morand@gmail.com>
 */

/**
 * Imports macros.
 *
 * <pre>
 *   {% from 'forms.html' import forms %}
 * </pre>
 */

/**
 * In Twig, a hash is considered a pure array, i.e. a non-keyed array, if its keys form a (xn = n) sequence -i.e. 0,1,2,3,4...
 *
 * @param map
 */

/**
 * Inherit the prototype methods from one constructor into another.
 *
 * The Function.prototype.inherits from lang.js rewritten as a standalone
 * function (not on Function.prototype). NOTE: If this file is to be loaded
 * during bootstrapping this function needs to be rewritten using some native
 * functions as prototype setup using normal JavaScript does not work as
 * expected during bootstrapping (see mirror.js in r114903).
 *
 * @param {function} ctor Constructor function which needs to inherit the
 *     prototype.
 * @param {function} superCtor Constructor function to inherit prototype from.
 */

/**
 * Initial route location where the router is. Can be used in navigation guards
 * to differentiate the initial navigation.
 *
 * @example
 * ```js
 * import { START_LOCATION } from 'vue-router'
 *
 * router.beforeEach((to, from) => {
 *   if (from === START_LOCATION) {
 *     // initial navigation
 *   }
 * })
 * ```
 */

/**
 * Initializes an array clone.
 *
 * @private
 * @param {Array} array The array to clone.
 * @returns {Array} Returns the initialized clone.
 */

/**
 * Initializes an object clone based on its `toStringTag`.
 *
 * **Note:** This function only supports cloning values with tags of
 * `Boolean`, `Date`, `Error`, `Map`, `Number`, `RegExp`, `Set`, or `String`.
 *
 * @private
 * @param {Object} object The object to clone.
 * @param {string} tag The `toStringTag` of the object to clone.
 * @param {boolean} [isDeep] Specify a deep clone.
 * @returns {Object} Returns the initialized clone.
 */

/**
 * Initializes an object clone.
 *
 * @private
 * @param {Object} object The object to clone.
 * @returns {Object} Returns the initialized clone.
 */

/**
 * Internationalization conversion: convert buffer to requested character encoding
 *
 * @param {string} inCharset The input charset.
 * @param {string} outCharset The output charset.
 * @param {Buffer} buffer The buffer to be converted.
 *
 * @returns {Buffer} the converted buffer or false on failure.
 */

/**
 * Is the given string a member of this set?
 *
 * @param String aStr
 */

/**
 * It converts an object into a FormData object
 *
 * @param {Object<any, any>} obj - The object to convert to form data.
 * @param {string} formData - The FormData object to append to.
 * @param {Object<string, any>} options
 *
 * @returns
 */

/**
 * It encodes a string by replacing all characters that are not in the unreserved set with
 * their percent-encoded equivalents
 *
 * @param {string} str - The string to encode.
 *
 * @returns {string} The encoded string.
 */

/**
 * It removes the brackets from the end of a string
 *
 * @param {string} key - The key of the parameter.
 *
 * @returns {string} the key without the brackets.
 */

/**
 * It replaces all instances of the characters `:`, `$`, `,`, `+`, `[`, and `]` with their
 * URI encoded counterparts
 *
 * @param {string} val The value to be encoded.
 *
 * @returns {string} The encoded value.
 */

/**
 * It takes a FormData object and returns a JavaScript object
 *
 * @param {string} formData The FormData object to convert to JSON.
 *
 * @returns {Object<string, any> | null} The converted object.
 */

/**
 * It takes a params object and converts it to a FormData object
 *
 * @param {Object<string, any>} params - The parameters to be converted to a FormData object.
 * @param {Object<string, any>} options - The options object passed to the Axios constructor.
 *
 * @returns {void}
 */

/**
 * It takes a path, a key, and a boolean, and returns a string
 *
 * @param {string} path - The path to the current key.
 * @param {string} key - The key of the current object being iterated over.
 * @param {string} dots - If true, the key will be rendered with dots instead of brackets.
 *
 * @returns {string} The path to the current key.
 */

/**
 * It takes a regular expression and a string, and returns an array of all the matches
 *
 * @param {string} regExp - The regular expression to match against.
 * @param {string} str - The string to search.
 *
 * @returns {Array<boolean>}
 */

/**
 * It takes a string like `foo[x][y][z]` and returns an array like `['foo', 'x', 'y', 'z']
 *
 * @param {string} name - The name of the property to get.
 *
 * @returns An array of strings.
 */

/**
 * It takes a string, tries to parse it, and if it fails, it returns the stringified version
 * of the input
 *
 * @param {any} rawValue - The value to be stringified.
 * @param {Function} parser - A function that parses a string into a JavaScript object.
 * @param {Function} encoder - A function that takes a value and returns a string.
 *
 * @returns {string} A stringified version of the rawValue.
 */

/**
 * Iterate over an Array or an Object invoking a function for each item.
 *
 * If `obj` is an Array callback will be called passing
 * the value, index, and complete array for each item.
 *
 * If 'obj' is an Object callback will be called passing
 * the value, key, and complete object for each property.
 *
 * @param {Object|Array} obj The object to iterate
 * @param {Function} fn The callback to invoke for each item
 *
 * @param {Boolean} [allOwnKeys = false]
 * @returns {any}
 */

/**
 * Iterate over each mapping between an original source/line/column and a
 * generated line/column in this source map.
 *
 * @param Function aCallback
 *        The function that is called with each mapping.
 * @param Object aContext
 *        Optional. If specified, this object will be the value of `this` every
 *        time that `aCallback` is called.
 * @param aOrder
 *        Either `SourceMapConsumer.GENERATED_ORDER` or
 *        `SourceMapConsumer.ORIGINAL_ORDER`. Specifies whether you want to
 *        iterate over the mappings sorted by the generated file's line/column
 *        order or the original's source/line/column order, respectively. Defaults to
 *        `SourceMapConsumer.GENERATED_ORDER`.
 */

/**
 * Iterate through internal items. This method takes the same arguments that
 * `Array.prototype.forEach` takes.
 *
 * NOTE: The order of the mappings is NOT guaranteed.
 */

/**
 * Joins the values to a string.
 *
 * The separator between elements is an empty string per default, you can define it with the optional parameter.
 *
 * <pre>
 *  {{ [1, 2, 3]|join('|') }}
 *  {# returns 1|2|3 #}
 *
 *  {{ [1, 2, 3]|join }}
 *  {# returns 123 #}
 * </pre>
 *
 * @param {any} value A value
 * @param {string} glue The separator
 * @param {string | null} and The separator for the last pair
 *
 * @returns {Promise<string>} The concatenated string
 */

/**
 * Joins two paths/URLs.
 *
 * @param aRoot The root path or URL.
 * @param aPath The path or URL to be joined with the root.
 *
 * - If aPath is a URL or a data URI, aPath is returned, unless aPath is a
 *   scheme-relative URL: Then the scheme of aRoot, if any, is prepended
 *   first.
 * - Otherwise aPath is a path. If aRoot is a URL, then its path portion
 *   is updated with the result and aRoot is returned. Otherwise the result
 *   is returned.
 *   - If aPath is absolute, the result is aPath.
 *   - Otherwise the two paths are joined with a slash.
 * - Joining for example 'http://' and 'www.example.com' is also supported.
 */

/**
 * Lexes a template string.
 *
 * @author Eric MORAND <eric.morand@gmail.com>
 */

/**
 * Like `String.prototype.join` except for SourceNodes. Inserts `aStr` between
 * each of `this.children`.
 *
 * @param aSep The separator.
 */

/**
 * Like `encodeQueryValue` but also encodes the `=` character.
 *
 * @param text - string to encode
 */

/**
 * Loads a template from a string.
 *
 * <pre>
 * {{ include(template_from_string("Hello {{ name }}")) }}
 * </pre>
 *
 * @param {TwingTemplate} template A TwingTemplate instance
 * @param {string} string A template as a string or object implementing toString()
 * @param {string} name An optional name for the template to be used in error messages
 *
 * @returns {Promise<TwingTemplate>}
 */

/**
 * Loads template from the filesystem.
 *
 * @author Eric MORAND <eric.morand@gmail.com>
 * @author Eric MORAND <eric.morand@gmail.com>
 */

/**
 * Loads templates from other loaders.
 *
 * @author Eric MORAND <eric.morand@gmail.com>
 */

/**
 * Loops over each item of a sequence.
 *
 * <pre>
 * <ul>
 *  {% for user in users %}
 *    <li>{{ user.username|e }}</li>
 *  {% endfor %}
 * </ul>
 * </pre>
 */

/**
 * Lowercase a string.
 *
 * @param  {String} str
 * @return {String}
 */

/**
 * Make a path relative to a URL or another path.
 *
 * @param aRoot The root path or URL.
 * @param aPath The path or URL to be made relative to aRoot.
 */

/**
 * Makes all methods read-only
 * @param {Object} obj
 */

/**
 * Mark that a method should not be used.
 * Returns a modified function which warns once by default.
 *
 * If `localStorage.noDeprecation = true` is set, then it is a no-op.
 *
 * If `localStorage.throwDeprecation = true` is set, then deprecated functions
 * will throw an Error when invoked.
 *
 * If `localStorage.traceDeprecation = true` is set, then deprecated functions
 * will invoke `console.trace()` instead of `console.error()`.
 *
 * @param {Function} fn - the function to deprecate
 * @param {String} msg - the string to print to the console when `fn` is invoked
 * @returns {Function} a new "deprecated" version of `fn`
 * @api public
 */

/**
 * Marks a content as safe.
 *
 * @author Eric MORAND <eric.morand@gmail.com>
 */

/**
 * Marks a section of a template as being reusable.
 *
 * <pre>
 *  {% block head %}
 *    <link rel="stylesheet" href="style.css" />
 *    <title>{% block title %}{% endblock %} - My Webpage</title>
 *  {% endblock %}
 * </pre>
 */

/**
 * Marks a section of a template to be escaped or not.
 */

/**
 * Marks a variable as being safe.
 *
 * @param {string | TwingMarkup} string A variable
 *
 * @return {Promise<string>}
 */

/**
 * Merge meta fields of an array of records
 *
 * @param matched - array of matched records
 */

/**
 * Merges an array with another one.
 *
 * <pre>
 *  {% set items = { 'apple': 'fruit', 'orange': 'fruit' } %}
 *
 *  {% set items = items|merge({ 'peugeot': 'car' }) %}
 *
 *  {# items now contains { 'apple': 'fruit', 'orange': 'fruit', 'peugeot': 'car' } #}
 * </pre>
 *
 * @param {any} iterable1 An iterable
 * @param {any} iterable2 An iterable
 *
 * @return {Promise<Map<any, any>>} The merged map
 */

/**
 * Module exports.
 */

/**
 * Namespace alloted for extensions to the framework.
 * @property ux
 * @type Object
 */

/**
 * Noop implementation of TwingLoaderInterface.
 *
 * @author Eric MORAND <eric.morand@gmail.com>
 */

/**
 * Normalize the optional `props` in a record to always be an object similar to
 * components. Also accept a boolean for components.
 * @param record
 */

/**
 * Normalizes a RouteRecordRaw. Creates a copy
 *
 * @param record
 * @returns the normalized version
 */

/**
 * Normalizes a base by removing any trailing slash and reading the base tag if
 * present.
 *
 * @param base - base to normalize
 */

/**
 * Normalizes a path, or the path portion of a URL:
 *
 * - Replaces consecutive slashes with one slash.
 * - Removes unnecessary '.' parts.
 * - Removes unnecessary '<dir>/..' parts.
 *
 * Based on code in the Node.js 'path' core module.
 *
 * @param aPath The path or url to normalize.
 */

/**
 * Number format filter.
 *
 * All of the formatting options can be left null, in that case the defaults will
 * be used.  Supplying any of the parameters will override the defaults set in the
 * environment object.
 *
 * @param {TwingTemplate} template
 * @param {*} number A float/int/string of the number to format
 * @param {number} decimal the number of decimal points to display
 * @param {string} decimalPoint the character(s) to use for the decimal point
 * @param {string} thousandSep the character(s) to use for the thousands separator
 *
 * @returns {Promise<string>} The formatted number
 */

/**
 * Parse the mappings in a string in to a data structure which we can easily
 * query (the ordered arrays in the `this.__generatedMappings` and
 * `this.__originalMappings` properties).
 */

/**
 * Performs a
 * [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero)
 * comparison between two values to determine if they are equivalent.
 *
 * @static
 * @memberOf _
 * @since 4.0.0
 * @category Lang
 * @param {*} value The value to compare.
 * @param {*} other The other value to compare.
 * @returns {boolean} Returns `true` if the values are equivalent, else `false`.
 * @example
 *
 * var object = { 'a': 1 };
 * var other = { 'a': 1 };
 *
 * _.eq(object, object);
 * // => true
 *
 * _.eq(object, other);
 * // => false
 *
 * _.eq('a', 'a');
 * // => true
 *
 * _.eq('a', Object('a'));
 * // => false
 *
 * _.eq(NaN, NaN);
 * // => true
 */

/**
 * Provide the JIT with a nice shape / hidden class.
 */

/**
 * Recursive implementation of binary search.
 *
 * @param aLow Indices here and lower do not contain the needle.
 * @param aHigh Indices here and higher do not contain the needle.
 * @param aNeedle The element being searched for.
 * @param aHaystack The non-empty array being searched.
 * @param aCompare Function which takes two elements and returns -1, 0, or 1.
 * @param aBias Either 'binarySearch.GREATEST_LOWER_BOUND' or
 *     'binarySearch.LEAST_UPPER_BOUND'. Specifies whether to return the
 *     closest element that is smaller than or greater than the one we are
 *     searching for, respectively, if the exact element cannot be found.
 */

/**
 * RegexParser
 * Parses a string input.
 *
 * @name RegexParser
 * @function
 * @param {String} input The string input that should be parsed as regular
 * expression.
 * @return {RegExp} The parsed regular expression.
 */

/**
 * Remove byte order marker. This catches EF BB BF (the UTF-8 BOM)
 *
 * @param {string} content with BOM
 *
 * @returns {string} content value without BOM
 */

/**
 * Removes <b>all</b> added captures from the Observable.
 * @param {Observable} o The Observable to release
 * @static
 */

/**
 * Removes `key` and its value from the hash.
 *
 * @private
 * @name delete
 * @memberOf Hash
 * @param {Object} hash The hash to modify.
 * @param {string} key The key of the value to remove.
 * @returns {boolean} Returns `true` if the entry was removed, else `false`.
 */

/**
 * Removes `key` and its value from the list cache.
 *
 * @private
 * @name delete
 * @memberOf ListCache
 * @param {string} key The key of the value to remove.
 * @returns {boolean} Returns `true` if the entry was removed, else `false`.
 */

/**
 * Removes `key` and its value from the map.
 *
 * @private
 * @name delete
 * @memberOf MapCache
 * @param {string} key The key of the value to remove.
 * @returns {boolean} Returns `true` if the entry was removed, else `false`.
 */

/**
 * Removes `key` and its value from the stack.
 *
 * @private
 * @name delete
 * @memberOf Stack
 * @param {string} key The key of the value to remove.
 * @returns {boolean} Returns `true` if the entry was removed, else `false`.
 */

/**
 * Removes all key-value entries from the hash.
 *
 * @private
 * @name clear
 * @memberOf Hash
 */

/**
 * Removes all key-value entries from the list cache.
 *
 * @private
 * @name clear
 * @memberOf ListCache
 */

/**
 * Removes all key-value entries from the map.
 *
 * @private
 * @name clear
 * @memberOf MapCache
 */

/**
 * Removes all key-value entries from the stack.
 *
 * @private
 * @name clear
 * @memberOf Stack
 */

/**
 * Removes an event handler (shorthand for {@link #removeListener}.)
 * @param {String}   eventName     The type of event the handler was associated with.
 * @param {Function} handler       The handler to remove. <b>This must be a reference to the function passed into the {@link #addListener} call.</b>
 * @param {Object}   scope         (optional) The scope originally specified for the handler.
 * @method
 */

/**
 * Removes whitespaces between HTML tags.
 *
 * @return {Promise<string>}
 */

/**
 * Render the source map being generated to a string.
 */

/**
 * Renders a template.
 *
 * @param {TwingTemplate} template
 * @param {TwingContext<any, any>} context
 * @param {TwingSource} from
 * @param {TwingOutputBuffer} outputBuffer
 * @param {string | Map<number, string | TwingTemplate>} templates The template to render or an array of templates to try consecutively
 * @param {any} variables The variables to pass to the template
 * @param {boolean} withContext
 * @param {boolean} ignoreMissing Whether to ignore missing templates or not
 * @param {boolean} sandboxed Whether to sandbox the template or not
 *
 * @returns {Promise<string>} The rendered template
 */

/**
 * Replaces strings within a string.
 *
 * @param {string} str String to replace in
 * @param {Array<string>|Map<string, string>} from Replace values
 *
 * @returns {Promise<string>}
 */

/**
 * Represents a block call node.
 *
 * @author Eric MORAND <eric.morand@gmail.com>
 */

/**
 * Represents a body node.
 *
 * @author Eric MORAND <eric.morand@gmail.com>
 */

/**
 * Represents a deprecated node.
 *
 * @author Eric MORAND <eric.morand@gmail.com>
 */

/**
 * Represents a do node.
 *
 * The do tag works exactly like the regular variable expression ({{ ... }}) just that it doesn't print anything:
 * {% do 1 + 2 %}
 *
 * @author Eric MORAND <eric.morand@gmail.com>
 * @author Eric Morand <eric.morand@gmail.com>
 */

/**
 * Represents a macro node.
 *
 * @author Eric MORAND <eric.morand@gmail.com>
 */

/**
 * Represents a module node that compiles into a JavaScript module.
 */

/**
 * Represents a verbatim node.
 *
 * @author Eric Morand <eric.morand@gmail.com>
 */

/**
 * Represents an arrow function.
 */

/**
 * Represents an autoescape node.
 *
 * The value is the escaping strategy (can be html, js, ...)
 *
 * The true value is equivalent to html.
 *
 * If autoescaping is disabled, then the value is false.
 *
 * @author Eric MORAND <eric.morand@gmail.com>
 */

/**
 * Represents an import node.
 *
 * @author Eric MORAND <eric.morand@gmail.com>
 */

/**
 * Resolve or reject a Promise based on response status.
 *
 * @param {Function} resolve A function that resolves the promise.
 * @param {Function} reject A function that rejects the promise.
 * @param {object} response The response.
 *
 * @returns {object} The response.
 */

/**
 * Resolves a relative path that starts with `.`.
 *
 * @param to - path location we are resolving
 * @param from - currentLocation.path, should start with `/`
 */

/**
 * Return how many unique items are in this ArraySet. If duplicates have been
 * added, than those do not count towards the size.
 *
 * @returns Number
 */

/**
 * Return the absolute value of a number.
 *
 * @param {number} x
 * @returns {Promise<number>}
 */

/**
 * Return the string representation of this source node. Walks over the tree
 * and concatenates all the various snippets together to one string.
 */

/**
 * Return the value of a property of an object, providing array to Map conversion.
 *
 * @param {any} object
 * @param {any} property
 */

/**
 * Return the values from a single column in the input array.
 *
 * <pre>
 *  {% set items = [{ 'fruit' : 'apple'}, {'fruit' : 'orange' }] %}
 *
 *  {% set fruits = items|column('fruit') %}
 *
 *  {# fruits now contains ['apple', 'orange'] #}
 * </pre>
 *
 * @param {*} thing An iterable
 * @param {*} columnKey The column key
 *
 * @return {Promise<Array<any>>} The array of values
 */

/**
 * Return true if we have the source content for every source in the source
 * map, false otherwise.
 */

/**
 * Returns a capitalized string.
 *
 * @param {TwingEnvironment} env
 * @param {string | TwingMarkup} string A string
 *
 * @returns {Promise<string>} The capitalized string
 */

/**
 * Returns a new date object modified.
 *
 * <pre>
 *   {{ post.published_at|date_modify("-1day")|date("m/d/Y") }}
 * </pre>
 *
 * @param {TwingTemplate} template
 * @param {DateTime|Duration|string} date A date
 * @param {string} modifier A modifier string
 *
 * @returns {Promise<DateTime>} A new date object
 */

/**
 * Returns a random integer within the range `low .. high` inclusive.
 *
 * @param {Number} low
 *        The lower bound on the range.
 * @param {Number} high
 *        The upper bound on the range.
 */

/**
 * Returns a random value depending on the supplied parameter type:
 * - a random item from a Traversable or array
 * - a random character from a string
 * - a random integer between 0 and the integer parameter.
 *
 * @param {TwingEnvironment} env
 * @param {*} values The values to pick a random item from
 * @param {number} max Maximum value used when values is an integer
 *
 * @throws TwingErrorRuntime when values is an empty array (does not apply to an empty string which is returned as is)
 *
 * @returns {Promise<any>} A random value from the given sequence
 */

/**
 * Returns a template content without rendering it.
 *
 * @param {TwingTemplate} template
 * @param {string} name The template name
 * @param {boolean} ignoreMissing Whether to ignore missing templates or not
 *
 * @return {Promise<string>} The template source
 */

/**
 * Returns a title-cased string.
 *
 * @param {string | TwingMarkup} string A string
 *
 * @returns {Promise<string>} The title-cased string
 */

/**
 * Returns a trimmed string.
 *
 * @returns {Promise<string>}
 *
 * @throws TwingErrorRuntime When an invalid trimming side is used (not a string or not 'left', 'right', or 'both')
 */

/**
 * Returns all generated line and column information for the original source,
 * line, and column provided. If no column is provided, returns all mappings
 * corresponding to a either the line we are searching for or the next
 * closest line that has any mappings. Otherwise, returns all mappings
 * corresponding to the given line and either the column we are searching for
 * or the next closest column that has any offsets.
 *
 * The only argument is an object with the following properties:
 *
 *   - source: The filename of the original source.
 *   - line: The line number in the original source.  The line number is 1-based.
 *   - column: Optional. the column number in the original source.
 *    The column number is 0-based.
 *
 * and an array of objects is returned, each with the following properties:
 *
 *   - line: The line number in the generated source, or null.  The
 *    line number is 1-based.
 *   - column: The column number in the generated source, or null.
 *    The column number is 0-based.
 */

/**
 * Returns the array representation of this set (which has the proper indices
 * indicated by indexOf). Note that this is a copy of the internal array used
 * for storing the members so that no one can mess with internal state.
 */

/**
 * Returns the base 64 VLQ encoded value.
 */

/**
 * Returns the first element of the item.
 *
 * @param {any} item
 *
 * @returns {Promise<any>} The first element of the item
 */

/**
 * Returns the flat, sorted array of mappings. The mappings are sorted by
 * generated position.
 *
 * WARNING: This method returns internal data without copying, for
 * performance. The return value must NOT be mutated, and should be treated as
 * an immutable borrow. If you want to take ownership, you must make your own
 * copy.
 */

/**
 * Returns the generated line and column information for the original source,
 * line, and column positions provided. The only argument is an object with
 * the following properties:
 *
 *   - source: The filename of the original source.
 *   - line: The line number in the original source.  The line number
 *     is 1-based.
 *   - column: The column number in the original source.  The column
 *     number is 0-based.
 *
 * and an object is returned with the following properties:
 *
 *   - line: The line number in the generated source, or null.  The
 *     line number is 1-based. 
 *   - column: The column number in the generated source, or null.
 *     The column number is 0-based.
 */

/**
 * Returns the generated line and column information for the original source,
 * line, and column positions provided. The only argument is an object with
 * the following properties:
 *
 *   - source: The filename of the original source.
 *   - line: The line number in the original source.  The line number
 *     is 1-based.
 *   - column: The column number in the original source.  The column
 *     number is 0-based.
 *   - bias: Either 'SourceMapConsumer.GREATEST_LOWER_BOUND' or
 *     'SourceMapConsumer.LEAST_UPPER_BOUND'. Specifies whether to return the
 *     closest element that is smaller than or greater than the one we are
 *     searching for, respectively, if the exact element cannot be found.
 *     Defaults to 'SourceMapConsumer.GREATEST_LOWER_BOUND'.
 *
 * and an object is returned with the following properties:
 *
 *   - line: The line number in the generated source, or null.  The
 *     line number is 1-based.
 *   - column: The column number in the generated source, or null.
 *     The column number is 0-based.
 */

/**
 * Returns the human representation of a token type.
 *
 * @param {TokenType} type The token type
 * @param {boolean} short Whether to return a short representation or not
 *
 * @returns {string} The string representation
 */

/**
 * Returns the keys for the given array.
 *
 * It is useful when you want to iterate over the keys of an array:
 *
 * <pre>
 *  {% for key in array|keys %}
 *      {# ... #}
 *  {% endfor %}
 * </pre>
 *
 * @param {Array<any>} array An array
 *
 * @returns {Promise<Array<any>>} The keys
 */

/**
 * Returns the last element of the item.
 *
 * @param item A variable
 *
 * @returns The last element of the item
 */

/**
 * Returns the length of a thing.
 *
 * @param {TwingEnvironment} env A TwingEnvironment instance
 * @param {any} thing A thing
 *
 * @returns {Promise<number>} The length of the thing
 */

/**
 * Returns the original source content. The only argument is the url of the
 * original source file. Returns null if no original source content is
 * available.
 */

/**
 * Returns the original source, line, and column information for the generated
 * source's line and column positions provided. The only argument is an object
 * with the following properties:
 *
 *   - line: The line number in the generated source.  The line number
 *     is 1-based.
 *   - column: The column number in the generated source.  The column
 *     number is 0-based.
 *
 * and an object is returned with the following properties:
 *
 *   - source: The original source file, or null.
 *   - line: The line number in the original source, or null.  The
 *     line number is 1-based.
 *   - column: The column number in the original source, or null.  The
 *     column number is 0-based.
 *   - name: The original identifier, or null.
 */

/**
 * Returns the original source, line, and column information for the generated
 * source's line and column positions provided. The only argument is an object
 * with the following properties:
 *
 *   - line: The line number in the generated source.  The line number
 *     is 1-based.
 *   - column: The column number in the generated source.  The column
 *     number is 0-based.
 *   - bias: Either 'SourceMapConsumer.GREATEST_LOWER_BOUND' or
 *     'SourceMapConsumer.LEAST_UPPER_BOUND'. Specifies whether to return the
 *     closest element that is smaller than or greater than the one we are
 *     searching for, respectively, if the exact element cannot be found.
 *     Defaults to 'SourceMapConsumer.GREATEST_LOWER_BOUND'.
 *
 * and an object is returned with the following properties:
 *
 *   - source: The original source file, or null.
 *   - line: The line number in the original source, or null.  The
 *     line number is 1-based.
 *   - column: The column number in the original source, or null.  The
 *     column number is 0-based.
 *   - name: The original identifier, or null.
 */

/**
 * Returns the router instance. Equivalent to using `$router` inside
 * templates.
 */

/**
 * Returns the string representation of this source node along with a source
 * map.
 */

/**
 * Reverse a map
 *
 * @param {Map<* ,*>} map
 * @param {boolean} preserveKeys
 *
 * @returns Map
 */

/**
 * Reverses a variable.
 *
 * @param {string | Map<*, *>} item A traversable instance, or a string
 * @param {boolean} preserveKeys Whether to preserve key or not
 *
 * @returns {Promise<string | Map<any, any>>} The reversed input
 */

/**
 * Rounds a number.
 *
 * @param value The value to round
 * @param {number} precision The rounding precision
 * @param {string} method The method to use for rounding
 *
 * @returns {Promise<number>} The rounded number
 */

/**
 * RouteRecord being rendered by the closest ancestor Router View. Used for
 * `onBeforeRouteUpdate` and `onBeforeRouteLeave`. rvlm stands for Router View
 * Location Matched
 *
 * @internal
 */

/**
 * ScrollBehavior instance used by the router to compute and restore the scroll
 * position when navigating.
 */

/**
 * Sentence case a string.
 *
 * @param  {string} str
 * @param  {string} locale
 * @param  {string} replacement
 * @return {string}
 */

/**
 * Serialize the accumulated mappings in to the stream of base 64 VLQs
 * specified by the source map format.
 */

/**
 * Set the source content for a source file.
 */

/**
 * Set the source content for a source file. This will be added to the SourceMapGenerator
 * in the sourcesContent field.
 *
 * @param aSourceFile The filename of the source file
 * @param aSourceContent The content of the source file
 */

/**
 * Sets the hash `key` to `value`.
 *
 * @private
 * @name set
 * @memberOf Hash
 * @param {string} key The key of the value to set.
 * @param {*} value The value to set.
 * @returns {Object} Returns the hash instance.
 */

/**
 * Sets the list cache `key` to `value`.
 *
 * @private
 * @name set
 * @memberOf ListCache
 * @param {string} key The key of the value to set.
 * @param {*} value The value to set.
 * @returns {Object} Returns the list cache instance.
 */

/**
 * Sets the map `key` to `value`.
 *
 * @private
 * @name set
 * @memberOf MapCache
 * @param {string} key The key of the value to set.
 * @param {*} value The value to set.
 * @returns {Object} Returns the map cache instance.
 */

/**
 * Sets the stack `key` to `value`.
 *
 * @private
 * @name set
 * @memberOf Stack
 * @param {string} key The key of the value to set.
 * @param {*} value The value to set.
 * @returns {Object} Returns the stack cache instance.
 */

/**
 * Settings contains static getters and setters that control Luxon's overall behavior. Luxon is a simple library with few options, but the ones it does have live here.
 */

/**
 * Simple flat clone using prototype, accepts only objects, usefull for property
 * override on FLAT configuration object (no nested props).
 *
 * USE WITH CAUTION! This may not behave as you wish if you do not know how this
 * works.
 */

/**
 * Slices a variable.
 *
 * @param item A variable
 * @param {number} start Start of the slice
 * @param {number} length Size of the slice
 * @param {boolean} preserveKeys Whether to preserve key or not (when the input is an object)
 *
 * @returns {Promise<string | Map<any, any>>} The sliced variable
 */

/**
 * Snake case a string.
 *
 * @param  {string} value
 * @param  {string} [locale]
 * @return {string}
 */

/**
 * Sort a map and maintain index association.
 *
 * @param {Map<*, *>} map
 * @param {Function} handler
 * @returns {Map<* ,*>}
 */

/**
 * Sort a map by key
 *
 * @param {Map<*, *>} map
 * @param {Function} handler
 */

/**
 * Sort the given array in-place with the given comparator function.
 *
 * @param {Array} ary
 *        An array to sort.
 * @param {function} comparator
 *        Function to use to compare two items.
 */

/**
 * Sorts an iterable.
 *
 * @param {Map<any, any>} iterable
 *
 * @returns {Promise<Map<any, any>>}
 */

/**
 * SourceNodes provide a way to abstract over interpolating/concatenating
 * snippets of generated JavaScript source code while maintaining the line and
 * column information associated with the original source code.
 *
 * @param aLine The original line number.
 * @param aColumn The original column number.
 * @param aSource The original source's filename.
 * @param aChunks Optional. An array of strings which are snippets of
 *        generated JS, or other SourceNodes.
 * @param aName The original identifier.
 */

/**
 * Special language-specific overrides.
 *
 * Source: ftp://ftp.unicode.org/Public/UCD/latest/ucd/SpecialCasing.txt
 *
 * @type {Object}
 */

/**
 * Split an hash into chunks.
 *
 * @param {*} hash
 * @param {number} size
 * @param {boolean} preserveKeys
 * @returns {Promise<Array<Map<any, any>>>}
 */

/**
 * Splits the string into an array.
 *
 * <pre>
 *  {{ "one,two,three"|split(',') }}
 *  {# returns [one, two, three] #}
 *
 *  {{ "one,two,three,four,five"|split(',', 3) }}
 *  {# returns [one, two, "three,four,five"] #}
 *
 *  {{ "123"|split('') }}
 *  {# returns [1, 2, 3] #}
 *
 *  {{ "aabbcc"|split('', 2) }}
 *  {# returns [aa, bb, cc] #}
 * </pre>
 *
 * @param {string} value A string
 * @param {string} delimiter The delimiter
 * @param {number} limit The limit
 *
 * @returns {Promise<Array<string>>} The split string as an array
 */

/**
 * Static method for creating ArraySet instances from an existing array.
 */

/**
 * Stringifies a URL object
 *
 * @param stringifyQuery
 * @param location
 */

/**
 * Stringifies a {@link LocationQueryRaw} object. Like `URLSearchParams`, it
 * doesn't prepend a `?`
 *
 * @internal
 *
 * @param query - query object to stringify
 * @returns string version of the query without the leading `?`
 */

/**
 * Strip any JSON XSSI avoidance prefix from the string (as documented
 * in the source maps specification), and then parse the string as
 * JSON.
 */

/**
 * Strips off the base from the beginning of a location.pathname in a non-case-sensitive way.
 *
 * @param pathname - location.pathname
 * @param base - base to strip off
 */

/**
 * Swap the elements indexed by `x` and `y` in the array `ary`.
 *
 * @param {Array} ary
 *        The array.
 * @param {Number} x
 *        The index of the first item.
 * @param {Number} y
 *        The index of the second item.
 */

/**
 * Syntactic sugar for invoking a function and expanding an array for arguments.
 *
 * Common use case would be to use `Function.prototype.apply`.
 *
 *  ```js
 *  function f(x, y, z) {}
 *  var args = [1, 2, 3];
 *  f.apply(null, args);
 *  ```
 *
 * With `spread` this example can be re-written.
 *
 *  ```js
 *  spread(function(x, y, z) {})([1, 2, 3]);
 *  ```
 *
 * @param {Function} callback
 *
 * @returns {Function}
 */

/**
 * SyntaxError
 *  Holds information about bad syntax found in a message pattern
 **/

/**
 * Tests a condition.
 *
 * <pre>
 * {% if users %}
 *  <ul>
 *    {% for user in users %}
 *      <li>{{ user.username|e }}</li>
 *    {% endfor %}
 *  </ul>
 * {% endif %}
 * </pre>
 */

/**
 * The Buffer constructor returns instances of `Uint8Array` that have their
 * prototype changed to `Buffer.prototype`. Furthermore, `Buffer` is a subclass of
 * `Uint8Array`, so the returned instances will have all the node `Buffer` methods
 * and the `Uint8Array` methods. Square bracket notation works as expected -- it
 * returns a single octet.
 *
 * The `Uint8Array` prototype remains unmodified.
 */

/**
 * The Info class contains static methods for retrieving general time and date related data. For example, it has methods for finding out if a time zone has a DST, for listing the months in any supported locale, and for discovering which of Luxon features are available in the current environment.
 */

/**
 * The Quick Sort algorithm.
 *
 * @param {Array} ary
 *        An array to sort.
 * @param {function} comparator
 *        Function to use to compare two items.
 * @param {Number} p
 *        Start index of the array
 * @param {Number} r
 *        End index of the array
 */

/**
 * The base implementation of `_.assignIn` without support for multiple sources
 * or `customizer` functions.
 *
 * @private
 * @param {Object} object The destination object.
 * @param {Object} source The source object.
 * @returns {Object} Returns `object`.
 */

/**
 * The base implementation of `_.assign` without support for multiple sources
 * or `customizer` functions.
 *
 * @private
 * @param {Object} object The destination object.
 * @param {Object} source The source object.
 * @returns {Object} Returns `object`.
 */

/**
 * The base implementation of `_.clone` and `_.cloneDeep` which tracks
 * traversed objects.
 *
 * @private
 * @param {*} value The value to clone.
 * @param {boolean} bitmask The bitmask flags.
 *  1 - Deep clone
 *  2 - Flatten inherited properties
 *  4 - Clone symbols
 * @param {Function} [customizer] The function to customize cloning.
 * @param {string} [key] The key of `value`.
 * @param {Object} [object] The parent object of `value`.
 * @param {Object} [stack] Tracks traversed objects and their clone counterparts.
 * @returns {*} Returns the cloned value.
 */

/**
 * The base implementation of `_.isArguments`.
 *
 * @private
 * @param {*} value The value to check.
 * @returns {boolean} Returns `true` if `value` is an `arguments` object,
 */

/**
 * The base implementation of `_.isMap` without Node.js optimizations.
 *
 * @private
 * @param {*} value The value to check.
 * @returns {boolean} Returns `true` if `value` is a map, else `false`.
 */

/**
 * The base implementation of `_.isNative` without bad shim checks.
 *
 * @private
 * @param {*} value The value to check.
 * @returns {boolean} Returns `true` if `value` is a native function,
 *  else `false`.
 */

/**
 * The base implementation of `_.isSet` without Node.js optimizations.
 *
 * @private
 * @param {*} value The value to check.
 * @returns {boolean} Returns `true` if `value` is a set, else `false`.
 */

/**
 * The base implementation of `_.isTypedArray` without Node.js optimizations.
 *
 * @private
 * @param {*} value The value to check.
 * @returns {boolean} Returns `true` if `value` is a typed array, else `false`.
 */

/**
 * The base implementation of `_.keysIn` which doesn't treat sparse arrays as dense.
 *
 * @private
 * @param {Object} object The object to query.
 * @returns {Array} Returns the array of property names.
 */

/**
 * The base implementation of `_.keys` which doesn't treat sparse arrays as dense.
 *
 * @private
 * @param {Object} object The object to query.
 * @returns {Array} Returns the array of property names.
 */

/**
 * The base implementation of `_.times` without support for iteratee shorthands
 * or max array length checks.
 *
 * @private
 * @param {number} n The number of times to invoke `iteratee`.
 * @param {Function} iteratee The function invoked per iteration.
 * @returns {Array} Returns the array of results.
 */

/**
 * The base implementation of `_.unary` without support for storing metadata.
 *
 * @private
 * @param {Function} func The function to cap arguments for.
 * @returns {Function} Returns the new capped function.
 */

/**
 * The base implementation of `assignValue` and `assignMergeValue` without
 * value checks.
 *
 * @private
 * @param {Object} object The object to modify.
 * @param {string} key The key of the property to assign.
 * @param {*} value The value to assign.
 */

/**
 * The base implementation of `getAllKeys` and `getAllKeysIn` which uses
 * `keysFunc` and `symbolsFunc` to get the enumerable property names and
 * symbols of `object`.
 *
 * @private
 * @param {Object} object The object to query.
 * @param {Function} keysFunc The function to get the keys of `object`.
 * @param {Function} symbolsFunc The function to get the symbols of `object`.
 * @returns {Array} Returns the array of property names and symbols.
 */

/**
 * The base implementation of `getTag` without fallbacks for buggy environments.
 *
 * @private
 * @param {*} value The value to query.
 * @returns {string} Returns the `toStringTag`.
 */

/**
 * The characters pairs recognized as brackets.
 */

/**
 * The list of original sources.
 */

/**
 * The version of the source mapping spec that we are consuming.
 */

/**
 * This allows detecting splats at the end of a path: /home/:id(.*)*
 *
 * @param score - score to check
 * @returns true if the last entry is negative
 */

/**
 * This function is like
 * [`Object.keys`](http://ecma-international.org/ecma-262/7.0/#sec-object.keys)
 * except that it includes inherited enumerable properties.
 *
 * @private
 * @param {Object} object The object to query.
 * @returns {Array} Returns the array of property names.
 */

/**
 * This is a helper function for getting values from parameter/options
 * objects.
 *
 * @param args The object we are extracting values from
 * @param name The name of the property we are getting.
 * @param defaultValue An optional value to return if the property is missing
 * from the object. If this is not specified and the property is missing, an
 * error will be thrown.
 */

/**
 * This is an implementation of binary search which will always try and return
 * the index of the closest element if there is no exact hit. This is because
 * mappings between original and generated line/col pairs are single points,
 * and there is an implicit region between each of them, so a miss just means
 * that you aren't on the very start of a region.
 *
 * @param aNeedle The element you are looking for.
 * @param aHaystack The array that is being searched.
 * @param aCompare A function which takes the needle and an element in the
 *     array and returns -1, 0, or 1 depending on whether the needle is less
 *     than, equal to, or greater than the element, respectively.
 * @param aBias Either 'binarySearch.GREATEST_LOWER_BOUND' or
 *     'binarySearch.LEAST_UPPER_BOUND'. Specifies whether to return the
 *     closest element that is smaller than or greater than the one we are
 *     searching for, respectively, if the exact element cannot be found.
 *     Defaults to 'binarySearch.GREATEST_LOWER_BOUND'.
 */

/**
 * This method calls {@link #item item()}.
 * Returns the item associated with the passed key OR index. Key has priority
 * over index.  This is the equivalent of calling {@link #key} first, then if
 * nothing matched calling {@link #itemAt}.
 * @param {String/Number} key The key or index of the item.
 * @return {Object} If the item is found, returns the item.  If the item was
 * not found, returns <tt>undefined</tt>. If an item was found, but is a Class,
 * returns <tt>null</tt>.
 */

/**
 * This method is like `_.clone` except that it recursively clones `value`.
 *
 * @static
 * @memberOf _
 * @since 1.0.0
 * @category Lang
 * @param {*} value The value to recursively clone.
 * @returns {*} Returns the deep cloned value.
 * @see _.clone
 * @example
 *
 * var objects = [{ 'a': 1 }, { 'b': 2 }];
 *
 * var deep = _.cloneDeep(objects);
 * console.log(deep[0] === objects[0]);
 * // => false
 */

/**
 * This method returns `false`.
 *
 * @static
 * @memberOf _
 * @since 4.13.0
 * @category Util
 * @returns {boolean} Returns `false`.
 * @example
 *
 * _.times(2, _.stubFalse);
 * // => [false, false]
 */

/**
 * This method returns a new empty array.
 *
 * @static
 * @memberOf _
 * @since 4.13.0
 * @category Util
 * @returns {Array} Returns the new empty array.
 * @example
 *
 * var arrays = _.times(2, _.stubArray);
 *
 * console.log(arrays);
 * // => [[], []]
 *
 * console.log(arrays[0] === arrays[1]);
 * // => false
 */

/**
 * Throws a `CanceledError` if cancellation has been requested.
 *
 * @param {Object} config The config that is to be used for the request
 *
 * @returns {void}
 */

/**
 * Transform the data for a request or a response
 *
 * @param {Array|Function} fns A single function or Array of functions
 * @param {?Object} response The response object
 *
 * @returns {*} The resulting transformed data
 */

/**
 * Transforms a URI into a normalized history location
 *
 * @param parseQuery
 * @param location - URI to normalize
 * @param currentLocation - current absolute location. Allows resolving relative
 * paths. Must start with `/`. Defaults to `/`
 * @returns a normalized history location
 */

/**
 * Transforms a queryString into a {@link LocationQuery} object. Accept both, a
 * version with the leading `?` and without Should work as URLSearchParams

 * @internal
 *
 * @param search - search string to parse
 * @returns a query object
 */

/**
 * Transforms a {@link LocationQueryRaw} into a {@link LocationQuery} by casting
 * numbers into strings, removing keys with an undefined value and replacing
 * undefined with null in arrays
 *
 * @param query - query object to normalize
 * @returns a normalized query object
 */

/**
 * Transitional option validator
 *
 * @param {function|boolean?} validator - set to false if the transitional option has been removed
 * @param {string?} version - deprecated version / removed since version
 * @param {string?} message - some message with additional info
 *
 * @returns {function}
 */

/**
 * Trims whitespace from either end of a string, leaving spaces within the string intact.  Example:
 * <pre><code>
var s = '  foo bar  ';
alert('-' + s + '-');         //alerts "- foo bar -"
alert('-' + s.trim() + '-');  //alerts "-foo bar-"
</code></pre>
 * @return {String} The trimmed string
 */

/**
 * Twing base error.
 *
 * @author Eric MORAND <eric.morand@gmail.com>
 */

/**
 * Typesafe alternative to Array.isArray
 * https://github.com/microsoft/TypeScript/pull/48228
 */

/**
 * URL encodes (RFC 3986) a string as a path segment or a hash as a query string.
 *
 * @param {string|{}} url A URL or a hash of query parameters
 *
 * @returns {Promise<string>} The URL encoded value
 */

/**
 * Used to match `RegExp`
 * [syntax characters](http://ecma-international.org/ecma-262/7.0/#sec-patterns).
 */

/**
 * Used to resolve the
 * [`toStringTag`](http://ecma-international.org/ecma-262/7.0/#sec-object.prototype.tostring)
 * of values.
 */

/**
 * Utility class to get the active class based on defaults.
 * @param propClass
 * @param globalClass
 * @param defaultClass
 */

/**
 * Utility function that allows you to easily switch a string between two alternating values.  The passed value
 * is compared to the current string, and if they are equal, the other value that was passed in is returned.  If
 * they are already different, the first value passed in is returned.  Note that this method returns the new value
 * but does not change the current string.
 * <pre><code>
// alternate sort directions
sort = sort.toggle('ASC', 'DESC');

// instead of conditional logic:
sort = (sort == 'ASC' ? 'DESC' : 'ASC');
</code></pre>
 * @param {String} value The value to compare to the current string
 * @param {String} other The new value to use if the string already equals the first value passed in
 * @return {String} The new value
 */

/**
 * Utility function to find the index of a source.  Returns -1 if not
 * found.
 */

/**
 * Walk over the tree of JS snippets in this node and its children. The
 * walking function is called once for each snippet of JS and is passed that
 * snippet and the its original associated source's line/column location.
 *
 * @param aFn The traversal function.
 */

/**
 * Walk over the tree of SourceNodes. The walking function is called for each
 * source file content and is passed the filename and source content.
 *
 * @param aFn The traversal function.
 */

/**
 * What is the element at the given index?
 *
 * @param Number aIdx
 */

/**
 * What is the index of the given string in the array?
 *
 * @param String aStr
 */

/**
 * create record from json string
 *
 * @param {String} json
 * @param {Record} recordClass
 * @returns {Record}
 */

/**
 * formatting information
 **/

/**
 * get combined status
 *
 * @param {CrewScheduling.PollReply[]} pollReplies
 * @returns {string}
 */

/**
 * get event_ref from event
 *
 * NOTE: poll replies could reference to recur event instances before they get saved.
 * *     as recur_id are unique per container only we prefix by base_event_it which makes ref unique
 *
 * @param event
 * @returns {string|*}
 */

/**
 * get translation data from generic locale object (partial clone of Zend Frameworks locale data)
 * 
 * @param   type (Date, Symbol, ...)
 * @param   key  the key
 * @return  translation data
 */

/**
 * get translation list from generic locale object (partial clone of Zend Frameworks locale data)
 * 
 * @param {String} type
 * @return {Object}
 */

/**
 * logging extension (only to console atm.)
 * 
 * NOTE: we extend the console object here so the console writer preserves 
 *       line number and files in its logging output!
 *       
 * @namespace   Ext.ux.log
 * @author      Cornelius Weiss <c.weiss@metaways.de>
 */

/**
 * parse
 *
 * Turns this:
 *  `You have { numBananas, plural,
 *       =0 {no bananas}
 *      one {a banana}
 *    other {# bananas}
 *  } for sale`
 *
 * into this:
 *  [ "You have ", [ "numBananas", "plural", 0, {
 *       "=0": [ "no bananas" ],
 *      "one": [ "a banana" ],
 *    "other": [ [ '#' ], " bananas" ]
 *  } ], " for sale." ]
 *
 * tokens:
 *  [
 *    [ "text", "You have " ],
 *    [ "syntax", "{" ],
 *    [ "space", " " ],
 *    [ "id", "numBananas" ],
 *    [ "syntax", ", " ],
 *    [ "space", " " ],
 *    [ "type", "plural" ],
 *    [ "syntax", "," ],
 *    [ "space", "\n     " ],
 *    [ "selector", "=0" ],
 *    [ "space", " " ],
 *    [ "syntax", "{" ],
 *    [ "text", "no bananas" ],
 *    [ "syntax", "}" ],
 *    [ "space", "\n    " ],
 *    [ "selector", "one" ],
 *    [ "space", " " ],
 *    [ "syntax", "{" ],
 *    [ "text", "a banana" ],
 *    [ "syntax", "}" ],
 *    [ "space", "\n  " ],
 *    [ "selector", "other" ],
 *    [ "space", " " ],
 *    [ "syntax", "{" ],
 *    [ "syntax", "#" ],
 *    [ "text", " bananas" ],
 *    [ "syntax", "}" ],
 *    [ "space", "\n" ],
 *    [ "syntax", "}" ],
 *    [ "text", " for sale." ]
 *  ]
 **/

/**
 * returns a clone of given record (in current window context)
 *
 * @param {Record} record
 * @return {Record}
 */

/**
 * returns the field
 *
 * @param {Object} fieldDefinition
 * @return {Object}
 */

/**
 * type mapping
 * @type {Object}
 */

/**
 Returns the number of milliseconds between this date and date
 @param {Date} date (optional) Defaults to now
 @return {Number} The diff in milliseconds
 @member Date getElapsed
 */

/**
* * https://tools.ietf.org/html/draft-josefsson-eddsa-ed25519-03#section-5.2
*
* EDDSA defines methods for encoding and decoding points and integers. These are
* helper convenience methods, that pass along to utility functions implied
* parameters.
*
*/

/**
* @param {Array|String} message - message bytes
* @param {Array|String|KeyPair} secret - secret bytes or a keypair
* @returns {Signature} - signature
*/

/**
* @param {Array} message - message bytes
* @param {Array|String|Signature} sig - sig bytes
* @param {Array|String|Point|KeyPair} pub - public key
* @returns {Boolean} - true if public key matches sig of message
*/

/**
* @param {EDDSA} eddsa - eddsa instance
* @param {Array<Bytes>|Object} sig -
* @param {Array<Bytes>|Point} [sig.R] - R point as Point or bytes
* @param {Array<Bytes>|bn} [sig.S] - S scalar as bn or bytes
* @param {Array<Bytes>} [sig.Rencoded] - R point encoded
* @param {Array<Bytes>} [sig.Sencoded] - S scalar encoded
*/

/**
* @param {EDDSA} eddsa - instance
* @param {Object} params - public/private key parameters
*
* @param {Array<Byte>} [params.secret] - secret seed bytes
* @param {Point} [params.pub] - public key point (aka `A` in eddsa terms)
* @param {Array<Byte>} [params.pub] - public key point encoded as bytes
*
*/

/**  @private */

/** @ignore */

/** @override **/

/** @private **/

/** @type {Parameters<define>[0]} */

/** @type {import('.')} */

/** @type {import('./eval')} */

/** @type {import('./range')} */

/** @type {import('./ref')} */

/** @type {import('./syntax')} */

/** @type {import('./type')} */

/** @type {import('./uri')} */

/** Built-in constructor references. */

/** Built-in value references. */

/** Detect free variable `exports`. */

/** Detect free variable `global` from Node.js. */

/** Detect free variable `self`. */

/** Used as a safe reference for `undefined` in pre-ES5 environments. */

/** Used as references for various `Number` constants. */

/** Used as the semantic version number. */

/** Used as the size to enable large array optimizations. */

/** Used for built-in method references. */

/** Used to check objects for own properties. */

/** Used to compose bitmasks for cloning. */

/** Used to convert symbols to primitives and strings. */

/** Used to detect methods masquerading as native. */

/** Used to detect overreaching core-js shims. */

/** Used to detect unsigned integer values. */

/** Used to identify `toStringTag` values supported by `_.clone`. */

/** Used to map Latin Unicode letters to basic Latin letters. */

/** Used to map characters to HTML entities. */

/** Used to match `RegExp` flags from their coerced string values. */

/** Used to resolve the decompiled source of functions. */

/** Used to stand-in for `undefined` hash values. */

/** `Object#toString` result references. */

/************************************************************************/

/******/

/***/

/**/

/*------------------------------------------------------------------------*/

/*--------------------------------------------------------------------------*/

/*.*/

/*/*/

/*: 'cardinal' | 'ordinal' */

/*: ?Object */

/*: ?Placeholder */

/*: ?string */

/*: AST */

/*: Context */

/*: GenerateId */

/*: Locales */

/*: Message */

/*: MissingTranslation */

/*: Object */

/*: Placeholder */

/*: Replacement */

/*: SubMessages */

/*: T */

/*: Translations */

/*: Types */

/*: any */

/*: any[] */

/*: boolean */

/*: number */

/*: string */

/*: string | SubMessages */

/*: string | number */

/*: string | string[] | void */

/*: { [string]: any } */

/*::
export type AST = Element[]
export type Element = string | Placeholder
export type Placeholder = Plural | Styled | Typed | Simple
export type Plural = [ string, 'plural' | 'selectordinal', number, SubMessages ]
export type Styled = [ string, string, string | SubMessages ]
export type Typed = [ string, string ]
export type Simple = [ string ]
export type SubMessages = { [string]: AST }
export type Token = [ TokenType, string ]
export type TokenType = 'text' | 'space' | 'id' | 'type' | 'style' | 'offset' | 'number' | 'selector' | 'syntax'
type Context = {|
  pattern: string,
  index: number,
  tagsType: ?string,
  tokens: ?Token[]
|}
*/

/*::
import type {
  AST,
  SubMessages
} from '../format-message-parse'
type Locale = string
type Locales = Locale | Locale[]
type Placeholder = any[] // https://github.com/facebook/flow/issues/4050
export type Type = (Placeholder, Locales) => (any, ?Object) => any
export type Types = { [string]: Type }
*/

/*::
import type { Types } from 'format-message-interpret'
type Locale = string
type Locales = Locale | Locale[]
type Message = string | {|
  id?: string,
  default: string,
  description?: string
|}
type Translations = { [string]: ?{ [string]: string | Translation } }
type Translation = {
  message: string,
  format?: (args?: Object) => string,
  toParts?: (args?: Object) => any[],
}
type Replacement = ?string | (string, string, locales?: Locales) => ?string
type GenerateId = (string) => string
type MissingTranslation = 'ignore' | 'warning' | 'error'
type FormatObject = { [string]: * }
type Options = {
  locale?: Locales,
  translations?: ?Translations,
  generateId?: GenerateId,
  missingReplacement?: Replacement,
  missingTranslation?: MissingTranslation,
  formats?: {
    number?: FormatObject,
    date?: FormatObject,
    time?: FormatObject
  },
  types?: Types
}
type Setup = {|
  locale: Locales,
  translations: Translations,
  generateId: GenerateId,
  missingReplacement: Replacement,
  missingTranslation: MissingTranslation,
  formats: {
    number: FormatObject,
    date: FormatObject,
    time: FormatObject
  },
  types: Types
|}
type FormatMessage = {
  (msg: Message, args?: Object, locales?: Locales): string,
  rich (msg: Message, args?: Object, locales?: Locales): any[],
  setup (opt?: Options): Setup,
  number (value: number, style?: string, locales?: Locales): string,
  date (value: number | Date, style?: string, locales?: Locales): string,
  time (value: number | Date, style?: string, locales?: Locales): string,
  select (value: any, options: Object): any,
  custom (placeholder: any[], locales: Locales, value: any, args: Object): any,
  plural (value: number, offset: any, options: any, locale: any): any,
  selectordinal (value: number, offset: any, options: any, locale: any): any,
  namespace (): FormatMessage
}
*/

/*:: <T: Object> */

/*:: ?: ?string */

/*:: ?: Locales */

/*:: ?: Object */

/*:: ?: Options */

/*:: ?: Types */

/*:: ?: boolean */

/*:: ?: number | Date */

/*:: ?: string */

/*:: ?: { tagsType?: string, tokens?: Token[] } */

/*:: export type Rule = 'zero' | 'one' | 'two' | 'few' | 'many' | 'other' */

/*</replacement>*/

/*<replacement>*/

/*eslint func-names:0*/

/*eslint no-param-reassign:0*/

/*eslint no-undef:0*/

/*global Ext, Tine*/

/*global Ext, Tine, Locale*/

//

// 

// 	Minutes, numeric

// 	Seconds, numeric, at least 2 digits with leading 0

// 	Years, numeric, at least 2 digits with leading 0

//                             i have no idea why i commited here, maybe just because of the id?

//                             let's solve it better the next time!

//                       corresponds to this chunk of generated code,

//                     corresponds to this chunk of generated code,

//                   http://www.ogcio.gov.hk/tc/business/tech_promotion/ccli/terms/doc/hkscs-2008-big5-iso.txt

//                0201-1976 Roman, 0208-1978, 0208-1983.

//               (0xA1-0xFE)x2   - 0208 plane (94x94).

//               0x00-0x7F       - lower part of 0201

//               0x8E, 0xA1-0xDF - upper part of 0201

//               0x8F, (0xA1-0xFE)x2 - 0212 plane (94x94).

//               Q = r^-1 (sR + -eG)

//               Used as-is in ISO2022 family.

//               Windows CP932 is a superset of Shift_JIS. Some companies added more chars, notably KDDI.

//               chunk of code,

//               encoding of 0208. Lead byte ranges: 0x81-0x9F, 0xE0-0xEF; Trail byte ranges: 0x40-0x7E, 0x80-0x9E, 0x9F-0xFC.

//              2 planes, first is superset of 0208, second - revised 0212.

//              Has several variations in 1978, 1983, 1990 and 1997.

//              Introduced in 2000, revised 2004. Some characters are in Unicode Plane 2 (0x2xxxx)

//             code.

//             test: 'skip-3'

//           note 1: For example, a=b=c&d====c

//           note 1: Please be aware that this function

//           note 1: Please be aware that this function expects \

//           note 1: This reflects PHP 5.3/6.0+ behavior

//           note 1: When a particular argument has been passed, and the

//           note 1: When no argument is specified, will put variables in global scope.

//           note 1: charset argument not supported

//           note 1: expects to encode into UTF-8 encoded strings, as found on

//           note 1: pages served as UTF-8

//           note 1: returned value is different parse_str of PHP.

//           note 1: to encode into UTF-8 encoded strings, as found on

//         <= NODE_START -> index of the next node in our trie to process next byte.

//         <= SEQ_START  -> index of the start of a character code sequence, in decodeTableSeq.

//         <= SEQ_START  -> it's an index in encodeTableSeq, see below. The character starts a sequence.

//         == GB18030_CODE -> this is the end of a GB18030 4-byte sequence.

//         == UNASSIGNED -> no conversion found. Output a default char.

//         == UNASSIGNED -> unknown/unassigned sequence.

//         fixed by: Mick@el

//         input by: AJ

//         input by: Brant Messenger (http://www.brantmessenger.com/)

//         input by: Brett Zamir (http://brett-zamir.me)

//         input by: David Pesta (http://davidpesta.com/)

//         input by: Devan Penner-Woelk

//         input by: Dreamer

//         input by: Francois

//         input by: Mailfaker (http://www.weedem.fr/)

//         input by: Michael Grier

//         input by: Ratheous

//         input by: ReverseSyntax

//         input by: Rick Waldron

//         input by: Scott Cariss

//         input by: Slawomir Kaniecki

//         input by: Steve Hilder

//         input by: Zaide (http://zaidesthings.com/)

//         input by: felix

//         input by: jeicquest

//         input by: travc

//        example 1: array_rand( ['Kevin'], 1 )

//        example 1: convert_uuencode("test\ntext text\r\n")

//        example 1: htmlspecialchars("<a href='test'>Test</a>", 'ENT_QUOTES')

//        example 1: htmlspecialchars_decode("<p>this -&gt; &quot;</p>", 'ENT_NOQUOTES')

//        example 1: levenshtein('Kevin van Zonneveld', 'Kevin van Sommeveld')

//        example 1: parse_str('first=foo&second=bar', $arr)

//        example 1: rawurlencode('Kevin van Zonneveld!')

//        example 1: stripslashes('Kevin\'s code')

//        example 1: strnatcasecmp(10, 1)

//        example 1: strnatcmp('abc', 'abc')

//        example 1: strncmp('aaa', 'aab', 2)

//        example 1: strrev('Kevin van Zonneveld')

//        example 1: urlencode('Kevin van Zonneveld!')

//        example 1: var $arr = {}

//        example 1: var $result = $arr

//        example 1: vprintf("%01.2f", 123.1)

//        example 2: htmlspecialchars("ab\"c'd", ['ENT_NOQUOTES', 'ENT_QUOTES'])

//        example 2: htmlspecialchars_decode("&amp;quot;")

//        example 2: levenshtein("carrrot", "carrots")

//        example 2: parse_str('str_a=Jack+and+Jill+didn%27t+see+the+well.', $arr)

//        example 2: rawurlencode('http://kvz.io/')

//        example 2: stripslashes('Kevin\\\'s code')

//        example 2: strnatcasecmp('1', '10')

//        example 2: strnatcmp('a', 'b')

//        example 2: strncmp('aaa', 'aab', 3 )

//        example 2: strrev('a\u0301haB')

//        example 2: urlencode('http://kvz.io/')

//        example 2: var $arr = {}

//        example 2: var $result = $arr

//        example 3: htmlspecialchars('my "&entity;" is still here', null, null, false)

//        example 3: levenshtein("carrrot", "carrots", 2, 3, 4)

//        example 3: parse_str('a[b]["c"]=def&a[q]=t+5', $abc)

//        example 3: rawurlencode('http://www.google.nl/search?q=Locutus&ie=utf-8')

//        example 3: strnatcmp('10', '1')

//        example 3: strrev('A\uD87E\uDC04Z')

//        example 3: urlencode('http://www.google.nl/search?q=Locutus&ie=utf-8')

//        example 3: var $abc = {3:'a'}

//        example 3: var $result = $abc

//        example 4: parse_str('a[][]=value', $arr)

//        example 4: strnatcmp('0000abc', '0abc')

//        example 4: var $arr = {}

//        example 4: var $result = $arr

//        example 5: parse_str('a=1&a[]=2', $arr)

//        example 5: strnatcmp('1239', '12345')

//        example 5: var $arr = {}

//        example 5: var $result = $arr

//        example 6: strnatcmp('t01239', 't012345')

//        example 7: strnatcmp('0A', '5N')

//        returns 1: "0=&5S=`IT97AT('1E>'0-\"@\n`\n"

//        returns 1: "Kevin's code"

//        returns 1: '&lt;a href=&#039;test&#039;&gt;Test&lt;/a&gt;'

//        returns 1: '0'

//        returns 1: '<p>this -> &quot;</p>'

//        returns 1: 'Kevin%20van%20Zonneveld%21'

//        returns 1: 'Kevin+van+Zonneveld%21'

//        returns 1: 'dlevennoZ nav niveK'

//        returns 1: 0

//        returns 1: 1

//        returns 1: 3

//        returns 1: 6

//        returns 1: { first: 'foo', second: 'bar' }

//        returns 2: "Kevin\'s code"

//        returns 2: '&quot;'

//        returns 2: 'Baha\u0301' // combining

//        returns 2: 'ab"c&#039;d'

//        returns 2: 'http%3A%2F%2Fkvz.io%2F'

//        returns 2: -1

//        returns 2: 2

//        returns 2: { str_a: "Jack and Jill didn't see the well." }

//        returns 3: 'Z\uD87E\uDC04A' // surrogates

//        returns 3: 'http%3A%2F%2Fwww.google.nl%2Fsearch%3Fq%3DLocutus%26ie%3Dutf-8'

//        returns 3: 'my &quot;&entity;&quot; is still here'

//        returns 3: 1

//        returns 3: 6

//        returns 3: {"3":"a","a":{"b":{"c":"def"},"q":"t 5"}}

//        returns 4: 0

//        returns 4: {"a":{"0":{"0":"value"}}}

//        returns 5: -1

//        returns 5: {"a":{"0":"2"}}

//        returns 6: 1

//        returns 7: -1

//        test: skip-2

//        test: skip-3 skip-4 skip-5 skip-6 skip-7

//       'https://github.com/crypto-browserify/crypto-browserify'

//       'sorry, ' + name + ' is not implemented yet',

//       'we accept pull requests',

//       2) `positive` is true if unsigned mod is requested

//       discuss at: http://locutus.io/php/array_rand/

//       discuss at: http://locutus.io/php/convert_uuencode/

//       discuss at: http://locutus.io/php/htmlspecialchars/

//       discuss at: http://locutus.io/php/htmlspecialchars_decode/

//       discuss at: http://locutus.io/php/levenshtein/

//       discuss at: http://locutus.io/php/parse_str/

//       discuss at: http://locutus.io/php/rawurlencode/

//       discuss at: http://locutus.io/php/stripslashes/

//       discuss at: http://locutus.io/php/strnatcasecmp/

//       discuss at: http://locutus.io/php/strnatcmp/

//       discuss at: http://locutus.io/php/strncmp/

//       discuss at: http://locutus.io/php/strrev/

//       discuss at: http://locutus.io/php/urlencode/

//       discuss at: http://locutus.io/php/vprintf/

//       for focus to work (e.g. iOS dosn't show keyborad)

//       generatedColumn: The column number in the generated code,

//       generatedLine: The line number in the generated code,

//       name: The name of the original symbol which generated this chunk of

//       originalColumn: The column number in the original source that

//       originalLine: The line number in the original source that

//       request both div & mod

//       revised by: Andrea Giammarchi (http://webreflection.blogspot.com)

//       revised by: Kevin van Zonneveld (http://kvz.io)

//       revised by: gorthaur

//       source: The path to the original source file that generated this

//       to `div` to request div only, or be absent to

//      bugfixed by: Arno

//      bugfixed by: Brett Zamir (http://brett-zamir.me)

//      bugfixed by: Joris

//      bugfixed by: Kevin van Zonneveld (http://kvz.io)

//      bugfixed by: MIO_KODUKI (http://mio-koduki.blogspot.com/)

//      bugfixed by: Mateusz "loonquawl" Zalega

//      bugfixed by: Nathan

//      bugfixed by: Onno Marsman (https://twitter.com/onnomarsman)

//      bugfixed by: Rafał Kukawski

//      bugfixed by: stag019

//      element than the one we are searching for, so we return -1.

//      improved by: Ates Goral (http://magnetiq.com)

//      improved by: Brett Zamir (http://brett-zamir.me)

//      improved by: Jack

//      improved by: Kevin van Zonneveld (http://kvz.io)

//      improved by: Lars Fischer

//      improved by: Michael White (http://getsprink.com)

//      improved by: Waldo Malqui Silva (https://fayr.us/waldo/)

//      improved by: marrtins

//      improved by: rezna

//      note 1: "original type" as numeric.

//      note 1: - code more compliant with developer guidelines

//      note 1: - for implementing PHP constant arguments look at

//      note 1: 1.0 is simplified to 1 before it can be accessed by the function, this makes

//      note 1: Assumes and converts to Unicode strings with character

//      note 1: C and en for LC_MONETARY/LC_NUMERIC; en for LC_COLLATE

//      note 1: Case-insensitive version of str_replace()

//      note 1: Compliant with PHP 5.0 str_ireplace() Full details at:

//      note 1: Consider using http://demo.icu-project.org/icu-bin/locexp as basis for localization (as in i18n_loc_set_default())

//      note 1: Great work. Ideas for improvement:

//      note 1: Handles rare Unicode characters if 'unicode.semantics' ini (PHP6) is set to 'on'

//      note 1: I have removed this behavior in favor of just calling `console.log`

//      note 1: IE does not allow deleting and re-adding of properties without caching

//      note 1: If the value is null, key and value are skipped in the

//      note 1: Important note: Per the ECMAScript specification,

//      note 1: In 1.3.2 and earlier, this function wrote to the body of the document when it

//      note 1: Is extensible, but currently only implements locales en,

//      note 1: It has been decided that we're not going to add global

//      note 1: Keep in mind that in accordance with PHP, the whole string is buffered and then

//      note 1: List of locales at <http://demo.icu-project.org/icu-bin/locexp>

//      note 1: Long code cause we're aiming for maximum PHP compatibility

//      note 1: May look like overkill, but in order to be truly faithful to handling all Unicode

//      note 1: One could easily represent (or convert the results) of a

//      note 1: Precision 'n' can be adjusted as desired

//      note 1: Relies on file_get_contents which does not work in the browser, so Node only.

//      note 1: Renamed in PHP6 from locale_get_default(). Not listed yet at php.net.

//      note 1: Returns < 0 if str1 is less than str2 ; > 0

//      note 1: See the commented out code below for a version which

//      note 1: Since I can't imageine a complelling use-case for this, and XUL is deprecated

//      note 1: Since JS objects' keys are always strings, and (the

//      note 1: Sorry about the crippled test. Needed because precision differs accross platforms.

//      note 1: The countObj parameter (optional) if used must be passed in as a

//      note 1: The examples are correct, this is a new way

//      note 1: The ini values must be set by ini_set or manually within an ini file

//      note 1: This depends on setlocale having the appropriate

//      note 1: This function deviates from PHP in returning a copy of the array instead

//      note 1: This involved >100 lines of boilerplate to do this in a safe way.

//      note 1: This will not set a global_value or access level for the ini item

//      note 1: To be usable with sort() if it is passed the `SORT_LOCALE_STRING`

//      note 1: Use tab and newline as tokenizing characters as well

//      note 1: Uses global: locutus to store locale info

//      note 1: We show double backslashes in the return value example

//      note 1: as in PHP

//      note 1: behavior by default if IE ever does allow it; only gives shallow copy since

//      note 1: but counts the number of characters, something like this is really necessary.

//      note 1: characters and to this function in PHP which does not count the number of bytes

//      note 1: chooses to create the constants themselves.

//      note 1: code below because a JavaScript string will not

//      note 1: code equivalents of the same numbers as in the from or

//      note 1: currently has no clear binary data type, we chose to use strings

//      note 1: default) SORT_REGULAR flag distinguishes by key type,

//      note 1: dependencies to Locutus, meaning the constants are not

//      note 1: en_US, en_GB, en_AU, fr, and fr_CA for LC_TIME only; C for LC_CTYPE;

//      note 1: flexibility & compatibility possible

//      note 1: function is compatible with PHP 5.2 and older

//      note 1: get the PHP behavior, but use this only if you are in an environment

//      note 1: hashed. If available, we'd recommend using Node's native crypto modules directly

//      note 1: http://ca3.php.net/manual/en/function.str-ireplace.php

//      note 1: http_build_query of PHP while in locutus they are not.

//      note 1: if str1 is greater than str2, and 0 if they are equal.

//      note 1: if the content is a numeric string, we treat the

//      note 1: in a steaming fashion for faster and more efficient hashing

//      note 1: is by reference in PHP anyways

//      note 1: it different from the PHP implementation. We can't fix this unfortunately.

//      note 1: locale (these examples use 'en_US')

//      note 1: object. The count will then be written by reference into it's `value` property

//      note 1: objects may not always iterate in a predictable order

//      note 1: of acting by reference and returning true; this was necessary because

//      note 1: of property position; you can set the ini of "locutus.sortByReference" to true to

//      note 1: property deletion is supported. Note that we intend to implement the PHP

//      note 1: real constants, but strings instead. Integers are also supported if someone

//      note 1: render them as backslashes otherwise

//      note 1: should be treated as actual Unicode, since the PHP function

//      note 1: sorting flag: http://php.net/manual/en/function.sort.php

//      note 1: srand() function)

//      note 1: string form as arrays of code points instead but since JavaScript

//      note 1: such as Firefox extensions where for-in iteration order is fixed and true

//      note 1: target character set; Note that neither the input or output

//      note 1: the pathinfo() function, it offers the greatest

//      note 1: this is original by does not either

//      note 1: was called in webbrowsers, in addition to supporting XUL.

//      note 1: will work with our experimental (though probably unnecessary)

//      note 2: Keep in mind that in accordance with PHP, the whole file is buffered and then

//      note 2: The countObj parameter (optional) if used must be passed in as a

//      note 2: This feature will not work in Node and hence is Browser-only

//      note 2: This function tries to establish the locale via the `window` global.

//      note 2: You'll see functions depends on `echo` instead of `console.log` as we'll want

//      note 2: efficient hashing

//      note 2: hashed. We'd recommend Node's native crypto modules for faster and more

//      note 2: object. The count will then be written by reference into it's `value` property

//      note 2: to have 1 contact point to interface with the outside world, so that it's easy

//      note 2: to support other ways of printing output.

//      original by: Ash Searle (http://hexmen.com/blog/)

//      original by: Brett Zamir (http://brett-zamir.me)

//      original by: Cagri Ekin

//      original by: Carlos R. L. Rodrigues (http://www.jsfromhell.com)

//      original by: Kevin van Zonneveld (http://kvz.io)

//      original by: Martijn Wieringa

//      original by: Martin Pool

//      original by: Mirek Slugen

//      original by: Ole Vrijenhoek

//      original by: Philip Peterson

//      original by: Waldo Malqui Silva (http://waldo.malqui.info)

//      the next-closest element.

//     #addition-add-2007-bl

//     #addition-add-2008-bbjlp

//     #addition-add-2008-hwcd-3

//     #doubling-dbl-2007-bl

//     #doubling-dbl-2008-bbjlp

//     #doubling-dbl-2008-hwcd

//     #doubling-dbl-2009-l

//     #doubling-mdbl-2007-bl

//     ].join('\n'))

//     throw new Error([

//     {

//     }

//    Great discussion & recap of what's going on https://bugzilla.mozilla.org/show_bug.cgi?id=912470#c31

//    Implementations are not consistent within browsers; sometimes labeled as just big5.

//    In the encoder, it might make sense to support encoding old PUA mappings to Big5 bytes seq-s.

//    MS Internet Explorer switches from big5 to big5-hkscs when a patch applied.

//    Official spec: http://www.ogcio.gov.hk/en/business/tech_promotion/ccli/terms/doc/2003cmp_2008.txt

//    Plus, it has 4 combining sequences.

//    Seems that Mozilla refused to support it for 10 yrs. https://bugzilla.mozilla.org/show_bug.cgi?id=162431 https://bugzilla.mozilla.org/show_bug.cgi?id=310299

//    another readable later.

//    because big5-hkscs is the only encoding to include astral characters in non-algorithmic way.

//    buffer.fill(buffer[, offset[, end]])

//    buffer.fill(number[, offset[, end]])

//    buffer.fill(string[, offset[, end]][, encoding])

//    care of it.

//    input by: Alan C

//    input by: Alex

//    input by: Amir Habibi (http://www.residence-mixte.com/)

//    input by: Amirouche

//    input by: Bjorn Roesbeke (http://www.bjornroesbeke.be/)

//    input by: Bobby Drake

//    input by: Brett Zamir (http://brett-zamir.me)

//    input by: Brian Tafoya (http://www.premasolutions.com/)

//    input by: Bug?

//    input by: Denny Wardhana

//    input by: Dreamer

//    input by: DxGx

//    input by: Erkekjetter

//    input by: Evertjan Garretsen

//    input by: Frank Forte

//    input by: Greenseed

//    input by: Hans Henrik (http://hanshenrik.tk/)

//    input by: JB

//    input by: James (http://www.james-bell.co.uk/)

//    input by: Jason Wong (http://carrot.org/)

//    input by: Jay Klehr

//    input by: Josep Sanz (http://www.ws3.es/)

//    input by: Kheang Hok Chin (http://www.distantia.ca/)

//    input by: Kirk Strobeck

//    input by: Kongo

//    input by: Marc Palau

//    input by: Marco van Oort

//    input by: Nate

//    input by: Nick Kolosov (http://sammy.ru)

//    input by: Oleg Eremeev

//    input by: Onno Marsman (https://twitter.com/onnomarsman)

//    input by: Paulo Freitas

//    input by: Pul

//    input by: Ratheous

//    input by: Robin

//    input by: Steve Hilder

//    input by: Taras Bogach

//    input by: William

//    input by: daniel airton wermann (http://wermann.com.br)

//    input by: ger

//    input by: incidence

//    input by: josh

//    input by: jpfle

//    input by: meo

//    input by: nord_ua

//    input by: pilus

//    input by: rem

//    input by: saulius

//    input by: uestla

//    many unicode code points moved from PUA to Supplementary plane (U+2XXXX) over the years.

//    new URL(sourceURL, sourceMapURL).toString()

//    or as double (for e,f,g) instead of float or wchar_t instead of char

//   'createCredentials'

//   'data' event.

//   'router-link-inactive'

//   * Every element in `ary[i+1 .. j-1]` is greater than the pivot.

//   * Every element in `ary[p .. i]` is less than or equal to the pivot.

//   * it has no body

//   * it has no macros

//   * it has no parent

//   // can take an extended ScrollPositionEntry

//   // returns a scroll position that can be saved in history

//   1. We find the exact element we are looking for.

//   101011

//   2. We did not find the exact element, but we can return the index of

//   3. We did not find the exact element, and there is no next-closest

//   : 0

//   : aScore.length > bScore.length

//   ? -1

//   ? 1

//   Continuation

//   If the sources are not absolute URLs after prepending of the

//   Line 4: An optional source root, useful for relocating source

//   SourceMap (like resolving script src in a html document).

//   V    V

//   _example 3: addcslashes("@a\u0000\u0010\u00A9", "\0..\37!@\177..\377"); // Escape as octals those specified and less than 32 (0x20) or greater than 126 (0x7E), but not otherwise

//   _example 4: addcslashes("\u0020\u007E", "\40..\175"); // Those between 32 (0x20 or 040) and 126 (0x7E or 0176) decimal value will be backslashed if specified (not octalized)

//   _example 5: addcslashes("\r\u0007\n", '\0..\37'); // Recognize C escape sequences if specified

//   _example 6: addcslashes("\r\u0007\n", '\0'); // Do not recognize C escape sequences if not specified

//   _returns 3: '\\@a\\000\\020\\302\\251'

//   _returns 4: '\\ ~'

//   _returns 5: "\\r\\a\\n"

//   _returns 6: "\r\u0007\n"

//   call read here would abort the flow and there's no other mechanism for

//   called push() with new data. In this case we skip performing more

//   case where the the stream has called the implementation defined _read()

//   color: 0xea5455,

//   compute(): ScrollPositionEntry

//   compute: computeScroll,

//   continuing the flow if the stream consumer has just subscribed to the

//   enough for the UTF-16 encoding (JavaScript internal use), to

//   entries in the “source” field.

//   example 1: (acos(0.3) + '').substr(0, 17)

//   example 1: (asin(0.3) + '').substr(0, 17)

//   example 1: Math.ceil(cos(8723321.4) * 10000000)

//   example 1: Math.ceil(sin(8723321.4) * 10000000)

//   example 1: Math.ceil(tan(8723321.4) * 10000000)

//   example 1: abs(4.2)

//   example 1: acosh(8723321.4)

//   example 1: addcslashes('foo[ ]', 'A..z'); // Escape all ASCII within capital A to lower z range, including square brackets

//   example 1: addslashes("kevin's birthday")

//   example 1: array_chunk(['Kevin', 'van', 'Zonneveld'], 2)

//   example 1: array_merge($arr1, $arr2)

//   example 1: asinh(8723321.4)

//   example 1: atan(8723321.4)

//   example 1: atan2(1, 1)

//   example 1: atanh(0.3)

//   example 1: base_convert('A37334', 16, 2)

//   example 1: bin2hex('Kev')

//   example 1: bindec('110011')

//   example 1: ceil(8723321.4)

//   example 1: chr(65536) === '\uD800\uDC00'

//   example 1: chr(75) === 'K'

//   example 1: chunk_split('Hello world!', 1, '*')

//   example 1: convert_cyr_string(String.fromCharCode(214), 'k', 'w').charCodeAt(0) === 230; // Char. 214 of KOI8-R gives equivalent number value 230 in win1251

//   example 1: cosh(-0.18127180117607017)

//   example 1: count_chars("Hello World!", 3)

//   example 1: ctype_alpha('Az')

//   example 1: decbin(12)

//   example 1: dechex(10)

//   example 1: decoct(15)

//   example 1: deg2rad(45)

//   example 1: echo('Hello world')

//   example 1: exp(0.3)

//   example 1: explode(' ', 'Kevin van Zonneveld')

//   example 1: expm1(1e-15)

//   example 1: floor(8723321.4)

//   example 1: fmod(5.7, 1.3)

//   example 1: get_html_translation_table('HTML_SPECIALCHARS')

//   example 1: getenv('LC_ALL')

//   example 1: getrandmax()

//   example 1: hex2bin('44696d61')

//   example 1: hexdec('that')

//   example 1: html_entity_decode('Kevin &amp; van Zonneveld')

//   example 1: htmlentities('Kevin & van Zonneveld')

//   example 1: http_build_query({foo: 'bar', php: 'hypertext processor', baz: 'boom', cow: 'milk'}, '', '&amp;')

//   example 1: hypot(3, 4)

//   example 1: i18n_loc_get_default()

//   example 1: implode(' ', ['Kevin', 'van', 'Zonneveld'])

//   example 1: ini_get('date.timezone')

//   example 1: ini_set('date.timezone', 'America/Chicago')

//   example 1: ini_set('date.timezone', 'Asia/Hong_Kong')

//   example 1: is_bool(false)

//   example 1: is_finite(Infinity)

//   example 1: is_float(186.31)

//   example 1: is_infinite(Infinity)

//   example 1: is_nan(NaN)

//   example 1: is_scalar(186.31)

//   example 1: krsort($data)

//   example 1: lcfirst('Kevin Van Zonneveld')

//   example 1: localeconv()

//   example 1: log(8723321.4, 7)

//   example 1: log10(10)

//   example 1: log1p(1e-15)

//   example 1: ltrim('    Kevin van Zonneveld    ')

//   example 1: max(1, 3, 5, 6, 7)

//   example 1: md5('Kevin van Zonneveld')

//   example 1: md5_file('test/never-change.txt')

//   example 1: metaphone('Gnu')

//   example 1: min(1, 3, 5, 6, 7)

//   example 1: money_format('%i', 1234.56)

//   example 1: mt_getrandmax()

//   example 1: mt_rand(1, 1)

//   example 1: nl2br('Kevin\nvan\nZonneveld')

//   example 1: number_format(1234.56)

//   example 1: octdec('77')

//   example 1: ord('K')

//   example 1: pi(8723321.4)

//   example 1: pow(8723321.4, 7)

//   example 1: printf("%01.2f", 123.1)

//   example 1: quoted_printable_encode('a=b=c')

//   example 1: quotemeta(". + * ? ^ ( $ )")

//   example 1: rad2deg(3.141592653589793)

//   example 1: rand(1, 1)

//   example 1: range ( 0, 12 )

//   example 1: round(1241757, -3)

//   example 1: rtrim('    Kevin van Zonneveld    ')

//   example 1: setlocale('LC_ALL', 'en_US')

//   example 1: sha1('Kevin van Zonneveld')

//   example 1: sha1_file('test/never-change.txt')

//   example 1: similar_text('Hello World!', 'Hello locutus!')

//   example 1: sinh(-0.9834330348825909)

//   example 1: soundex('Kevin')

//   example 1: sprintf("%01.2f", 123.1)

//   example 1: sqrt(8723321.4)

//   example 1: sscanf('SN/2350001', 'SN/%d')

//   example 1: str_getcsv('"abc","def","ghi"')

//   example 1: str_ireplace('M', 'e', 'name')

//   example 1: str_pad('Kevin van Zonneveld', 30, '-=', 'STR_PAD_LEFT')

//   example 1: str_repeat('-=', 10)

//   example 1: str_replace(' ', '.', 'Kevin van Zonneveld')

//   example 1: str_rot13('Kevin van Zonneveld')

//   example 1: str_split('Hello Friend', 3)

//   example 1: str_word_count("Hello fri3nd, you're\r\n       looking          good today!", 1)

//   example 1: strcasecmp('Hello', 'hello')

//   example 1: strcmp( 'waldo', 'owald' )

//   example 1: strcoll('a', 'b')

//   example 1: strcspn('abcdefg123', '1234567890')

//   example 1: strip_tags('<p>Kevin</p> <br /><b>van</b> <i>Zonneveld</i>', '<i><b>')

//   example 1: stripos('ABC', 'a')

//   example 1: stristr('Kevin van Zonneveld', 'Van')

//   example 1: strlen('Kevin van Zonneveld')

//   example 1: strncasecmp('Price 12.9', 'Price 12.15', 2)

//   example 1: strpbrk('This is a Simple text.', 'is')

//   example 1: strpos('Kevin van Zonneveld', 'e', 5)

//   example 1: strrchr("Line 1\nLine 2\nLine 3", 10).substr(1)

//   example 1: strripos('Kevin van Zonneveld', 'E')

//   example 1: strrpos('Kevin van Zonneveld', 'e')

//   example 1: strspn('42 is the answer, what is the question ...', '1234567890')

//   example 1: strstr('Kevin van Zonneveld', 'van')

//   example 1: strtolower('Kevin van Zonneveld')

//   example 1: strtoupper('Kevin van Zonneveld')

//   example 1: strtr('hi all, I said hello', $trans)

//   example 1: substr('abcdef', 0, -1)

//   example 1: substr_compare("abcde", "bc", 1, 2)

//   example 1: substr_count('Kevin van Zonneveld', 'e')

//   example 1: substr_replace('ABCDEFGH:/MNRPQR/', 'bob', 0)

//   example 1: tanh(5.4251848798444815)

//   example 1: trim('    Kevin van Zonneveld    ')

//   example 1: ucfirst('kevin van zonneveld')

//   example 1: ucwords('kevin van  zonneveld')

//   example 1: utf8_encode('Kevin van Zonneveld')

//   example 1: var $arr1 = {"color": "red", 0: 2, 1: 4}

//   example 1: var $arr2 = {0: "a", 1: "b", "color": "green", "shape": "trapezoid", 2: 4}

//   example 1: var $b = ''

//   example 1: var $data = {d: 'lemon', a: 'orange', b: 'banana', c: 'apple'}

//   example 1: var $result = $b

//   example 1: var $result = $data

//   example 1: var $result = $rnd >= 0 && $rnd <= 1

//   example 1: var $result = $shuffled.length

//   example 1: var $rnd = lcg_value()

//   example 1: var $shuffled = str_shuffle("abcdef")

//   example 1: var $string = "\t\t\t\nThis is\tan example\nstring\n"

//   example 1: var $tok = strtok($string, " \n\t")

//   example 1: var $trans = {'hello' : 'hi', 'hi' : 'hello'}

//   example 1: var_export(null)

//   example 1: while ($tok !== false) {$b += "Word="+$tok+"\n"; $tok = strtok(" \n\t");}

//   example 1: wordwrap('Kevin van Zonneveld', 6, '|', true)

//   example 2: abs(-4.2)

//   example 2: addcslashes("zoo['.']", 'z..A'); // Only escape z, period, and A here since not a lower-to-higher range

//   example 2: array_chunk(['Kevin', 'van', 'Zonneveld'], 2, true)

//   example 2: array_merge($arr1, $arr2)

//   example 2: bin2hex(String.fromCharCode(0x00))

//   example 2: bindec('000110011')

//   example 2: chunk_split('Hello world!', 10, '*')

//   example 2: count_chars("Hello World!", 1)

//   example 2: decbin(26)

//   example 2: dechex(47)

//   example 2: decoct(264)

//   example 2: hex2bin('00')

//   example 2: hexdec('a0')

//   example 2: html_entity_decode('&amp;lt;')

//   example 2: htmlentities("foo'bar","ENT_QUOTES")

//   example 2: http_build_query({'php': 'hypertext processor', 0: 'foo', 1: 'bar', 2: 'baz', 3: 'boom', 'cow': 'milk'}, 'myvar_')

//   example 2: hypot([], 'a')

//   example 2: i18n_loc_get_default()

//   example 2: i18n_loc_set_default('pt_PT')

//   example 2: implode(' ', {first:'Kevin', last: 'van Zonneveld'})

//   example 2: ini_set('locutus.sortByReference', true)

//   example 2: ini_set('unicode.semantics', 'on')

//   example 2: is_bool(0)

//   example 2: is_finite(-Infinity)

//   example 2: is_infinite(-Infinity)

//   example 2: is_nan(0)

//   example 2: is_scalar({0: 'Kevin van Zonneveld'})

//   example 2: krsort($data)

//   example 2: log10(1)

//   example 2: max([2, 4, 5])

//   example 2: metaphone('bigger')

//   example 2: min([2, 4, 5])

//   example 2: money_format('%14#8.2n', 1234.5678)

//   example 2: nl2br("\nOne\nTwo\n\nThree\n", false)

//   example 2: number_format(1234.56, 2, ',', ' ')

//   example 2: ord('\uD800\uDC00'); // surrogate pair to create a single Unicode character

//   example 2: quoted_printable_encode('abc   \r\n123   \r\n')

//   example 2: range( 0, 100, 10 )

//   example 2: round(3.6)

//   example 2: similar_text('Hello World!', null)

//   example 2: soundex('Ellery')

//   example 2: sprintf("[%10s]", 'monkey')

//   example 2: sscanf('SN/2350001', 'SN/%d', myVar)

//   example 2: str_getcsv('"row2""cell1","row2cell2","row2cell3"', null, null, '"')

//   example 2: str_ireplace('M', 'e', 'name', $countObj)

//   example 2: str_pad('Kevin van Zonneveld', 30, '-', 'STR_PAD_BOTH')

//   example 2: str_replace(['{name}', 'l'], ['hello', 'm'], '{name}, lars')

//   example 2: str_rot13('Xriva ina Mbaariryq')

//   example 2: str_word_count("Hello fri3nd, you're\r\n       looking          good today!", 2)

//   example 2: strcmp( 'owald', 'waldo' )

//   example 2: strcspn('123abc', '1234567890')

//   example 2: strip_tags('<p>Kevin <img src="someimage.png" onmouseover="someFunction()">van <i>Zonneveld</i></p>', '<p>')

//   example 2: stristr('Kevin van Zonneveld', 'VAN', true)

//   example 2: strlen('A\ud87e\udc04Z')

//   example 2: strncasecmp('Price 12.09', 'Price 12.15', 10)

//   example 2: strrpos('somepage.com', '.', false)

//   example 2: strspn('foo', 'o', 1, 2)

//   example 2: strstr('Kevin van Zonneveld', 'van', true)

//   example 2: strtr('äaabaåccasdeöoo', 'äåö','aao')

//   example 2: substr(2, 0, -6)

//   example 2: substr_count('Kevin van Zonneveld', 'K', 1)

//   example 2: substr_replace($var, 'bob', 0, $var.length)

//   example 2: trim('Hello World', 'Hdle')

//   example 2: ucwords('HELLO WORLD')

//   example 2: var $arr1 = []

//   example 2: var $arr2 = {1: "data"}

//   example 2: var $countObj = {}

//   example 2: var $data = {2: 'van', 3: 'Zonneveld', 1: 'Kevin'}

//   example 2: var $result = $countObj.value

//   example 2: var $result = $data

//   example 2: var $result = myVar.value

//   example 2: var $var = 'ABCDEFGH:/MNRPQR/'

//   example 2: var myVar = {}

//   example 2: var_export({0: 'Kevin', 1: 'van', 2: 'Zonneveld'}, true)

//   example 2: wordwrap('The quick brown fox jumped over the lazy dog.', 20, '<br />\n')

//   example 3: abs(-5)

//   example 3: array_chunk({1:'Kevin', 2:'van', 3:'Zonneveld'}, 2)

//   example 3: bindec('111')

//   example 3: decbin('26')

//   example 3: dechex(-1415723993)

//   example 3: hex2bin('2f1q')

//   example 3: http_build_query({foo: 'bar', php: 'hypertext processor', baz: 'boom', cow: 'milk'}, '', '&amp;', 'PHP_QUERY_RFC3986')

//   example 3: ini_set('unicode.semantics', 'on')

//   example 3: is_finite(0)

//   example 3: is_infinite(0)

//   example 3: max(0, 'hello')

//   example 3: metaphone('accuracy')

//   example 3: min(0, 'hello')

//   example 3: money_format('%14#8.2n', -1234.5678)

//   example 3: nl2br("\nOne\nTwo\n\nThree\n", true)

//   example 3: number_format(1234.5678, 2, '.', '')

//   example 3: quoted_printable_encode('0123456789012345678901234567890123456789012345678901234567890123456789012345')

//   example 3: range( 'a', 'i' )

//   example 3: round(2.835, 2)

//   example 3: soundex('Euler')

//   example 3: sprintf("[%'#10s]", 'monkey')

//   example 3: sscanf("10--20", "%2$d--%1$d") // Must escape '$' in PHP, but not JS

//   example 3: str_replace(Array('S','F'),'x','ASDFASDF')

//   example 3: str_rot13(33)

//   example 3: str_word_count("Hello fri3nd, you're\r\n       looking          good today!", 1, '\u00e0\u00e1\u00e3\u00e73')

//   example 3: strcspn('abcdefg123', '1234567890', 1)

//   example 3: strip_tags("<a href='http://kvz.io'>Kevin van Zonneveld</a>", "<a>")

//   example 3: strncasecmp('Price 12.90', 'Price 12.15', 30)

//   example 3: strrpos('baa', 'a', 3)

//   example 3: strstr('name@example.com', '@')

//   example 3: strtr('ääääääää', 'ä', 'a')

//   example 3: substr('a\uD801\uDC00', 0, -1)

//   example 3: substr_count('Kevin van Zonneveld', 'Z', 0, 10)

//   example 3: substr_replace('ABCDEFGH:/MNRPQR/', 'bob', 0, 0)

//   example 3: trim(16, 1)

//   example 3: ucwords('у мэри был маленький ягненок и она его очень любила')

//   example 3: var data = 'Kevin'

//   example 3: var_export(data, true)

//   example 3: wordwrap('Lorem ipsum dolor sit amet, consectetur adipisicing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat.')

//   example 4: abs('_argos')

//   example 4: array_chunk({1:'Kevin', 2:'van', 3:'Zonneveld'}, 2, true)

//   example 4: ini_set('unicode.semantics', 'on')

//   example 4: max('hello', 0)

//   example 4: metaphone('batch batcher')

//   example 4: min('hello', 0)

//   example 4: money_format('%(14#8.2n', 1234.5678)

//   example 4: nl2br(null)

//   example 4: number_format(67, 2, ',', '.')

//   example 4: range( 'c', 'a' )

//   example 4: round(1.1749999999999, 2)

//   example 4: sprintf("%d", 123456789012345)

//   example 4: str_replace(['A','D'], ['x','y'] , 'ASDFASDF' , countObj)

//   example 4: str_word_count('hey', 2)

//   example 4: strcspn('abcdefg123', '1234567890', -6, -5)

//   example 4: strip_tags('1 < 5 5 > 1')

//   example 4: strncasecmp('Version 12.9', 'Version 12.15', 20)

//   example 4: strrpos('baa', 'a', 2)

//   example 4: strstr('name@example.com', '@', true)

//   example 4: strtr('http', 'pthxyz','xyzpth')

//   example 4: substr('a\uD801\uDC00', 0, 2)

//   example 4: substr_replace('ABCDEFGH:/MNRPQR/', 'bob', 10, -1)

//   example 4: ucwords('τάχιστη αλώπηξ βαφής ψημένη γη, δρασκελίζει υπέρ νωθρού κυνός')

//   example 4: var $result = countObj.value

//   example 4: var countObj = {}

//   example 5: ini_set('unicode.semantics', 'on')

//   example 5: max(-1, 'hello')

//   example 5: min(-1, 'hello')

//   example 5: money_format('%(14#8.2n', -1234.5678)

//   example 5: number_format(1000)

//   example 5: round(58551.799999999996, 2)

//   example 5: sprintf('%-03s', 'E')

//   example 5: strip_tags('1 <br/> 1')

//   example 5: strncasecmp('Version 12.15', 'Version 12.9', 20)

//   example 5: strtr('zyyx', 'pthxyz','xyzpth')

//   example 5: substr('a\uD801\uDC00', -1, 1)

//   example 5: substr_replace('ABCDEFGH:/MNRPQR/', 'bob', -7, -1)

//   example 6: ini_set('unicode.semantics', 'on')

//   example 6: max([2, 4, 8], [2, 5, 7])

//   example 6: min([2, 4, 8], [2, 5, 7])

//   example 6: money_format('%=014#8.2n', 1234.5678)

//   example 6: number_format(67.311, 2)

//   example 6: sprintf('%+010d', 9)

//   example 6: strip_tags('1 <br/> 1', '<br>')

//   example 6: strtr('aa', {'a':1,'aa':2})

//   example 6: substr('a\uD801\uDC00z\uD801\uDC00', -3, 2)

//   example 6: substr_replace('ABCDEFGH:/MNRPQR/', '', 10, -1)

//   example 7: ini_set('unicode.semantics', 'on')

//   example 7: money_format('%=014#8.2n', -1234.5678)

//   example 7: number_format(1000.55, 1)

//   example 7: sprintf('%+0\'@10d', 9)

//   example 7: strip_tags('1 <br/> 1', '<br><br/>')

//   example 7: substr('a\uD801\uDC00z\uD801\uDC00', -3, -1)

//   example 8: money_format('%=*14#8.2n', 1234.5678)

//   example 8: number_format(67000, 5, ',', '.')

//   example 8: sprintf('%.f', 3.14)

//   example 8: strip_tags('<i>hello</i> <<foo>script>world<</foo>/script>')

//   example 9: money_format('%=*14#8.2n', -1234.5678)

//   example 9: number_format(0.9, 0)

//   example 9: sprintf('%% %2$d', 1, 2)

//   example 9: strip_tags(4)

//   exports[name] = function () {

//   files on a server or removing repeated values in the

//   id: errorsLayerId,

//   is available. If highWaterMark is 0 and we are not in the flowing mode

//   is responsible for filling the buffer with enough data if such data

//   label: 'Router Errors',

//   method, but they are processing the call asynchronously and have _not_

//   options.linkInactiveClass,

//   parent.children.push(originalRecord)

//   props.inactiveClass,

//   read()s. The execution ends in this method again after the _read() ends

//   require representation with two surrogates (reserved non-characters

//   return -1;

//   returns 1: " !HWdelor"

//   returns 1: "0.304692654015397"

//   returns 1: "1.266103672779499"

//   returns 1: "Word=This\nWord=is\nWord=an\nWord=example\nWord=string\n"

//   returns 1: "\\f\\o\\o\\[ \\]"

//   returns 1: "kevin\\'s birthday"

//   returns 1: '    Kevin van Zonneveld'

//   returns 1: ' USD 1,234.56'

//   returns 1: '-=-=-=-=-=-=-=-=-=-='

//   returns 1: '-=-=-=-=-=-Kevin van Zonneveld'

//   returns 1: '0ea65a1f4b4d69712affc58240932f3eb8a2af66'

//   returns 1: '1,235'

//   returns 1: '101000110111001100110100'

//   returns 1: '1100'

//   returns 1: '123.10'

//   returns 1: '17'

//   returns 1: '4b6576'

//   returns 1: '54916d2e62f65b3afa6e192e6a601cdbe5cb5897'

//   returns 1: '6e658d4bfcb59cc13f96c14450ac40b9'

//   returns 1: 'Asia/Hong_Kong'

//   returns 1: 'Dima'

//   returns 1: 'H*e*l*l*o* *w*o*r*l*d*!*'

//   returns 1: 'K150'

//   returns 1: 'KEVIN VAN ZONNEVELD'

//   returns 1: 'Kevin & van Zonneveld'

//   returns 1: 'Kevin &amp; van Zonneveld'

//   returns 1: 'Kevin <b>van</b> <i>Zonneveld</i>'

//   returns 1: 'Kevin Van  Zonneveld'

//   returns 1: 'Kevin van Zonneveld    '

//   returns 1: 'Kevin van Zonneveld'

//   returns 1: 'Kevin van zonneveld'

//   returns 1: 'Kevin.van.Zonneveld'

//   returns 1: 'Kevin<br />\nvan<br />\nZonneveld'

//   returns 1: 'Kevin|van|Zonnev|eld'

//   returns 1: 'Line 3'

//   returns 1: 'N'

//   returns 1: 'Xriva ina Mbaariryq'

//   returns 1: '\\. \\+ \\* \\? \\^ \\( \\$ \\)'

//   returns 1: 'a'

//   returns 1: 'a=3Db=3Dc'

//   returns 1: 'abcde'

//   returns 1: 'bc3aa724b0ec7dce4c26e7f4d0d9b064'

//   returns 1: 'bob'

//   returns 1: 'en_US'

//   returns 1: 'en_US_POSIX'

//   returns 1: 'foo=bar&amp;php=hypertext+processor&amp;baz=boom&amp;cow=milk'

//   returns 1: 'hello all, I said hi'

//   returns 1: 'is is a Simple text.'

//   returns 1: 'kevin Van Zonneveld'

//   returns 1: 'kevin van zonneveld'

//   returns 1: 'naee'

//   returns 1: 'van Zonneveld'

//   returns 1: -1

//   returns 1: -1.1497971402636502

//   returns 1: -1812718

//   returns 1: -9834330

//   returns 1: 0

//   returns 1: 0.3095196042031118

//   returns 1: 0.5

//   returns 1: 0.7853981633974483

//   returns 1: 0.9999612058841574

//   returns 1: 1

//   returns 1: 1.0000000000000007e-15

//   returns 1: 1.0164747716114113

//   returns 1: 1.3498588075760032

//   returns 1: 1.5707962121596615

//   returns 1: 10

//   returns 1: 1242000

//   returns 1: 14

//   returns 1: 16

//   returns 1: 16.674657798418625

//   returns 1: 16.67465779841863

//   returns 1: 180

//   returns 1: 19

//   returns 1: 2

//   returns 1: 2147483647

//   returns 1: 2953.5269424875746

//   returns 1: 3

//   returns 1: 3.141592653589793

//   returns 1: 3.8439091680779e+48

//   returns 1: 4.2

//   returns 1: 5

//   returns 1: 51

//   returns 1: 54251849

//   returns 1: 6

//   returns 1: 63

//   returns 1: 7

//   returns 1: 75

//   returns 1: 8

//   returns 1: 8.212871815082147

//   returns 1: 8723321

//   returns 1: 8723322

//   returns 1: 9.999999999999995e-16

//   returns 1: [ 'Kevin', 'van', 'Zonneveld' ]

//   returns 1: ['Hel', 'lo ', 'Fri', 'end']

//   returns 1: ['Hello', 'fri', 'nd', "you're", 'looking', 'good', 'today']

//   returns 1: ['abc', 'def', 'ghi']

//   returns 1: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12]

//   returns 1: [2350001]

//   returns 1: [['Kevin', 'van'], ['Zonneveld']]

//   returns 1: false

//   returns 1: null

//   returns 1: true

//   returns 1: undefined

//   returns 1: {"color": "green", 0: 2, 1: 4, 2: "a", 3: "b", "shape": "trapezoid", 4: 4}

//   returns 1: {'"': '&quot;', '&': '&amp;', '<': '&lt;', '>': '&gt;'}

//   returns 1: {d: 'lemon', c: 'apple', b: 'banana', a: 'orange'}

//   returns 1: {decimal_point: '.', thousands_sep: '', positive_sign: '', negative_sign: '-', int_frac_digits: 2, frac_digits: 2, p_cs_precedes: 1, p_sep_by_space: 0, n_cs_precedes: 1, n_sep_by_space: 0, p_sign_posn: 1, n_sign_posn: 1, grouping: [], int_curr_symbol: 'USD ', currency_symbol: '$', mon_decimal_point: '.', mon_thousands_sep: ',', mon_grouping: [3, 3]}

//   returns 2: "\\zoo['\\.']"

//   returns 2: "array (\n  0 => 'Kevin',\n  1 => 'van',\n  2 => 'Zonneveld'\n)"

//   returns 2: ' $     1,234.57'

//   returns 2: '&lt;'

//   returns 2: '------Kevin van Zonneveld-----'

//   returns 2: '00'

//   returns 2: '1 234,56'

//   returns 2: '11010'

//   returns 2: '2f'

//   returns 2: '410'

//   returns 2: '<br>\nOne<br>\nTwo<br>\n<br>\nThree<br>\n'

//   returns 2: '<p>Kevin van Zonneveld</p>'

//   returns 2: 'BKR'

//   returns 2: 'E460'

//   returns 2: 'HELLO WORLD'

//   returns 2: 'Hello worl*d!*'

//   returns 2: 'Kevin '

//   returns 2: 'Kevin van Zonneveld'

//   returns 2: 'The quick brown fox<br />\njumped over the lazy<br />\ndog.'

//   returns 2: '[    monkey]'

//   returns 2: '\x00'

//   returns 2: 'aaabaaccasdeooo'

//   returns 2: 'abc  =20\r\n123  =20\r\n'

//   returns 2: 'bob'

//   returns 2: 'foo&#039;bar'

//   returns 2: 'hemmo, mars'

//   returns 2: 'myvar_0=foo&myvar_1=bar&myvar_2=baz&myvar_3=boom&php=hypertext+processor&cow=milk'

//   returns 2: 'o Wor'

//   returns 2: 'pt_PT'

//   returns 2: -1

//   returns 2: 0

//   returns 2: 1

//   returns 2: 160

//   returns 2: 2

//   returns 2: 2350001

//   returns 2: 3

//   returns 2: 4

//   returns 2: 4.2

//   returns 2: 5

//   returns 2: 51

//   returns 2: 65536

//   returns 2: 8

//   returns 2: ['row2"cell1', 'row2cell2', 'row2cell3']

//   returns 2: [0, 10, 20, 30, 40, 50, 60, 70, 80, 90, 100]

//   returns 2: [{0:'Kevin', 1:'van'}, {2: 'Zonneveld'}]

//   returns 2: false

//   returns 2: null

//   returns 2: true

//   returns 2: {0: "data"}

//   returns 2: {0: 'Hello', 6: 'fri', 10: 'nd', 14: "you're", 29: 'looking', 46: 'good', 51: 'today'}

//   returns 2: {32:1,33:1,72:1,87:1,100:1,101:1,108:3,111:2,114:1}

//   returns 2: {3: 'Zonneveld', 2: 'van', 1: 'Kevin'}

//   returns 3: "'Kevin'"

//   returns 3: "<a href='http://kvz.io'>Kevin van Zonneveld</a>"

//   returns 3: '-$     1,234.57'

//   returns 3: '012345678901234567890123456789012345678901234567890123456789012345678901234=\r\n5'

//   returns 3: '11010'

//   returns 3: '1234.57'

//   returns 3: '33'

//   returns 3: '6'

//   returns 3: '<br />\nOne<br />\nTwo<br />\n<br />\nThree<br />\n'

//   returns 3: '@example.com'

//   returns 3: 'AKKRS'

//   returns 3: 'AxDxAxDx'

//   returns 3: 'E460'

//   returns 3: 'Lorem ipsum dolor sit amet, consectetur adipisicing elit, sed do eiusmod\ntempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim\nveniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea\ncommodo consequat.'

//   returns 3: '[####monkey]'

//   returns 3: 'a'

//   returns 3: 'aaaaaaaa'

//   returns 3: 'ab9dc427'

//   returns 3: 'bobABCDEFGH:/MNRPQR/'

//   returns 3: 'foo=bar&amp;php=hypertext%20processor&amp;baz=boom&amp;cow=milk'

//   returns 3: 'У Мэри Был Маленький Ягненок И Она Его Очень Любила'

//   returns 3: 0

//   returns 3: 2.84

//   returns 3: 5

//   returns 3: 6

//   returns 3: 7

//   returns 3: 8

//   returns 3: ['Hello', 'fri3nd', "you're", 'looking', 'good', 'today']

//   returns 3: ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i']

//   returns 3: [20, 10]

//   returns 3: [['Kevin', 'van'], ['Zonneveld']]

//   returns 3: false

//   returns 3: true

//   returns 4: ' $     1,234.57 '

//   returns 4: ''

//   returns 4: '1 < 5 5 > 1'

//   returns 4: '123456789012345'

//   returns 4: '67,00'

//   returns 4: 'ABCDEFGH:/bob/'

//   returns 4: 'BXBXR'

//   returns 4: 'a\uD801\uDC00'

//   returns 4: 'hello'

//   returns 4: 'name'

//   returns 4: 'zyyx'

//   returns 4: 'Τάχιστη Αλώπηξ Βαφής Ψημένη Γη, Δρασκελίζει Υπέρ Νωθρού Κυνός'

//   returns 4: 0

//   returns 4: 1

//   returns 4: 1.17

//   returns 4: 2

//   returns 4: 4

//   returns 4: 8

//   returns 4: ['c', 'b', 'a']

//   returns 4: [{1: 'Kevin', 2: 'van'}, {3: 'Zonneveld'}]

//   returns 4: {0: 'hey'}

//   returns 5: '($     1,234.57)'

//   returns 5: '1  1'

//   returns 5: '1,000'

//   returns 5: 'ABCDEFGH:/bob/'

//   returns 5: 'E00'

//   returns 5: '\uD801\uDC00'

//   returns 5: 'hello'

//   returns 5: 'http'

//   returns 5: -1

//   returns 5: -8

//   returns 5: 58551.8

//   returns 6: ' $000001,234.57'

//   returns 6: '+000000009'

//   returns 6: '1 <br/> 1'

//   returns 6: '2'

//   returns 6: '67.31'

//   returns 6: 'ABCDEFGH://'

//   returns 6: '\uD801\uDC00z'

//   returns 6: [2, 4, 8]

//   returns 6: [2, 5, 7]

//   returns 7: '-$000001,234.57'

//   returns 7: '1 <br/> 1'

//   returns 7: '1,000.6'

//   returns 7: '@@@@@@@@+9'

//   returns 7: '\uD801\uDC00z'

//   returns 8: ' $*****1,234.57'

//   returns 8: '3.140000'

//   returns 8: '67.000,00000'

//   returns 8: 'hello world'

//   returns 9: '% 2'

//   returns 9: '-$*****1,234.57'

//   returns 9: '1'

//   returns 9: '4'

//   scroll(position: ScrollPosition): void

//   scroll: scrollToPosition,

//   the loop below is responsible for ensuring read() is called. Failing to

//   up calling push() with more data.

//   used for building other characters; the first is "high" and the next "low")

//   we should _not_ attempt to buffer any extra data. We'll get more data

//   when the stream consumer calls read() instead.

//   |    Sign

//   |    |

//   }

//   “sourceRoot”, the sources are resolved relative to the

//   “sources” entry.  This value is prepended to the individual

//  * "-&" while in base64 is not allowed.

//  * Base64 must not be used to represent direct characters.

//  * Base64 part is started by "&" instead of "+"

//  * Big5-2003 (Taiwan standard) almost superset of cp950.

//  * Big5-HKSCS (-2001, -2004, -2008). Hong Kong standard. 

//  * Direct characters are 0x20-0x7E, except "&" (0x26)

//  * EUC-JP:    Up to 3 bytes per character. Used mostly on *nixes.

//  * ISO2022-JP-1: Adds esc seq for 0212-1990.

//  * ISO2022-JP-2004: Adds 0213-2004 Plane 1.

//  * ISO2022-JP-2: Adds esc seq for GB2313-1980, KSX1001-1992, ISO8859-1, ISO8859-7.

//  * ISO2022-JP-3: Adds esc seq for 0201-1976 Kana set, 0213-2000 Planes 1, 2.

//  * ISO2022-JP: Stateful encoding, with escape sequences to switch between ASCII, 

//  * In Base64, "," is used instead of "/"

//  * JIS X 208: 7-bit, direct encoding of 0208. Byte ranges: 0x21-0x7E (94 values). Uncommon.

//  * No implicit shift back from Base64 (should always end with '-')

//  * Shift_JIS: Compatible with 0201, uses not defined chars in top half as lead bytes for double-byte

//  * String must end in non-shifted position.

//  * Unicode-at-on (UAO) / Mozilla 1.8. Falling out of use on the Web. Not supported by other browsers.

//  * Windows CP 950: Microsoft variant of Big5. Canonical: http://www.unicode.org/Public/MAPPINGS/VENDORS/MICSFT/WINDOWS/CP950.TXT

//  * Windows CP 951: Microsoft variant of Big5-HKSCS-2001. Seems to be never public. http://me.abelcheung.org/articles/research/what-is-cp951/

//  * a name, which is equivalent to a string -- a

//  * a number -- 12

//  * a string -- 'a'

//  * an expression, which must be enclosed in parentheses -- (1 + 2)

//  discuss at: http://locutus.io/php/abs/

//  discuss at: http://locutus.io/php/acos/

//  discuss at: http://locutus.io/php/acosh/

//  discuss at: http://locutus.io/php/addcslashes/

//  discuss at: http://locutus.io/php/addslashes/

//  discuss at: http://locutus.io/php/array_chunk/

//  discuss at: http://locutus.io/php/array_merge/

//  discuss at: http://locutus.io/php/asin/

//  discuss at: http://locutus.io/php/asinh/

//  discuss at: http://locutus.io/php/atan/

//  discuss at: http://locutus.io/php/atan2/

//  discuss at: http://locutus.io/php/atanh/

//  discuss at: http://locutus.io/php/base_convert/

//  discuss at: http://locutus.io/php/bin2hex/

//  discuss at: http://locutus.io/php/bindec/

//  discuss at: http://locutus.io/php/ceil/

//  discuss at: http://locutus.io/php/chr/

//  discuss at: http://locutus.io/php/chunk_split/

//  discuss at: http://locutus.io/php/convert_cyr_string/

//  discuss at: http://locutus.io/php/cos/

//  discuss at: http://locutus.io/php/cosh/

//  discuss at: http://locutus.io/php/count_chars/

//  discuss at: http://locutus.io/php/ctype_alpha/

//  discuss at: http://locutus.io/php/decbin/

//  discuss at: http://locutus.io/php/dechex/

//  discuss at: http://locutus.io/php/decoct/

//  discuss at: http://locutus.io/php/deg2rad/

//  discuss at: http://locutus.io/php/echo/

//  discuss at: http://locutus.io/php/exp/

//  discuss at: http://locutus.io/php/explode/

//  discuss at: http://locutus.io/php/expm1/

//  discuss at: http://locutus.io/php/floor/

//  discuss at: http://locutus.io/php/fmod/

//  discuss at: http://locutus.io/php/get_html_translation_table/

//  discuss at: http://locutus.io/php/getenv/

//  discuss at: http://locutus.io/php/getrandmax/

//  discuss at: http://locutus.io/php/hex2bin/

//  discuss at: http://locutus.io/php/hexdec/

//  discuss at: http://locutus.io/php/html_entity_decode/

//  discuss at: http://locutus.io/php/htmlentities/

//  discuss at: http://locutus.io/php/http_build_query/

//  discuss at: http://locutus.io/php/hypot/

//  discuss at: http://locutus.io/php/i18n_loc_get_default/

//  discuss at: http://locutus.io/php/implode/

//  discuss at: http://locutus.io/php/ini_get/

//  discuss at: http://locutus.io/php/ini_set/

//  discuss at: http://locutus.io/php/is_bool/

//  discuss at: http://locutus.io/php/is_finite/

//  discuss at: http://locutus.io/php/is_float/

//  discuss at: http://locutus.io/php/is_infinite/

//  discuss at: http://locutus.io/php/is_nan/

//  discuss at: http://locutus.io/php/is_scalar/

//  discuss at: http://locutus.io/php/krsort/

//  discuss at: http://locutus.io/php/lcfirst/

//  discuss at: http://locutus.io/php/lcg_value/

//  discuss at: http://locutus.io/php/localeconv/

//  discuss at: http://locutus.io/php/log/

//  discuss at: http://locutus.io/php/log10/

//  discuss at: http://locutus.io/php/log1p/

//  discuss at: http://locutus.io/php/ltrim/

//  discuss at: http://locutus.io/php/max/

//  discuss at: http://locutus.io/php/md5/

//  discuss at: http://locutus.io/php/md5_file/

//  discuss at: http://locutus.io/php/metaphone/

//  discuss at: http://locutus.io/php/min/

//  discuss at: http://locutus.io/php/money_format/

//  discuss at: http://locutus.io/php/mt_getrandmax/

//  discuss at: http://locutus.io/php/mt_rand/

//  discuss at: http://locutus.io/php/nl2br/

//  discuss at: http://locutus.io/php/number_format/

//  discuss at: http://locutus.io/php/octdec/

//  discuss at: http://locutus.io/php/ord/

//  discuss at: http://locutus.io/php/pi/

//  discuss at: http://locutus.io/php/pow/

//  discuss at: http://locutus.io/php/printf/

//  discuss at: http://locutus.io/php/quoted_printable_encode/

//  discuss at: http://locutus.io/php/quotemeta/

//  discuss at: http://locutus.io/php/rad2deg/

//  discuss at: http://locutus.io/php/rand/

//  discuss at: http://locutus.io/php/range/

//  discuss at: http://locutus.io/php/round/

//  discuss at: http://locutus.io/php/rtrim/

//  discuss at: http://locutus.io/php/setlocale/

//  discuss at: http://locutus.io/php/sha1/

//  discuss at: http://locutus.io/php/sha1_file/

//  discuss at: http://locutus.io/php/similar_text/

//  discuss at: http://locutus.io/php/sin/

//  discuss at: http://locutus.io/php/sinh/

//  discuss at: http://locutus.io/php/soundex/

//  discuss at: http://locutus.io/php/sprintf/

//  discuss at: http://locutus.io/php/sqrt/

//  discuss at: http://locutus.io/php/sscanf/

//  discuss at: http://locutus.io/php/str_getcsv/

//  discuss at: http://locutus.io/php/str_ireplace/

//  discuss at: http://locutus.io/php/str_pad/

//  discuss at: http://locutus.io/php/str_repeat/

//  discuss at: http://locutus.io/php/str_replace/

//  discuss at: http://locutus.io/php/str_rot13/

//  discuss at: http://locutus.io/php/str_shuffle/

//  discuss at: http://locutus.io/php/str_split/

//  discuss at: http://locutus.io/php/str_word_count/

//  discuss at: http://locutus.io/php/strcasecmp/

//  discuss at: http://locutus.io/php/strcmp/

//  discuss at: http://locutus.io/php/strcoll/

//  discuss at: http://locutus.io/php/strcspn/

//  discuss at: http://locutus.io/php/strip_tags/

//  discuss at: http://locutus.io/php/stripos/

//  discuss at: http://locutus.io/php/stristr/

//  discuss at: http://locutus.io/php/strlen/

//  discuss at: http://locutus.io/php/strncasecmp/

//  discuss at: http://locutus.io/php/strpbrk/

//  discuss at: http://locutus.io/php/strpos/

//  discuss at: http://locutus.io/php/strrchr/

//  discuss at: http://locutus.io/php/strripos/

//  discuss at: http://locutus.io/php/strrpos/

//  discuss at: http://locutus.io/php/strspn/

//  discuss at: http://locutus.io/php/strstr/

//  discuss at: http://locutus.io/php/strtok/

//  discuss at: http://locutus.io/php/strtolower/

//  discuss at: http://locutus.io/php/strtoupper/

//  discuss at: http://locutus.io/php/strtr/

//  discuss at: http://locutus.io/php/substr/

//  discuss at: http://locutus.io/php/substr_compare/

//  discuss at: http://locutus.io/php/substr_count/

//  discuss at: http://locutus.io/php/substr_replace/

//  discuss at: http://locutus.io/php/tan/

//  discuss at: http://locutus.io/php/tanh/

//  discuss at: http://locutus.io/php/trim/

//  discuss at: http://locutus.io/php/ucfirst/

//  discuss at: http://locutus.io/php/ucwords/

//  discuss at: http://locutus.io/php/utf8_encode/

//  discuss at: http://locutus.io/php/var_export/

//  discuss at: http://locutus.io/php/wordwrap/

//  example 10: money_format('%=*^14#8.2n', 1234.5678)

//  example 10: number_format('1.20', 2)

//  example 11: money_format('%=*^14#8.2n', -1234.5678)

//  example 11: number_format('1.20', 4)

//  example 12: money_format('%=*!14#8.2n', 1234.5678)

//  example 12: number_format('1.2000', 3)

//  example 13: money_format('%=*!14#8.2n', -1234.5678)

//  example 13: number_format('1 000,50', 2, '.', ' ')

//  example 14: money_format('%i', 3590)

//  example 14: number_format(1e-8, 8, '.', '')

//  get moved around. Make sure all root level vnodes inherit el.

//  incremental id for route records and inspector state

//  returns 10: '  $****1234.57'

//  returns 10: '1.20'

//  returns 11: ' -$****1234.57'

//  returns 11: '1.2000'

//  returns 12: ' *****1,234.57'

//  returns 12: '1.200'

//  returns 13: '-*****1,234.57'

//  returns 13: '100 050.00'

//  returns 14: ' USD 3,590.00'

//  returns 14: '0.00000001'

//  revised by: Brett Zamir (http://brett-zamir.me)

//  revised by: Christoph

//  revised by: Der Simon (http://innerdom.sourceforge.net/)

//  revised by: Jonas Raoni Soares Silva (http://www.jsfromhell.com)

//  revised by: Kevin van Zonneveld (http://kvz.io)

//  revised by: Luke Smith (http://lucassmith.name)

//  revised by: Onno Marsman (https://twitter.com/onnomarsman)

//  revised by: Rafał Kukawski (http://blog.kukawski.pl)

//  revised by: T.Wild

//  revised by: Theriault

//  revised by: Theriault (https://github.com/Theriault)

//  revised by: gorthaur

//  revised by: stag019

// "&-" -> "&"

// "+-" -> "+"

// "Software"), to deal in the Software without restriction, including

// "block" tags that are not captured (see above) are only used for defining

// "lookup" algorithm http://tools.ietf.org/html/rfc4647#section-3.4

// "mapping.generatedColumn" with "lastMapping"

// "name": intentionally not styling

// "the promise rejected with null" or "the promise fulfilled with undefined".

// #1153: fast path should not be taken for non-stable (v-for) fragments

// #1497 this ensures better active/exact matching

// #2078 in the case of <component :is="vnode" ref="extra"/>

// #2080 if the stable fragment has a key, it's a <template v-for> that may

// #2134 or if it's a component root, it may also get moved around

// #2715 the previous fragment could've been a BAILed one as a result

// #3666, avoid reference pollution when reusing vnode

// #4096 array checkboxes need to be deep traversed

// #674 we manually inherit them

// #72 and bugzil.la/889492.

// #8326: extend call and options.name access are considered side-effects

// #extractData into DataReader base, since the implementations are almost identical for JsonReader, XmlReader

// %23

// ''

// '+' is default

// ','

// '-'

// '.'

// '0' - '9'

// '\000lambda_1'. Since it will probably not be a common use to

// 'a'

// 'abxxcd' will be treated as 'ab')

// 'chunk' is an input chunk.

// 'error'

// 'i' vs. 'n' ('USD' vs. '$')

// 'path' module extracted from Node.js v8.11.1 (only the posix part)

// 'readable' etc.

// ( ष ) DEVANAGARI LETTER SSA

// ( ि ) DEVANAGARI VOWEL SIGN I

// ( ந ) TAMIL LETTER NA

// ( ி ) TAMIL VOWEL SIGN I

// ( ำ ) THAI CHARACTER SARA AM

// ( เ ) THAI CHARACTER MAI THO

// ( เ ) THAI CHARACTER SARA E

// ( ᄀ ) HANGUL CHOSEONG KIYEOK

// ( ᅡ ) HANGUL JUNGSEONG A

// ( ◌̈ ) COMBINING DIAERESIS

// ( ◌்) TAMIL SIGN VIRAMA

// ( ◌ั ) THAI CHARACTER MAI HAN-AKAT

// (#4815)

// (0x7ffffff)

// (1) Partitioning.

// (2) Recurse on each half.

// (angle / 180) * Math.PI;

// (but shouldn't be whitespace in format anyways, so no difference here)

// (could change last hex to 0xDB7F to treat high private surrogates

// (could change last hex to 0xDB7F to treat high private surrogates as single characters)

// (e.g., if to be 1,23,456, could be [3, 2])

// (gregorian data or ordinal) + (weekYear or weekNumber) -> error

// (gregorian month or day) + ordinal -> error

// (http://ejohn.org/blog/javascript-micro-templating/)

// (in contrast, the rest of the condition is used heavily)

// (manually changing the url or calling history.hash = '#/somewhere'),

// (set with i18n_loc_set_default() as of PHP6)

// (since `REGEX_NEWLINE` captures its match).

// (the slowest part of adding a route) is very fast

// )]: !link.isExactActive,

// *below* the call to _read.  The reason is that in certain

// - #1942 if hmr is enabled with sfc component

// - In the case of a Fragment, we need to provide the actual parent

// - In the case of a component, it could contain anything.

// - In the case of different nodes, there is going to be a replacement

// - No data in the buffer, and the stream is in flowing mode. In this mode

// - Not enough data buffered (state.length < state.highWaterMark). The loop

// - The stream has ended (state.ended).

// - There is already a pending 'read' operation (state.reading). This is a

// - buffer - a Buffer to search

// - byteOffset - an index into `buffer`; will be clamped to an int32

// - dir - true for indexOf, false for lastIndexOf

// - encoding - an optional encoding, relevant is val is a string

// - val - a string, Buffer, or number

// - vite#872 non-sfc component used by sfc component

// -- Decoding

// -- Encoding

// -- Encoding (pass-through)

// -0 = 0

// -1 - if `this` < `num`

// -121665 * (121666^(-1)) (mod P)

// -> applies to existing records (on server). we don't have a concept for new (phantom) records yet!

// -this - num = -(this + num)

// ... except it avoids using URL, which wasn't available in the

// ... is U+007F OR

// ... is `-` (U+002D) OR ...

// ... is `_` (U+005F) OR ...

// ... is a `-` (U+002D) AND ...

// ... is greater than or equal to U+0080 OR ...

// ... is in the range [0-9] (U+0030 to U+0039) OR ...

// ... is in the range [A-Z] (U+0041 to U+005A) OR ...

// ... is in the range [\1-\1F] (U+0001 to U+001F) OR ...

// ... is in the range [a-z] (U+0061 to U+007A) ...

// ... is the first character AND ...

// ... is the first character and is in the range [0-9] (U+0030 to U+0039) OR ...

// ... is the second character and is in the range [0-9] (U+0030 to U+0039)

// ... there is no second character ...

// .col-[1-12]|auto (xs)

// .end() fully uncorks

// .replace(/\r\n/g, "\n").replace(/\r/g, "\n");

// /prefix_:p()_suffix

// 0 - 25: ABCDEFGHIJKLMNOPQRSTUVWXYZ

// 0 - if `this` == `num`

// 0 means "already installed".

// 0 ≤ j ≤ i

// 0. Get next character.

// 0: no space between curr. symbol and value

// 0: no space between curr. symbol and value; 1: space sep. them unless symb.

// 0: parentheses surround quantity and curr. symbol; 1: sign precedes them;

// 0: parentheses surround value and curr. symbol;

// 0x36 ^ 0x5c = 0x6a

// 1 - if `this` > `num`

// 1, 9, 17, 25, 33, 41, 49, 57

// 1. Figure out what the state of things will be after we do

// 1. Handle surrogates.

// 1. It is not flowing, as the flow mechanism will take

// 1. The format options tell us to show the zone. We can't do that, so the best

// 1.1. Let x = r + jn.

// 1.6.1 Compute Q = r^-1 (sR -  eG)

// 10M + 1S

// 12M + 4S + 7A

// 1: flags, 3: width, 5: left, 7: right, 8: conversion

// 1: sign precedes them;

// 1: space sep. them unless symb. and sign are adjacent then space sep. them from value

// 1M + 2S + 1A + N * (4S + 5M + 8A)

// 1M + 5S + 14A

// 1M + 5S + 15A

// 1kb of data being output.  In this case, you could write a very small

// 2 ^ 255 - 19

// 2 ^ 53 (unsafe)

// 2 leads in a row

// 2, 10, 18, 26, 34, 42, 50, 58

// 2. Convert uCode character.

// 2. If that resulting state will trigger a _read, then call _read.

// 2. It is not ended.

// 2. The format options don't tell us to show the zone. Then we can adjust them

// 2025-01-15 - cweiss - NOTE: we can't commit here as we would loose __meta modified

// 24-bits chunks

// 256 = 9 * 26 + 22

// 26 - 51: abcdefghijklmnopqrstuvwxyz

// 26 Feb 16:19:34

// 2: sign follows them;

// 2: sign follows them; 3: sign immed. precedes curr. symbol; 4: sign immed.

// 2: space sep. sign and value unless symb. and sign are adjacent then space separates

// 2M + 2S + 4A

// 2M + 5S + 13A

// 2P = O

// 3, 11, 19, 27, 35, 43, 51, 59

// 3-length-padded UTF-8 octets

// 3. Actually pull the requested chunks out of the buffer and return.

// 3. It is below the highWaterMark, so we can schedule

// 3. Write dbcsCode character.

// 3.74

// 32 x 32bit words

// 36, 44, 52, 60

// 3: sign immed. precedes curr. symbol; (but may be space between)

// 3M + 5S

// 4, 12, 20, 28

// 4/5

// 4: sign immed. succeeds curr. symbol; (but may be space between)

// 4M + 2S + 6A

// 4M + 4S

// 4M + 6S + 10A

// 5, 13, 21, 29, 39, 47, 55, 63

// 52 - 61: 0123456789

// 5M + 10S + ...

// 6, 14, 22, 30, 39, 47, 55, 63

// 62: +

// 63: /

// 7, 15, 23, 31, 39, 47, 55, 63

// 8M

// 8M + 3S + 7A

// ;[

// <-- That's what it's all about

// <-- There's implementation of ugly bit, setting the raw record-data.

// <-- copy phantom-id -> _phid, so we can remap in Store#onCreateRecords

// <-- true to return [Ext.data.Record]

// <option>s.

// <select multiple> value need to be deep traversed

// == Big5/Taiwan/Hong Kong ================================================

// == Chinese/GBK ==========================================================

// == Decoder ==================================================================

// == Encoder ==================================================================

// == Japanese/ShiftJIS ====================================================

// == Korean ===============================================================

// == UTF-16 codec =============================================================

// == UTF16-BE codec. ==========================================================

// ================

// => Check whether `dest` is still a piping destination.

// @TODO evaluate inputFilters. inputFilters run on server when the key ist set in the data whereas validators always run

// @TODO implement me

// @TODO retry n times, replaceProxy might be registered late!

// @TODO: use grants model and set all grants to true for new records

// @flow

// @see http://www.stucox.com/blog/you-cant-detect-a-touchscreen/

// @see https://github.com/tc39/proposal-intl-datetime-style

// @see https://github.com/tine20/tine20/issues/6236

// @see https://github.com/twigphp/Twig/issues/3174 as to why we don't check macro existence in parents

// @see https://stackoverflow.com/questions/17989777/detect-if-ios-is-using-webapp/40932301#40932301

// @todo how can we move that to the server?

// @todo: &amp; problem

// @todo: Does PHP do anything with these? Seems not to matter

// @todo: Don't rely on ini here, use internal krsort instead

// @todo: Double-check i whitespace ignored in string and/or formats

// @todo: How does p_sep_by_space affect the count if there is a space?

// @todo: Make this more readable

// @todo: Should handle locales (as per setlocale)

// @todo: This one taken from strcmp, but need for other locales; we don't use localeCompare

// @todo: ^-- Now that `table` is an array, maybe we can use that directly using slices,

// @todo: add overflows as above?

// @todo: for IE parseFloat(0.55).toFixed(0) = 0;

// @todo: locale if declared locale hasn't been defined

// @todo: unclear on whether and how sepBySpace, signPosn, or csPrecedes have

// @ts-expect-error

// @ts-expect-error getAttribute does exist

// @ts-expect-error getAttribute exists

// @ts-expect-error: TS errors on an inherited property for some reason

// @ts-expect-error: force empty params when a string is passed to let

// @ts-expect-error: intentionally avoid the type check

// @ts-expect-error: the key matches

// @ts-expect-error: this is internal

// @ts-ignore

// A * x + B * y = x

// A = (Y1 - X1) * (Y2 - X2)

// A = X1 + Z1

// A = X1^2

// A = X2 + Z2

// A = Z1 * Z2

// A bit simpler than readable streams.

// A bit ugly this, too bad the Record's raw data couldn't be saved in a common property named "raw" or something.

// A linked list is used to store data chunks instead of an array because the

// A reduce context, could be using montgomery or something better, depending

// A single base 64 digit can contain 6 bits of data. For the base 64 variable

// A template can be used as a trait if:

// AA = A^2

// ABDAY_

// ABMON_

// AES constants

// AM_STR/PM_STR

// ANY_CALL or ARRAY_CALL

// ANY_CALL or METHOD_CALL

// ActiveX objects in IE.

// Actual mapping tables consist of chunks. Use them to fill up decode tables.

// Adapt this line at the top of any loop, passing in the whole string and

// Add ".UTF-8" or allow ".@latint", etc. to the end?

// Add GB18030 decode tables.

// Add `Array` methods to `lodash.prototype`.

// Add `LazyWrapper` methods for `_.drop` and `_.take` variants.

// Add `LazyWrapper` methods for `_.head` and `_.last`.

// Add `LazyWrapper` methods for `_.initial` and `_.tail`.

// Add `LazyWrapper` methods that accept an `iteratee` value.

// Add `LazyWrapper` methods to `lodash.prototype`.

// Add `num` to `this`

// Add `num` to `this` in-place

// Add aliases.

// Add bit and propagate, if needed

// Add chain sequence methods to the `lodash` wrapper.

// Add decoder for versions of Node not supporting CESU-8

// Add headers to the request

// Add lazy aliases.

// Add methods that return unwrapped values in chain sequences.

// Add methods that return wrapped values in chain sequences.

// Add methods to `Hash`.

// Add methods to `LazyWrapper`.

// Add methods to `ListCache`.

// Add methods to `MapCache`.

// Add methods to `SetCache`.

// Add methods to `Stack`.

// Add methods to `lodash.prototype`.

// Add more encoding pairs when needed.

// Add padding

// Add padding to key

// Add plain number `num` to `this`

// Add properties assigned by `RegExp#exec`.

// Add responseType to request if needed

// Add termination characters

// Add the source content to the _sourcesContents map.

// Add to current entry the information of where we are going

// Add withCredentials to request if needed

// Add xsrf header

// Adding children with empty path should still appear before the parent

// Adding the second element, need to change to array.

// Adjust comment to avoid issue on locutus.io display

// Adjust strings when encounter non-matching whitespace,

// After JIS X 0213 appeared, Shift_JIS-2004, EUC-JISX0213 and ISO2022-JP-2004 followed, with just changing the planes.

// After some profiling, the cache seems to be unnecessary because tokenizePath

// Alert: action must be taken immediately

// Alias UNICODE-1-1-UTF-7

// Alias with options. Can be layered.

// Aliases of generated encodings.

// All clean. Most often case.

// All codecs and aliases are kept here, keyed by encoding name/alias.

// All even indices of this array are one line of the generated code,

// All japanese encodings are based on JIS X set of standards:

// All properties except for `generatedLine` and `generatedColumn` can be

// All the actual chunk generation logic needs to be

// Allow different priority orders of languages, esp. if implement gettext as in

// Allow for a single string or an array of string flags

// Allow for axios('example/url'[, config]) a la fetch API

// Allow for deprecating things in the process of starting up.

// Allow for unix-like usage: A.pipe(B).pipe(C)

// Allow the keys array to be GC'ed.

// Allow us to exit

// Also http://www.mathworks.com/access/helpdesk/help/techdoc/ref/sscanf.html

// Also, if we have no data yet, we can stand some more bytes.

// Although sscanf doesn't support locales,

// Although these are set individually, they are all accumulated

// Always choose a random pivot so that an input array which is reverse

// Ampersand -> '&-'

// An `NaN` primitive is the only value that is not equal to itself.

// And `num` with `this`

// And `num` with `this` in-place

// And first word and num

// And remove leading zeroes

// Anything that was given is translated to buffer

// Apache License 2.0

// Append

// Append data to buffer

// Append length

// Append our div, do our calculation and then remove it

// Apply config defaults

// Apply f() x16 times

// Applying the SourceMap can add and remove items from the sources and

// Are we oob?

// Arguments:

// ArrayBuffer or Uint8Array objects from other contexts (i.e. iframes) do not pass

// As long as the user only uses trusted templates, this is safe.

// Assemble symbol/value/sign and possible space as appropriate

// Assign default placeholders.

// Associate first line with "lastMapping"

// Associate the code between "lastGeneratedColumn" and

// Associate the remaining code in the current line with "lastMapping"

// Assume C locale is like English (?) (We need C locale for LC_CTYPE)

// Assume cyclic values are equal.

// Assumes that `num` is less than `P^2`

// Assuming distinction between numeric and monetary is thus:

// At least give some kind of context to the user

// At this point both numbers are positive

// At this point both numbers have the same sign

// At this point the path should be resolved to a full absolute path, but

// Attempt to read more data if we should.

// Attempts to complete a multi-byte UTF-8 character using bytes from a Buffer.

// Attempts to complete a partial non-UTF-8 character using bytes from a Buffer

// Augment

// Avoid adding a record that doesn't display anything. This allows passing through records without a component to

// Avoid lazy use if the iteratee has a "length" value other than `1`.

// Avoids trying to get a char that does not exist

// Axios

// B = (X1 + Y1)^2

// B = (Y1 + X1) * (Y2 + X2)

// B = A^2

// B = X2 - Z2

// B = Y1^2

// BMP characters: 1 code unit

// BN

// BROWSER QUIRK

// Backwards-compat with node 0.10.x

// Backwards-compat with node 0.4.x

// Base reduction engine

// Base64 ended.

// Based on John Resig's `tmpl` implementation

// Based on http://stackoverflow.com/a/22747272/680742, the browser with

// Basic char

// Because `null` is a special error value in callbacks which means "no error

// Because each offset is encoded relative to the previous one,

// Because it can be sparse, it is represented as array of buckets by 256 chars each. Bucket can be null.

// Because we are modifying the entries (by converting string sources and

// Better compat for @vue/compat users

// Big5 has many variations and is an extension of cp950. We use Encoding Standard's as a consensus.

// Bigint, return as it is (assume big endian)

// Bignum, assume big endian

// Binary search for GB18030. Returns largest i such that table[i] <= val.

// Bootstrap margins and paddings require the +6/+12 corrections

// Both close and finish should trigger unpipe, but only once.

// Both numbers are positive at this point

// Buffer rest of the input

// Buffer#write(string)

// Build up the path for nested routes if the child isn't an absolute

// But allow more writes to happen in this tick.

// But don't agree with "Гг | Hh", nobody talks like that.

// But only overwritten by inherrited constructors

// But the goal of props.transProps is to overwrite base properties

// By convention, when a data property is converted to an accessor

// By default EventEmitters will print a warning if more than 10 listeners are

// By using Object.keys we support both, arrays and objects

// Byte encodings are:

// C = X1^2

// CAPABILITIES

// CESU-8 decoder is not implemented in Node v4.0+

// CESU-8 encoder is also special.

// CHARACTER FOLLOWING PERCENT IS NOT A PERCENT

// CJK ... Yi

// CJK Compatibility Forms

// CJK Compatibility Ideographs

// COERCION

// COMPARE

// CONCATENATED MODULE: ../../CrewScheduling/js/Model/Poll.js

// CONCATENATED MODULE: ../../CrewScheduling/js/pollClient/src/PollClient.vue?vue&type=script&lang=js

// CONCATENATED MODULE: ./SinglePageApplication.js

// CONCATENATED MODULE: ./SinglePageApplication.vue?vue&type=script&setup=true&lang=js

// CONCATENATED MODULE: ./node_modules/@vue/devtools-api/lib/esm/index.js

// CONCATENATED MODULE: ./node_modules/@vue/devtools-api/lib/esm/proxy.js

// CONCATENATED MODULE: ./node_modules/@vue/devtools-api/lib/esm/time.js

// CONCATENATED MODULE: ./node_modules/axios/lib/adapters/xhr.js

// CONCATENATED MODULE: ./node_modules/axios/lib/axios.js

// CONCATENATED MODULE: ./node_modules/axios/lib/cancel/CancelToken.js

// CONCATENATED MODULE: ./node_modules/axios/lib/cancel/CanceledError.js

// CONCATENATED MODULE: ./node_modules/axios/lib/cancel/isCancel.js

// CONCATENATED MODULE: ./node_modules/axios/lib/core/AxiosError.js

// CONCATENATED MODULE: ./node_modules/axios/lib/core/InterceptorManager.js

// CONCATENATED MODULE: ./node_modules/axios/lib/core/buildFullPath.js

// CONCATENATED MODULE: ./node_modules/axios/lib/core/dispatchRequest.js

// CONCATENATED MODULE: ./node_modules/axios/lib/core/mergeConfig.js

// CONCATENATED MODULE: ./node_modules/axios/lib/core/settle.js

// CONCATENATED MODULE: ./node_modules/axios/lib/core/transformData.js

// CONCATENATED MODULE: ./node_modules/axios/lib/env/classes/FormData.js

// CONCATENATED MODULE: ./node_modules/axios/lib/env/data.js

// CONCATENATED MODULE: ./node_modules/axios/lib/helpers/AxiosURLSearchParams.js

// CONCATENATED MODULE: ./node_modules/axios/lib/helpers/HttpStatusCode.js

// CONCATENATED MODULE: ./node_modules/axios/lib/helpers/bind.js

// CONCATENATED MODULE: ./node_modules/axios/lib/helpers/buildURL.js

// CONCATENATED MODULE: ./node_modules/axios/lib/helpers/combineURLs.js

// CONCATENATED MODULE: ./node_modules/axios/lib/helpers/cookies.js

// CONCATENATED MODULE: ./node_modules/axios/lib/helpers/formDataToJSON.js

// CONCATENATED MODULE: ./node_modules/axios/lib/helpers/isAxiosError.js

// CONCATENATED MODULE: ./node_modules/axios/lib/helpers/isURLSameOrigin.js

// CONCATENATED MODULE: ./node_modules/axios/lib/helpers/parseProtocol.js

// CONCATENATED MODULE: ./node_modules/axios/lib/helpers/speedometer.js

// CONCATENATED MODULE: ./node_modules/axios/lib/helpers/spread.js

// CONCATENATED MODULE: ./node_modules/axios/lib/helpers/toFormData.js

// CONCATENATED MODULE: ./node_modules/axios/lib/helpers/toURLEncodedForm.js

// CONCATENATED MODULE: ./node_modules/axios/lib/utils.js

// CONCATENATED MODULE: ./node_modules/twig-lexer/dist/es/lib/SyntaxError.js

// CONCATENATED MODULE: ./node_modules/twig-lexer/dist/es/lib/Token.js

// CONCATENATED MODULE: ./node_modules/twig-lexer/dist/es/lib/TokenStream.js

// CONCATENATED MODULE: ./node_modules/twig-lexer/dist/es/lib/TokenType.js

// CONCATENATED MODULE: ./node_modules/twing/dist/es/base.js

// CONCATENATED MODULE: ./node_modules/twing/dist/es/browser.js

// CONCATENATED MODULE: ./node_modules/twing/dist/es/lib/base-node-visitor.js

// CONCATENATED MODULE: ./node_modules/twing/dist/es/lib/cache/null.js

// CONCATENATED MODULE: ./node_modules/twing/dist/es/lib/callable-wrapper.js

// CONCATENATED MODULE: ./node_modules/twing/dist/es/lib/compiler.js

// CONCATENATED MODULE: ./node_modules/twing/dist/es/lib/context.js

// CONCATENATED MODULE: ./node_modules/twing/dist/es/lib/environment.js

// CONCATENATED MODULE: ./node_modules/twing/dist/es/lib/environment/browser.js

// CONCATENATED MODULE: ./node_modules/twing/dist/es/lib/error.js

// CONCATENATED MODULE: ./node_modules/twing/dist/es/lib/error/loader.js

// CONCATENATED MODULE: ./node_modules/twing/dist/es/lib/error/runtime.js

// CONCATENATED MODULE: ./node_modules/twing/dist/es/lib/error/syntax.js

// CONCATENATED MODULE: ./node_modules/twing/dist/es/lib/extension-set.js

// CONCATENATED MODULE: ./node_modules/twing/dist/es/lib/extension.js

// CONCATENATED MODULE: ./node_modules/twing/dist/es/lib/extension/core.js

// CONCATENATED MODULE: ./node_modules/twing/dist/es/lib/extension/core/filters/abs.js

// CONCATENATED MODULE: ./node_modules/twing/dist/es/lib/extension/core/filters/array-keys.js

// CONCATENATED MODULE: ./node_modules/twing/dist/es/lib/extension/core/filters/batch.js

// CONCATENATED MODULE: ./node_modules/twing/dist/es/lib/extension/core/filters/capitalize.js

// CONCATENATED MODULE: ./node_modules/twing/dist/es/lib/extension/core/filters/column.js

// CONCATENATED MODULE: ./node_modules/twing/dist/es/lib/extension/core/filters/convert-encoding.js

// CONCATENATED MODULE: ./node_modules/twing/dist/es/lib/extension/core/filters/date-modify.js

// CONCATENATED MODULE: ./node_modules/twing/dist/es/lib/extension/core/filters/date.js

// CONCATENATED MODULE: ./node_modules/twing/dist/es/lib/extension/core/filters/default.js

// CONCATENATED MODULE: ./node_modules/twing/dist/es/lib/extension/core/filters/escape.js

// CONCATENATED MODULE: ./node_modules/twing/dist/es/lib/extension/core/filters/filter.js

// CONCATENATED MODULE: ./node_modules/twing/dist/es/lib/extension/core/filters/first.js

// CONCATENATED MODULE: ./node_modules/twing/dist/es/lib/extension/core/filters/format.js

// CONCATENATED MODULE: ./node_modules/twing/dist/es/lib/extension/core/filters/join.js

// CONCATENATED MODULE: ./node_modules/twing/dist/es/lib/extension/core/filters/json-encode.js

// CONCATENATED MODULE: ./node_modules/twing/dist/es/lib/extension/core/filters/last.js

// CONCATENATED MODULE: ./node_modules/twing/dist/es/lib/extension/core/filters/length.js

// CONCATENATED MODULE: ./node_modules/twing/dist/es/lib/extension/core/filters/lower.js

// CONCATENATED MODULE: ./node_modules/twing/dist/es/lib/extension/core/filters/map.js

// CONCATENATED MODULE: ./node_modules/twing/dist/es/lib/extension/core/filters/merge.js

// CONCATENATED MODULE: ./node_modules/twing/dist/es/lib/extension/core/filters/nl2br.js

// CONCATENATED MODULE: ./node_modules/twing/dist/es/lib/extension/core/filters/number-format.js

// CONCATENATED MODULE: ./node_modules/twing/dist/es/lib/extension/core/filters/raw.js

// CONCATENATED MODULE: ./node_modules/twing/dist/es/lib/extension/core/filters/reduce.js

// CONCATENATED MODULE: ./node_modules/twing/dist/es/lib/extension/core/filters/replace.js

// CONCATENATED MODULE: ./node_modules/twing/dist/es/lib/extension/core/filters/reverse.js

// CONCATENATED MODULE: ./node_modules/twing/dist/es/lib/extension/core/filters/round.js

// CONCATENATED MODULE: ./node_modules/twing/dist/es/lib/extension/core/filters/slice.js

// CONCATENATED MODULE: ./node_modules/twing/dist/es/lib/extension/core/filters/sort.js

// CONCATENATED MODULE: ./node_modules/twing/dist/es/lib/extension/core/filters/spaceless.js

// CONCATENATED MODULE: ./node_modules/twing/dist/es/lib/extension/core/filters/split.js

// CONCATENATED MODULE: ./node_modules/twing/dist/es/lib/extension/core/filters/striptags.js

// CONCATENATED MODULE: ./node_modules/twing/dist/es/lib/extension/core/filters/title.js

// CONCATENATED MODULE: ./node_modules/twing/dist/es/lib/extension/core/filters/trim.js

// CONCATENATED MODULE: ./node_modules/twing/dist/es/lib/extension/core/filters/upper.js

// CONCATENATED MODULE: ./node_modules/twing/dist/es/lib/extension/core/filters/url-encode.js

// CONCATENATED MODULE: ./node_modules/twing/dist/es/lib/extension/core/functions/constant.js

// CONCATENATED MODULE: ./node_modules/twing/dist/es/lib/extension/core/functions/cycle.js

// CONCATENATED MODULE: ./node_modules/twing/dist/es/lib/extension/core/functions/date.js

// CONCATENATED MODULE: ./node_modules/twing/dist/es/lib/extension/core/functions/dump.js

// CONCATENATED MODULE: ./node_modules/twing/dist/es/lib/extension/core/functions/include.js

// CONCATENATED MODULE: ./node_modules/twing/dist/es/lib/extension/core/functions/max.js

// CONCATENATED MODULE: ./node_modules/twing/dist/es/lib/extension/core/functions/min.js

// CONCATENATED MODULE: ./node_modules/twing/dist/es/lib/extension/core/functions/random.js

// CONCATENATED MODULE: ./node_modules/twing/dist/es/lib/extension/core/functions/range.js

// CONCATENATED MODULE: ./node_modules/twing/dist/es/lib/extension/core/functions/source.js

// CONCATENATED MODULE: ./node_modules/twing/dist/es/lib/extension/core/functions/template-from-string.js

// CONCATENATED MODULE: ./node_modules/twing/dist/es/lib/extension/core/tests/divisible-by.js

// CONCATENATED MODULE: ./node_modules/twing/dist/es/lib/extension/core/tests/empty.js

// CONCATENATED MODULE: ./node_modules/twing/dist/es/lib/extension/core/tests/even.js

// CONCATENATED MODULE: ./node_modules/twing/dist/es/lib/extension/core/tests/iterable.js

// CONCATENATED MODULE: ./node_modules/twing/dist/es/lib/extension/core/tests/null.js

// CONCATENATED MODULE: ./node_modules/twing/dist/es/lib/extension/core/tests/odd.js

// CONCATENATED MODULE: ./node_modules/twing/dist/es/lib/extension/core/tests/same-as.js

// CONCATENATED MODULE: ./node_modules/twing/dist/es/lib/filter.js

// CONCATENATED MODULE: ./node_modules/twing/dist/es/lib/function.js

// CONCATENATED MODULE: ./node_modules/twing/dist/es/lib/helpers/asort.js

// CONCATENATED MODULE: ./node_modules/twing/dist/es/lib/helpers/chunk.js

// CONCATENATED MODULE: ./node_modules/twing/dist/es/lib/helpers/clone-map.js

// CONCATENATED MODULE: ./node_modules/twing/dist/es/lib/helpers/compare.js

// CONCATENATED MODULE: ./node_modules/twing/dist/es/lib/helpers/constant.js

// CONCATENATED MODULE: ./node_modules/twing/dist/es/lib/helpers/count.js

// CONCATENATED MODULE: ./node_modules/twing/dist/es/lib/helpers/ctype-digit.js

// CONCATENATED MODULE: ./node_modules/twing/dist/es/lib/helpers/ctype-space.js

// CONCATENATED MODULE: ./node_modules/twing/dist/es/lib/helpers/ensure-traversable.js

// CONCATENATED MODULE: ./node_modules/twing/dist/es/lib/helpers/evaluate.js

// CONCATENATED MODULE: ./node_modules/twing/dist/es/lib/helpers/examine-object.js

// CONCATENATED MODULE: ./node_modules/twing/dist/es/lib/helpers/fill.js

// CONCATENATED MODULE: ./node_modules/twing/dist/es/lib/helpers/first.js

// CONCATENATED MODULE: ./node_modules/twing/dist/es/lib/helpers/format-date-time.js

// CONCATENATED MODULE: ./node_modules/twing/dist/es/lib/helpers/format-duration.js

// CONCATENATED MODULE: ./node_modules/twing/dist/es/lib/helpers/get-attribute.js

// CONCATENATED MODULE: ./node_modules/twing/dist/es/lib/helpers/get.js

// CONCATENATED MODULE: ./node_modules/twing/dist/es/lib/helpers/iconv.js

// CONCATENATED MODULE: ./node_modules/twing/dist/es/lib/helpers/is-countable.js

// CONCATENATED MODULE: ./node_modules/twing/dist/es/lib/helpers/is-in.js

// CONCATENATED MODULE: ./node_modules/twing/dist/es/lib/helpers/is-map.js

// CONCATENATED MODULE: ./node_modules/twing/dist/es/lib/helpers/is-plain-object.js

// CONCATENATED MODULE: ./node_modules/twing/dist/es/lib/helpers/is-pure-array.js

// CONCATENATED MODULE: ./node_modules/twing/dist/es/lib/helpers/is-traversable.js

// CONCATENATED MODULE: ./node_modules/twing/dist/es/lib/helpers/iterate.js

// CONCATENATED MODULE: ./node_modules/twing/dist/es/lib/helpers/iterator-to-array.js

// CONCATENATED MODULE: ./node_modules/twing/dist/es/lib/helpers/iterator-to-hash.js

// CONCATENATED MODULE: ./node_modules/twing/dist/es/lib/helpers/iterator-to-map.js

// CONCATENATED MODULE: ./node_modules/twing/dist/es/lib/helpers/ksort.js

// CONCATENATED MODULE: ./node_modules/twing/dist/es/lib/helpers/merge.js

// CONCATENATED MODULE: ./node_modules/twing/dist/es/lib/helpers/modify-date.js

// CONCATENATED MODULE: ./node_modules/twing/dist/es/lib/helpers/parse-regex.js

// CONCATENATED MODULE: ./node_modules/twing/dist/es/lib/helpers/push.js

// CONCATENATED MODULE: ./node_modules/twing/dist/es/lib/helpers/reverse.js

// CONCATENATED MODULE: ./node_modules/twing/dist/es/lib/helpers/slice.js

// CONCATENATED MODULE: ./node_modules/twing/dist/es/lib/lexer.js

// CONCATENATED MODULE: ./node_modules/twing/dist/es/lib/loader/array.js

// CONCATENATED MODULE: ./node_modules/twing/dist/es/lib/loader/chain.js

// CONCATENATED MODULE: ./node_modules/twing/dist/es/lib/loader/null.js

// CONCATENATED MODULE: ./node_modules/twing/dist/es/lib/markup.js

// CONCATENATED MODULE: ./node_modules/twing/dist/es/lib/node-traverser.js

// CONCATENATED MODULE: ./node_modules/twing/dist/es/lib/node-type.js

// CONCATENATED MODULE: ./node_modules/twing/dist/es/lib/node-visitor/escaper.js

// CONCATENATED MODULE: ./node_modules/twing/dist/es/lib/node-visitor/macro-auto-import.js

// CONCATENATED MODULE: ./node_modules/twing/dist/es/lib/node-visitor/safe-analysis.js

// CONCATENATED MODULE: ./node_modules/twing/dist/es/lib/node-visitor/sandbox.js

// CONCATENATED MODULE: ./node_modules/twing/dist/es/lib/node.js

// CONCATENATED MODULE: ./node_modules/twing/dist/es/lib/node/auto-escape.js

// CONCATENATED MODULE: ./node_modules/twing/dist/es/lib/node/block-reference.js

// CONCATENATED MODULE: ./node_modules/twing/dist/es/lib/node/block.js

// CONCATENATED MODULE: ./node_modules/twing/dist/es/lib/node/body.js

// CONCATENATED MODULE: ./node_modules/twing/dist/es/lib/node/check-security.js

// CONCATENATED MODULE: ./node_modules/twing/dist/es/lib/node/check-to-string.js

// CONCATENATED MODULE: ./node_modules/twing/dist/es/lib/node/comment.js

// CONCATENATED MODULE: ./node_modules/twing/dist/es/lib/node/deprecated.js

// CONCATENATED MODULE: ./node_modules/twing/dist/es/lib/node/do.js

// CONCATENATED MODULE: ./node_modules/twing/dist/es/lib/node/embed.js

// CONCATENATED MODULE: ./node_modules/twing/dist/es/lib/node/expression.js

// CONCATENATED MODULE: ./node_modules/twing/dist/es/lib/node/expression/array.js

// CONCATENATED MODULE: ./node_modules/twing/dist/es/lib/node/expression/arrow-function.js

// CONCATENATED MODULE: ./node_modules/twing/dist/es/lib/node/expression/assign-name.js

// CONCATENATED MODULE: ./node_modules/twing/dist/es/lib/node/expression/binary.js

// CONCATENATED MODULE: ./node_modules/twing/dist/es/lib/node/expression/binary/add.js

// CONCATENATED MODULE: ./node_modules/twing/dist/es/lib/node/expression/binary/and.js

// CONCATENATED MODULE: ./node_modules/twing/dist/es/lib/node/expression/binary/bitwise-and.js

// CONCATENATED MODULE: ./node_modules/twing/dist/es/lib/node/expression/binary/bitwise-or.js

// CONCATENATED MODULE: ./node_modules/twing/dist/es/lib/node/expression/binary/bitwise-xor.js

// CONCATENATED MODULE: ./node_modules/twing/dist/es/lib/node/expression/binary/concat.js

// CONCATENATED MODULE: ./node_modules/twing/dist/es/lib/node/expression/binary/div.js

// CONCATENATED MODULE: ./node_modules/twing/dist/es/lib/node/expression/binary/ends-with.js

// CONCATENATED MODULE: ./node_modules/twing/dist/es/lib/node/expression/binary/equal.js

// CONCATENATED MODULE: ./node_modules/twing/dist/es/lib/node/expression/binary/floor-div.js

// CONCATENATED MODULE: ./node_modules/twing/dist/es/lib/node/expression/binary/greater-equal.js

// CONCATENATED MODULE: ./node_modules/twing/dist/es/lib/node/expression/binary/greater.js

// CONCATENATED MODULE: ./node_modules/twing/dist/es/lib/node/expression/binary/in.js

// CONCATENATED MODULE: ./node_modules/twing/dist/es/lib/node/expression/binary/less-equal.js

// CONCATENATED MODULE: ./node_modules/twing/dist/es/lib/node/expression/binary/less.js

// CONCATENATED MODULE: ./node_modules/twing/dist/es/lib/node/expression/binary/matches.js

// CONCATENATED MODULE: ./node_modules/twing/dist/es/lib/node/expression/binary/mod.js

// CONCATENATED MODULE: ./node_modules/twing/dist/es/lib/node/expression/binary/mul.js

// CONCATENATED MODULE: ./node_modules/twing/dist/es/lib/node/expression/binary/not-equal.js

// CONCATENATED MODULE: ./node_modules/twing/dist/es/lib/node/expression/binary/not-in.js

// CONCATENATED MODULE: ./node_modules/twing/dist/es/lib/node/expression/binary/or.js

// CONCATENATED MODULE: ./node_modules/twing/dist/es/lib/node/expression/binary/power.js

// CONCATENATED MODULE: ./node_modules/twing/dist/es/lib/node/expression/binary/range.js

// CONCATENATED MODULE: ./node_modules/twing/dist/es/lib/node/expression/binary/starts-with.js

// CONCATENATED MODULE: ./node_modules/twing/dist/es/lib/node/expression/binary/sub.js

// CONCATENATED MODULE: ./node_modules/twing/dist/es/lib/node/expression/block-reference.js

// CONCATENATED MODULE: ./node_modules/twing/dist/es/lib/node/expression/call.js

// CONCATENATED MODULE: ./node_modules/twing/dist/es/lib/node/expression/conditional.js

// CONCATENATED MODULE: ./node_modules/twing/dist/es/lib/node/expression/constant.js

// CONCATENATED MODULE: ./node_modules/twing/dist/es/lib/node/expression/filter.js

// CONCATENATED MODULE: ./node_modules/twing/dist/es/lib/node/expression/filter/default.js

// CONCATENATED MODULE: ./node_modules/twing/dist/es/lib/node/expression/function.js

// CONCATENATED MODULE: ./node_modules/twing/dist/es/lib/node/expression/get-attribute.js

// CONCATENATED MODULE: ./node_modules/twing/dist/es/lib/node/expression/hash.js

// CONCATENATED MODULE: ./node_modules/twing/dist/es/lib/node/expression/method-call.js

// CONCATENATED MODULE: ./node_modules/twing/dist/es/lib/node/expression/name.js

// CONCATENATED MODULE: ./node_modules/twing/dist/es/lib/node/expression/null-coalesce.js

// CONCATENATED MODULE: ./node_modules/twing/dist/es/lib/node/expression/parent.js

// CONCATENATED MODULE: ./node_modules/twing/dist/es/lib/node/expression/temp-name.js

// CONCATENATED MODULE: ./node_modules/twing/dist/es/lib/node/expression/test.js

// CONCATENATED MODULE: ./node_modules/twing/dist/es/lib/node/expression/test/constant.js

// CONCATENATED MODULE: ./node_modules/twing/dist/es/lib/node/expression/test/defined.js

// CONCATENATED MODULE: ./node_modules/twing/dist/es/lib/node/expression/unary.js

// CONCATENATED MODULE: ./node_modules/twing/dist/es/lib/node/expression/unary/neg.js

// CONCATENATED MODULE: ./node_modules/twing/dist/es/lib/node/expression/unary/not.js

// CONCATENATED MODULE: ./node_modules/twing/dist/es/lib/node/expression/unary/pos.js

// CONCATENATED MODULE: ./node_modules/twing/dist/es/lib/node/flush.js

// CONCATENATED MODULE: ./node_modules/twing/dist/es/lib/node/for-loop.js

// CONCATENATED MODULE: ./node_modules/twing/dist/es/lib/node/for.js

// CONCATENATED MODULE: ./node_modules/twing/dist/es/lib/node/if.js

// CONCATENATED MODULE: ./node_modules/twing/dist/es/lib/node/import.js

// CONCATENATED MODULE: ./node_modules/twing/dist/es/lib/node/include.js

// CONCATENATED MODULE: ./node_modules/twing/dist/es/lib/node/inline-print.js

// CONCATENATED MODULE: ./node_modules/twing/dist/es/lib/node/line.js

// CONCATENATED MODULE: ./node_modules/twing/dist/es/lib/node/macro.js

// CONCATENATED MODULE: ./node_modules/twing/dist/es/lib/node/module.js

// CONCATENATED MODULE: ./node_modules/twing/dist/es/lib/node/print.js

// CONCATENATED MODULE: ./node_modules/twing/dist/es/lib/node/sandbox.js

// CONCATENATED MODULE: ./node_modules/twing/dist/es/lib/node/sandboxed-print.js

// CONCATENATED MODULE: ./node_modules/twing/dist/es/lib/node/set.js

// CONCATENATED MODULE: ./node_modules/twing/dist/es/lib/node/spaceless.js

// CONCATENATED MODULE: ./node_modules/twing/dist/es/lib/node/text.js

// CONCATENATED MODULE: ./node_modules/twing/dist/es/lib/node/verbatim.js

// CONCATENATED MODULE: ./node_modules/twing/dist/es/lib/node/with.js

// CONCATENATED MODULE: ./node_modules/twing/dist/es/lib/operator.js

// CONCATENATED MODULE: ./node_modules/twing/dist/es/lib/output-buffer.js

// CONCATENATED MODULE: ./node_modules/twing/dist/es/lib/parser.js

// CONCATENATED MODULE: ./node_modules/twing/dist/es/lib/sandbox/security-error.js

// CONCATENATED MODULE: ./node_modules/twing/dist/es/lib/sandbox/security-not-allowed-filter-error.js

// CONCATENATED MODULE: ./node_modules/twing/dist/es/lib/sandbox/security-not-allowed-function-error.js

// CONCATENATED MODULE: ./node_modules/twing/dist/es/lib/sandbox/security-not-allowed-method-error.js

// CONCATENATED MODULE: ./node_modules/twing/dist/es/lib/sandbox/security-not-allowed-property-error.js

// CONCATENATED MODULE: ./node_modules/twing/dist/es/lib/sandbox/security-not-allowed-tag-error.js

// CONCATENATED MODULE: ./node_modules/twing/dist/es/lib/sandbox/security-policy.js

// CONCATENATED MODULE: ./node_modules/twing/dist/es/lib/source-map/node-factory.js

// CONCATENATED MODULE: ./node_modules/twing/dist/es/lib/source-map/node-factory/spaceless.js

// CONCATENATED MODULE: ./node_modules/twing/dist/es/lib/source-map/node.js

// CONCATENATED MODULE: ./node_modules/twing/dist/es/lib/source-map/node/spaceless.js

// CONCATENATED MODULE: ./node_modules/twing/dist/es/lib/source.js

// CONCATENATED MODULE: ./node_modules/twing/dist/es/lib/template.js

// CONCATENATED MODULE: ./node_modules/twing/dist/es/lib/test.js

// CONCATENATED MODULE: ./node_modules/twing/dist/es/lib/token-parser.js

// CONCATENATED MODULE: ./node_modules/twing/dist/es/lib/token-parser/apply.js

// CONCATENATED MODULE: ./node_modules/twing/dist/es/lib/token-parser/auto-escape.js

// CONCATENATED MODULE: ./node_modules/twing/dist/es/lib/token-parser/block.js

// CONCATENATED MODULE: ./node_modules/twing/dist/es/lib/token-parser/deprecated.js

// CONCATENATED MODULE: ./node_modules/twing/dist/es/lib/token-parser/do.js

// CONCATENATED MODULE: ./node_modules/twing/dist/es/lib/token-parser/embed.js

// CONCATENATED MODULE: ./node_modules/twing/dist/es/lib/token-parser/extends.js

// CONCATENATED MODULE: ./node_modules/twing/dist/es/lib/token-parser/filter.js

// CONCATENATED MODULE: ./node_modules/twing/dist/es/lib/token-parser/flush.js

// CONCATENATED MODULE: ./node_modules/twing/dist/es/lib/token-parser/for.js

// CONCATENATED MODULE: ./node_modules/twing/dist/es/lib/token-parser/from.js

// CONCATENATED MODULE: ./node_modules/twing/dist/es/lib/token-parser/if.js

// CONCATENATED MODULE: ./node_modules/twing/dist/es/lib/token-parser/import.js

// CONCATENATED MODULE: ./node_modules/twing/dist/es/lib/token-parser/include.js

// CONCATENATED MODULE: ./node_modules/twing/dist/es/lib/token-parser/line.js

// CONCATENATED MODULE: ./node_modules/twing/dist/es/lib/token-parser/macro.js

// CONCATENATED MODULE: ./node_modules/twing/dist/es/lib/token-parser/sandbox.js

// CONCATENATED MODULE: ./node_modules/twing/dist/es/lib/token-parser/set.js

// CONCATENATED MODULE: ./node_modules/twing/dist/es/lib/token-parser/spaceless.js

// CONCATENATED MODULE: ./node_modules/twing/dist/es/lib/token-parser/use.js

// CONCATENATED MODULE: ./node_modules/twing/dist/es/lib/token-parser/verbatim.js

// CONCATENATED MODULE: ./node_modules/twing/dist/es/lib/token-parser/with.js

// CONCATENATED MODULE: ./node_modules/twing/dist/es/lib/token-stream.js

// CONCATENATED MODULE: ./node_modules/vue-router/dist/vue-router.mjs

// CONCATENATED MODULE: ./util/markdown.js

// CONCATENATED MODULE: ./util/transliterate.js

// CONCATENATED MODULE: ./ux/Log.js

// CONSTRUCT

// Cached version of prime

// Calculate skipping beyond initial percent too

// Call `cb(err)` when you are done with this chunk.  If you pass

// Call `push(newChunk)` to pass along transformed output

// Can add to the locales

// Can typed array instances can be augmented?

// Can we throw a warning instead? That would be more in line with PHP

// Canonicalize encoding name: strip all non-alphanumeric chars and appended year.

// Carry

// Chainable

// Char is one of surrogates.

// Character begins range

// Character is by itself

// Character sequence (our own encoding used)

// Characters emitted in case of error.

// Check BOM.

// Check Symbol.for because not everywhere where Symbol defined

// Check bit and return

// Check for circular references and return its corresponding clone.

// Check for listener leak

// Check for overlong encoding, but support Modified UTF-8 (encoding NULL as C0 80)

// Check if data is there

// Check if it can be mapped by the source map, then update the mapping.

// Check if module is in cache

// Check if tag is there

// Check if we're actually ready to finish, but don't emit yet

// Check that cyclic values are equal.

// Check that value is an object with an inspect function on it

// Check that we didn't get one last unshift.

// Check which string ended first

// Checking for a Stream.Duplex instance is faster here instead of inside

// Checks at most 3 bytes at the end of a Buffer in order to detect an

// Checks that a user-supplied chunk is valid, especially for the particular

// Checks the type of a UTF-8 byte, whether it's ASCII, a leading byte, or a

// Choose the decoding node where we'll write our chars.

// Choose the lambda that is matching selected beta

// Choose the smallest beta

// Chromium doesn't support fixed-offset zones like Etc/GMT+8 in its formatter,

// Clamp

// Clamp excess bits

// Class DBCSCodec reads and initializes mapping tables.

// Clean up request

// Clean-up references to points and coefficients

// Cleanup code by stripping empty strings.

// Codec is not chosen yet. Accumulate initial bytes.

// Codec itself.

// Codec.

// Coerce booleans to `1` or `0` and dates to milliseconds.

// Coerce regexes to strings and treat strings, primitives and objects,

// Coerce to Number.

// Comb small window NAFs

// Comments include nl_langinfo() constant equivalents and any

// Common case.

// CommonJS

// Compare two numbers and return:

// Compatibility with BaseCurve

// Compose partial arguments.

// Compose partial right arguments.

// Computation

// Compute a class based on the current route

// Compute beta and lambda, that lambda * P = (beta * Px; Py)

// Compute constants

// Compute double table

// Compute inv sub bytes, inv mix columns tables

// Compute multiplication

// Compute sbox

// Concat

// Construct base tree

// Constructor

// Consumes a specified amount of bytes from the buffered data.

// Consumes a specified amount of bytes or characters from the buffered data.

// Consumes a specified amount of characters from the buffered data.

// Continuation byte

// Convert

// Convert each char in bytes[] to a byte

// Convert key to integer if it is stringified

// Convert message to array, pad it, and join into 32bit blocks

// Convert string to WordArray, else assume WordArray already

// Convert to normal trFrom->trTo chars

// Convert to string

// Cooley-Tukey algorithm for FFT

// Copy 0 bytes; we're done

// Copy axios.prototype to instance

// Copy context to instance

// Copy mapping

// Copy one byte at a time

// Copy one word at a time

// Copy properties from require('buffer')

// Copy rest of the words

// Copy sourcesContent into SourceNode

// Copy sourcesContents of applied map.

// Copy static methods from Buffer

// Copyright Joyent, Inc. and other Node contributors.

// Could use URL and URLSearchParams but IE 11 doesn't support it

// Could use `inherits` module, but don't want to move from single file

// Count number of octets

// Count octets required to store length

// Count zeroes

// Country flags are comprised of two regional indicator symbols,

// Country flags: 4 code units (2 code points)

// Counts of chars in both positions

// Create a four-byte string (length 2) since this code point is high

// Create a new _sourcesContents map if the property is null.

// Create a new module (and put it into the cache)

// Create altered use decoder if implicit is set

// Create bucket on demand.

// Create default initializer

// Create lookup table for `toString('hex')`

// Create new node.

// Create possibly bigger array to ensure that it fits the number

// Create root node.

// Create the default instance to be exported

// Create the main formatMessage that tries to get instance but falls back gracefully

// Create the regular expression

// Critical: critical conditions

// Crypto is kind of old and crusty.  Historically, its default string

// Currencies

// Current character is not part of the sequence.

// Current understanding of how to deal with Big5(-HKSCS) is in the Encoding Standard, http://encoding.spec.whatwg.org/#big5-encoder

// Currently in sync with Node.js lib/internal/util/types.js

// Curve configuration, optional

// Curve: A * X^2 + Y^2 = C^2 * (1 + D * X^2 * Y^2)

// Cyrillic

// D = a * A

// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR

// DATE BASICS

// DAY_

// DOCUMENTED UNDER SPRINTF

// DOCUMENTED UNDER SSCANF

// D_FMT

// D_FMT // switched order of %m and %d; changed %y to %Y (C uses %y)

// D_T_FMT

// D_T_FMT // changed %T to %r per results

// Danger Will Robinson

// Days, numeric

// Days, numeric, at least 2 digits with leading 0

// Debug: debug messages

// Decide how many code units make up the current character.

// Decode children

// Decode contained/encoded by schema, only in bit or octet strings

// Decode in chunks to avoid "call stack size exceeded".

// Decode root node

// Decode surrogate

// Decode tables: MBCS -> Unicode.

// Decoder chooses automatically from UTF-16LE and UTF-16BE using BOM and space-based heuristic.

// Decoder default can be changed: iconv.decode(buf, 'utf16', {defaultEncoding: 'utf-16be'});

// Decoder helpers

// Decoder state

// Decoding

// Default value

// Default value, can be overridden

// Defaults to UTF-16LE, as it's prevalent and default in Node.

// Define injection key at module level

// Definite form

// Denormalize

// Description of supported double byte encodings and aliases.

// Detect free variable `module`

// Detect free variables `exports`

// Determine if the form group will be rendered horizontal

// Differences:

// Direct alias to other encoding.

// Direct character or '&'.

// Do not allow % in last char. class

// Do not allow % in last char. class:

// Do not cache `Buffer.isEncoding` when checking encoding names as some

// Doesn't matter what the args are here.

// Don't bother if no value provided

// Don't do anything if add isn't an object

// Don't emit readable right away in sync mode, because this can trigger

// Don't have enough

// Don't raise the hwm > 1GB

// Don't store the `typeof` result in a variable to avoid a JIT bug in Safari 9.

// Don't use 'blue' not visible on cmd.exe

// Double in extended coordinates

// Double lead surrogate found.

// Duplex streams are both readable and writable, but share

// E = (X1 + Y1)^2 - A - B

// E = 3 * A

// E = C + D

// E = a * C

// ECDH

// ECDSA

// ES6 symbol

// ESM COMPAT FLAG

// EUC-KR, KS_C_5601 and KS X 1001 are exactly the same.

// EXPORTS

// EXTERNAL MODULE: ./common.js

// EXTERNAL MODULE: ./node_modules/@vue/reactivity/dist/reactivity.esm-bundler.js

// EXTERNAL MODULE: ./node_modules/@vue/runtime-core/dist/runtime-core.esm-bundler.js

// EXTERNAL MODULE: ./node_modules/@vue/runtime-dom/dist/runtime-dom.esm-bundler.js

// EXTERNAL MODULE: ./node_modules/css-loader/dist/cjs.js!./node_modules/bootstrap-vue-next/dist/bootstrap-vue-next.css

// EXTERNAL MODULE: ./node_modules/css-loader/dist/cjs.js!./node_modules/vue-loader/dist/stylePostLoader.js!./node_modules/vue-loader/dist/index.js??ruleSet[1].rules[14].use[0]!../../CrewScheduling/js/pollClient/src/PollClient.vue?vue&type=style&index=0&id=4bd1f384&lang=css

// EXTERNAL MODULE: ./node_modules/events/events.js

// EXTERNAL MODULE: ./node_modules/form-data/lib/browser.js

// EXTERNAL MODULE: ./node_modules/locutus/php/math/index.js

// EXTERNAL MODULE: ./node_modules/locutus/php/strings/index.js

// EXTERNAL MODULE: ./node_modules/lodash/lodash.js

// EXTERNAL MODULE: ./node_modules/luxon/build/cjs-browser/luxon.js

// EXTERNAL MODULE: ./node_modules/path-browserify/index.js

// EXTERNAL MODULE: ./node_modules/source-map/source-map.js

// EXTERNAL MODULE: ./node_modules/style-loader/dist/runtime/injectStylesIntoStyleTag.js

// EXTERNAL MODULE: ./node_modules/twing-intl/browser.js

// EXTERNAL MODULE: ./node_modules/twing/dist/es/browser.js + 245 modules

// EXTERNAL MODULE: ./node_modules/util/util.js

// EXTERNAL MODULE: ./util/datetimeformat.js

// Each line is added as separate string.

// Each object in the arrays is of the form:

// Earlier IE may not support access by string index

// Either this is the first call, activity has stopped and we're at the

// Emergency: system is unusable

// Emits a 'removeListener' event if and only if the listener was removed.

// Emoji with skin-tone modifiers: 4 code units (2 code points)

// Empty buffer means no match

// Emulate crypto API using randy

// Enable the 3 lines below to set the same limits on string length as PHP does

// Encode children first

// Encode data itself

// Encode matching character

// Encode space before CRLF sequence to prevent spaces from being stripped

// Encode tables: Unicode -> DBCS.

// Encoder helpers

// Encoder is mostly trivial

// Encoder state

// Encoder uses UTF-16LE and prepends BOM (which can be overridden with addBOM: false).

// Encoding

// Encoding buffer.

// Encodings

// Enough data, try updating

// Ensure `LazyWrapper` is an instance of `baseLodash`.

// Ensure locale data is available

// Ensure readable listeners eventually get something

// Ensure string.

// Ensure that the priv won't be bigger than n, otherwise we may fail

// Ensure the locale data we need is set up

// Ensure the loop is entered when path is empty.

// Ensure the sign of `-0` is preserved.

// Ensure wrappers are instances of `baseLodash`.

// Error: error conditions

// Escape characters that can't be included in string literals.

// Etc/GMT+8 -> -480

// EventEmitters, we do not listen for `error` events here.

// EventTarget does not have `error` event semantics like Node

// Every written chunk gets output as-is.

// Everything else in the universe uses 'utf8', though.

// Ex overwrite this.preventDefault = () => true is valid. Could be a TS issue

// Except base64 encoder, which must keep its state.

// Execute the module function

// Existing node.

// Exit early for strings to avoid a performance hit in some environments.

// Exit early if metadata can't be merged.

// Export Node.js internal encodings.

// Export for testing

// Export lodash.

// Exported mostly for testing purposes, use plain name instead

// Exports

// Expose Axios class to allow class inheritance

// Expose AxiosError class

// Expose Cancel & CancelToken

// Expose Lodash on the global object to prevent errors when Lodash is

// Expose `MapCache`.

// Expose all/spread

// Expose isAxiosError

// Expose mergeConfig

// Extend the buffer with leading zeroes

// Extended mode, copy masked part

// Extension does not match, so our result is the entire path

// F = E + D

// F = E^2

// FORMAT PRESETS

// Factory for creating new instances

// Failure

// Fallback for data views, maps, sets, and weak maps in IE 11 and promises in Node.js < 6.

// Fallback, but not a true polyfill

// Fast case

// Fast case - exact division

// Fast case, write everything using _writev()

// Fast case: bit is much higher than all existing words

// Fast forward

// Fast length reduction

// Fast path: If `val` fits into a single byte, use that numeric value.

// Faster (in FF) than type checking

// Fatal error conditions

// Fedor, you are amazing.

// Filter children

// Filter children and args

// Filter out the util module, it's inspect function is special

// Final message update

// Finally, search either indexOf (if dir is true) or lastIndexOf

// Find Q and S, that Q * 2 ^ S = (P - 1)

// Find Round(`this` / `num`)

// Find `this` % `num`

// Find `this` / `num`

// Find d and s, (n - 1) = (2 ^ s) * d;

// Find length of limb in base

// Find mappings for the "sourceFile"

// Find roots of for x^2 + x + 1 in F

// Find the section containing the generated position we're trying to map

// Finds either the first index of `val` in `buffer` at offset >= `byteOffset`,

// Firefox 3 canonicalizes DDA to undefined when it's not accessed directly

// First check if there is a new line in between.

// First chunk is a perfect match.

// First element of chunk is the hex mbcs code where we start.

// First phase

// Fixes an `Array#sort` bug in the JS engine embedded in Adobe applications

// Flag the module as loaded

// Flatten headers

// Following are from nl_langinfo() or http://www.cptec.inpe.br/sx4/sx4man2/g1ab02e/strftime.4.html

// For IE11 support

// For UTF-16LE we do not explicitly append special replacement characters if we

// For UTF-8, a replacement character is added when ending on a partial

// For cases like 'first argument'

// For detailed explanations, see http://web.archive.org/web/20031128125047/http://www.uwm.edu/cgi-bin/IMT/wwwman?topic=scanf%283%29&msection=

// For example: from='/'; to='/foo'

// For example: from='/foo'; to='/'

// For example: from='/foo/bar'; to='/foo/bar/baz'

// For example: from='/foo/bar/baz'; to='/foo/bar'

// For example: https://github.com/Polymer/polymer-bundler/pull/519

// For lambda functions, var_export() outputs such as the following:

// For now when you opt-in to autoDestroy we allow

// For old IE

// For some reason typeof null is "object", so special case here.

// Force an array if not already something iterable

// Force coercion to uint32. This will also coerce falsey/NaN values to 0.

// Force redgomery representation when loading from JSON

// Force the navigation, this also resets the call count

// Format indicated a percent literal, but not actually present

// Found. Write it.

// Four or more are not supported for CESU-8.

// Fractional digits only for money defaults?

// Frame code as the function body.

// Full-blown Unicode including non-Basic-Multilingual-Plane characters

// Fullwidth Forms

// GB18030 is an algorithmic extension of GBK.

// GBK (~22000 chars) is an extension of CP936 that added user-mapped chars and some other.

// Generage random bytes until a number less than n is found.

// Generalized Greg Maxwell's trick

// Generally 3M + 4S or 2M + 4S

// Generate a random number greater than or equal to start and less than stop.

// Generate the relative path based on the path difference between `to`

// Generated by CoffeeScript 2.4.0

// Generated column.

// Generated data for sbcs codec. Don't edit manually. Regenerate using generation/gen-sbcs.js script.

// Generic flexbox .col (xs)

// Generic utils

// Get NAF form

// Get basis vectors, used for balanced length-two representation

// Get character; suppresses skipping over whitespace!

// Get integer portion

// Get non-dir info

// Get the next highest power of 2 to prevent increasing hwm excessively in

// Get the root of character tree according to first character of the sequence.

// Global attributes allowed on any supplied element below.

// Go one further, since one of the "characters" is part of a surrogate pair

// Go to next trie node.

// Greedy match

// H = (c * Z1)^2

// H = Z1^2

// HELPER FUNCTIONS

// HTTP basic authentication

// Had to add Check for XmlReader, #isData returns true if root is an Xml-object.  Want to check in order to re-factor

// Handle browser request cancellation (as opposed to a manual cancellation)

// Handle cancellation

// Handle complete words

// Handle invocations in a tight loop.

// Handle low level network errors

// Handle progress if needed

// Handle string cases:

// Handle the residue

// Handle timeout

// Hangul Jamo init. consonants

// Hangul Syllables

// Hash final blocks

// Hash for function for DRBG

// Helper

// Helpful info at http://ftp.gnu.org/pub/pub/old-gnu/Manuals/glibc-2.2.3/html_chapter/libc_7.html

// Here we could also revert the navigation by calling history.go(-delta)

// Here we could call if (info.delta) routerHistory.go(-info.delta,

// Here we go...

// Here's how this works:

// High surrogate (could change last hex to 0xDB7F to

// High surrogate (could change last hex to 0xDB7F to treat

// High surrogate (could change last hex to 0xDB7F to treat high private surrogates as single

// Historically, SourceMapConsumer did not take the sourceMapURL as

// Hours, numeric

// Hours, numeric, at least 2 digits with leading 0

// However, even in such a pathological case, only a single written chunk

// However, if we're not ended, or reading, and the length < hwm,

// However, some cases require setting options to different

// I really want to avoid writing a BCP 47 parser

// I think this is right

// I'm just going to ignore that

// IE

// IE 8 does not throw here

// IE 8 has a broken defineProperty

// IE 8 has a broken gOPD

// IE 8 throws on Object.getOwnPropertyDescriptor(arguments, '')

// IE does not have builtin `{ once: true }` support so we

// IE doesn't make error fields non-enumerable

// IE needs attribute set twice to normalize properties

// IE only adds stack when thrown

// IE returns elements with the 'name' and 'id' attribute.

// IE won't copy toString using the loop above

// INFO

// ISO and SQL parsing

// ISO duration parsing

// If --no-deprecation is set, then it is a no-op.

// If LSB(V_i) is 1, V_i+1 = (V_i >> 1) ^ R

// If _read pushed data synchronously, then `reading` will be false,

// If `variable` is not specified wrap a with-statement around the generated

// If a char was set before - make it a single-char subsequence.

// If aSourceFile is omitted, we will use the file property of the SourceMap

// If both pairs are regional indicator symbols, take 4

// If bytes.length is odd, the last 8 bits must be ignored (same as node.js)

// If has modified constructor

// If has modified prototype

// If it's different, we're in a hole time. The offset has changed, but the we don't adjust the time

// If no character left in expression

// If not a boolean, ensure that value is null

// If not, change the ts by the difference in the offset

// If our lower bound is less than our upper bound, we (1) partition the

// If rs is NOT an array but data IS, see if data contains just 1 record.  If so extract it and carry on.

// If setEncoding(null), decoder.encoding equals utf8

// If so, offset didn't change and we're done

// If that gives us the local time we want, we're done

// If the 'end' option is not supplied, dest.end() will be called when

// If the _sourcesContents map is empty, set the property to null.

// If the curve is endomorphic, precalculate beta and lambda

// If the next pair make a Fitzpatrick skin tone

// If the only part of the root that is left is the scheme (i.e. http://,

// If the user unpiped during `dest.write()`, it is possible

// If the user uses them, then switch into old mode.

// If the writable side ended, then we're ok.

// If there is no 'error' event listener then throw.

// If this is our first dot, mark it as the start of our extension

// If url is already wrapped in quotes, remove them

// If we don't have a value that is part of a surrogate pair, or we're at

// If we don't know, then assume that we are waiting for one.

// If we have nothing in the buffer, then we want to know

// If we reached a path separator that was not part of a set of path

// If we return false, then we need a drain event, so set that flag.

// If we tried to read() past the EOF, then emit end on the next tick.

// If we're asking for more than the current hwm, then raise the hwm.

// Ignore non-index properties.

// Ignores initial zeroes, unlike %i and parseFloat()

// Ignores initial zeroes, unlike %i and parseInt()

// Immediately after `j` is incremented in this loop, the following hold

// Implement an async ._write(chunk, encoding, cb), and it'll handle all

// In Firefox 4-22, defining length on an array throws an exception.

// In a transform stream, the written data is placed in a buffer.  When

// In addition to the above conditions to keep reading data, the following

// In case of duplex streams we need a way to detect

// In order to make Suspense tree-shakable, we need to avoid importing it

// In other cases, the parent container is not actually used so we

// In theory there could be aribitrary day periods. We're gonna assume there are exactly two

// In true node style we process the callback on `nextTick` with all the

// In-place Multiplication

// In-place division by number

// Include content inside buttons

// Include content inside links

// Included in count presumably?

// Incomplete surrogate pair - only lead surrogate found.

// Incomplete surrogate pair - only trail surrogate found.

// Increment at the bit position in-line

// Indefinite form

// Indefinite length or overflow

// Indefinite length... find END tag

// IndexedSourceMapConsumer.prototype.sourceContentFor. In that case, we

// Informational: informational messages

// Initial 0x not necessary here

// Initial Permutation

// Initial values

// Initialization and Errors

// Initialize as zero

// Initialize quotient

// Initializer's prototype is the subtype object

// Insert new dimension

// Inspired by stringToUtf8ByteArray() in closure-library by Google

// Instantiate Hmac_DRBG

// Instead, we'll do this:

// Integer with base detection (Equivalent of 'd', but base 0 instead of 10)

// Integer, meaning increasing sequence starting with prev character.

// Intermediate hash value

// Invalid dates are coerced to `NaN`.

// Invalid flags

// Invalid ranges are not set to a default, so can range check early.

// Invert number in the field F(num)

// Invoke the leading edge.

// It is also done this way as a slight performance increase instead of using a

// It is an ugly unfortunate mess of history.

// It is forgiving, closer to standard UTF-7 (for example, '-' is optional at the end).

// It is possible for the path to be above the root. In this case, simply

// It seems a linked list but it is not

// It should not recurse.

// It turns out that some (most?) JavaScript engines don't self-host

// It'll be called only once (for each different options object).

// Iterate over array values

// Iterate over current buffer to convert already stored Buffers:

// Iterate over object keys

// Iterate to stop any buffered/delayed events

// Iterate until either we run out of mappings, or we run into

// J +- J

// J +- P

// J = E - 2 * H

// J = F - 2 * H

// JIS X 0201 - Single-byte encoding of ASCII + ¥ + Kana chars at 0xA1-0xDF.

// JIS X 0208 - Main set of 6879 characters, placed in 94x94 plane, to be encoded by 2 bytes. 

// JIS X 0212 - Supplementary plane of 6067 chars in 94x94 plane. 1990. Effectively dead.

// JIS X 0213 - Extension and modern replacement of 0208 and 0212. Total chars: 11233.

// JIT'd JS is rather slow *and* loses JIT type information, resulting in

// JSONP chunk loading for javascript

// JavaScript style would be to return Number.NEGATIVE_INFINITY

// Just add the character unescaped

// Just for compatibility with Short curve

// Just get the locale

// Just like this:

// Just truncate output

// K = 0x1000003d1 = [ 0x40, 0x3d1 ]

// K = 0x13

// Keep Unicode combining characters together with the character preceding

// Keep hard line breaks intact; CRLF sequences

// KeyPair(ec, { priv: ..., pub: ... })

// LANGUAGE env. var.? (e.g., show German if French is not available)

// LIFO order

// Lastly, append the rest of the destination (`to`) path that comes after

// Latin Extended-A block.

// Latin-1 Supplement block.

// Lazily create decoder

// Lazily create encoder

// Lazy load all encoding definitions.

// Leading byte

// Leading zeroes

// Legacy `process.binding('util')` for Node.js < 10.

// Legacy aliases to convert functions

// Len is always even.

// Length is the combined lengths of all the buffers in the list.

// Levenshtein distance

// Leverage the exponentiation by squaring algorithm for a faster repeat.

// Lines are stored 0-based

// Listen for ready state to emulate onloadend

// Load & create GB18030 tables when needed.

// Load GB18030 ranges.

// Load Node primitive extensions.

// Load extensions in Node. All of them are omitted in Browserify build via 'browser' field in package.json.

// Load streaming support in Node v0.10+

// Load tables.

// Locale not found

// Locale.Gettext.PO

// Long form

// Look up the keys of the object.

// Lookup in current trie node.

// Low surrogate

// Low surrogate (0xDC00 <= code && code <= 0xDFFF)

// Lower case the entire string.

// M = 3 * XX + a

// M = 3 * XX + a; a = 0

// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN

// MISC

// MON_

// Main source: https://www.w3.org/TR/encoding/#gbk-encoder

// Make "sourceFile" relative if an absolute Url is passed.

// Make Array say that they are Array

// Make RegExps say that they are RegExps

// Make a list of key names

// Make copies

// Make dates with properties first say the date

// Make error with message first say the error

// Make functions say that they are functions

// Make prev buf overlap a little to make it easier to slice later.

// Make sure our error handler is attached before userland ones.

// Make sure the linked list only shows the minimal necessary information.

// Make sure we add a "../" for each component we removed from the root.

// Manually added data to be used by sbcs codec in addition to generated one.

// Manually shove something into the read() buffer.

// Map

// Map minified method names to their real names.

// Mappings do not contain a field for the last generated columnt. We

// Mappings end at eol

// Mark that a method should not be used.

// Marker for special handling inside the renderer. We are not using a ===

// Math.LN10

// Math.PI

// Math.pow(`this`, `num`)

// Maybe aSource is an absolute URL as returned by |sources|.  In

// Microseconds, numeric

// Microseconds, numeric, at least 6 digits with leading 0

// Microsoft

// Microsoft's CP936 is a subset and approximation of GBK.

// Might be overrided

// Mimic the constructor's `return` behavior.

// Minimal chunk: 2 quads -> 2x3 bytes -> 3 chars.

// Minimum supported duration is 1 second

// Minus is absorbed after base64.

// Minus may be absorbed after base64.

// Minutes, numeric, at least 2 digits with leading 0

// Modern browsers

// Module

// Montgomery method engine

// Montgomery points only have an `x` coordinate.

// Months, numeric

// Months, numeric, at least 2 digits with leading 0

// More LC_TIME

// Most of the time, the content has ASCII chars (U+00**), but the opposite (U+**00) is uncommon.

// Move PURE marker to new line to workaround compiler discarding it

// Mozilla

// Multi-octet tag - load

// Multibyte codec. In this scheme, a character is represented by 1 or more bytes.

// Multiply `this` by `num`

// Multiply employing FFT

// Must force callback to be called on nextTick, so that we don't

// N * Q + Q = ((N / 2) * Q + Q)) + (N / 2) * Q

// N * Q + Q = 2 * ((N / 2) * Q + Q)

// N * Q = ((N / 2) * Q + Q) + ((N / 2) * Q)

// N * Q = 2 * ((N / 2) * Q + Q))

// N = 1 => 6M + 6S + 9A

// NAMESPACE OBJECT: ./node_modules/vue/dist/vue.runtime.esm-bundler.js

// NB: mutates parameters

// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,

// NOTE (from Ext docs): The default value used when a Record is being created by a Reader when the item referenced by the mapping does not exist in the data object (i.e. undefined). (defaults to "")

// NOTE: (qj / bhi) is (0x3ffffff * 0x4000000 + 0x3ffffff) / 0x2000000 max

// NOTE: 1) `mode` can be set to `mod` to request mod only,

// NOTE: Date.parseDate is an ext augmentation, should not be necessary for our ISO date format

// NOTE: Greg Maxwell's trick, inspired by:

// NOTE: Important as we are creating point in Base.call()

// NOTE: Safari throws a SecurityError when calling this function 100 times in 30 seconds

// NOTE: Server can't handle this properly, see {tine20/vendor/zendframework/zendframework1/library/Zend/Filter/Input.php:998}

// NOTE: These type checking functions intentionally don't use `instanceof`

// NOTE: We are ignoring errors here, to let parser continue with other

// NOTE: `hint` is a lowest bit before trailing zeroes

// NOTE: at this point to.matched is normalized and does not contain any () => Promise<Component>

// NOTE: at this stage it is known that the top bit is set

// NOTE: gets overwritten with Record.getDefaultData (see below) for autogenerated models in appStarter

// NOTE: if `extended` is present - it will be filled with destroyed bits

// NOTE: lo is 27bit maximum

// NOTE: some browsers require user interaction (like click events)

// NOTE: this field default is meant for doctrine on server

// NOTE: ui config overwrites db config

// NOTE: we can't use export / import syntax as es6 modules require strict mode and this code can't cope with it

// NOTE: we could also allow a function to be applied to every component.

// NOTE: we want to flag colorful emojis only, therefore we can't use the emoji-regex lib

// NUMBERS AND STRINGS

// Naive implementation, but it works because CESU-8 is especially easy

// Naive implementation.

// Need to add 2 to ensure we leave enough space

// Need to change any of these for English as opposed to C?

// Needs special escaping

// Negative limit

// New line encoded data starts with number of bytes encoded.

// No BOM found. Try to deduce encoding from initial content.

// No apostrophe at beginning unless allowed in charlist (or locale)

// No decimal or fractional digits

// No efficient endomorphism

// No error code for this since it is a Warning

// No hyphen at beginning or end unless allowed in charlist (or locale)

// No instance available, use default textdomain

// No more remaining code, continue

// No need to verify that "this.length <= MAX_UINT32" since it's a read-only

// No operation performed.

// No-op

// Node allows for non-padded base64 strings (missing trailing ===), base64-js does not

// Node converts strings with length < 2 to ''

// Node strips out invalid characters like \n and \t from the string, base64-js does not

// Node takes equal signs as end of the Base64 encoding

// Node v0.8 doesn't have this method.

// Node's code seems to be doing this and not & 0x7F..

// Node.js 0.10 has enumerable non-index properties on buffers.

// Node.js >= 4.5.0

// Node.js LazyTransform implementation, which has a non-trivial getter for

// Node.js or Web worker with no crypto support

// Non `Object` object instances with different constructors are not equal.

// Non-BMP characters (represented by surrogate pairs): 2 code units

// Non-direct character

// Non-direct chars are encoded as "+<base64>-"; single "+" char is encoded as "+-".

// Non-greedy match

// Normalize byteOffset

// Normalize byteOffset: negative offsets start from the end of the buffer

// Normalize coordinates

// Normalize signs

// Normalize the path

// Normalize val

// Not ``this`` with ``width`` bitwidth

// Not all browsers support upload events

// Not available in nl_langinfo()

// Not supported - couldn't distinguish from other integers

// Not supported by iconv, not sure why.

// Not supported in PHP sscanf; the argument is treated as an integer,

// Not thread-safe; temporarily set to true

// Note that array_slice() will reorder and reset the ***numeric*** array indices by default. [...]

// Note that this may be asynchronous, or synchronous.  Yes, it is

// Note: 0 is a valid value, means "don't call _read preemptively ever"

// Note: 0 is a valid value, means that we always return false if

// Note: Change prototype *after* Buffer.from is defined to workaround Chrome bug:

// Note: The comments on the `throw` lines are intentional, they show

// Note: UTF16-LE (or UCS2) codec is Node.js native. See encodings/internal.js

// Note: cannot use `length < K_MAX_LENGTH` here because that fails when

// Notice: normal but significant condition

// Number of characters processed so far

// Number of trailing zero bits

// O + P = P

// OBJECTS AND ARRAYS

// OK

// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF

// OR the last index of `val` in `buffer` at offset <= `byteOffset`.

// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE

// OUTPUT

// Objects are kept separately from encodeTable to increase performance.

// Obviously not all Emitters should be limited to 10. This function allows

// Octal

// Octal begins range

// Octal integer // @todo: add overflows as above?

// Octal is by itself

// Ok to replace with j++;?

// Old junk

// Oldest GB2312 (1981, ~7600 chars) is a subset of CP936

// Once again, Sass deviates from the spec and supplies the version as a

// Only apply `aria-labelledby` if we are a horizontal fieldset

// Only consider this section if the requested source is in the list of

// Only flow one buffer at a time

// Only inspect one level.

// Only invoke if we have `lastArgs` which means `func` has been

// Only needed for Opera Mini

// Only remove fractional portion if explicitly set to zero digits

// Optimization - zeroify

// Optimize the case of one listener. Don't need the extra array object.

// Optional additional data

// Optional encoding

// Optional entropy enc

// Optionally signed decimal integer

// Or `num` with `this`

// Or `num` with `this` in-place

// Or accept compatible API

// Order matters here since the props.transProps would get overwritten if it came first

// Original column.

// Original line.

// Original name.

// Original source.

// Otherwise people can pipe Writable streams, which is just wrong.

// Otherwise we risk emitting data in the flow()

// Otherwise, PHP returns the portion of the string from start to end.

// Our UTC time is just a guess because our offset is just a guess

// Our codec supports UTF-16 surrogates, extensions for GB18030 and unicode sequences.

// Our needle is greater than aHaystack[mid].

// Our needle is less than aHaystack[mid].

// Output a sequence of chars.

// Overall, it seems that it's a mess :( http://www8.plala.or.jp/tkubota1/unicode-symbols-map2.html

// Overrided methods

// P + (-P) = O

// P + O = P

// P + P = 2P

// P + Q = O

// P = 2 ^ N - K

// PARSING

// PHP behavior may differ by including whitespace even outside of the enclosure

// PHP behavior, you would need to add ".replace(/~/g, '%7E');" to the following.

// PHP doesn't currently escape if more than one 0, but it should:

// PHP returns an empty string if start and end are the same.

// PHP returns false if start does not fall within the string.

// PHP returns false if the calculated end comes before the calculated start.

// PHP-style

// POST-PROCESSING

// PROCESS

// PROCESS CHARACTER

// Pad values

// Pad with zeroes

// Parse input

// Parse remaining as usual.

// Part is done as: http://zakon4.rada.gov.ua/laws/show/55-2010-%D0%BF

// Pass `true` below to allow duplicate names and sources. While source maps

// Pass bytes on through for single-byte encodings (e.g. ascii, latin1, hex)

// Peel one iteration (compiler can't do it, because of code complexity)

// Per PHP behavior, there seems to be no extra padding

// Percent does not seem to be allowed with intervening content

// Perform concrete-algorithm logic

// Perform concrete-hasher logic

// Perform primitive values validation

// Perform regular backslashed escaping

// Perform the `toStringTag` check first to avoid errors with some

// Performance will be enhanced with the next two lines of code commented

// Performs "tweedling" phase, therefore 'emulating'

// Perhaps a Uint8Array

// Permission is hereby granted, free of charge, to any person obtaining a

// PhantomJS 2 has enumerable non-index properties on typed arrays.

// Plain Math.round doesn't just truncate

// Pluck off n bytes from an array of buffers.

// Point on curve

// Polyfill comb

// Pop object

// Ported from https://github.com/mafintosh/end-of-stream with

// Ported from https://github.com/mafintosh/pump with

// Positive limit

// Possible sign change

// Precompute window

// Precomputed endomorphism

// Prepare char buffer for decoding.

// Prepare the response

// Previous code is invalid

// Prime numbers with efficient reduction

// Primitive types cannot have properties

// Process blocks

// Process pending data in blocks

// Processed fragments are accessed by calling `shiftNextLine`.

// Protocols

// Provide a hook for user-specified inspect functions.

// Provide aliases for supported request methods

// Provide the compiled function's source by its `toString` method or

// Proxy hash functions to the main object

// Pseudo-Mersenne prime

// Public API.

// Public methods

// Push carried bits as a mask

// Push object on stack

// Put all encoding/alias/codec definitions to single object and export it. 

// Put another way, a template can be used as a trait if it

// Put this first to avoid double-encoding

// Put this in last place to avoid escape being double-decoded

// Q

// Queue rest

// RFC 2822/5322

// RFC3501 Sec. 5.1.3 Modified UTF-7 (http://tools.ietf.org/html/rfc3501#section-5.1.3)

// Range ends with character

// Range ends with octal

// Re-assign `events` because a newListener handler could have caused the

// Readable by everyone,

// Readable class this is attached to

// Real errors are hidden from us by the browser

// Reason: innerHTML.

// Rebuild array with sorted key names

// Received replace_pairs?

// Reconcile Windows vs. *nix locale names?

// Recursively compare arrays (susceptible to call stack limits).

// Recursively compare objects (susceptible to call stack limits).

// Recursively convert values (susceptible to call stack limits).

// Recursively flatten arrays (susceptible to call stack limits).

// Recursively merge objects and arrays (susceptible to call stack limits).

// Recursively populate clone (susceptible to call stack limits).

// Reduction context

// Reference supertype

// Regular character

// Remove Content-Type if data is undefined

// Remove comments and folding whitespace and replace multiple-spaces with a single space

// Remove common factor of two

// Remove excessive symbols

// Remove leading `0` from `this`

// Remove processed words

// Remove the source file from the _sourcesContents map.

// Remove when above check is fixed

// Render the toast in place, rather than in a portal-target

// Repeating last grouping (may only be one) until highest portion of integer reached

// Replace delimiters with snippets.

// Replace parent to maintain backward link

// Represent k1, k2 in a Joint Sparse Form

// Represent num in a w-NAF form

// Reset any `maxWait` timer.

// Reset data buffer

// Reset trie node.

// Resolve string input to bitwise e.g. 'ENT_IGNORE' becomes 4

// Resolve string input to bitwise e.g. 'PATHINFO_EXTENSION' becomes 4

// Resolves . and .. elements in a path with directory names

// Restart the timer.

// Rethrow the error if it exists to avoid swallowing it

// Return an augmented `Uint8Array` instance

// Return early if start > this.length. Done here to prevent potential uint32

// Return final computed hash

// Return negative clone of `this`

// Return negative clone of `this` % `red modulo`

// Return number of used bits in a BN

// Return only lowers bits of number

// Return only lowers bits of number (in-place)

// Return processed words

// Return skipped data

// Return the exports of the module

// Return undefined (instead of 0) in these cases, where fraction is not set

// Returns a modified function which warns once by default.

// Returns all complete UTF-8 characters in a Buffer. If the Buffer ended on a

// Returns binary-reversed representation of `x`

// Returns only complete characters in a Buffer

// Reusable object

// Reverse Initial Permutation

// Reverse the bytes

// Reverse the combining marks so they will end up in the same order

// Root = (-1 +- Sqrt(-3)) / 2

// Round down

// Round up

// Round up to include partial blocks

// Run EGCD, until r(L + 1) < aprxSqrt

// Sadly this is not cacheable as some libraries bundle their own

// Safari 9 has enumerable `arguments.length` in strict mode.

// Same as 'x'?

// Same as above, or return something different since this returns an array?

// Sanitize URL

// Sanity checks

// Save it to be reused later.

// Scroll behavior

// Search for a byte value [0-255]

// Search for a codec in iconv.encodings. Cache codec data in iconv._codecDataCache.

// Second phase

// Seconds, numeric

// Section 13.3.3.7 Runtime Semantics: KeyedBindingInitialization.

// See [MDN](https://mdn.io/round#Examples) for more details.

// See also below a UTF-7-IMAP codec, according to http://tools.ietf.org/html/rfc3501#section-5.1.3

// See below for C locale

// See http://emojipedia.org/flags/

// See http://emojipedia.org/modifiers/

// See http://requirejs.org/docs/errors.html#mismatch for more details.

// See http://unicode.org/reports/tr44/#Property_Table (Me+Mn)

// See https://bugs.chromium.org/p/chromium/issues/detail?id=364374.

// See https://bugs.chromium.org/p/v8/issues/detail?id=90 for more details.

// See https://bugs.webkit.org/show_bug.cgi?id=156034 for more details.

// See https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Symbol#Browser_compatibility

// See https://drafts.csswg.org/css-values-3/#urls

// See https://en.wikipedia.org/wiki/Exponentiation_by_squaring for more details.

// See https://es5.github.io/#x13.2.2 for more details.

// See https://github.com/mozilla/source-map/issues/16

// See: https://en.wikipedia.org/wiki/Base64#URL_applications

// See: https://github.com/beatgammit/base64-js/issues/42

// See: https://github.com/feross/buffer/issues/154

// See: https://github.com/feross/buffer/issues/166

// See: https://github.com/feross/buffer/issues/219

// Select proper method for tag

// Send the request

// Sequence continues.

// Sequence finished. Write it.

// Sequence start

// Serves as infimum

// Set `bit` of `this`

// Set and get locale

// Set config.method

// Set initial values

// Set key

// Set reporter to share it with a child class

// Set the leaf to given dbcsCode.

// Set the request timeout in MS

// Set when currying a bound function.

// Share reporter state

// Shift by 9 limbs

// Shift next

// Shift with exponential notation to avoid floating-point issues.

// Shift-left

// Shift-left in-place

// Shift-right

// Shift-right in-place

// Short form

// Short-cut

// Shortcut

// Shortcut `elliptic.ec(curve-name)`

// Shortcut for `elliptic.ec(elliptic.curves.curveName)`

// Shortcuts

// Shorten key, if needed

// Should .destroy() be called after 'end' (and potentially 'finish')

// Should .destroy() be called after 'finish' (and potentially 'end')

// Should close be emitted on destroy. Defaults to true.

// Should create new instance on each method

// Should only compare up to the desired length

// Should this be just null?

// Should url be wrapped?

// Sign "-" when negative, "+" when positive

// Sign "-" when negative, empty when positive

// Simple variation: don't support surrogates or subsequences in seq.

// Since JS doesn't have multiple prototypal inheritance, this class

// Since a mismatched character sets us off track from future

// Since mappings are sorted, this is guaranteed to find all mappings for

// Single-byte code

// Single-byte codec. Needs a 'chars' string parameter that contains 256 or 128 chars that

// Skip 1 character in the buffer.

// Skip dots and range end (already skipped range end backslash if present)

// Skip empty entries

// Skip index properties.

// Skip leading zeroes

// Skip range begin

// Skip range end backslash

// Slow case, write chunks one-by-one

// So we have to make do. Two cases:

// So, if this is awaiting a drain, then we just call it now.

// So, the steps are:

// So, we count ASCII as if it was LE or BE, and decide from that.

// Solution would be installing npm modules "buffer" and "stream" explicitly.

// Some chars can be decoded, but need not be encoded.

// Some environments don't have global Buffer (e.g. React Native).

// Some errors for maximum PHP compatibility

// Some latest browsers when str is null return and unexpected null value

// Some type of object without properties can be shortcutted.

// Some versions of I.E. have different rules for clearTimeout vs setTimeout

// Some warnings for maximum PHP compatibility

// Sometimes a MBCS char corresponds to a sequence of unicode chars. We store them as arrays of integers here. 

// Spawn

// Special case to return head of iframe instead of iframe itself

// Special case: looking for empty string/buffer always fails

// Specifically not if we're in a web worker, or react-native.

// Square root over p

// Standard

// Standard browser envs have full support of the APIs needed to test

// Start the timer for the trailing edge.

// State

// Static content here can only come from compiled templates.

// Static data

// Step 1: deal with combining marks and astral symbols (surrogate pairs)

// Step 2: reverse the code units in the string

// Store a copy of SharedArrayBuffer in case it's deleted elsewhere

// Store the value of LSB(V_i)

// String, write as-is.

// StringDecoder provides an interface for efficiently splitting a series of

// Strings are immutable in JS -> we use ucs2 buffer to speed up computations.

// Strip both numbers to approximate shift value

// Strip last softline break

// Strip the last path component, but keep the "/".

// Subtract `num` from `this`

// Subtract `num` from `this` in-place

// Subtract plain number `num` from `this`

// Subtraction overflow

// Sum all words with the same `i + j = k` and accumulate `ncarry`,

// Support decoding URL-safe base64 strings, as Node.js does.

// Support for limit

// Supposed to treat period, begin and end as individual characters only, not a range

// Swap `a` and `b` to make `a` always bigger than `b`

// Switches role to 'status' and aria-live to 'polite'

// Symbols & Accents

// T = M ^ 2 - 2*S

// T = M^2 - 2 * S

// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS

// TODO return Ext.data.Response instance instead.  @see #readResponse

// TODO this component will likely have an issue with inheritAttrs

// TODO(BridgeAR): Write a test for these two error cases

// TODO(indutny): implement me

// TODO(indutny): it may be reasonable to omit it for users who don't need

// TODO(indutny): optimize it, this is far from optimal

// TODO(indutny): this should be thrown on DSL level

// TODO(ronag): Throw ERR_VALUE_OUT_OF_RANGE.

// TODO: Callback with seq.

// TODO: IBM CCSID 942 = CP932, but F0-F9 custom chars and other char changes.

// TODO: IBM CCSID 943 = Shift_JIS = CP932 with original Shift_JIS lower 128 chars.

// TODO: KDDI extension to Shift_JIS

// TODO: Let exception-handler choose to commit or not rather than blindly rs.commit() here.

// TODO: RFC about how to save scroll position

// TODO: Should this be set to '' if value is out of range?

// TODO: add normalized records for more flexibility

// TODO: can display if it's an alias, its props

// TODO: create field registry, add fields here

// TODO: defer error events consistently everywhere, not just the cb

// TODO: dev only warn double trailing slash

// TODO: is it worth handling nested regexp? like :p(?:prefix_([^/]+)_suffix)

// TODO: move to new URL()

// TODO: only keep optional params coming from a parent record

// TODO: refactor the whole before guards by internally using router.beforeEach

// TODO: should be moved to web history?

// TODO: support rbnf

// TODO: this probably needs to be updated so it can be used by vue-termui

// TODO: use options in the future

// TODO: we could allow currentRoute as a prop to expose `isActive` and

// TODO: wrap with error handlers

// TRANSFORM

// TYPES

// T_FMT

// T_FMT // changed from %T to %r  (%T is default for C, not English US)

// T_FMT_AMPM (Fixed for all locales)

// Tables are not require()-d until they are needed to speed up library load.

// Take note if the _read call is sync or async (ie, if the read call

// Take over router.beforeEach and afterEach

// Taken from here and modified for better browser support

// Technically, only some code points are meant to be

// Temporarily reverse

// Temporary arrays

// Temporary disable, see https://github.com/indutny/bn.js/issues/211

// Test if n bit is set

// Test whether the zone matches the offset for this ts

// That we got here means that the readable side wants more data.

// The (right-most) trimmed path component is exactly '..'

// The JS engine embedded in Adobe products needs `match` returned in

// The SourceNode we want to fill with the generated code

// The Transform stream has all the aspects of the readable and writable

// The above copyright notice and this permission notice shall be included

// The chunk loading function for additional chunks

// The codec function must load all tables and return object with .encoder and .decoder methods.

// The conditions for reading more data are (one of):

// The decoder is more involved as we must handle chunks in stream.

// The exact needle element was not found in this haystack. Determine if

// The first part is blank if the path is absolute. Trying to go

// The following are based on *nix settings

// The last mapping for each line spans the entire line.

// The mappings coming from the consumer for the section have

// The module cache

// The offset fields are 0-based, but we use 1-based indices when

// The partitioning chooses a pivot between `p` and `r` and moves all

// The request errored out and we didn't get a response, this will be

// The require function

// The rest will be decoded in future.

// The spec says:

// The stream needs another readable event if

// The url field will require support for asynchronicity.

// The use of `Object#toString` avoids issues with the `typeof` operator

// There are lots of tables for Big5 and cp950. Please see the following links for history:

// There are still more digits in this value, so we must make sure the

// There is no new line in between.

// There was no sequence object - allocate a new one.

// There's already a sequence with  - use it.

// These are a little braindead. EDT *should* tell us that we're in, say, America/New_York

// These don't discriminate here as both allow exponential float of either case

// These options can be provided separately as readableXXX and writableXXX.

// These should technically only be non-null on mounted VNodes. However,

// They are lazy loaded in `iconv.getCodec` from `encodings/index.js`.

// This also ensures a stable sort in V8 and other engines.

// This behaves neither like String nor Uint8Array in that we set start/end

// This cannot be the first navigation because the initial location

// This could be > 0xFF because of astral characters.

// This ensures that 0..n-1 have an equal probability of being selected.

// This entry need to be wrapped in an IIFE because it need to be in strict mode.

// This file contains only the entry chunk.

// This follows what Chrome does.

// This function allow to reference async chunks

// This function is designed to be inlinable, so please take care when making

// This function is used recursively from

// This function terminates when one of the following is true:

// This function will be called when the browser

// This helper is used in the index.js file

// This is *not* part of the readable stream interface.

// This is a hack to make sure that our error handler is attached before any

// This is only done if running in a standard browser environment.

// This is reduced incarnation of the binary EEA

// This is relevant for synchronous Transform streams

// This is the part where you do stuff!

// This is to work around cases where hwm=0, such as the repl.

// This is utter bullshit. Different calendars are going to define eras totally differently. What I need is the minimum set of dates

// This is where the true default is made

// This may not be correct, because it doesn't get correct type inferences in children

// This property is used by `Buffer.isBuffer` (and the `is-buffer` npm package)

// This returns true if the highWaterMark has not been hit yet,

// This way, back-pressure is actually determined by the reading side,

// This will throw an exception if access to iframe is blocked

// This would need to be processed later

// Three-byte code

// Tilde should be allowed unescaped in future versions of PHP (as reflected below),

// To avoid recursion in the case that type === "newListener"! Before

// To return the position we are searching for, we must first find the

// To save memory and loading time, we read table files only when requested.

// Tonelli-Shanks algorithm (Totally unoptimized and slow)

// Total number of days as a result of a DateTime::diff() or (unknown) otherwise

// Transform request data

// Transform response data

// Translate arguments

// Translate into more windowed form

// Traverse iconv.encodings to find actual codec.

// Traverse nodes deeper into the trie.

// Traverse the character tree, allocating new nodes as needed.

// Treat as a range

// Treats subsequent as long double (for e,f,g)

// Treats subsequent as long int (for d,i,n), or unsigned long int (for o,u,x);

// Treats subsequent as short int (for d,i,n) or unsigned short int (for o,u,x)

// Tree methods

// Trial and Error

// Trie root is decodeTables[0].

// Trim any leading backslashes

// Trim off extra bytes after placeholder bytes are found

// True if the error was already emitted and should not be thrown again

// Try default character for this sequence

// Try start flowing on next tick if stream isn't explicitly paused

// Try to avoid Projective points, if possible

// Try to match the explicit extension

// Try to parse again, after skipping first byte of the sequence ('i' will be incremented by 'for' cycle).

// Try to parse all remaining chars.

// Try to read the message from Ext.Error.lang

// Trying to use the custom `instanceof` for Writable here will also break the

// Two-byte code

// U = (M + E)^2 - MM - EE - T

// USE OR OTHER DEALINGS IN THE SOFTWARE.

// UTF-16BE BOM

// UTF-16LE BOM

// UTF-16LE typically needs two bytes per character, but even if we have an even

// UTF-7 codec, according to https://tools.ietf.org/html/rfc2152

// UTF-7-IMAP codec.

// Unexpected continuation byte

// Unhandled 'error' event

// Unhandled stream error in pipe.

// Unicode mapping (http://www.unicode.org/Public/MAPPINGS/OBSOLETE/EASTASIA/OTHER/BIG5.TXT) is said to be wrong.

// Units in the supported calendars, sorted by bigness

// Unknown char.

// Unshift should *always* be something directly out of read()

// Unsigned comparison

// Unwrap explicit values

// Unwrap implicit and normal values

// Update the hash

// Update this array if you add/rename/remove files in this directory.

// Usage:

// Use GB18030 algorithm to find character(s) to write.

// Use Montgomery, when there is no fast reduction for the prime

// Use `_.noConflict` to remove Lodash from the global object.

// Use `util.types` for Node.js 10+.

// Use a `switch` statement to work with class constructors. See

// Use a for loop to avoid recursion

// Use built-in when available, missing from IE11

// Use complement of `s`, if it is > `n / 2`

// Use decode trie to recursively fill out encode tables.

// Use extended coordinates

// Use for rare cases of non-BMP characters

// Use onloadend if available

// Use source `argPos` if available.

// Use source `arity` if one is not provided.

// Use source `ary` if it's smaller.

// Use source `func` and merge bitmasks.

// Use source `thisArg` if available.

// Use utf8 for decoding.

// Used by sql_regcase

// Used to group navigations together, hide from devtools

// Useful for many curves

// Utility methods

// Utils

// V-model prop

// V_i+1 = V_i >> 1

// Validate input

// Validate signature

// Validates as many continuation bytes for a multi-byte UTF-8 character as

// Values: >=  0 -> it is a normal char. Write the value (if <=256 then 1 byte, if <=65536 then 2 bytes, etc.).

// Values: >=  0 -> unicode character code. can be > 0xFFFF

// Variations, in roughly number of defined chars:

// Variations: 2 code units

// Vertical forms

// Very short reduction

// WARNING: DEPRECATED

// Walk through subject and replace chars when needed

// Warning: maxLength not taken into account in base64Write

// Warning: warning conditions

// We DO NOT return the promise as it gives the user a false sense that

// We add the code from "lastMapping" to "mapping":

// We add the generated code until the first mapping

// We also add the low surrogate range at the beginning here so it will be

// We are in the middle of the sequence

// We can clean all this up when Chrome fixes this.

// We can pass over low surrogates now as the second

// We can pass over low surrogates now as the second component in a pair which we have already

// We can push more data if we are below the highWaterMark.

// We decode base64.

// We don't want negative symbol represented here yet

// We get here if `from` is the exact base path for `to`.

// We get here if `from` is the root

// We get here if `to` is the exact base path for `from`.

// We get here if `to` is the root.

// We go 1 magnitude less, for safety

// We have enough bytes -> detect endianness.

// We have found either the exact element, or the next-closest element than

// We have processed all mappings.

// We have tests that rely on errors being emitted

// We matched the extension, so mark this as the end of our path

// We mostly implement W3C recommendation: https://www.w3.org/TR/encoding/#gbk-encoder

// We need 'g' set to get lastIndex

// We need more bytes to use space heuristic (see below)

// We need to check if there is someone still listening to

// We need to defer via nextTick because if .destroy(err) is

// We need to go backwards to simulate negative look-behind (don't split on

// We saw a non-dot and non-path separator before our dot, so we should

// We saw a non-dot character immediately before the dot

// We saw the first non-path separator

// We saw the first non-path separator, mark this as the end of our

// We saw the first non-path separator, remember this index in case

// We support Browserify by skipping automatic module discovery and requiring modules directly.

// We use 'output' element to make this accept a `<label for="id">` (Except IE)

// We use node.js internal decoder. Its signature is the same as ours.

// We want to be able to have it callable to everyone,

// We won't deal with integer overflows due to signs

// We're in direct mode.

// We're in the sequence.

// We're waiting for it.

// We've got lead surrogate.

// We've got trail surrogate.

// Weierstrass/Edwards points on the other hand have both `x` and

// When aOriginal is truthy but has empty values for .line and .column,

// When supporting browsers where an automatic publicPath is not supported you must specify an output.publicPath manually via configuration

// When the writable side finishes, then flush out anything remaining.

// When there is no exact match, BasicSourceMapConsumer.prototype._findMapping

// When we are in I.E. but the script has been evaled so I.E. doesn't  trust the global object when called normally

// When we are in I.E. but the script has been evaled so I.E. doesn't trust the global object when called normally

// Where possible: http://cldr.unicode.org/translation/date-time#TOC-Stand-Alone-vs.-Format-Styles

// While the output is causally related to the input, it's not a

// Whitespace doesn't need to be an exact match)

// With one exception: request that using file: protocol, most browsers

// Working variables

// Works as strcasecmp

// Would need user feedback for use cases

// Wrap in explicit

// Writable ctor is applied to Duplexes, too.

// Writable.

// Write '&', then go to base64 mode.

// Write '-', then go to direct mode.

// Write all other elements of the chunk to the table.

// Write an error, then current char.

// Write beginning of the sequence.

// Write blocks

// Write direct character

// Write direct chars until '&'

// Write direct chars until '+'

// Write direct chars.

// Write the character to buffer, handling higher planes using surrogate pair.

// Writing a hex string, for example, that contains invalid characters will

// X3 = (B - C - D) * (F - 2)

// X3 = (B-C-D)*J

// X3 = 4 * (X1 * EE - 4 * YY * U)

// X3 = F - 2 * D

// X3 = T

// X3 = alpha^2 - 8 * beta

// X3 = c * (B - E) * J

// XHTML 1.0 only

// XX = X1^2

// XXX Is there any way to tell if the number is odd without converting it

// XXX This code assumes that zero is always zero in red

// XXX: file:// URIs and absolute paths lead to unexpected behavior for

// Xor `num` with `this`

// Xor `num` with `this` in-place

// Y3 = 8 * Y1 * (U * (T - U) - E * EE)

// Y3 = A * G * (D - C)

// Y3 = A * G * (D - a * C)

// Y3 = E * (D - X3) - 8 * C

// Y3 = F * (E - D)

// Y3 = M * (S - T) - 8 * YYYY

// Y3 = alpha * (4 * beta - X3) - 8 * gamma^2

// Y3 = c * E * (C - D)

// YY = Y1^2

// Years, numeric

// Z = 1

// Z3 = (Y1 + Z1)^2 - gamma - delta

// Z3 = (Z1 + E)^2 - ZZ - EE

// Z3 = 2 * Y1

// Z3 = 2 * Y1 * Z1

// Z3 = 2*Y1

// Z3 = E * J

// Z3 = F * G

// Z3 = F * J

// Z3 = F^2 - 2 * F

// Z3 = c * F * G

// Z_i+1 = Z_i ^ V_i

// Zero-extend key to provide enough entropy

// Zeroify references

// [3] (every 3 digits in U.S.A. locale)

// [getLinkClass(

// [resolve, reject, Promise] = chunk loading, 0 = chunk loaded

// \uHHHH

// \xHH

// ].forEach(function (name) {

// _('No Access') - we need this string in other apps if relation is not shown e.g. record_removed_reason

// __UNSAFE__

// __vccOpts is added by vue-class-component and contain the regular options

// _prime_ fields F(p) at a maximal speed

// _read(n) is called, it transforms the queued up data, calling the

// _transform does all the work.

// `!reason` guard inspired by bluebird (Ref: https://goo.gl/t5IS6M).

// `Array.prototype.sort`. This makes sense because C++ will likely remain

// `__generatedMappings` and `__originalMappings` are arrays that hold the

// `_generatedMappings` is ordered by the generated positions.

// `_originalMappings` getters respectively, and we only parse the mappings

// `_originalMappings` is ordered by the original positions.

// `_writableState` that would lead to infinite recursion.

// `encodeTableSeq` is used when a sequence of unicode characters is encoded as a single code. We use a tree of

// `encodeTable` is array mapping from unicode char to encoded char. All its values are integers for performance.

// `isExactActive` behavior should go through an RFC

// `join('http://', 'www.example.com')`

// `join(foo, '//www.example.org')`

// `null`.

// `object` and `other`. See https://github.com/jashkenas/underscore/pull/1247

// `realHasInstance` is necessary because using plain `instanceof`

// `slice` is the same for buffers and strings.

// `this` * `this`

// `this` * `this` in-place

// `y` coordinates.

// a "block" tag in such a node will serve as a block definition AND be displayed in place as well

// a > b

// a Promise means "currently loading".

// a copy of the entry or else bad things happen. Shared mutable state

// a duplex stream is just a stream that is both readable and writable.

// a few lines down. This is needed to support once('readable').

// a flag to be able to tell if the event 'readable'/'data' is emitted

// a flag to be able to tell if the onwrite cb is called immediately,

// a flag to know if we're processing previously buffered items, which

// a flag to see when we're in the middle of a write.

// a hash key can be:

// a mapping for a different line than the one we found. Since

// a mapping for a different line than the one we were searching for.

// a matched percent literal

// a more recent navigation took place

// a new navigation has been triggered, so we do not want to revert, that will change the current history

// a nextTick recursion warning, but that's not so bad.

// a parameter.  This mode is still somewhat supported, which is why

// a passthrough stream.

// a pathological inflate type of transform can cause excessive buffering

// a prefix that fits, or we run out of components to remove.

// a read from the buffer.

// a server-rendered async wrapper is already in resolved state

// a setTimeout of 16ms seems to work but there is no guarantee for

// a single UTF-8 replacement character ('\ufffd'), to match v8's UTF-8 decoding

// a space within an operator can be any amount of whitespaces

// a transform stream is a readable/writable stream where you do

// a zlib stream might take multiple plain-text writes(), and then

// a ~3500ms mean speed-up in `bench/bench.html`.

// a) if the string has no -u extensions, just leave it alone

// a.length > b.length

// above the root is a no-op. Therefore we can remove all '..' parts

// above, designated to invert members of the

// abstract method.  to be overridden in specific implementation classes.

// accept current navigation

// accessing global.localStorage can trigger a DOMException in sandboxed iframes

// actions that shouldn't happen until "later" should generally also

// adapted from https://github.com/apatil/pemstrip

// add "moreModules" to the modules object,

// add an id to be able to select it. Using the `path` is not possible because

// add initial routes

// add pre defined type

// add static functions

// added before. This works because we remove guards when

// added to it. This is a useful default which helps finding memory leaks.

// adding it to the listeners, first emit "newListener".

// after error

// after navigation, all matched components are resolved

// after readable has been emitted but before I/O (nextTick) to

// again. This runs in O(n) time.

// alias

// alias for CanceledError for backward compatibility

// all chunks have JS

// all components here have been resolved once because we are leaving

// all fall-throughs

// all the elements that are greater than it after it. The effect is that

// allocate the first CorkedRequest, there is always

// allow overwriting date pattern in model

// allow the = character

// allow trailing slash

// allowing us to avoid a second parse if we encounter the same

// allows hash bases like #, /#, #/, #!, #!/, /#!/, or even /folder#end

// alpha depends on locale, so this var might need an update

// already added a slash above:

// already have a bunch of data in the buffer, then just trigger

// already incremented

// also allow partial matching on the path

// also exclude jsdom

// also returned false.

// also to avoid inline import() in generated d.ts files

// also try camelCase event handler (#2249)

// also, that means that the chunk and cb are currently

// alternative to using Object.keys for old browsers

// always follow error

// always force full diff in dev

// always table[l] <= val < table[r]

// amount of input, and end up with a very large amount of output.  In

// an `originalValue` property. Here, when we detect this, we

// an alias to avoid ESLint no-prototype-builtins detection

// an empty array like /home/ -> [[{home}], []]

// an error, then that'll put the hurt on the whole operation.  If you

// an escaped enclosure even if followed by the delimiter and another enclosure mark)

// an extra variable for ts types

// an impact here (as they do below), but assuming for now behaves as signPosn 0 as

// an operator that ends with a character must be followed by a whitespace or an opening parenthesis

// anchor may have changed if it's in a fragment

// anchor will not be used if this is hydration, so only need to

// and Laura Doktorova's doT.js (https://github.com/olado/doT).

// and `from`

// and add the remaining lines without any mapping

// and called read() to consume some data.  that may have triggered

// and children have the same index

// and converted to camelCase (#955)

// and create these arrays once queried for a source location. We jump through

// and cut is forced

// and http://publib.boulder.ibm.com/infocenter/zos/v1r10/index.jsp?topic=/com.ibm.zos.r10.bpxbd00/strfmp.htm

// and it will never need to change.

// and not just that we're in -240 *right now*. But since I don't think these are used that often

// and others

// and presented as a binary number

// and sign are adjacent then space sep. them from value; 2: space sep. sign

// and that the callback throwing will reject the promise.

// and the SourceMap

// and the bad zone doesn't show up.

// and the first character is a `-` (U+002D) ...

// and the leading slash would cause problems

// and this commonizes their handling

// and undefined/non-string values are only allowed in object mode.

// and value unless symb. and sign are adjacent then space separates

// and we need to re-evaluate how much data we can return to the user.

// android chrome

// angle / Math.PI * 180

// another read() call => stack overflow.  This way, it might trigger

// any actions that shouldn't happen until "later" should generally also

// anything leftover becomes the decimal for the last unit

// anything we haven't boiled down yet should get boiled to this unit

// api.addTimelineLayer({

// appear

// apply a match state if there is a payload

// aprxSqrt >= sqrt(this.n)

// arbitrary, and perhaps not very meaningful.

// architecture yet.

// are intended to be compressed and deduplicated, the TypeScript compiler

// are lazily instantiated, accessed via the `_generatedMappings` and

// are present, and so on.

// are using the namespaced version, note that create_function() will

// array into two pieces and (2) recurse on each half. If it is not, this is

// array.shift()

// as equal. See http://www.ecma-international.org/ecma-262/7.0/#sec-regexp.prototype.tostring

// as single characters)

// as soon as we *do* get something into the buffer.

// as the component is being moved.

// as the hot path ends with doWrite

// as the legend is no longer a direct child of fieldset

// as well as saving the current position

// ascii decimals to real symbols

// assets

// assume utf8

// assume we have the higher-order units

// assumes normalized language tags, and matches in a case sensitive manner

// assumes there are no non-BMP characters;

// at the start of calling end()

// at this point, the user has presumably seen the 'readable' event,

// attach listener to history to trigger navigations

// attached to `meta` and used to group events

// attempts to access the passive property

// avoid a block node from tracking itself

// avoid an optional / if there are more segments e.g. /:p?-static

// avoid comparing the child with its parent

// avoid creating an object with an empty key and empty value

// avoid empty path when we have multiple optional params

// avoid extra slice()

// avoid mem leaks in IE.

// avoid setting up listeners twice due to an invalid first navigation

// avoid transferring params if the redirect has a path

// b = min-length(num, this)

// b) if it does, use Intl to resolve everything

// b, F,G give errors in PHP, but 'g', though also disallowed, doesn't

// backward compatibility to store.js

// backward compatibility, the user is explicitly

// backwards compatibility.

// base64 is 4/3 + up to two characters of the original data

// based on Windows "english" (English_United States.1252) locale

// based on the aes implimentation in triple sec

// based on the existence of 'content-col' or 'label-col' props

// basically just the most minimal sort of Transform stream.

// be a valid example of a transform, of course.)

// because it is fragile and can be easily faked with `Object.create()`.

// because of split('&')

// because otherwise some prototype manipulation in

// because we don't have any way to figure out what they are

// before there was *not* enough.

// behave like it would if they were running a local HTTP server. See

// behavior. The continuation byte check is included three times in the case

// behaviour of the recursive algorithm

// being processed, so move the buffer counter past them.

// binary search in table of non-spacing characters

// block handlers

// blocks are safe by definition

// blow up if no successProperty

// boolean

// bounded at: 0x40 * 0x3ffffff + 0x3d0 = 0x100000390

// browser environment to avoid the timer handle stalling test runner exit

// buffer.slice automatically checks if the end is past the end of

// buffered _write cb's as it consumes chunks.  If consuming a single

// buffered up.  When you call read(), that calls _read(n) until

// buffers into a series of JS strings without breaking apart multi-byte

// bugfixed by: Alex

// bugfixed by: Allan Jensen (http://www.winternet.no)

// bugfixed by: Anton Ongson

// bugfixed by: Benjamin Lupton

// bugfixed by: Brett Zamir (http://brett-zamir.me)

// bugfixed by: Cetvertacov Alexandr (https://github.com/cetver)

// bugfixed by: Chris McMacken

// bugfixed by: Daniel Esteban

// bugfixed by: Diogo Resende

// bugfixed by: EdorFaus

// bugfixed by: Eric Nagel

// bugfixed by: Eugene Bulkin (http://doubleaw.com/)

// bugfixed by: Feras ALHAEK

// bugfixed by: Fox

// bugfixed by: Glen Arason (http://CanadianDomainRegistry.ca)

// bugfixed by: Howard Yeend

// bugfixed by: Jarkko Rantavuori original by findings in stackoverflow (http://stackoverflow.com/questions/14136349/how-does-similar-text-work)

// bugfixed by: Kevin van Zonneveld (http://kvz.io)

// bugfixed by: Linuxworld

// bugfixed by: MIO_KODUKI (http://mio-koduki.blogspot.com/)

// bugfixed by: Marco

// bugfixed by: Michael Grier

// bugfixed by: Michael White (http://getsprink.com)

// bugfixed by: Nate

// bugfixed by: Oleg Eremeev

// bugfixed by: Onno Marsman (https://twitter.com/onnomarsman)

// bugfixed by: Rafał Kukawski (http://blog.kukawski.pl)

// bugfixed by: Reynier de la Rosa (http://scriptinside.blogspot.com.es/)

// bugfixed by: Rival

// bugfixed by: T.Wild

// bugfixed by: Tim de Koning (https://www.kingsquare.nl)

// bugfixed by: Tomasz Wesolowski

// bugfixed by: Tymon Sturgeon (https://scryptonite.com)

// bugfixed by: Ulrich

// bugfixed by: kirilloid

// bugfixed by: madipta

// bugfixed by: noname

// bugfixed by: pseudaria (https://github.com/pseudaria)

// build current history entry as this is a fresh navigation

// but all aliases point to the original record, this will always compare

// but doesn't do any validation, makes a bunch of assumptions about what units

// but if there is no previous whitespace

// but if you want to reflect current

// but that's not a great name for it, since that implies a thing where

// by Juho Vähä-Herttua

// by Rollup, so we have to wrap it in a pure-annotated IIFE.

// by handling the zone options

// bypass empty nodes starting with a BOM

// bypass nodes that "capture" the output

// byteOffset: it it's undefined, null, NaN, "foo", etc, search whole buffer

// bytes of output.  Writing the 4 bytes {ff,ff,ff,ff} would result in

// c) if Intl fails, try again without the -u

// cached from whatever global is present so that test runners that stub it

// call all listeners

// call cb(er, data) where data is <= n in length.

// call internal read method

// called, the error will be emitted via nextTick, and

// can come up with an optimistic estimate, however, by assuming that

// can do at once see https://developer.mozilla.org/en-US/docs/Web/API/window.crypto.getRandomValues

// can implement the source URL resolution algorithm as outlined in

// can't outdent by more steps than the current indentation level

// can't right-pad 0s on integers

// cannot be a redirect route because it was in history

// cannot be manually navigated to

// cannot be null or undefined because we went into the for loop

// cases:

// cause everything after the first invalid character to be ignored. (e.g.

// cause the system to run out of memory.

// change URL only if the user did a push/replace and if it's not the initial navigation because

// changes from Blues' implementation

// changes to the function body.

// changing, but it was changed by the manual url change, so we

// char at index

// charCode will always be < 0x10000 in javascript.

// character.

// characters)

// characters.

// check directly on KeepAlive in the renderer, because importing it directly

// check global guards beforeEach

// check global guards beforeResolve

// check in components beforeRouteUpdate

// check in-component beforeRouteEnter

// check instance[type] first which is resolved for options API

// check that the body does not contain non-empty output nodes

// check the route beforeEnter

// check usage of non-defined loop-items

// checking whether the root is a prefix of the path won't work. Instead, we

// checks for null and undefined

// checks if the start is equal to or before the end

// checks that the node only contains "constant" elements

// child of the same parent

// children routes will appear as nested

// cleanup event handlers once the pipe is broken

// clear existing enterCallbacks, these are added by extractComponentsGuards

// clone really means "create another instance just like this one, but with these changes"

// clone really means, "make a new object with these modifications". all "setters" really use this

// cloning null always returns null

// code to add the data object to the top of the scope chain.

// coercion fail below.

// combined with the skin tone modifiers. This function

// compact is optional argument

// compare items as strings

// compare items as strings, based on the current locale

// compare items normally (don't change types)

// compare items numerically

// component

// component doesn't need to update, it needs to persist the instance on to

// component in a pair which we have already processed

// component may have been moved before resolve.

// component nodes also should always be patched, because even if the

// computation

// compute the actual time

// conditions prevent the data from being read:

// configure ourselves to deal with gregorian dates or week stuff

// consider the comment placeholder case.

// console.log({ deltaFromCurrent })

// const EXTRA_RESERVED_RE = /[!'()*]/g

// const encodeReservedReplacer = (c: string) => '%' + c.charCodeAt(0).toString(16)

// const errorsLayerId = 'router:errors'

// const keyFieldDef = Tine.Tinebase.widgets.keyfield.getDefinitionFromMC(this.constructor, this.titleProperty);

// const objectLocation = routerLocationAsObject(rawLocation)

// const tokenCache = new Map<string, Token[][]>()

// constants are marked safe for all

// construct, create_function() (though dollar signs must be on the

// consume data

// consume it so it's not used again

// contains buffers or objects.

// continuation bit is marked.

// continuation bit. The continuation bit tells us whether there are more

// continuation byte. If an invalid byte is detected, -2 is returned.

// continue

// convert "echo a ? b : c" to "a ? echo b : echo c" recursively

// convert a calendar object to a epoch timestamp

// convert an epoch timestamp into a calendar object with the given offset

// copies of the 'buffer' package in use. This method works even for Buffer

// copy arguments first

// copy of this software and associated documentation files (the

// copy reused instances

// copy(targetBuffer, targetStart=0, sourceStart=0, sourceEnd=buffer.length)

// correspond to encoded bytes (if 128 - then lower half is ASCII). 

// count buffered requests

// covert a calendar object to a local timestamp (epoch, but with the offset baked in)

// create a fake namespace object

// create a new DT instance by adding a duration, adjusting for DSTs

// create dummy domain

// create error before stack unwound to get useful stacktrace later

// create method call params

// create padding and handle blocks

// create the object beforehand, so it can be passed to children

// css module (injected by vue-loader)

// current location params are decoded, we need to encode them in case the

// custom comparator function, calling back and forth between the VM's C++ and

// custom elements may use _value internally

// custom operators

// custom placeholder type

// cut at next possible whitespace after the limit

// cut just at the defined limit

// date

// date is PHP timestamp - i.e. in seconds

// dates

// debounce: {type: [String, Number], default: 0}, TODO: not implemented yet

// debounced at least once.

// decode the last character properly.

// decodeTables is a trie, encoded as an array of arrays of integers. Internal arrays are trie nodes and all have len = 256.

// deep merge for vals

// deeply ugly to write APIs this way, but that still doesn't mean

// default format by locale and with two decimals

// default in iojs

// default options

// default pattern for a param: non-greedy everything but /

// default type is auto

// defaults for unspecified units in the supported calendars

// defer the callback if we are being called synchronously

// define __esModule on exports

// define getter functions for harmony exports

// define once

// degree of precision

// delta = Z1^2

// deprecated

// designed to be sync/async agnostic.

// destroy(err, cb) is a private API

// determine the timezone

// determiner: 'must be' or 'must not be'

// devtools only

// didn't get any data, stop spinning.

// digits in this value following this digit.

// directly after the root.

// directly in the renderer. The renderer checks for the __isSuspense flag

// discard any existing params in the current location that do not exist here

// dispatch to the lexing functions depending on the current state

// display state added by the router

// distribute, sublicense, and/or sell copies of the Software, and to permit

// do not restore history on unknown direction

// do not return if both are equal

// do not trigger beforeEnter on reused views

// doWrite is almost always async, defer these to save a bit of time

// does not check the current pair to see if it is

// don't add a scroll as the user may have an anchor, and we want

// don't break things.  But we need to wrap it in a try catch in case it is

// don't leave dangling pipes when there are errors.

// don't polute global namspace if no one else did

// don't push empty TEXT tokens

// don't redirect if `target="_blank"`

// don't redirect on right click

// don't redirect when preventDefault called

// don't redirect with control keys

// don't skip over falsy values in objectMode

// don't want to throw if we can't find the source - we just want to

// don't || this because we want to preserve -0

// double is always 1 '

// double quoted string

// drain event flag.

// due to cross-origin restrictions

// due to dynamic routing, and to hash history with manual navigation

// due to functional component being no longer eager in Vue 3

// due to type annotation

// dumbed-down version of the ISO one

// e.g. history panel

// e.g. options.readableObjectMode vs. options.writableObjectMode, etc.

// e.g., 3

// e.g., English

// e.g., French

// e.g., ordinal

// each represented by a surrogate pair.

// each safe for removal

// effect.

// element. Make sure we always return the smallest of these.

// elements that are less than or equal to the pivot to the before it, and

// embedded templates are set as attributes so that they are only visited once by the visitors

// emit

// emit 'drain' before the write() consumer gets the 'false' return

// emit 'readable' now to make sure it gets picked up.

// emit a single compressed chunk some time in the future.

// emit an error with process.nextTick

// emit prefinish if the only thing we're waiting for is _write cbs

// emit removeListener for all listeners on all events

// empty path children would collide with their parents

// empty path means a relative query or hash `?foo=f`, `#thing`

// empty string to avoid regexp issues

// encode to utf16 (surrogate pair dance)

// encode utf8

// encoding is 'binary' so we have to make this configurable.

// encoding/decoding from VLQ.

// end of quoted

// end on a partial character, we simply let v8 handle that.

// end placeholder

// end up in an overlapped onwrite situation.

// endverbatim itself

// ensure leading slash when it was removed by the regex above avoid leading

// ensure setup of localization variables takes place

// ensure setup of localization variables takes place, if not already

// enter

// entry while a different route is displayed

// era

// eras

// escape all non-alphanumeric characters

// eslint-disable-line camelcase

// eslint-disable-line consistent-return

// eslint-disable-line eqeqeq

// eslint-disable-line new-cap

// eslint-disable-line no-eval

// eslint-disable-line no-proto

// eslint-disable-line no-restricted-syntax, no-unreachable-loop

// eslint-disable-line no-self-compare

// eslint-disable-line no-unmodified-loop-condition,max-len

// eslint-disable-line no-unused-expressions

// eslint-disable-next-line @typescript-eslint/ban-ts-comment

// eslint-disable-next-line @typescript-eslint/no-explicit-any

// eslint-disable-next-line @typescript-eslint/no-unused-vars

// eslint-disable-next-line consistent-return

// eslint-disable-next-line func-names

// eslint-disable-next-line no-console

// eslint-disable-next-line no-empty

// eslint-disable-next-line no-eq-null,eqeqeq

// eslint-disable-next-line no-nested-ternary

// eslint-disable-next-line no-param-reassign

// eslint-disable-next-line no-restricted-syntax

// eslint-disable-next-line no-throw-literal

// eslint-disable-next-line no-undef

// eslint-disable-next-line no-use-before-define

// event emitter implementation with them.

// except for type specifiers

// exception case: `/`

// exclude `base` from the options

// existing patch flag to be reliable and need to add the FULL_PROPS flag.

// expect category is str

// expect this (unhelpful) form, we'll use another PHP-exportable

// expected as the definition is not part of the default template code flow.

// explicit UTC offset

// export const scrollHandler: ScrollHandler<ScrollPosition> = {

// export interface ScrollHandler<ScrollPositionEntry extends HistoryStateValue, ScrollPosition extends ScrollPositionEntry> {

// export the public type for h/tsx inference

// expose the modules object (__webpack_modules__)

// exposed for testing purposes only.

// expressions

// extend object

// extension

// extracted keys

// f(r, k)

// fact by caching the parsed variable length fields of each segment,

// fact, when sorting with a comparator, these costs outweigh the benefits of

// fall through

// fallback tree will not have suspense context

// falls through

// false) but this is bug prone as we have no way to wait the

// far as localized sepBySpace and signPosn behavior

// fast path needed to support multiple this.push()

// fast paths only.

// faster than JS when doing raw CPU-intensive sorting. However, when using a

// field width: w (minimum field width)

// file:///, etc.), one or more slashes (/), or simply nothing at all, we

// filter expression is safe when the filter is safe

// filter out skipped interceptors

// filters

// find container by selection or use defaultContainer by registry

// find record from dataset

// find record from deeplink

// find the best mapping.

// find the right offset a given local time. The o input is our guess, which determines which

// first

// first mapping ends where the second one starts).

// first, determine if we are parsing an arrow function by finding => (long form)

// flag: ! (suppress currency symbol)

// flag: =f (numeric fill)

// flag: ^ (disable grouping characters (of locale))

// flag: parenth. for negative

// flowing again.

// flowing needs to be set to true now, otherwise

// following conditions:

// foo x y z

// foo-x-y-z

// foo.x.y.z

// foo[x][y][z]

// for AM and PM. This is probably wrong, but it's makes parsing way easier.

// for Object prototype breakers

// for Twig, a string is not traversable

// for camelCase

// for character classification and conversion, for example strtoupper()

// for date and time formatting with strftime()

// for decimal separator (See also localeconv())

// for each line of text

// for kebab-case

// for legacy reasons, years between 0 and 99 are interpreted as 19XX; revert that

// for localeconv()

// for more details.

// for msgid_plural == ""

// for now assuming pure a-z

// for optional parameters to allow to be empty

// for prototype!

// for readable, but we still have to call

// for sign when there is a positive number, though my

// for string comparison, see strcoll()

// for system responses (available if PHP was compiled with libintl):

// for tests

// for virtual (non-string, non-buffer) streams, "length" is somewhat

// force empty params

// from http://bitwiseshiftleft.github.io/sjcl/doc/symbols/src/core_gcm.js.html

// from https://github.com/Rantanen/node-dtls/blob/25a7dc861bda38cfeac93a723500eea4f0ac2e86/Certificate.js

// from https://github.com/indutny/self-signed/blob/gh-pages/lib/asn1.js

// function because try/catches deoptimize in certain engines.

// function expression is safe when the function is safe

// functions

// gamma = Y1^2

// generate an array of records to correctly handle aliases

// generated file.

// generated positions relative to the start of the section, so we

// get default data from fields config

// get slice of length one char above limit

// getDefaultExport function for compatibility with non-harmony modules

// getRandomValues fails on IE if size == 0

// give browser some time to clear registry

// global properties

// global registration

// go back one character if we were not modifying

// go through the array every three bytes, we'll deal with trailing stuff later

// go up in the from array

// got a match.

// got an "options" object

// gregorian data + weekday serves only to validate

// h and <component :is="..."> both accept vnodes

// handle late devtools injection - only do this if we are in an actual

// handle relative paths to be safe (might happen when process.cwd() fails)

// handle the escaped )

// handle whitespace control modifiers

// handled by onerror instead

// handler in flow(), but adding and removing repeatedly is

// handling at a lower level.

// has a sign

// has current parent block

// has it been destroyed

// has not been initialized yet

// has returned yet), so that we know whether or not it's safe to emit

// hash

// have a good chance at having a non-empty extension

// have exhausted all components, so the path is not relative to the root.

// have to do it manually.

// helper useful in turning the results of parsing into real dates

// helper variables

// helps handle the details

// here to prevent dependency on Date.js

// here, nested means "being at the root level of a child template"

// here.  For example, imagine a stream where every byte of input is

// hide the / route

// high byte

// high private surrogates as single characters)

// history entry and trigger a new navigation as requested by the

// history state if it exists

// history.listen is with a redirect, which makes it become a push

// history.replaceState

// hours

// however, don't suppress the throwing behavior for this.

// however, if we've ended, then there's no point, and if we're already

// http date

// http://ecma-international.org/ecma-262/7.0/#sec-ecmascript-function-objects-call-thisargument-argumentslist

// http://en.wikipedia.org/wiki/ANSI_escape_code#graphics

// http://en.wikipedia.org/wiki/GBK

// http://en.wikipedia.org/wiki/UTF-16 and http://encoding.spec.whatwg.org/#utf-16le

// http://hyperelliptic.org/EFD/g1p/auto-montgom-xz.html#diffadd-dadd-1987-m-3

// http://hyperelliptic.org/EFD/g1p/auto-montgom-xz.html#doubling-dbl-1987-m-3

// http://icu-project.org/docs/papers/gb18030.html

// http://locutus.io/php/get_html_translation_table:416#comment_97660

// http://moztw.org/docs/big5/  http://www.haible.de/bruno/charsets/conversion-tables/Big5.html

// http://msdn.microsoft.com/en-us/library/ie/dww52sbt(v=vs.94).aspx

// http://php.net/manual/en/function.strtr.php

// http://source.icu-project.org/repos/icu/data/trunk/charset/data/xml/gb-18030-2000.xml

// http://www.khngai.com/chinese/charmap/tblgbk.php?page=0

// https://bugzilla.mozilla.org/show_bug.cgi?id=885597.

// https://code.google.com/p/crypto-js/

// https://developer.mozilla.org/en-US/docs/Web/API/Crypto/getRandomValues

// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/endsWith

// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/includes

// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/startsWith

// https://git.io/vad3K

// https://github.com/feross/buffer/pull/148

// https://github.com/google/closure-library/blob/8598d87242af59aac233270742c8984e2b2bdbe0/closure/goog/crypt/crypt.js#L117-L143

// https://github.com/google/closure-library/blob/master/LICENSE

// https://github.com/keybase/triplesec

// https://github.com/nodejs/node/blob/v10.8.0/lib/internal/errors.js

// https://github.com/nodejs/node/commit/112cc7c27551254aa2b17098fb774867f05ed0d9

// https://github.com/sindresorhus/p-is-promise/blob/cda35a513bda03f977ad5cde3a079d237e82d7ef/index.js

// https://github.com/tc39/proposal-shadowrealm/pull/384#issuecomment-1364264229

// https://github.com/vuejs/router/issues/1124

// https://github.com/vuejs/router/issues/1315

// https://github.com/vuejs/router/issues/328#issuecomment-649481567

// https://github.com/vuejs/router/issues/366

// https://paths.esm.dev/?p=AAMeJbiAwQEcDKbAoAAkP60PG2R6QAvgNaA6AFACM2ABuQBB#

// https://stackoverflow.com/questions/588004/is-floating-point-math-broken

// hyperelliptic.org/EFD/g1p/auto-shortw-jacobian-0.html

// hyperelliptic.org/EFD/g1p/auto-shortw-jacobian-0.html#tripling-tpl-2007-bl

// hyperelliptic.org/EFD/g1p/auto-shortw-jacobian-3.html

// hyperelliptic.org/EFD/g1p/auto-shortw-jacobian-3.html#doubling-dbl-2001-b

// hyperelliptic.org/EFD/g1p/auto-twisted-extended-1.html

// hyperelliptic.org/EFD/g1p/auto-twisted-projective.html

// i - 2

// if (!(symObj instanceof Symbol)) { return false; }

// if (!segment.length) pattern += '/'

// if (String(sym) !== Symbol.prototype.toString.call(sym)) { return false; }

// if (i<80) {

// if (l1 > LEVENSHTEIN_MAX_LENGTH || l2 > LEVENSHTEIN_MAX_LENGTH) {

// if (parent && isAliasRecord(originalRecord)) {

// if (sym instanceof Symbol) { return false; }

// if (tokenCache.has(path)) return tokenCache.get(path)!

// if (typeof Symbol.prototype.toString !== 'function') { return false; }

// if _final has been called

// if a and b share the same score entries but b has more, sort b first

// if clearTimeout wasn't available but was latter defined

// if cut wasn't forced

// if default data is empty, it will be resolved to an array

// if it was a redirect we already called `pushWithRedirect` above

// if multiple useLink are used

// if no id, call the auto id method

// if primitive value, replace with object

// if recordType defined make sure extraction functions are defined

// if setTimeout wasn't available but was latter defined

// if the dest has an error, then stop piping into it.

// if the last subsegment was Static, the shorter segments should be sorted first

// if the length is currently zero, then we *need* a readable event.

// if the parent and matched route have the same path, this link is

// if the parent name is not dynamic, then we can cache the parent as it will never change

// if the readable side is ready for autoDestroy as well

// if the reader is waiting for a drain event from this

// if the slice ends with whitespace

// if the symbol does not exist in the current scope (0), try in the main/global scope (last index)

// if the user is using a custom query lib like qs, we might have

// if the vnode is cloned with extra props, we can no longer assume its

// if the vnode itself already has a ref, cloneVNode will need to merge

// if the writable side is ready for autoDestroy as well

// if there is no instance but to and from are the same this might be

// if there may be such characters, then it is best to turn it on (critical in true XHTML/XML)

// if there was no original record, then the first one was not an alias and all

// if there's nothing in the write buffer, then that means

// if there's something in the buffer waiting, then process it

// if this is a duplex stream mark the writable part as destroyed as well

// if this is not a hydration, instance.subTree will be the comment

// if true, a maybeReadMore has been scheduled

// if var app is a record class, the getMeta method is called

// if we are an alias we must tell the original record that we exist,

// if we are currently firing this event, don't disturb the listener loop

// if we are sync, wait until next tick to emit the data.

// if we currently have less than the highWaterMark, then also read some

// if we didn't call the onwrite immediately, then

// if we didn't set the day but we ended up on an overflow date,

// if we fail we don't finalize the navigation

// if we have detected an error in the meanwhile

// if we have more than one optional param like /:a?-static we don't need to care about the optional param

// if we have multiple next() calls

// if we need a readable event, then we need to do some reading.

// if we're already writing something, then just put this

// if we're doing read(0) to trigger a readable event, but we

// if we're not piping anywhere, then do nothing.

// if we've ended, and we're now clear, then finish it up.

// if you want to output a technical format (e.g. RFC 2822), this helper

// ignore the popstate and reset the pauseState

// ignore the second part

// ignore unnecessary end() calls.

// immediately, or on a later tick.  We set this to true at first, because

// implementation from standard node.js 'util' module

// implications (stack, `uncaughtException`, `async_hooks`)

// import a list of modules into the list

// import emojiRegex from 'emoji-regex';

// important when wrapping filters and duplexes.

// imprived by: Robert Eisele (http://www.xarg.org/)

// improved by: Alexander Ermolaev (http://snippets.dzone.com/user/AlexanderErmolaev)

// improved by: Allidylls

// improved by: Ates Goral (http://magnetiq.com)

// improved by: Atli Þór

// improved by: Brett Zamir (http://brett-zamir.me)

// improved by: CoursesWeb (http://www.coursesweb.net/)

// improved by: Dj

// improved by: Dj (http://locutus.io/php/htmlentities:425#comment_134018)

// improved by: Gabriel Paderni

// improved by: Ian Carter (http://euona.com/)

// improved by: Itsacon (http://www.itsacon.net/)

// improved by: Jack

// improved by: Jonas Raoni Soares Silva (http://www.jsfromhell.com)

// improved by: KELAN

// improved by: Karol Kowalski

// improved by: Kevin van Zonneveld (http://kvz.io)

// improved by: Legaev Andrey

// improved by: Luke Godfrey

// improved by: Markus Padourek (taken from http://www.kevinhq.com/2012/06/php-similartext-function-in-javascript_16.html)

// improved by: Maximusya

// improved by: Michael White (http://getsprink.com)

// improved by: Nate

// improved by: Nick Callen

// improved by: Onno Marsman (https://twitter.com/onnomarsman)

// improved by: Oskar Larsson Högfeldt (http://oskar-lh.name/)

// improved by: Philip Peterson

// improved by: Rafał Kukawski (http://blog.kukawski.pl)

// improved by: Rafał Kukawski (http://kukawski.net)

// improved by: Rafał Kukawski (http://kukawski.pl)

// improved by: Robert Eisele (http://www.xarg.org/)

// improved by: Robin

// improved by: Sakimori

// improved by: Simon Willison (http://simonwillison.net)

// improved by: Steven Levithan (http://blog.stevenlevithan.com)

// improved by: Theriault (https://github.com/Theriault)

// improved by: Thomas

// improved by: Thomas Grainger (http://graingert.co.uk)

// improved by: Tod Gentille

// improved by: Waldo Malqui Silva (http://waldo.malqui.info)

// improved by: Waldo Malqui Silva (https://fayr.us/waldo/)

// improved by: WebDevHobo (http://webdevhobo.blogspot.com/)

// improved by: Will Rowe

// improved by: Yves Sucaet

// improved by: davook

// improved by: dude

// improved by: echo is bad

// improved by: http://stackoverflow.com/questions/57803/how-to-convert-decimal-to-hex-in-javascript

// improved by: johnrembo

// improved by: kirilloid

// improved by: marc andreu

// improved by: marrtins

// improved by: mdsjack (http://www.mdsjack.bo.it)

// improved by: nobbler

// improved by: ntoniazzi (http://locutus.io/php/bin2hex:361#comment_177616)

// improved by: sowberry

// in IE 6-8, typeof document.all is "object" and it's truthy

// in Safari 9 which returns 'object' for typed arrays and other constructors.

// in a sandbox tag, only include tags are allowed

// in a tree-shakable way

// in all copies or substantial portions of the Software.

// in fixed multiplication method

// in the queue, and wait our turn.  Otherwise, call _write

// in the same tick, so changing this is semver major.

// in this context, string operators are variable names

// in turn another _read(n) call, in which case reading = true if

// inL => outL

// inR => outR

// inactiveClass: String,

// incomplete multi-byte UTF-8 character. The total number of bytes (2, 3, or 4)

// increment to support multiple router instances

// index on the path

// indicate successive group lengths after first group

// infinity and NaN values are treated as strings

// inheritAttrs

// init regular expressions

// inject a fake parent to make the parent() function work

// inpired by a similar function in mootools library

// install a JSONP callback for chunk loading

// instances that were created from another copy of the `buffer` package.

// instances when navigating to a new route

// instantiate response object

// instead of converting it to a string and substringing

// internal

// internally, and returns false if there's a lot of pending writes

// internals.

// interpreted as an integer from 0-255, and then results in that many

// intersect safeness of both operands

// into their \x or \uHHHH representations

// invalidate the current navigation

// is surrogate component

// is this really something people need since you can also write

// is unsupported, so let's not set it

// istanbul ignore if

// istanbul ignore next

// it already works by escaping the closing )

// it as the trailing edge, or we've hit the `maxWait` limit.

// it does not catch all problems (for instance when a for is included into another or when the variable is used in an include)

// it is async

// it is most likely a programmer error. In this case we throw a very

// it means that we need to wait until it does.

// it to work on every browser. So instead we do not restore the

// it would fail so +8

// it's in progress.

// it's just reflecting the url

// it's like a push but lacks the information of the direction

// it's overridden right after

// it's possible the original props was passed in as kebab-case

// iterable protocol

// iterator protocol

// itself.

// just a weekday -> this week's instance of that weekday, no worries

// just one destination.  most common case.

// just pass the block element here to avoid a DOM parentNode call.

// keep a reference to the enterCallbackArray to prevent pushing callbacks if a new navigation took place

// keep back and forward entries but override current position

// keep null values

// keep options

// keep original redirectedFrom if it exists

// keep sign (+ or -) in front

// keep the # character

// keep the hash encoded so fullPath is effectively path + encodedQuery +

// keep the values set in the inner context for variables defined in the outer context

// key attached in the `createSlots` helper, respect that

// last

// last char was a lead

// lastUnit must be defined since units is not empty

// later on (after another round of reversing)

// lazy init

// lazy init tempalte

// lead to problems

// leave

// leave the scrollRestoration if no scrollBehavior is provided

// leavingRecords is already reversed

// left, right

// left-justified (pad to right)

// legacy

// legacy streams

// legacy.

// legacy...

// legitimate finds, we just scan

// length is NaN (which is otherwise coerced to zero.)

// length quantities we use in the source map spec, the first bit is the sign,

// lifecycle

// lifecycle hooks

// like 'T'

// like 'Tues'

// like 'Tuesday'

// like +0600

// like +06:00

// like +6

// like 000012

// like 0012

// like 01

// like 01, doesn't seem to work

// like 1

// like 14

// like 2014

// like AD

// like America/New_York

// like Anno Domini

// like EST

// like Eastern Standard Time

// like J

// like Jan

// like January

// limit of Crypto.getRandomValues()

// line itself

// lines are stored 0-based in SourceMap spec version 3

// linked list can remove elements from the beginning faster than

// loadScript function to load a script via script tag

// loaded by a script tag in the presence of an AMD loader.

// local registration

// local resolved assets

// locationNormalized is always a new object

// log is just a thin wrapper to console.log that prepends a timestamp

// logging the error

// lone ' is just a '

// look for filters

// look for functions

// look for tags

// look for the next statement

// loop.

// macro handlers

// maintain two arrays for circular references, where corresponding parents

// maintained with its preceding high surrogate

// make all the buffer merging and length checks go away

// make args available, in function below

// make dots optional and also make them literal

// make sense because it will create an extra unnecessary navigation and could

// make sure the regexp is valid before using it

// make sure the values we have are in range

// make sure we are not registering the devtool twice

// making instance === oldInstance, so we check if guards have been

// making it explicit this property is not enumerable

// making sure precision is integer

// making sure the allowed arg is a string containing only tags in lowercase (<a><b><c>)

// managing destroyed

// manual change in hash history #916

// manual change in hash history #916 ending up in the URL not

// many segments often have the same encoding. We can exploit this

// many users. We can help them out when they expect file:// URIs to

// mapping for the given position and then return the opposite position it

// mappings are contiguous (i.e. given two consecutive mappings, the

// mappings are sorted, this is guaranteed to find all mappings for

// mark active routes

// mark children as matches

// mark router-link as active and display tags on router views

// mark that we need a transform, so that any data that comes in

// match by name or path of current route

// matcher merges the params

// matcher should have a value after the loop

// may be a completely synchronous operation which may change

// may call the _write() callback in the same tick, so that we don't

// means end of sequence (needed when one sequence is a strict subsequence of another).

// meridiem

// meridiems

// minutes

// mode & 16: return value when it's Promise-like

// mode & 1: value is a module id, require it

// mode & 2: merge all properties of value into the ns

// mode & 4: return value when already ns object

// mode & 8|1: behave like require

// mode the stream is in. Currently this means that `null` is never accepted

// modifier, take 4

// modules monkey-patch it to support additional encodings

// months

// months - format

// months - standalone

// mounting component will mount before the matchedRoute changes,

// move passed #

// move passed ,

// move passed <

// move passed >

// move passed offset:

// move passed {

// move passed }

// ms

// much of this based on https://github.com/indutny/self-signed/blob/gh-pages/lib/rsa.js

// multiple times when the router is used in multiple apps

// multiplication (like elliptic secp256k1).

// must be multiple of 3

// must fall back to [[Set]], and was not explicitly asked to make non-enumerable, non-writable, or non-configurable

// name is defined if record is because of the function overload

// named sortTypes are supported, here we look them up

// names to indices into the sources and names ArraySets), we have to make

// navigated to a different location so the value is different

// navigation guard.

// navigation is confirmed, call afterGuards

// navigation redirects still mark the router as ready

// navigation to be finished before calling pushWithRedirect. Using

// necessarily symmetric or synchronous transformation.  For example,

// need to be passed to the listeners so the navigation can be accepted

// need to manually change it ourselves

// need to offset them to be relative to the start of the concatenated

// need to remove components from the root one by one, until either we find

// need to revisit examples

// needed or are available. If we see a non-continuation byte where we expect

// needed to complete the UTF-8 character (if applicable) are returned.

// negative + positive

// nested objects, so we keep the query as is, meaning it can contain

// never call cb(), then you'll never get another chunk.

// new Array(64)

// no "this" reference for friendly out of scope calls

// no HMR

// no HMR manifest

// no base or base is not found at the beginning

// no default, invalid units throw in normalizeUnit()

// no lead yet

// no more data can be written.

// no need to resolve the path with the matcher as it was provided

// no on chunks loaded

// no prefetching

// no preloaded

// no route will be active if matched is empty

// no search and no query

// no such thing as a sparse string.

// no suspense so unmount hooks fire now

// noPrefetch: {type: [Boolean, String] as PropType<Booleanish>, default: false},

// noWheel: {type: [Boolean, String] as PropType<Booleanish>, default: false}, TODO: not implemented yet

// node sometimes defaults to "und". Override that because that is dumb

// node v0.6 has a bug where array lengths can be Set but not Defined

// node visitors

// node::ParseEncoding() requires lower case.

// non async event listener returned false

// non objects are treated as ids and -> No Information

// non-existing one-word test

// non-existing two-words test

// non-negative solution to the equation (length + 1 + (rem + 1)) === finalSize mod blockSize

// none found

// noop

// normalize

// normalized ordered array of matchers

// not a function

// not a regex

// not an actual buffer we keep track of, but a measurement

// not be available as a global

// not be reached and pass through the catch all route

// not happen before the first read call.

// not happen before the first write call.

// not listening for removeListener, no need to emit

// not setting this directly to LocalZone.instance bc loading order issues

// not used by this implementation

// not using enums here because it results in computed properties

// note that ncarry could be >= 0x3ffffff

// note: preserve flag for fragments since they use the flag for children

// note: we are moving the render call into an async callback,

// nothing buffered

// null

// num = HI * (2 ^ N - K) + HI * K + LO = HI * K + LO (mod P)

// number

// number of bytes are available.

// number of bytes available, we need to check if we end on a leading/high

// number of pending user-supplied write callbacks

// numbers at `$route.query`, but at the point, the user will have to

// object is another kind of object

// object method

// object property

// object stream flag to indicate whether or not this stream

// object stream flag. Used to make read(n) ignore n and to

// object to store loaded and loading chunks

// objects

// objects where keys correspond to characters in sequence and leafs are the encoded dbcs values. A special DEF_CHAR key

// occurred", we error-wrap so the callback consumer can distinguish between

// of how much we're waiting to get pushed to some underlying

// of renderSlot() with no valid children

// of the Fragment itself so it can move its children.

// offset

// offset is optional

// offset we'll pick in ambiguous cases (e.g. there are two 3 AMs b/c Fallback DST)

// offset/zone

// ok, so this is wild, but see the matrix in the tests

// old school shim for old browsers

// old-style streams.  Note that the pipe method (the only relevant

// oldVNode may be an errored async setup() component inside Suspense

// older releases of node still supported by this library.

// on a vnode's type and calls the `process` method, passing in renderer

// on the `m` itself.

// on the initial navigation, we want to reuse the scroll position from

// on the left side

// on the source.  This would be more elegant with a .once()

// once partition is done, the pivot is in the exact place it will be when

// one allocated and free to use, and we maintain at most two

// one of them.

// one, we "replace" the validated continuation bytes we've seen so far with

// onerror should only fire if it's a network error

// only add the original record to the name map

// only append & with non-empty search

// only apply the strict bonus to the last score

// only cache other properties when instance has declared (thus stable)

// only consider as push if it's not the first navigation

// only console writer atm.

// only contains blocks and use statements.

// only keep going if diff === 0

// only keep params that exist in the resolved location

// only null adds the value

// only when necessary

// operators

// optimize array, hash and Map calls

// or /:p?-:p2

// or on a later tick.  We set this to true at first, because any

// or pass an empty string ("") and set the __webpack_public_path__ variable from your code to use your own logic.

// or should be turned into a regex

// order to produce the correct `offset` value.

// ordinals

// original by: Alfonso Jimenez (http://www.alfonsojimenez.com)

// original by: Arnout Kazemier (http://www.3rd-Eden.com)

// original by: Ash Searle (http://hexmen.com/blog/)

// original by: Ates Goral (http://magnetiq.com)

// original by: Blues (http://hacks.bluesmoon.info/strftime/strftime.js)

// original by: Brett Zamir (http://brett-zamir.me)

// original by: Carlos R. L. Rodrigues (http://www.jsfromhell.com)

// original by: Dumitru Uzun (http://duzun.me)

// original by: Enrique Gonzalez

// original by: GeekFG (http://geekfg.blogspot.com)

// original by: Glen Arason (http://CanadianDomainRegistry.ca)

// original by: Greg Frazier

// original by: Jonas Raoni Soares Silva (http://www.jsfromhell.com)

// original by: Kevin van Zonneveld (http://kvz.io)

// original by: Leslie Hoare

// original by: Martijn Wieringa

// original by: Ole Vrijenhoek

// original by: Onno Marsman (https://twitter.com/onnomarsman)

// original by: Paulo Freitas

// original by: Philip Peterson

// original by: Philippe Baumann

// original by: Rafał Kukawski (http://blog.kukawski.pl)

// original by: Saulo Vallory

// original by: Theriault (https://github.com/Theriault)

// original by: Valentina De Rosa

// original by: Waldo Malqui Silva (http://waldo.malqui.info)

// original by: Webtoolkit.info (http://www.webtoolkit.info/)

// original by: YUI Library (http://developer.yahoo.com/yui/docs/YAHOO.util.DateLocale.html)

// original by: john (http://www.jd-tech.net)

// original by: strcasecmp, strcmp

// other aliases (if any) need to reference this record when adding children

// otherwise cut at previous whitespace

// otherwise just use weeks or ordinals or gregorian, depending on what's specified

// otherwise sort the longest segment first

// otherwise, keep it in the wings to boil it later

// otherwise, the first record is the original and others are aliases

// out if you don't care about combining characters

// outputted bit calls the readcb, and subsequent chunks just go into

// override the parent with the correct one

// override this function in implementation classes.

// p, S, C arguments in C function not available

// pad the end with zeros, but make sure to not forget the extra bytes

// pad with spaces by default

// params like when `name` is provided

// paramsFromLocation is a new object

// parent block is safe by definition

// parent is a string

// parent may have changed if it's in a teleport

// parent path doesn't have a trailing slash

// parse modifiers

// parsed mapping coordinates from the source map's "mappings" attribute. They

// part of this class) is overridden in the Readable class.

// partial character, the character's bytes are buffered until the required

// parts of encoded data

// pass encoded values to the matcher, so it can produce encoded path and fullPath

// pass the vnode to the slot as a prop.

// pass undefined as the old value when it's changed for the first time

// passed in one, but it's not the right one.

// path component

// path could be relative in object as well

// path.resolve([from ...], to)

// pause() and resume() are remnants of the legacy readable stream API

// permission from the author, Mathias Buus (@mafintosh).

// persons to whom the Software is furnished to do so, subject to the

// phantomjs needs to throw

// php for [className, functionName]

// placeholder.

// plus anything further down the chain that should be rolled up in to this

// plus anything that's already in this unit

// points to. Because the mappings are sorted, we can use binary search to

// populate the template name of all node children

// positive + negative

// positive currency symbol follows value = 0; precedes value = 1

// possible parent record

// post-create lifecycle registrations are noops during SSR (except for serverPrefetch)

// pre decode the + into space

// pre-process children

// prebuilt conversion function for this field, instead of

// precedence: getXxx() > isXxx() > hasXxx()

// prefetch: {type: [Boolean, String] as PropType<Booleanish>, default: null},

// preg_quote()

// prepend the slash if we are starting a new segment

// prepend the starting slash to hash so the url starts with /#

// presence of a patch flag indicates this node needs patching on updates.

// preserve an existing replacement but allow the redirect to override it

// preserve the original redirectedFrom if any

// prime mod 10 needs to equal 3 or 7

// private

// private function a store will createSequence upon

// private utility functions

// private variables

// processed

// produce result

// property of a typed array.

// property to emulate a data property that does not suffer from

// property, i.e., returning the value rather than the getter

// props

// props default value

// props does not exist on redirect records, but we can set false directly

// props from route configuration

// props.responsive === undefined ? 'offcanvas' : `offcanvas-${props.responsive}`,

// protected.  Extensions place their error-strings here.

// prototypally inherits from Readable, and then parasitically from

// prototype class for hash functions

// provide / inject

// proxy all the other methods.

// proxy certain important events.

// prune post-render after `current` has been updated

// public API

// punctuation

// purpose is to treat the first part of a surrogate pair as the whole character and then

// push the text

// r is a BN v4 instance

// r is a BN v5 instance

// read it all, truncate the list

// read part of list

// readable and reset the state. However this needs to happen

// reading, then it's unnecessary.

// readystate handler is calling before onerror or ontimeout handlers,

// record.commit();

// recurse

// recurse this function so we don't reset allParents and allChildren

// recursively remove tags to ensure that the returned string doesn't contain forbidden tags after previous passes (e.g. '<<bait/>switch/>')

// redirect only after logout (redirectAlways == false) - we can't wait for the browser here...

// redirect to correct URL for current user

// redirect to login

// referring to the empty child. Or we currently are on a different

// refresh active state

// reimplemented by: Alexander M Beedie

// reimplemented by: Brett Zamir (http://brett-zamir.me)

// reimplemented by: Kristof Coomans (SCK-CEN (Belgian Nucleair Research Centre))

// reimplemented by: Ole Vrijenhoek

// reimplemented by: Pierre-Luc Paour

// reimplemented by: Rafał Kukawski

// reimplemented by: Rafał Kukawski (http://blog.kukawski.pl)

// reimplemented by: stag019

// reject any unknown error

// reject if we are waiting for data in the Promise

// reject straight away

// reliably in a browserify context because there could be multiple different

// reload mainscreen to make sure registry gets updated

// reload registry/mainscreen - registry problem?

// remove all the event listeners that were added.

// remove all.

// remove any character before the hash

// remove any nullish param

// remove css image flicker

// remove leading whitespace from rest of line to parse

// remove some "private" loop variables (needed for nested loops)

// remove the component if it wasn't buffered

// remove the instance reference to prevent leak

// remove the last slash as we could be at the end

// remove the route if named and only for the top record (avoid in nested calls)

// remove the trailing slash so all other method can just do `base + fullPath`

// remove unnecessary operator spaces

// remove variables that can contain vue instances

// removes tha '<' char at the end of the string to replicate PHP's behaviour

// render inner content

// rendering, and the name

// replace the function with the resolved component

// replacement char (U+FFFD) and advance only 1 byte

// request.destroy just do .end - .abort is what we want

// require('getprototypeof');

// require()-s are direct to support Browserify.

// reset match state to false

// reset state

// reset the matching state

// resets the score if we are inside a sub-segment /:a-other-:b

// resolve the greatest numeric key

// resolveDynamicModel expects an uppercase tag name, but vnode.type is lowercase

// resolved props and emits options

// respect <base> tag

// resume within the same tick will have no

// resume()

// return -1 if a, 1 if b, 0 otherwise

// return aScore.length < bScore.length

// return fftm.mulp(self, num, out);

// return null, so we provide a flag to exit gracefully.

// return once no more tags are removed

// return the difference of chars

// return the list of modules as css string

// return the smaller one so that we can append the calendar and numbering overrides to it

// returned by next() and store the error

// returns the index of the closest mapping less than the needle. By

// reuse the free corkReq.

// reverse-compat since 1.2; we always round down now, never up, and we do it by default

// reversed order so parents are at the beginning

// revert the navigation

// rewind for better error message

// rewind, since should have been submessages

// right-justified (pad to left)

// rouds .5 towards the next even integer

// rounds .5 away from zero

// rounds .5 toward zero

// rounds .5 towards the next odd integer

// route. Only add the / delimiter if the child path isn't empty and if the

// rsa keys can be interpreted as ecdsa ones in openssl

// run the queue of per route beforeEnter guards

// run the queue of per route beforeRouteLeave guards

// runtime helper for setting properties on components

// sa = Object.prototype.toString.call(s) === '[object Array]'

// same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error

// same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error.

// same as finalizing a param

// sanitize containerProperty label

// save matches state based on the payload

// scrollBehavior to be triggered without a saved position

// seconds

// see above

// see http://php.net/manual/en/function.array-slice.php

// see https://github.com/Microsoft/TypeScript/issues/29204

// see p_cs_precedes

// see p_sep_by_space

// see, e.g. https://github.com/wooorm/bcp-47

// segment again.

// semver major update we should change the default to this.

// separators at the end of the string, stop now

// set default options

// set default sortType for strings and dates

// set default values for missing stuff

// set initial checked on mount to wait for true-value/false-value

// set up data events if they are asked for

// set up the listener and prepare teardown callbacks

// set up the listeners and prepare teardown callbacks

// set value in mounted & updated because <select> relies on its children

// set value on mounted so it's after min/max for type="range"

// setZone is a valid option in the calling methods, but not in fromObject

// setting needle.originalColumn to 0, we thus find the last mapping for

// setting them to null

// setup Promise in chunk cache

// shim for using process in browser

// short array syntax (one argument, no parentheses)?

// should check for parent.loop.XXX usage

// should we decode strings into buffers before passing to _write?

// shuffle the array of keys

// sign of the number

// signedOffset('-5', '30') -> -330

// similar to how Writable.write() returns true if you should

// simple cache for applying multiple behaviors to same selector does query multiple times

// simulate PHP's behaviour: '-9a' doesn't give a warning, but 'a9' does.

// since _read has to be called to start processing a new chunk.  However,

// since enterCallbackArray is truthy, both record and name also are

// since it doesn't overflow neither write partial UTF-8 characters.

// since its locale is not settable

// since other matchers are aliases, they should be removed by the original matcher

// since the original record has an undefined value for aliasOf

// since we are navigating to the same location, we don't need to pick the

// single equals check for both `null` and `undefined`

// skintone modifier

// skip beyond duplicated percent

// skip consecutive whitespace

// skip get() and is() methods (in which case, name is empty)

// skip restricted props in strict mode

// skip undefined values in arrays as if they were not present

// skip update and leave guards if the route component is not mounted

// slash with hash because the file could be read from the disk like file://

// slice?

// slightly revisited to rely on looping instead of recursion

// slot content array of a dynamic conditional slot may have a branch

// slow case. multiple pipe destinations.

// smaller code than using filter

// so Buffer.isBuffer(Buffer.prototype) will be false

// so that async components cache is hold on the original record

// so they align in future checks above

// so we can be removed

// so we should call onloadend on the next 'tick'

// socket or file.

// some bits pass through, and others are simply ignored.  (That would

// some envs mock window but not fully

// some old browsers...

// something with the data.  Sometimes it's called a "filter",

// sometimes generates source maps with duplicates in them. See Github issue

// sorted does not cause O(n^2) running time.

// sorting in C++. By using our own JS-implemented Quick Sort (below), we get

// source gets the 'end' or 'close' events.  Only dest.end() once.

// source-map node constructors

// source-map@6 types are faulty, we have to force-type chunks as any

// sources of the consumer.

// specific error message to try to guide them the right way.

// specific writer, then it would cause it to never start

// sscanf documented decimal number; equivalent of 'd';

// sscanf seems to disallow all conversion specification components (of sprintf)

// standardize case and plurality in units

// start chunk loading

// start out asking for a readable event once data is transformed.

// start position in str

// start requesting the chunk already

// start the flow if it hasn't been started already.

// state

// still not ready if an error happened

// str1 is longer than str2

// stream classes.  When you write(chunk), that calls _write(chunk,cb)

// streamline line separators

// strikes again! See github issue #191.

// string

// string rather than a number, so we use loose equality checking here.

// strip C slashes

// strip full URL origin

// strrpos' offset indicates starting point of range till end,

// succeeds curr. symbol

// such a pathological inflating mechanism, there'd be no way to tell

// support array as roots

// support container records

// support grid renderers

// support once('readable', fn) cycles. This means that calling

// support records

// surrogate pairs

// surrogate. In that case, we need to wait for the next two bytes in order to

// suspense related

// swap

// switch to run as app has no view right

// switching every time we're reading a value

// sync guard flag.

// synthetic stream cases, such as passthrough streams, _read

// t2 = sigma0 + maj

// tag handlers

// target += _pad(cca.toString(8), 3);break; // Sufficient for UTF-16

// technical time formats (e.g. the time part of ISO 8601), take some options

// tell the dest that it's being piped to

// temp disabled per https://github.com/WebReflection/get-own-property-symbols/issues/4

// temp disabled per https://github.com/ljharb/object.assign/issues/17

// template alias

// test for 8-bit control characters

// test operator

// tests

// thanks to @Rantanen

// that Readable wants before the first _read call, so unset the

// that causes it, under certain circumstances, to provide the same value for

// that could have changed the offset by going over a DST, but we want to keep the ts the same

// that nothing more will ever be provided

// that the Readable class should behave improperly, as streams are

// that to be increased. Set to zero for unlimited.

// that we're awaiting a 'readable' event emission.

// the 'readable' event and move on.

// the .. operator is equivalent to the range() function

// the EVENTS flag is only for hydration and if it is the only flag, the

// the ReadableState constructor, at least with V8 6.5

// the WritableState constructor, at least with V8 6.5

// the `instanceof` check but they should be treated as of that type.

// the `source` property as a convenience for inlining compiled templates.

// the amount of scores is the same as the length of segments except for the root segment "/"

// the amount that is being written when _write is called.

// the array is put in sorted order, and it will not need to be moved

// the buffer so we don't have to here

// the callback that the user supplies to write(chunk,encoding,cb)

// the callback that's passed to _write(chunk,cb)

// the caller expect this to happen before if

// the common path parts

// the component instance is reused for a different route or name, so

// the content of the block. In such a case, nesting it does not work as

// the current iteration and returning a variable to represent the individual character;

// the drain event emission and buffering.

// the else clause below will detect !this.isData and throw exception.

// the empty array and our base case.

// the end, only take the value at i

// the entire buffer is not flushed immediately on write()

// the error is already handled by router.push we just want to avoid

// the error to be emitted nextTick. In a future

// the first visit

// the given line, provided such a mapping exists.

// the hash appears before the search, so it's not part of the search string

// the leading comma is intentional so empty string "" is also included

// the least I can do is make error messages for the rest of the node.js/crypto api.

// the length is off by one, we need to decrease it

// the line we are searching for.

// the line we found.

// the listener, so we end up triggering both

// the loop variable cannot be used in the condition

// the lowest limit is Chrome, with 0x10000 args.

// the matcher might have merged current location params, so

// the names array.

// the next four bits are the actual value, and the 6th bit is the

// the next vnode so that it can be properly unmounted later.

// the no-half-open enforcer

// the number of writers that are awaiting a drain event in .pipe()s

// the one we are searching for. However, there may be more than one such

// the original record

// the override mistake, that accessor's getter is marked with

// the point at which it stops calling _read() to fill the buffer

// the point at which write() starts returning false

// the prependListener() method. The goal is to eventually remove this hack.

// the promise is actually somehow related to the callback's execution

// the read buffer, and will cause it to emit 'readable' if necessary.

// the readable code triggers during a read() call

// the refs so the single vnode can be set on multiple refs

// the regexp as a string

// the results of the previous transformed chunk were consumed.

// the root segment needs special treatment

// the router is not attached to an app anymore

// the router parse them again

// the routes view isn't active

// the same options object.

// the segment will always be valid because we get into the initial state

// the source map URL to SourceMapConsumer, so that this function

// the spec.  This block is basically the equivalent of:

// the state of the read buffer, providing enough data when

// the system to stop doing the transform.  A single 4MB write could

// the time and tell the formatter to show it to us in UTC, so that the time is right

// the type doesn't matter because we are comparing per reference

// the upcoming resume will not flow.

// the user provided a custom regexp /:id(\\d+)

// them and which they are modifying (as in PHP 6)

// them is expensive, so we only want to do it if we must.

// them since them being non-null during a mount doesn't affect the logic as

// then flag all "chunkIds" as loaded and fire callback

// then go ahead and try to read some more preemptively.

// then perfect moment to cut the line

// there could be a redirect record in history

// there will be only 2 of these for each stream

// there's enough pending readable data buffered up.

// these all have the offsets removed because we don't have access to them

// these aren't really private, but nor are they really useful to document

// these hoops because there can be many thousands of mappings, and parsing

// these needs to be populated by the parent

// they *should* be copied for kept-alive vnodes. So we just always copy

// they will simply be overwritten.

// this - (-num) = this + num

// this allows us to hold a copy of the `components` option

// this also allows the user to control the encoding

// this can emit finish, and it will always happen

// this can emit finish, but finish must

// this case we can't simply undo the transform.

// this code block is conditional.  However, it's preferable to pass

// this forcesimple option is never used (the only caller short-circuits on it, but it seems safer to leave)

// this initial navigation is only necessary on client, on server it doesn't

// this is IE 8, which has a broken gOPD

// this is a dumbed down version of fromObject() that runs about 60% faster

// this is a push, the only way for it to be triggered from a

// this is here so that some node-core streams can optimize string

// this is mainly useful for booleans that are not rendered the same way in PHP and JavaScript

// this is the max bytes crypto.getRandomValues

// this is the ternary version

// this is ugly but we have to ensure that each element of the array is rendered as PHP would render it

// this is used instead of '%F'; seems to be same as %e

// this is what openssl does

// this listener will have to be adapted to not trigger again and to wait for the url

// this logic is optimized to support for await loops,

// this may be a Weex event which doesn't have this method

// this module should only have a default export

// this must be 0 before 'finish' can be emitted

// this probably doesn't work for all locales

// this will handle "floating point madness" by removing extra decimal places

// this will update the instance for new instances as well as reused

// this works because the original record is the first one

// this would override user added attrs but Vue will still add

// this._events to be assigned to a new object

// throw new Error('unknown key type ' + type)

// throws if cannot be stringified

// time

// timestamp are UTC by definition

// tiny amounts

// to an original position.

// to avoid piling up things on the stack

// to be immediately set

// to be removed completely in Twig 3.0

// to be set immediately

// to be updated before triggering the listeners. Some kind of validation function would also

// to build an href

// to continue to work with older versions of Node.js that do not include

// to convert from UTF-16 (which all JS strings are encoded in).

// to create a new object while only changing some of the properties

// to definitely enumerate them.

// to detect a Buffer instance. It's not possible to use `instanceof Buffer`

// to get stuck in a permanently paused state if that write

// to make it re-entrance safe in case destroy() is called within callbacks

// to non-red form?

// to support multiple router instances

// to the SourceNode without any mapping.

// to the end for any other conversion specifications (besides a percent literal),

// to the readable side.  You may call 'push' zero or more times.

// to their upper/lower bounds if the value passed is out of range.

// to work with 256-bit numbers, otherwise it gives 20% improvement for 256-bit

// toFixed will give an out of bound error so we fix it like this:

// todo: what other type of data can parameter be?

// token parsers

// tokenCache.set(path, tokens)

// too slow.

// trailing edge, the system time has gone backwards and we're treating

// transplited with Babel

// treat high private surrogates as single characters)

// trigger beforeRouteEnter next callbacks

// trigger scroll to allow scrolling to the same anchor

// true:

// try 2-words tests

// try to find the right one.

// uint32

// uint64

// uncompressed, hybrid-odd, hybrid-even

// undefined

// undefined = chunk not loaded, null = chunk preloaded/prefetched

// undefined = never times out

// undefined is handled specially as per ECMA-262 6th Edition,

// underlying stream.

// understanding of the description is that there should be padding;

// undocumented cb() API, needed for core, not for public API

// unexpected trail

// unicode split

// unique to Safari 2

// unit conversion constants

// unknown specifier, consume that char and return empty

// unlexable

// unmounting/deactivating components

// unpaired lead

// unsigned decimal integer

// unsuidable generator

// up in Node's output if this results in an unhandled exception.

// update length

// update readableListening so that resume() may be a no-op

// update state

// update the buffer info.

// uphold the illusion by pretending to see that original data

// urlParsingNode provides the UrlUtils interface - http://url.spec.whatwg.org/#urlutils

// use 'interna' Ext we create and export here

// use a regexp without $ at the end to match nested routes better

// use current history state to gracefully handle a wrong call to

// use grouping characters

// use mon_thousands_sep; "" for no grouping; additional array members

// use the last day of the right month

// use their own type anyway.

// used for the initial navigation client side to avoid pushing

// used later on to remove by name

// userland ones.  NEVER DO THIS. This is here only because this code needs

// userland will fail

// utf8_encode

// utils is a library of generic helper functions non-specific to axios

// v8 likes predictible objects

// valid lead

// valid surrogate pair

// validFeedbackContent

// value, and has a chance to attach a 'drain' listener.

// values for the readable and the writable sides of the duplex stream,

// values for the readable and the writable sides of the duplex stream.

// var LEVENSHTEIN_MAX_LENGTH = 255 // PHP limits the function to max 255 character-long strings

// var fftm = new FFTM();

// var groupBase = Math.pow(base, groupSize);

// var groupSize = Math.floor(BN.wordSize * Math.LN2 / Math.log(base));

// var matches = format.match(/%[+-]?([ 0]|'.)?-?\d*(\.\d+)?[bcdeufFosxX]/g);

// var sa = ''

// variable name

// variables in JavaScript); if using instead in JavaScript and you

// verbatim itself

// vnode should not be considered dynamic due to handler caching.

// waiting to be emitted.

// warn against deprecated usage with <transition> & <keep-alive>

// warn against params with the same name

// warn if the user is passing invalid params so they can debug it better when they get removed

// watch

// watch at the same time the component instance, the route record we are

// we are dealing with nested routes

// we are in termination case (3) or (2) and return the appropriate thing.

// we cache week data on the DT object and this intermediates the cache

// we can be expecting either 'end' or

// we can do is format the date in UTC.

// we can guarantee we have that here, because we control the

// we can't determine kStringMaxLength in environments where process.binding

// we can't go below zero, but we still need to increment toPosition

// we cannot guarantee that there is no error lingering around

// we copy any saved update or leave guards. With async setup, the

// we could use the formatter, but this is an easier way to get the minimum string

// we create a copy to modify it later

// we defer if data is null

// we did not generate a valid codePoint so insert a

// we do a strict check to return the element with only the id attribute

// we don't support ZZZZ (PST) or ZZZZZ (Pacific Standard Time) in parsing

// we flow only if there is no one listening

// we get some perf out of doing this here, annoyingly

// we have implemented the _read method, and done the other things

// we ignore the value if the stream

// we know the matcher works because we tested the regexp

// we might be the child of an alias

// we must ensure that previous needDrain will not be reset to false.

// we must run before auto-escaping

// we need it if the extension ends up not matching

// we need some help as js intl is not yet ready

// we need the value at the time we render because when we unmount, we

// we need to discard the wrapping "TwingNode" for the "body" node

// we need to run the decoding again

// we set destroyed to true before firing error callbacks in order

// we set here to have the right order

// we stay on the same position

// we wait for the next tick, because it might

// we will wait for the previous Promise to finish

// we'd be able to check the generator

// we'd like to absorb these fractions in another unit

// we'll use buffer.write to truncate,

// webpackBootstrap

// weekNumber (W)

// weekYear (k)

// weekdays

// weekdays - format

// weekdays - standalone

// weird!

// weird...rs is an array but data isn't??  recurse but just send in the whole data object.

// weird...rs is an array but data isn't??  recurse but just send in the whole invalid data object.

// when 'finish' is emitted

// when end() has been called, and returned

// when padding with zeros

// when the dest drains, it reduces the awaitDrain counter

// when true all writes will be buffered until .uncork() call

// when we repeat we must take care of the repeating leading slash

// when we try to consume some more bytes, simply unpause the

// when when somebody has screwed with setTimeout but no I.E. maddness

// whenever we return null, then we set a flag to say

// where all of the continuation bytes for a character exist in the same buffer.

// where next() is only called once at a time

// whether the request URL is of the same origin as current location.

// which also requires the correct parent container

// which is in turn based on the one from crypto-js

// which means it won't track dependencies - but it's ok because

// which phpjs wants to support

// which will not have a mounted element

// while all odd indices are the newlines between two adjacent lines

// while lastIndexOf's optional 2nd argument indicates ending point of range from the beginning

// will be set synchronously right after creation

// will get processed, now that we've asked for it.

// will return status as 0 even though it's a successful request

// with the leading /

// without all the intl stuff this is backfilling

// without arguments the php class name of the this is returned

// without limitation the rights to use, copy, modify, merge, publish,

// without triggering the next() queue

// works on IE10/11 and Surface

// worse generated code for the comparator function than would be optimal. In

// would be consumed, and then the rest would wait (un-transformed) until

// would prevent it from being tree-shaken.

// would return false, as no `_writableState` property is attached.

// wrap an old-style stream as the async data source.

// wrap outer nodes that can implicitly call toString()

// wrap print to check toString() calls

// wrapped in strict mode code which doesn't define any globals.  It's inside a

// wrapping with Promise.resolve allows it to work with both async and sync guards

// write() some more.

// written chunk would result in multiple output chunks, then the first

// x % n but takes the sign of n instead of x

// x1 * z2^2 == x2 * z1^2

// x^2 = (y^2 - c^2) / (c^2 d y^2 - a)

// y1 * z2^3 == y2 * z1^3

// years

// yes, let's parse it properly

// you can override either this method, or the async _read(n) below.

// zero (rem + 1) trailing bits, where (rem + 1) is the smallest

// zone

// }

// })

// ~~ acts much like Math.trunc

//# sourceMappingURL=_phpCastString.js.map

//# sourceMappingURL=abs.js.map

//# sourceMappingURL=acos.js.map

//# sourceMappingURL=acosh.js.map

//# sourceMappingURL=addcslashes.js.map

//# sourceMappingURL=addslashes.js.map

//# sourceMappingURL=array_chunk.js.map

//# sourceMappingURL=array_merge.js.map

//# sourceMappingURL=array_rand.js.map

//# sourceMappingURL=asin.js.map

//# sourceMappingURL=asinh.js.map

//# sourceMappingURL=atan.js.map

//# sourceMappingURL=atan2.js.map

//# sourceMappingURL=atanh.js.map

//# sourceMappingURL=base_convert.js.map

//# sourceMappingURL=bin2hex.js.map

//# sourceMappingURL=bindec.js.map

//# sourceMappingURL=bootstrap-vue-next.mjs.map

//# sourceMappingURL=ceil.js.map

//# sourceMappingURL=chop.js.map

//# sourceMappingURL=chr.js.map

//# sourceMappingURL=chunk_split.js.map

//# sourceMappingURL=convert_cyr_string.js.map

//# sourceMappingURL=convert_uuencode.js.map

//# sourceMappingURL=cos.js.map

//# sourceMappingURL=cosh.js.map

//# sourceMappingURL=count_chars.js.map

//# sourceMappingURL=crc32.js.map

//# sourceMappingURL=ctype_alpha.js.map

//# sourceMappingURL=decbin.js.map

//# sourceMappingURL=dechex.js.map

//# sourceMappingURL=decoct.js.map

//# sourceMappingURL=deg2rad.js.map

//# sourceMappingURL=echo.js.map

//# sourceMappingURL=exp.js.map

//# sourceMappingURL=explode.js.map

//# sourceMappingURL=expm1.js.map

//# sourceMappingURL=file_get_contents.js.map

//# sourceMappingURL=floor.js.map

//# sourceMappingURL=fmod.js.map

//# sourceMappingURL=get_html_translation_table.js.map

//# sourceMappingURL=getenv.js.map

//# sourceMappingURL=getrandmax.js.map

//# sourceMappingURL=hex2bin.js.map

//# sourceMappingURL=hexdec.js.map

//# sourceMappingURL=html_entity_decode.js.map

//# sourceMappingURL=htmlentities.js.map

//# sourceMappingURL=htmlspecialchars.js.map

//# sourceMappingURL=htmlspecialchars_decode.js.map

//# sourceMappingURL=http_build_query.js.map

//# sourceMappingURL=hypot.js.map

//# sourceMappingURL=i18n_loc_get_default.js.map

//# sourceMappingURL=implode.js.map

//# sourceMappingURL=index.js.map

//# sourceMappingURL=ini_get.js.map

//# sourceMappingURL=ini_set.js.map

//# sourceMappingURL=is_bool.js.map

//# sourceMappingURL=is_finite.js.map

//# sourceMappingURL=is_float.js.map

//# sourceMappingURL=is_infinite.js.map

//# sourceMappingURL=is_nan.js.map

//# sourceMappingURL=is_scalar.js.map

//# sourceMappingURL=join.js.map

//# sourceMappingURL=krsort.js.map

//# sourceMappingURL=lcfirst.js.map

//# sourceMappingURL=lcg_value.js.map

//# sourceMappingURL=levenshtein.js.map

//# sourceMappingURL=localeconv.js.map

//# sourceMappingURL=log.js.map

//# sourceMappingURL=log10.js.map

//# sourceMappingURL=log1p.js.map

//# sourceMappingURL=ltrim.js.map

//# sourceMappingURL=luxon.js.map

//# sourceMappingURL=max.js.map

//# sourceMappingURL=md5.js.map

//# sourceMappingURL=md5_file.js.map

//# sourceMappingURL=metaphone.js.map

//# sourceMappingURL=min.js.map

//# sourceMappingURL=money_format.js.map

//# sourceMappingURL=mt_getrandmax.js.map

//# sourceMappingURL=mt_rand.js.map

//# sourceMappingURL=nl2br.js.map

//# sourceMappingURL=nl_langinfo.js.map

//# sourceMappingURL=number_format.js.map

//# sourceMappingURL=octdec.js.map

//# sourceMappingURL=ord.js.map

//# sourceMappingURL=parse_str.js.map

//# sourceMappingURL=pi.js.map

//# sourceMappingURL=pow.js.map

//# sourceMappingURL=printf.js.map

//# sourceMappingURL=quoted_printable_decode.js.map

//# sourceMappingURL=quoted_printable_encode.js.map

//# sourceMappingURL=quotemeta.js.map

//# sourceMappingURL=rad2deg.js.map

//# sourceMappingURL=rand.js.map

//# sourceMappingURL=range.js.map

//# sourceMappingURL=rawurlencode.js.map

//# sourceMappingURL=round.js.map

//# sourceMappingURL=rtrim.js.map

//# sourceMappingURL=setlocale.js.map

//# sourceMappingURL=sha1.js.map

//# sourceMappingURL=sha1_file.js.map

//# sourceMappingURL=similar_text.js.map

//# sourceMappingURL=sin.js.map

//# sourceMappingURL=sinh.js.map

//# sourceMappingURL=soundex.js.map

//# sourceMappingURL=split.js.map

//# sourceMappingURL=sprintf.js.map

//# sourceMappingURL=sqrt.js.map

//# sourceMappingURL=sscanf.js.map

//# sourceMappingURL=str_getcsv.js.map

//# sourceMappingURL=str_ireplace.js.map

//# sourceMappingURL=str_pad.js.map

//# sourceMappingURL=str_repeat.js.map

//# sourceMappingURL=str_replace.js.map

//# sourceMappingURL=str_rot13.js.map

//# sourceMappingURL=str_shuffle.js.map

//# sourceMappingURL=str_split.js.map

//# sourceMappingURL=str_word_count.js.map

//# sourceMappingURL=strcasecmp.js.map

//# sourceMappingURL=strchr.js.map

//# sourceMappingURL=strcmp.js.map

//# sourceMappingURL=strcoll.js.map

//# sourceMappingURL=strcspn.js.map

//# sourceMappingURL=strip_tags.js.map

//# sourceMappingURL=stripos.js.map

//# sourceMappingURL=stripslashes.js.map

//# sourceMappingURL=stristr.js.map

//# sourceMappingURL=strlen.js.map

//# sourceMappingURL=strnatcasecmp.js.map

//# sourceMappingURL=strnatcmp.js.map

//# sourceMappingURL=strncasecmp.js.map

//# sourceMappingURL=strncmp.js.map

//# sourceMappingURL=strpbrk.js.map

//# sourceMappingURL=strpos.js.map

//# sourceMappingURL=strrchr.js.map

//# sourceMappingURL=strrev.js.map

//# sourceMappingURL=strripos.js.map

//# sourceMappingURL=strrpos.js.map

//# sourceMappingURL=strspn.js.map

//# sourceMappingURL=strstr.js.map

//# sourceMappingURL=strtok.js.map

//# sourceMappingURL=strtolower.js.map

//# sourceMappingURL=strtoupper.js.map

//# sourceMappingURL=strtr.js.map

//# sourceMappingURL=substr.js.map

//# sourceMappingURL=substr_compare.js.map

//# sourceMappingURL=substr_count.js.map

//# sourceMappingURL=substr_replace.js.map

//# sourceMappingURL=tan.js.map

//# sourceMappingURL=tanh.js.map

//# sourceMappingURL=trim.js.map

//# sourceMappingURL=ucfirst.js.map

//# sourceMappingURL=ucwords.js.map

//# sourceMappingURL=urlencode.js.map

//# sourceMappingURL=utf8_encode.js.map

//# sourceMappingURL=var_export.js.map

//# sourceMappingURL=vprintf.js.map

//# sourceMappingURL=vsprintf.js.map

//# sourceMappingURL=wordwrap.js.map

//------------------------------------------------------------------------------

//@ts-ignore

//@ts-ignore How can we narrow this type down

//normal enviroments in sane situations

//not a prime so +1

//not a safe prime

//rs.commit();

//todo

//var curSeq = (seqStart >= 0) ? buf.slice(seqStart, i+1) : prevBuf.slice(seqStart + prevBufOffset, i+1 + prevBufOffset);
