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

/*
          '<span class="preview-panel-bold">',
          'Ansprechpartner<br/>',
          'Newsletter<br/>',
          'Ticketnummer<br/>',
          'Ticketsubjekt<br/>',
          '</span>',
      */

/*
         * 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) 2019 Metaways Infosystems GmbH (http://www.metaways.de)
 */

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

/*
 * Tine 2.0
 * 
 * @package     Timetracker
 * @license     http://www.gnu.org/licenses/agpl.html AGPL Version 3
 * @author      Philipp Schüle <p.schuele@metaways.de>
 * @copyright   Copyright (c) 2007-2011 Metaways Infosystems GmbH (http://www.metaways.de)
 *
 */

/*
 * Tine 2.0
 * 
 * @package     Timetracker
 * @license     http://www.gnu.org/licenses/agpl.html AGPL Version 3
 * @author      Philipp Schüle <p.schuele@metaways.de>
 * @copyright   Copyright (c) 2007-2016 Metaways Infosystems GmbH (http://www.metaways.de)
 *
 */

/*
 * Tine 2.0
 * 
 * @package     Timetracker
 * @license     http://www.gnu.org/licenses/agpl.html AGPL Version 3
 * @author      Philipp Schüle <p.schuele@metaways.de>
 * @copyright   Copyright (c) 2007-2016 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!
 */

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

/* 
 * Tine 2.0
 * 
 * @license     http://www.gnu.org/licenses/agpl.html AGPL Version 3
 * @author      Michael Spahn <M.Spahn@bitExpert.de>
 * @copyright   Copyright (c) 2016 Metaways Infosystems GmbH (http://www.metaways.de)
 */

/* 
 * Tine 2.0
 * 
 * @license     http://www.gnu.org/licenses/agpl.html AGPL Version 3
 * @author      Philipp Schüle <p.schuele@metaways.de>
 * @copyright   Copyright (c) 2016 Metaways Infosystems GmbH (http://www.metaways.de)
 */

/* "__proto__".length */

/* '$' */

/* '_' */

/* 'o' */

/* 'p' */

/* 'r' */

/* 't' */

/* + ' ' + response.message  */

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

/* -1 -1 */

/* -1 0 */

/* -1 1 */

/* . */

/* .ArraySet */

/* .DecoderBuffer */

/* .EncoderBuffer */

/* .MappingList */

/* .Reporter */

/* .SourceMapGenerator */

/* .StringDecoder */

/* .codes */

/* .codes.ERR_INVALID_OPT_VALUE */

/* .codes.ERR_STREAM_PREMATURE_CLOSE */

/* .quickSort */

/* .version */

/* 0 -1 */

/* 0 0 */

/* 0 1 */

/* 1 */

/* 1 -1 */

/* 1 0 */

/* 3 */

/* 5 */

/* </replacement> */

/* DateTime */

/* DateTime.fromISO */

/* DateTime.fromJSDate */

/* DateTime.fromMillis */

/* DateTime.fromRFC2822 */

/* DateTime.fromSQL */

/* DateTime.invalid */

/* DateTime.local */

/* Duration */

/* HTMLProxy */

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

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

/* Settings.defaultZoneName */

/* TwingExtensionIntl */

/* ["default"] */

/* ["default"].locals */

/* asset import */

/* binding */

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

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

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

/* eslint-disable camelcase */

/* eslint-disable no-proto */

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

/* globals document: false */

/* greater-than sign */

/* harmony default export */

/* harmony export */

/* harmony import */

/* internal */

/* istanbul ignore if  */

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

/* module decorator */

/* pkg: Timetracker FAT Client (css/Timetracker-FAT.css)*/

/* pkg: Timetracker FAT Client (js/Timetracker-FAT.js)*/

/* provided dependency */

/* reexport */

/* unused reexport */

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

/*'Duration*/

/*'First Entry'*/

/*'Last Entry*/

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

/**
     * 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 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 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 end of the Interval
     * @type {DateTime}
     */

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

/**
     * 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 true if the given extension is registered.
     *
     * @param {string} name
     * @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();
     */

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

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

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

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

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

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

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

/**
     * {@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}
     */

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

/**
   * @access private
   */

/**
   * @cfg {Bool} showClosed
   */

/**
   * @cfg {Record} foreignRecordClass needed for explicit defined filters
   */

/**
   * @cfg {String} filterName server side filterGroup Name, needed for explicit defined filters
   */

/**
   * @cfg {String} linkType {relation|foreignId} needed for explicit defined filters
   */

/**
   * @cfg {String} ownField for explicit filterRow
   */

/**
   * @cfg {bool} blurOnSelect
   * blur this combo when record got selected, useful to be used in editor grids (defaults to false)
   */

/**
   * @deprecated use fromFormat instead
   */

/**
   * @deprecated use fromFormatExplain instead
   */

/**
   * @param node
   * @param e
   * @returns {boolean}
   */

/**
   * @param node
   * @param event
   * @returns {boolean}
   */

/**
   * @param {string} name - Zone name
   * @return {IANAZone}
   */

/**
   * @private
   */

/**
   * @property showClosedBtn
   * @type Ext.Button
   */

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

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

/**
   * Always set is_billable if timeaccount is billable. This is needed for copied sheets where the
   * original is set to not billable
   */

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

/**
   * Apply quick tag to current selection
   */

/**
   * Autoscrolling
   */

/**
   * Border
   */

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

/**
   * Closes selected timeaccount
   */

/**
   * Context menu for leaf
   */

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

/**
   * Delete fav action
   */

/**
   * Delete selected favorite
   *
   * @returns {boolean}
   */

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

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

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

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

/**
   * Merge an array of Intervals into a equivalent minimal set of Intervals.
   * Combines overlapping and adjacent Intervals.
   * @param {[Interval]} intervals
   * @return {[Interval]}
   */

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

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

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

/**
   * 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 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 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 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 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 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 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 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 up context menu
   */

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

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

/**
   * 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 current node of context menu
   */

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

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

/**
   * activates copy action
   */

/**
   * add custom items to context menu
   *
   * @return {Array}
   */

/**
   * add custom items to context menu
   * 
   * @return {Array}
   */

/**
   * append showClosed value
   */

/**
   * apply showClosed value
   */

/**
   * check user exportGrant for timeaccounts
   * NOTE: manage_timeaccounts ALWAYS allows to export
   *
   * @param action
   * @param grants
   * @param records
   * @returns {boolean}
   */

/**
   * default implementation to replace proxy in dom
   *
   * @param html
   * @private
   */

/**
   * disabled exportbutton in TimesheetEditDialog
   */

/**
   * don't eval grants as TAs have very special grants and we only show the dialog to users with MANAGE right
   */

/**
   * get a Promise which resolves with the final content
   * @returns {Promise<String>}
   */

/**
   * get core data nodes
   ** @returns Array
   */

/**
   * init this treePanel
   */

/**
   * is called is billed field changes
   */

/**
   * only allow multi edit with manage_timeaccounts right (because of timeaccount handling in edit dlg)
   */

/**
   * overwrite update toolbars function (we don't have record grants yet)
   */

/**
   * overwrites the isValid method on multipleEdit
   */

/**
   * register a custom replacer method for this proxy
   * @param {Function} fn
   */

/**
   * replace proxy by given html
   * @param html
   * @returns {Promise<boolean|void>}
   */

/**
   * returns additional save params
   *
   * @returns {{checkBusyConflicts: boolean}}
   */

/**
   * returns dialog
   * 
   * NOTE: when this method gets called, all initalisation is done.
   */

/**
   * returns dialog
   * 
   * NOTE: when this method gets called, all initialization is done.
   */

/**
   * set the render/producer function this HTMLProxy proxies
   *
   * @param renderPromise
   * @returns {Promise}
   */

/**
   * show error if request fails
   * 
   * @param {} response
   * @param {} request
   * @private
   */

/**
   * this gets called when initializing and if a new timeaccount is chosen
   * 
   * @param {} field
   * @param {} timeaccount
   */

/**
   * this gets called when initializing and if cleared checkbox is changed
   *
   * @param {} field
   * @param {} newValue
   *
   * @todo    add prompt later?
   */

/**
   * value renderer
   * 
   * @param {Ext.data.Record} filter line
   * @param {Ext.Element} element to render to 
   */

/**
   * {@link toLocaleString} format like 10/14/1983
   * @type {Object}
   */

/**
 *
 * @param value
 * @returns {boolean}
 */

/**
 * @author Eric MORAND <eric.morand@gmail.com>
 */

/**
 * @class
 */

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

/**
 * @namespace   Tine.Timetracker
 * @author      Cornelius Weiss <c.weiss@metaways.de>
 * @class       Tine.Timetracker.TimeaccountPickerCombo
 * @extends     Tine.Tinebase.widgets.form.RecordPickerComboBox
 * 
 * adds show closed handling
 */

/**
 * @namespace   Tine.Timetracker
 * @class       Tine.Timetracker.TimeaccountContractFilterModel
 * @extends     Tine.widgets.grid.ForeignRecordFilter
 * 
 * @author      Alexander Stintzing <a.stintzing@metaways.de>
 */

/**
 * @namespace   Tine.Timetracker
 * @class       Tine.Timetracker.TimeaccountResponsibleFilterModel
 * @extends     Tine.widgets.grid.ForeignRecordFilter
 *
 * @author      Alexander Stintzing <a.stintzing@metaways.de>
 */

/**
 * @namespace   Tine.Timetracker
 * @class       Tine.Timetracker.TreePanel
 * @extends     Tine.Tinebase.Application
 * Timetracker TreePanel<br>
 *
 * @author Michael Spahn <M.Spahn@bitExpert.de>
 *
 */

/**
 * @param {"luxon".luxon.Duration} duration
 * @param {string} format
 *
 * @returns {string} The formatted interval.
 */

/**
 * @param {string} input
 * @returns {RegExp}
 */

/**
 * @private
 */

/**
 * 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 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 zone identified by an IANA identifier, like America/New_York
 * @implements {Zone}
 */

/**
 * Abstract class for all nodes that represents an expression.
 */

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

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

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

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

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

/**
 * 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 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  |
 * └─────────┴───────┴───────┴───────┴───────┴───────┴───────┴───────┴───────┴───────┴───────┴─────────┴───────┴───────┘
 */

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

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

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

/**
 * 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 new SourceMapGenerator based on a SourceMapConsumer
 *
 * @param aSourceMapConsumer The SourceMap.
 */

/**
 * Creates a new filled Buffer instance.
 * alloc(size[, fill[, encoding]])
 **/

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

/**
 * 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 whether mappingB is after mappingA with respect to generated
 * position.
 */

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

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

/**
 * Externalize the source map.
 */

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

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

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

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

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

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

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

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

/**
 * Noop implementation of TwingLoaderInterface.
 *
 * @author Eric MORAND <eric.morand@gmail.com>
 */

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

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

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

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

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

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

/**
 * Strip any JSON XSSI avoidance prefix from the string (as documented
 * in the source maps specification), and then parse the string as
 * JSON.
 */

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

/**
 * 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 characters pairs recognized as brackets.
 */

/**
 * The list of original sources.
 */

/**
 * The version of the source mapping spec that we are consuming.
 */

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

/**
 * Timeaccount grid panel
 * 
 * @namespace   Tine.Timetracker
 * @class       Tine.Timetracker.TimeaccountGridPanel
 * @extends     Tine.widgets.grid.GridPanel
 * 
 * <p>Timeaccount Grid Panel</p>
 * <p><pre>
 * TODO         copy action needs to copy the acl too
 * </pre></p>
 * 
 * @license     http://www.gnu.org/licenses/agpl.html AGPL Version 3
 * @author      Philipp Schuele <p.schuele@metaways.de>
 * @copyright   Copyright (c) 2007-2009 Metaways Infosystems GmbH (http://www.metaways.de)
 * 
 * @param       {Object} config
 * @constructor
 * Create a new Tine.Timetracker.TimeaccountGridPanel
 */

/**
 * Timesheet grid panel
 * 
 * @namespace   Tine.Timetracker
 * @class       Tine.Timetracker.TimesheetGridPanel
 * @extends     Tine.widgets.grid.GridPanel
 * 
 * <p>Timesheet Grid Panel</p>
 * <p><pre>
 * </pre></p>
 * 
 * @license     http://www.gnu.org/licenses/agpl.html AGPL Version 3
 * @author      Philipp Schüle <p.schuele@metaways.de>
 * 
 * @param       {Object} config
 * @constructor
 * Create a new Tine.Timetracker.TimesheetGridPanel
 */

/**
 * Timetracker Edit Dialog
 */

/**
 * Timetracker TimeaccountWestPanel west panel
 *
 * @namespace   Tine.Timetracker
 * @class       Tine.Timetracker.TimeaccountWestPanel
 * @extends     Tine.widgets.mainscreen.TimeaccountWestPanel
 *
 * @author      Michael Spahn <M.Spahn@bitExpert.de>
 */

/**
 * Timetracker TimesheetWestPanel west panel
 * 
 * @namespace   Tine.Timetracker
 * @class       Tine.Timetracker.TimesheetWestPanel
 * @extends     Tine.widgets.mainscreen.TimesheetWestPanel
 * 
 * @author      Michael Spahn <M.Spahn@bitExpert.de>
 */

/**
 * Tine 2.0
 *
 * @package     Timetracker
 * @license     http://www.gnu.org/licenses/agpl.html AGPL Version 3
 * @author      Alexander Stintzing <a.stintzing@metaways.de>
 * @copyright   Copyright (c) 2014 Metaways Infosystems GmbH (http://www.metaways.de)
 */

/**
 * Tine 2.0
 *
 * @package     Timetracker
 * @license     http://www.gnu.org/licenses/agpl.html AGPL Version 3
 * @author      Michael Spahn <M.Spahn@bitExpert.de>
 * @copyright   Copyright (c) 2016 Metaways Infosystems GmbH (http://www.metaways.de)
 * @copyright   Copyright (c) 2016 bitExpert AG (http://bitexpert.de)
 *
 */

/**
 * Tine 2.0
 * 
 * @package     Timetracker
 * @license     http://www.gnu.org/licenses/agpl.html AGPL Version 3
 * @author      Alexander Stintzing <a.stintzing@metaways.de>
 * @copyright   Copyright (c) 2012 Metaways Infosystems GmbH (http://www.metaways.de)
 */

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

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

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

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

/**
 * Tine 2.0
 * 
 * @package     Timetracker
 * @license     http://www.gnu.org/licenses/agpl.html AGPL Version 3
 * @author      Philipp Schüle <p.schuele@metaways.de>
 * @copyright   Copyright (c) 2007-2016 Metaways Infosystems GmbH (http://www.metaways.de)
 *
 */

/**
 * Twing base error.
 *
 * @author Eric MORAND <eric.morand@gmail.com>
 */

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

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

/**
 * moved to Ext.ux -> stub left here for backward compat
 */

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

/** Built-in constructor references. */

/** Used as a safe reference for `undefined` in pre-ES5 environments. */

/** Used as the semantic version number. */

/** Used for built-in method references. */

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

/***/

/**/

/*------------------------------------------------------------------------*/

/*--------------------------------------------------------------------------*/

/*.*/

/*/*/

/*</replacement>*/

/*<replacement>*/

//

// 

// 	Minutes, numeric

// 	Seconds, numeric, at least 2 digits with leading 0

// 	Years, numeric, at least 2 digits with leading 0

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

//         height: 'auto',

//         id: 'TimeaccountFavoritesPanel'

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

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

//     items.push(new Tine.Timetracker.TimeaccountFavoritesPanel({

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

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

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

//   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()

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

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

//   method, but they are processing the call asynchronously and have _not_

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

//   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, '.', '')

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

// "mapping.generatedColumn" with "lastMapping"

// "name": intentionally not styling

// "the promise rejected with null" or "the promise fulfilled with undefined".

// #72 and bugzil.la/889492.

// ''

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

// (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)

// (set with i18n_loc_set_default() as of PHP6)

// (since `REGEX_NEWLINE` captures its match).

// *below* the call to _read.  The reason is that in certain

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

// -- Decoding

// -- Encoding

// -- Encoding (pass-through)

// -0 = 0

// -1 - if `this` < `num`

// -121665 * (121666^(-1)) (mod P)

// -this - num = -(this + num)

// ... except it avoids using URL, which wasn't available in the

// .end() fully uncorks

// .replace(/\r\n/g, "\n").replace(/\r/g, "\n");

// 0 - 25: ABCDEFGHIJKLMNOPQRSTUVWXYZ

// 0 - if `this` == `num`

// 0 ≤ j ≤ i

// 0. Get next character.

// 00:00:00 means end of day

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

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

// ;[

// == 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 implement me

// @TODO retry n times, replaceProxy might be registered late!

// @see https://github.com/tc39/proposal-intl-datetime-style

// @see https://github.com/twigphp/Twig/issues/3174 as to why we don't check macro existence in parents

// @todo add custom fields here

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

// 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 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 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 termination characters

// Add the source content to the _sourcesContents map.

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

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

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

// 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 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 lazy use if the iteratee has a "length" value other than `1`.

// Avoids trying to get a char that does not exist

// B = (X1 + Y1)^2

// B = (Y1 + X1) * (Y2 + X2)

// B = A^2

// B = X2 - Z2

// B = Y1^2

// BMP characters: 1 code unit

// BN

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

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

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

// But allow more writes to happen in this tick.

// But don't agree with "Гг | Hh", nobody talks like that.

// By convention, when a data property is converted to an accessor

// By default disallow export, this apply for example, if there is no selection yet

// 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: ../../Timetracker/js/Model/Timesheet.js

// CONCATENATED MODULE: ../../Timetracker/js/Timetracker.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: ./twingEnv.es6.js

// CONCATENATED MODULE: ./util/transliterate.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 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 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 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 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 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 `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 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 regular expression

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

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

// Defaults to UTF-16LE, as it's prevalent and default in Node.

// Definite form

// Denormalize

// Description of supported double byte encodings and aliases.

// Detect free variable `module`

// Detect free variables `exports`

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

// E.g. filter changes and so on

// ECDH

// ECDSA

// ES6 symbol

// ESM COMPAT FLAG

// EUC-KR, KS_C_5601 and KS X 1001 are exactly the same.

// EXPORTS

// EXTERNAL MODULE: ./node_modules/events/events.js

// EXTERNAL MODULE: ./node_modules/locutus/php/math/index.js

// EXTERNAL MODULE: ./node_modules/locutus/php/strings/index.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/twing-intl/browser.js

// EXTERNAL MODULE: ./node_modules/twing/dist/es/browser.js + 245 modules

// EXTERNAL MODULE: ./node_modules/util/util.js

// EXTERNAL MODULE: ./twingEnv.es6.js + 1 modules

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

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

// Escape characters that can't be included in string literals.

// Etc/GMT+8 -> -480

// Every written chunk gets output as-is.

// Everything else in the universe uses 'utf8', though.

// Except base64 encoder, which must keep its state.

// 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 Lodash on the global object to prevent errors when Lodash is

// Expose `MapCache`.

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

// Failure

// Fallback for data views, maps, sets, and weak maps in IE 11 and promises in Node.js < 6.

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

// 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 coercion to uint32. This will also coerce falsey/NaN values to 0.

// Force redgomery representation when loading from JSON

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

// Get NAF form

// Get basis vectors, used for balanced length-two representation

// Get character; suppresses skipping over whitespace!

// Get filter model for current selection

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

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

// Handle complete words

// Handle invocations in a tight loop.

// Handle string cases:

// Handle the residue

// 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 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'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 doesn't make error fields non-enumerable

// IE only adds stack when thrown

// 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, change the ts by the difference in the offset

// If our lower bound is less than our upper bound, we (1) partition the

// 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 was at least one selection which had the exportGrant, allow to export

// 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 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 case of success, just reload grid

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

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

// Initial 0x not necessary here

// Initial Permutation

// Initial values

// 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 current buffer to convert already stored Buffers:

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

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

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

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

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

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

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

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

// NB: mutates parameters

// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,

// NOTE: (qj / bhi) is (0x3ffffff * 0x4000000 + 0x3ffffff) / 0x2000000 max

// NOTE: 1) `mode` can be set to `mod` to request mod only,

// NOTE: Greg Maxwell's trick, inspired by:

// NOTE: Important as we are creating point in Base.call()

// 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 stage it is known that the top bit is set

// NOTE: if `extended` is present - it will be filled with destroyed bits

// NOTE: lo is 27bit maximum

// NUMBERS AND STRINGS

// Naive implementation, but it works because CESU-8 is especially easy

// Naive implementation.

// 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 hyphen at beginning or end unless allowed in charlist (or locale)

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

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

// 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 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 remove fractional portion if explicitly set to zero digits

// Optimization - zeroify

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

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

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

// Readable class this is attached to

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

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

// Sanity checks

// Save it to be reused later.

// 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 request to backend

// Sequence continues.

// Sequence finished. Write it.

// Sequence start

// Serves as infimum

// Set `bit` of `this`

// Set and get locale

// Set initial values

// Set key

// Set reporter to share it with a child class

// Set the leaf to given dbcsCode.

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

// Square root over p

// Start the timer for the trailing edge.

// State

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

// 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 get timeaccount from filter if set - should be done in grid (onCreateNewRecord)

// 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: defer error events consistently everywhere, not just the cb

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

// Tag to assign

// Take note if the _read call is sync or async (ie, if the read call

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

// 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 could be > 0xFF because of astral characters.

// This ensures that 0..n-1 have an equal probability of being selected.

// This follows what Chrome does.

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

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

// Trying to use the custom `instanceof` for Writable here will also break the

// Two-byte code

// U = (M + E)^2 - MM - EE - T

// UNUSED EXPORTS: Expression

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

// Useful for many curves

// Utility methods

// Utils

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

// 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 need to go through all timeaccounts and check if the user is trying to export a timesheet of a timeaccount

// 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 node.js internal decoder. Its signature is the same as ours.

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

// Working variables

// Works as strcasecmp

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

// \uHHHH

// \xHH

// ].forEach(function (name) {

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

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

// accessing global.localStorage can trigger a DOMException in sandboxed iframes

// actions that shouldn't happen until "later" should generally also

// activities and tags

// adapted from https://github.com/apatil/pemstrip

// add renderer for invoice position gridpanel

// add static functions

// adopt duration if starttime is set

// adopt end_time if duration is set

// adopt endtime if starttime is set

// after error

// after readable has been emitted but before I/O (nextTick) to

// again. This runs in O(n) time.

// alias

// all fall-throughs

// all the elements that are greater than it after it. The effect is that

// allocate the first CorkedRequest, there is always

// allowing us to avoid a second parse if we encounter the same

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

// also returned false.

// also, that means that the chunk and cb are currently

// alternative to using Object.keys for old browsers

// always follow error

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

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

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

// 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 hot path ends with doWrite

// ascii decimals to real symbols

// assume utf8

// assume we have the higher-order units

// assumes there are no non-BMP characters;

// at the start of calling end()

// at this point, the user has presumably seen the 'readable' event,

// avoid extra slice()

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

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

// boolean

// bounded at: 0x40 * 0x3ffffff + 0x3d0 = 0x100000390

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

// 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 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 cb(er, data) where data is <= n in length.

// call default exception handler

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

// cases:

// cause everything after the first invalid character to be ignored. (e.g.

// cause the system to run out of memory.

// changes from Blues' implementation

// changes to the function body.

// charCode will always be < 0x10000 in javascript.

// character.

// characters)

// characters.

// check for manage_timeaccounts right

// check that the body does not contain non-empty output nodes

// check usage of non-defined loop-items

// checking whether the root is a prefix of the path won't work. Instead, we

// checks if the start is equal to or before the end

// checks that the node only contains "constant" elements

// cleanup event handlers once the pipe is broken

// clearable depends on timeaccount is_billable as well (changed by ps / 2009-09-01, behaviour was inconsistent)

// 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 in a pair which we have already processed

// computation

// compute the actual time

// conditions prevent the data from being read:

// configure ourselves to deal with gregorian dates or week stuff

// constants are marked safe for all

// construct, create_function() (though dollar signs must be on the

// consume data

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

// 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 of this software and associated documentation files (the

// 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 new DT instance by adding a duration, adjusting for DSTs

// create padding and handle blocks

// custom comparator function, calling back and forth between the VM's C++ and

// custom operators

// cut at next possible whitespace after the limit

// cut just at the defined limit

// date

// date is PHP timestamp - i.e. in seconds

// dates

// dd from modelConfig

// deadline exception

// 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 in iojs

// default options

// defaults for unspecified units in the supported calendars

// defer the callback if we are being called synchronously

// degree of precision

// delta = Z1^2

// designed to be sync/async agnostic.

// destroy(err, cb) is a private API

// determine the timezone

// determiner: 'must be' or 'must not be'

// didn't get any data, stop spinning.

// digits in this value following this digit.

// directly after the root.

// dispatch to the lexing functions depending on the current state

// distribute, sublicense, and/or sell copies of the Software, and to permit

// 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 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 push empty TEXT tokens

// 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 quoted string

// drain event flag.

// due to cross-origin restrictions

// dumbed-down version of the ISO one

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

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

// 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 on a partial character, we simply let v8 handle that.

// end up in an overlapped onwrite situation.

// endverbatim itself

// ensure setup of localization variables takes place

// ensure setup of localization variables takes place, if not already

// 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-restricted-syntax, no-unreachable-loop

// eslint-disable-line no-self-compare

// eslint-disable-line no-unmodified-loop-condition,max-len

// eslint-disable-next-line no-throw-literal

// event emitter implementation with them.

// except for type specifiers

// exclude `base` from the options

// 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 should be allowed always if user is allowed to manage timeaccounts

// exposed for testing purposes only.

// expressions

// extension

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

// falls through

// far as localized sepBySpace and signPosn behavior

// fast path needed to support multiple this.push()

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

// filters

// find the best mapping.

// find the right offset a given local time. The o input is our guess, which determines which

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

// for AM and PM. This is probably wrong, but it's makes parsing way easier.

// for Twig, a string is not traversable

// 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 legacy reasons, years between 0 and 99 are interpreted as 19XX; revert that

// for localeconv()

// for more details.

// for now assuming pure a-z

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

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

// generated file.

// generated positions relative to the start of the section, so we

// get slice of length one char above limit

// getRandomValues fails on IE if size == 0

// go through the array every three bytes, we'll deal with trailing stuff later

// got a match.

// got an "options" object

// gregorian data + weekday serves only to validate

// handle relative paths to be safe (might happen when process.cwd() fails)

// handle whitespace control modifiers

// handler in flow(), but adding and removing repeatedly is

// handling at a lower level.

// has a sign

// has it been destroyed

// has not been initialized yet

// has returned yet), so that we know whether or not it's safe to emit

// have a good chance at having a non-empty extension

// have exhausted all components, so the path is not relative to the root.

// helper useful in turning the results of parsing into real dates

// helper variables

// helps handle the details

// here, nested means "being at the root level of a child template"

// here.  For example, imagine a stream where every byte of input is

// high byte

// high private surrogates as single characters)

// 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://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 (String(sym) !== Symbol.prototype.toString.call(sym)) { return false; }

// if (i<80) {

// if (l1 > LEVENSHTEIN_MAX_LENGTH || l2 > LEVENSHTEIN_MAX_LENGTH) {

// if (sym instanceof Symbol) { return false; }

// if (this.app.featureEnabled('featureTimeaccountBookmark')) {

// if (typeof Symbol.prototype.toString !== 'function') { return false; }

// if _final has been called

// if clearTimeout wasn't available but was latter defined

// if cut wasn't forced

// if primitive value, replace with object

// if setTimeout wasn't available but was latter defined

// if the dest has an error, then stop piping into it.

// if the length is currently zero, then we *need* a readable event.

// 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 writable side is ready for autoDestroy as well

// if there may be such characters, then it is best to turn it on (critical in true XHTML/XML)

// 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 true, a maybeReadMore has been scheduled

// 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 have detected an error in the meanwhile

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

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

// incomplete multi-byte UTF-8 character. The total number of bytes (2, 3, or 4)

// indicate successive group lengths after first group

// infinity and NaN values are treated as strings

// init regular expressions

// inject a fake parent to make the parent() function work

// instances that were created from another copy of the `buffer` package.

// instead of converting it to a string and substringing

// internally, and returns false if there's a lot of pending writes

// interpreted as an integer from 0-255, and then results in that many

// interrupt process flow until dialog is rendered

// intersect safeness of both operands

// into their \x or \uHHHH representations

// is surrogate component

// is unsupported, so let's not set it

// istanbul ignore if

// istanbul ignore next

// 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 would fail so +8

// it's in progress.

// itself.

// just a weekday -> this week's instance of that weekday, no worries

// just one destination.  most common case.

// keep sign (+ or -) in front

// keep the values set in the inner context for variables defined in the outer context

// last char was a lead

// lastUnit must be defined since units is not empty

// later on (after another round of reversing)

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

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

// loaded by a script tag in the presence of an AMD loader.

// log is just a thin wrapper to console.log that prepends a timestamp

// 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 dots optional and also make them literal

// make sure the values we have are in range

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

// 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 that we need a transform, so that any data that comes in

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

// ms

// much of this based on https://github.com/indutny/self-signed/blob/gh-pages/lib/rsa.js

// multiplication (like elliptic secp256k1).

// must be multiple of 3

// names to indices into the sources and names ArraySets), we have to make

// necessarily symmetric or synchronous transformation.  For example,

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

// never call cb(), then you'll never get another chunk.

// new Array(64)

// no default, invalid units throw in normalizeUnit()

// no lead yet

// no more data can be written.

// no such thing as a sparse string.

// node sometimes defaults to "und". Override that because that is dumb

// node visitors

// node::ParseEncoding() requires lower case.

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

// not a function

// not an actual buffer we keep track of, but a measurement

// not be available as a global

// not happen before the first read call.

// not happen before the first write call.

// not setting this directly to LocalZone.instance bc loading order issues

// not used by this implementation

// note that ncarry could be >= 0x3ffffff

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

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

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

// offset

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

// older releases of node still supported by this library.

// on the `m` itself.

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

// only contains blocks and use statements.

// only eval grants in action updater if user does not have the right to manage timeaccounts

// only if useInvoice = false

// operators

// optimize array, hash and Map calls

// or on a later tick.  We set this to true at first, because any

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

// original length, plus the receiver, minus any additional arguments (after the receiver)

// otherwise cut at previous whitespace

// otherwise just use weeks or ordinals or gregorian, depending on what's specified

// otherwise, keep it in the wings to boil it later

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

// parent block is safe by definition

// parent is a string

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

// passed in one, but it's not the right one.

// path component

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

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

// precedence: getXxx() > isXxx() > hasXxx()

// preg_quote()

// prime mod 10 needs to equal 3 or 7

// private

// private utility functions

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

// prototypally inherits from Readable, and then parasitically from

// prototype class for hash functions

// proxy all the other methods.

// proxy certain important events.

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

// recordProxy: Tine.Timetracker.timeaccountBackend,

// recordProxy: Tine.Timetracker.timesheetBackend,

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

// register actions in updater

// 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 if we are waiting for data in the Promise

// reject straight away

// reliably in a browserify context because there could be multiple different

// remove all the event listeners that were added.

// remove all.

// remove leading whitespace from rest of line to parse

// remove some "private" loop variables (needed for nested loops)

// remove unnecessary operator spaces

// removes tha '<' char at the end of the string to replicate PHP's behaviour

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

// resolve the greatest numeric key

// resume within the same tick will have no

// resume()

// return -1 if a, 1 if b, 0 otherwise

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

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

// rsa keys can be interpreted as ecdsa ones in openssl

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

// seconds

// 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 account id to the current user, if he doesn't have the right to edit other users timesheets

// set default options

// set default values for missing stuff

// set factor from timeaccount except it was manually changed before

// set is_billable for new records according to the timeaccount setting

// set up data events if they are asked for

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

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

// 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 it doesn't overflow neither write partial UTF-8 characters.

// since its locale is not settable

// single equals check for both `null` and `undefined`

// skip beyond duplicated percent

// skip consecutive whitespace

// skip get() and is() methods (in which case, name is empty)

// slice?

// slightly revisited to rely on looping instead of recursion

// slow case. multiple pipe destinations.

// so Buffer.isBuffer(Buffer.prototype) will be false

// so they align in future checks above

// socket or file.

// some bits pass through, and others are simply ignored.  (That would

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

// 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 out asking for a readable event once data is transformed.

// start position in str

// start the flow if it hasn't been started already.

// state

// stop further events

// stop loop

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

// 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 once('readable', fn) cycles. This means that calling

// surrogate pairs

// surrogate. In that case, we need to wait for the next two bytes in order to

// swap

// 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 we're awaiting a 'readable' event emission.

// the 'readable' event and move on.

// the .. operator is equivalent to the range() function

// 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 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 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 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 to be emitted nextTick. In a future

// the given line, provided such a mapping exists.

// the least I can do is make error messages for the rest of the node.js/crypto api.

// the line we are searching for.

// the line we found.

// the loop variable cannot be used in the condition

// the lowest limit is Chrome, with 0x10000 args.

// the names array.

// the next four bits are the actual value, and the 6th bit is the

// 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 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 results of the previous transformed chunk were consumed.

// the same options object.

// 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 upcoming resume will not flow.

// them and which they are modifying (as in PHP 6)

// them is expensive, so we only want to do it if we must.

// then go ahead and try to read some more preemptively.

// then perfect moment to cut the line

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

// this - (-num) = this + num

// 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 is IE 8, which has a broken gOPD

// this is a dumbed down version of fromObject() that runs about 60% faster

// 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 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 logic is optimized to support for await loops,

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

// throw new Error('unknown key type ' + type)

// time

// timestamp are UTC by definition

// tiny amounts

// to an original position.

// to avoid piling up things on the stack

// to be removed completely in Twig 3.0

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

// too slow.

// trailing edge, the system time has gone backwards and we're treating

// transplited with Babel

// treat high private surrogates as single characters)

// true:

// try 2-words tests

// try to find the right one.

// uint32

// uint64

// uncompressed, hybrid-odd, hybrid-even

// undefined

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

// unit conversion constants

// unknown specifier, consume that char and return empty

// unlexable

// unpaired lead

// unsigned decimal integer

// unsuidable generator

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

// use default Tpl for default and multi view

// use grouping characters

// use mon_thousands_sep; "" for no grouping; additional array members

// use the last day of the right month

// userland ones.  NEVER DO THIS. This is here only because this code needs

// userland will fail

// utf8_encode

// v8 likes predictible objects

// valid lead

// valid surrogate pair

// value

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

// waiting to be emitted.

// 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 cannot guarantee that there is no error lingering around

// we could use the formatter, but this is an easier way to get the minimum string

// we defer if data is null

// we did not generate a valid codePoint so insert a

// 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 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 to discard the wrapping "TwingNode" for the "body" node

// we set destroyed to true before firing error callbacks in order

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

// weekNumber (W)

// weekYear (k)

// weekdays

// weekdays - format

// weekdays - standalone

// weird!

// 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 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 he has no permission to export.

// where next() is only called once at a time

// which is in turn based on the one from crypto-js

// which phpjs wants to support

// 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 get processed, now that we've asked for it.

// without all the intl stuff this is backfilling

// without limitation the rights to use, copy, modify, merge, publish,

// without triggering the next() queue

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

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

// }

// })

//# 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=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

//------------------------------------------------------------------------------

//Always reset is_billable to true on copy timesheet (only if Timaccount is billable of course)

//Time Account is closed

//normal enviroments in sane situations

//not a prime so +1

//not a safe prime

//var curSeq = (seqStart >= 0) ? buf.slice(seqStart, i+1) : prevBuf.slice(seqStart + prevBufOffset, i+1 + prevBufOffset);
