@react-fabric/utilities 1.0.0-beta.5 → 1.0.0-beta.52

package/dist/cjs/_ascii.js

@@ -1,8 +1,31 @@
 'use strict';
 
-var _slicedToArray = require('@babel/runtime/helpers/slicedToArray');
 var _isType = require('./_isType.js');
 
+/*
+ * React Fabric
+ * @version: 1.0.0
+ *
+ *
+ * The MIT License (MIT)
+ * Copyright (c) 2024 Adarsh Pastakia
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy of this software
+ * and associated documentation files (the "Software"), to deal in the Software without restriction,
+ * including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so,
+ * subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all copies or substantial
+ * portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED
+ * TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
+ * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+
 /** ***************** latin-ascii conversions *******************/
 var conversions = {
   AE: "Æ|Ǽ",
@@ -58,17 +81,19 @@ var conversions = {
 };
 
 /**
- * latin to ascii converter for convenient searching
- * @internal
+ * Converts a string to its ASCII representation by replacing
+ * special characters with their ASCII equivalents.
+ * This function is useful for normalizing strings for search or display purposes.
+ * It replaces characters like "Ä" with "Ae", "ß" with "ss", etc.
+ *
+ * @param {string} str - The input string to be converted.
+ * @returns {string} - The ASCII representation of the input string.
  */
 var ascii = function ascii(str) {
   if (_isType.isEmpty(str)) return "";
-  Object.entries(conversions).forEach(function (_ref) {
-    var _ref2 = _slicedToArray(_ref, 2),
-      a = _ref2[0],
-      l = _ref2[1];
-    var re = new RegExp(l, "g");
-    str = "".concat(str).replace(re, a);
+  Object.entries(conversions).forEach(function (entry) {
+    var re = new RegExp(entry[1], "g");
+    str = "".concat(str).replace(re, entry[0]);
   });
   return str;
 };

package/dist/cjs/_boundingBox.js

@@ -18,8 +18,13 @@ var _getBox = function _getBox(box) {
 };
 
 /**
- * box "x,y,w,h" | [x,y,w,h]
- * returns canvas box [x,y,w,h]
+ * Get bounding box from a string or array.
+ * The box can be in the format "x,y,w,h" or [x,y,w,h].
+ * The box is adjusted to ensure that x and y are non-negative.
+ * The width and height are adjusted accordingly.
+ *
+ * @param box "x,y,w,h" | [x,y,w,h]
+ * @returns canvas box [x,y,w,h]
  */
 var getBox = function getBox() {
   var box = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : "0,0,0,0";
@@ -37,8 +42,15 @@ var getBox = function getBox() {
 };
 
 /**
- * box "x1,y1,x2,y2" | [x1,y1,x2,y2]
- * returns canvas box [x,y,w,h]
+ * Get bounding box from a string or array.
+ * The box can be in the format "x1,y1,x2,y2" or [x1,y1,x2,y2].
+ * The box is adjusted to ensure that x1 and y1 are non-negative.
+ * The width and height are calculated as x2 - x1 and y2 - y1 respectively.
+ * If x1 or y1 are negative, they are set to 0 and the width and height are adjusted accordingly.
+ * This is useful for ensuring that the bounding box is always within the canvas area.
+ *
+ * @param box "x1,y1,x2,y2" | [x1,y1,x2,y2]
+ * @returns canvas box [x,y,w,h]
  */
 var getBoundingBox = function getBoundingBox() {
   var box = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : "0,0,0,0";

package/dist/cjs/_countries.js

@@ -26,32 +26,42 @@
 /* istanbul ignore file */
 
 /**
- * @internal
+ * Country interface
  */
 
 /**
- * country list with helper functions
+ * Country list with helper functions
+ * This is a list of all countries with their details.
+ * It includes information such as continent, ISO codes, name, full name, capital, top-level domain (TLD), currency, phone code, and emoji.
+ * This list can be used to retrieve country information based on various codes or names.
+ * @type {Country[]}
  */
 var Countries = {
   /**
-   * Get iso2 code
-   * @param code
+   * Get ISO2 country code
+   *
+   * @param code - The country code to search for. It can be an ISO2 code, ISO3 code, or an alternative code.
+   * @return {string | undefined} - Returns the ISO2 country code if found, otherwise undefined.
    */
   toIso2: function toIso2(code) {
     var ctry = this.find(code);
     return ctry != null ? ctry.iso2 : undefined;
   },
   /**
-   * Get iso3 code
-   * @param code
+   * Get ISO3 country code
+   *
+   * @param code - The country code to search for. It can be an ISO2 code, ISO3 code, or an alternative code.
+   * @return {string | undefined} - Returns the ISO3 country code if found, otherwise undefined.
    */
   toIso3: function toIso3(code) {
     var ctry = this.find(code);
     return ctry != null ? ctry.iso3 : undefined;
   },
   /**
-   * Country flag emoji
-   * @param code
+   * Get country emoji
+   *
+   * @param code - The country code to search for. It can be an ISO2 code, ISO3 code, or an alternative code.
+   * @return {string} - Returns the emoji representation of the country if found, otherwise returns a default flag emoji.
    */
   emoji: function emoji(code) {
     var ctry = this.find(code);
@@ -59,25 +69,25 @@ var Countries = {
   },
   /**
    * Get country name
-   * @param code
+   *
+   * @param code - The country code to search for. It can be an ISO2 code, ISO3 code, or an alternative code.
+   * @return {string} - Returns the name of the country if found, otherwise returns the code itself.
    */
   name: function name(code) {
     var ctry = this.find(code);
     return ctry != null ? ctry.name : code;
   },
   /**
-   * Find country by code
-   * @param code
-   * @return continent: string;
-   * @return iso2: string;
-   * @return iso3: string;
-   * @return name: string;
-   * @return fullname: string;
-   * @return capital: string;
-   * @return tld: string;
-   * @return currency: string;
-   * @return phone: string;
-   * @return emoji: string;
+   * This function searches for a country in the list by its code.
+   * It supports various formats:
+   * - ISO2 code (e.g., "US")
+   * - ISO3 code (e.g., "USA")
+   * - Alternative code (e.g., "US", "USA", "United States")
+   * It returns the first matching country object or undefined if not found.
+   * This function is useful for retrieving country details based on different code formats.
+   *
+   * @param code - The country code to search for. It can be an ISO2 code, ISO3 code, or an alternative code.
+   * @return {Country | undefined} - Returns the country object if found, otherwise undefined.
    */
   find: function find(code) {
     return this.list.find(function (ct) {
@@ -85,6 +95,14 @@ var Countries = {
       return ((_ct$alt = ct.alt) !== null && _ct$alt !== void 0 ? _ct$alt : "__").toLowerCase() === code.toLowerCase() || ct.iso3.toLowerCase() === code.toLowerCase() || ct.iso2.toLowerCase() === code.toLowerCase();
     });
   },
+  /**
+   * Country list
+   * This is a list of all countries with their details.
+   * It includes information such as continent, ISO codes, name, full name, capital, top-level domain (TLD), currency, phone code, and emoji.
+   * This list can be used to retrieve country information based on various codes or names.
+   *
+   * @type {Country[]}
+   */
   list: [{
     continent: "Asia",
     iso2: "AF",

package/dist/cjs/_debounce.js

@@ -26,8 +26,14 @@
 /* istanbul ignore file */
 
 /**
- * debounce callback
- * @internal
+ * Debounce function to limit the rate at which a function can fire.
+ * It will delay the execution of the function until after a specified timeout
+ * has elapsed since the last time the function was invoked.
+ *
+ * @param fn - The function to debounce.
+ * @param timeout - The number of milliseconds to wait before invoking the function.
+ * @returns A debounced version of the function that can be called with any arguments.
+ *          The debounced function also has a `cancel` method to clear the timeout.
  */
 var debounce = function debounce(fn) {
   var timeout = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 500;

package/dist/cjs/_dedupe.js

@@ -25,6 +25,18 @@ var _isType = require('./_isType.js');
  * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  */
 
+
+/**
+ * Remove duplicates from a list of objects based on a key or the entire object.
+ * If a key is provided, it will deduplicate based on the value of that key.
+ * If no key is provided, it will deduplicate based on the entire object.
+ * This is useful for normalizing data structures that may have nested arrays or objects.
+ *
+ * @param list
+ * @param key
+ * @typedef {T} AnyObject - A generic type representing list items.
+ * @returns {T[]} - A new array with duplicates removed.
+ */
 var dedupe = function dedupe(list, key) {
   var filtered = list.filter(function (i) {
     return !_isType.isEmpty(i);
@@ -33,20 +45,54 @@ var dedupe = function dedupe(list, key) {
     return Array.from(new Set(filtered).values());
   }
   return Array.from(new Map(filtered.map(function (obj) {
-    var _obj$key;
-    return [(_obj$key = obj[key]) !== null && _obj$key !== void 0 ? _obj$key : obj, obj];
+    return [obj[key], obj];
   })).values());
 };
+
+/**
+ * Flatten a list of objects, removing any empty objects.
+ * It will flatten up to 5 levels deep and filter out any empty objects.
+ * This is useful for normalizing data structures that may have nested arrays or objects.
+ *
+ * @param list
+ * @typedef {T} AnyObject - A generic type representing list items.
+ * @returns {T[]} - A flattened array of objects.
+ */
 var flatten = function flatten(list) {
   return list.flat(5).filter(function (i) {
     return !_isType.isEmpty(i);
   });
 };
+
+/**
+ * Flatten a list of objects and remove duplicates based on a key or the entire object.
+ * If a key is provided, it will deduplicate based on the value of that key.
+ * If no key is provided, it will deduplicate based on the entire object.
+ * This is useful for normalizing data structures that may have nested arrays or objects.
+ * Flattening is done first, followed by deduplication.
+ *
+ * @param list
+ * @param key
+ * @typedef {T} AnyObject - A generic type representing list items.
+ * @returns {T[]} - A new array with duplicates removed.
+ */
 var flattenAndDedupe = function flattenAndDedupe() {
   var list = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : [];
   var key = arguments.length > 1 ? arguments[1] : undefined;
   return dedupe(flatten(list), key);
 };
+
+/**
+ * Group a list of objects by a specific property.
+ * If the property is not present in an object, it will use the `missingKey` value as the key.
+ * This is useful for organizing data into categories based on a specific property.
+ *
+ * @param list
+ * @param prop
+ * @param missingKey
+ * @typedef {T} KeyValue - A generic type representing list items with key-value pairs.
+ * @returns {KeyValue<T[]>} - An object mapping keys to arrays of items.
+ */
 var groupBy = function groupBy(list, prop, missingKey) {
   return list.reduce(function (r, i) {
     var _i$prop;

package/dist/cjs/_fetch.js

@@ -10,13 +10,18 @@ function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t =
 var _signals = new Map();
 
 /**
- * Fetch helper
- * @param method
- * @param url
- * @param options.headers
- * @param options.body
- * @param options.signal
- * @internal
+ * Fetch utility function to make HTTP requests.
+ * It supports GET, POST, PUT, and DELETE methods.
+ * It automatically handles JSON responses and error codes.
+ * It also supports aborting requests using an AbortController.
+ *
+ * @param method - The HTTP method to use (GET, POST, PUT, DELETE).
+ * @param url - The URL to send the request to.
+ * @param options.headers - Headers to include in the request.
+ * @param options.body - The body of the request (for POST and PUT requests).
+ * @param options.signal - An AbortSignal to cancel the request.
+ * @returns A promise that resolves to the JSON response from the server.
+ * @throws An error if the request fails or if the response contains an error code.
  */
 var _fetch = /*#__PURE__*/function () {
   var _ref2 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee2(method, url, _ref) {

package/dist/cjs/_fileType.js

@@ -27,7 +27,20 @@ var _slicedToArray = require('@babel/runtime/helpers/slicedToArray');
 
 /* istanbul ignore file */
 
+/**
+ * File type utility to get the file type from a MIME type.
+ * This utility provides a mapping of common MIME types to their human-readable names.
+ * It can be used to display file types in a user-friendly manner.
+ */
 var _fileType = {
+  /**
+   * Get the human-readable file type from a MIME type.
+   * This method looks up the MIME type in a predefined list
+   * and returns a user-friendly name.
+   *
+   * @param mime MIME type string, e.g. "application/pdf"
+   * @returns {string} - The human-readable file type.
+   */
   mime: function mime() {
     var mime = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : "";
     var ret = this.mimeList[mime.split(";")[0]];
@@ -40,6 +53,9 @@ var _fileType = {
     }
     return ret || "Unknown type";
   },
+  /**
+   * List of common MIME types and their human-readable names.
+   */
   mimeList: {
     "application/x-tika-msoffice": "Microsft Office File",
     "application/x-tika-ooxml": "Open Office File",

package/dist/cjs/_format.js

@@ -30,10 +30,13 @@ var _isType = require('./_isType.js');
  */
 
 
+/**
+ * Format utility functions for various data types.
+ * This namespace provides methods to format phone numbers, numbers, bytes, percentages, dates, and durations.
+ */
 // eslint-disable-next-line @typescript-eslint/no-namespace
 exports.Format = void 0;
 (function (_Format) {
-  /** ***************** get phone number object using `libphonenumber-js` *******************/
   var getPhone = function getPhone(value, country) {
     var phone = value.match(/^[0+]/) != null ? value.replace(/^00/, "+") : "+".concat(value);
     var number = libphonenumberJs.parsePhoneNumberFromString(phone, country);
@@ -45,8 +48,6 @@ exports.Format = void 0;
       }
     };
   };
-
-  /** ***************** common number format method using `numeral` *******************/
   var numberFormat = function numberFormat(number) {
     var format = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : "0,0[.]00a";
     if (_isType.isNil(number)) {
@@ -66,7 +67,19 @@ exports.Format = void 0;
     }
   };
 
-  /** ***************** format phone number using `libphonenumber-js` *******************/
+  /**
+   * Format phone number with country flag or emoji.
+   * It takes a phone number string, a country code, and a boolean to indicate whether to use CSS classes for flags.
+   * If the phone number is empty, less than 6 characters, or does not match the regex for valid phone numbers,
+   * it returns the original value.
+   * If the phone number is valid, it formats the phone number using `libphonenumber-js` and returns it with the country flag or emoji.
+   * The country flag is represented as a CSS class, and the emoji is obtained from the `Countries` module.
+   *
+   * @param {string} value - The phone number to format.
+   * @param {string} country - The country code to use for formatting.
+   * @param {boolean} useCss - Whether to use CSS classes for flags.
+   * @returns {string} The formatted phone number with country flag or emoji.
+   */
   _Format.phone = function (value) {
     var _phone$country;
     var country = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : "AE";
@@ -86,8 +99,8 @@ exports.Format = void 0;
     return numberFormat(number, "0,0[.]00%");
   };
   _Format.date = function (date) {
-    var fmt = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : "d-M-y";
-    return date ? dateFns.format(new Date(date), fmt) : "";
+    var format = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : "d-M-y";
+    return date ? dateFns.format(new Date(date), format) : "";
   };
   _Format.duration = function (number, isFraction) {
     if (_isType.isNil(number)) {

package/dist/cjs/_getByPath.js

@@ -36,7 +36,7 @@ var _get = function _get(hit, field) {
   if (_isType.isNil(field)) {
     return hit;
   }
-  if (_isType.isObject(hit)) {
+  if (_isType.isObject(hit) || _isType.isArray(hit)) {
     /** ***************** return value if object.property is not empty *******************/
     if (!_isType.isNil(hit[field])) {
       return hit[field];
@@ -92,8 +92,14 @@ var _get = function _get(hit, field) {
 };
 
 /**
- * get property value by path
- * @internal
+ * Get a value from an object by a given path.
+ * This function allows you to retrieve a value from a nested object structure using a dot-separated path.
+ * If the path does not exist or the object is empty, it returns a default value.
+ * @param {KeyValue} obj - The object from which to retrieve the value.
+ * @param {string} path - The dot-separated path to the value within the object.
+ * @param {any} defaultValue - The value to return if the path does not exist or the object is empty.
+ * @typedef {T} AnyObject - The type of the value to be returned.
+ * @returns {T} The value at the specified path, or the default value if the path does not exist.
  */
 var getByPath = function getByPath(obj, path) {
   var defaultValue = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : undefined;
@@ -109,8 +115,13 @@ var getByPath = function getByPath(obj, path) {
 };
 
 /**
- * get first available value in list
- * @internal
+ * Get the first non-empty value from the provided arguments.
+ * This function is useful for finding a default value or fallback when multiple values are provided.
+ * It checks each argument in order and returns the first one that is not empty.
+ * If all arguments are empty, it returns `undefined`.
+ *
+ * @param {...any} args - The values to check for non-emptiness.
+ * @returns {any} The first non-empty value, or `undefined` if all are empty.
  */
 var getValue = function getValue() {
   for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {

package/dist/cjs/_hash.js

@@ -27,9 +27,11 @@ var _isType = require('./_isType.js');
 
 
 /**
- * calculate hash from string
+ * Generate a hash from a string.
+ * This function computes a simple hash by iterating over each character in the string,
+ * performing bitwise operations to produce a 32-bit integer hash.
  * @param str
- * @internal
+ * @returns {number} A 32-bit integer hash of the input string.
  */
 var hash = function hash(str) {
   var hash = 0;
@@ -45,16 +47,20 @@ var hash = function hash(str) {
 };
 
 /**
- * generate short hash from current time
- * @internal
+ * Generate a short hash using the current timestamp and a random number.
+ * This function creates a unique identifier by combining the current time in milliseconds
+ * with a random number, and then converting it to a base-36 string.
+ * @returns {string} A short hash string.
  */
 var shortHash = function shortHash() {
-  return (new Date().getTime() + Math.trunc(Math.random() * 1000)).toString(36);
+  return (new Date().getTime() * Math.random()).toString(36);
 };
 
 /**
- * generate uuid using `crypto.getRandomValues`
- * @internal
+ * Generate a UUID (Universally Unique Identifier).
+ * This function creates a version 4 UUID by generating random numbers
+ * and formatting them according to the UUID standard.
+ * @returns {string} A UUID string in the format xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx.
  */
 var uuid = function uuid() {
   return [1e7, 1e3, 4e3, 8e3, 1e11].join("-").replace(/[018]/g, function (c) {

package/dist/cjs/_interpolate.js

@@ -27,8 +27,13 @@ var _getByPath = require('./_getByPath.js');
 
 
 /**
- * interpolate string template using model
- * @internal
+ * Interpolate a string with values from a model.
+ * This function replaces placeholders in the format ${key} with corresponding values from the model object.
+ * If the value is not a string or number, it returns an empty string.
+ *
+ * @param {string} str - The string to interpolate.
+ * @param {KeyValue} model - The model object containing key-value pairs for interpolation.
+ * @returns {string} The interpolated string with placeholders replaced by values from the model.
  */
 var interpolate = function interpolate(str, model) {
   return str.replace(/\${([^{}]*)}/g, function (a, b) {
@@ -36,6 +41,17 @@ var interpolate = function interpolate(str, model) {
     return typeof r === "string" || typeof r === "number" ? "".concat(r) : "";
   });
 };
+
+/**
+ * Render a template string with values from a model.
+ * This function replaces placeholders in the format {{key}} with corresponding values from the model object.
+ * If the value is not a string or number, it returns an empty string.
+ * This is similar to the interpolate function but for handlebar templates.
+ *
+ * @param {string} str - The template string to render.
+ * @param {KeyValue} model - The model object containing key-value pairs for rendering the template.
+ * @returns {string} The rendered template string with placeholders replaced by values from the model.
+ */
 var renderTemplate = function renderTemplate(str, model) {
   return str.replace(/{{([^{}]*)}}/g, function (a, b) {
     var r = _getByPath.getByPath(model, b);

package/dist/cjs/_isEqual.js

@@ -28,10 +28,23 @@ var _isType = require('./_isType.js');
 
 
 /**
- * check equality of objects
- * @internal
+ * Compare two objects or values for equality.
+ * This function checks if two values are equal, including nested objects and arrays.
+ * It handles various data types such as strings, numbers, booleans, arrays, and objects.
+ * If both values are `null` or `undefined`, they are considered equal.
+ * If both values are primitive types (string, number, boolean), they are compared directly.
+ * If both values are arrays, they are compared element by element.
+ * If both values are objects, they are compared by their keys and values.
+ * If the values are of different types or structures, they are considered not equal.
+ *
+ * @param {unknown} obj - The first value to compare.
+ * @param {unknown} test - The second value to compare against the first.
+ * @returns {boolean} - Returns true if the values are equal, false otherwise.
  */
 var isEqual = function isEqual(obj, test) {
+  if (_isType.isNil(obj) && _isType.isNil(test)) {
+    return true;
+  }
   if (_isType.isString(obj) || _isType.isNumber(obj) || _isType.isBoolean(obj)) {
     return obj === test;
   } else if (Array.isArray(obj) && Array.isArray(test)) {
@@ -65,8 +78,20 @@ var isEqual = function isEqual(obj, test) {
 };
 
 /**
- * match strings
- * @internal
+ * Match a string against another string with options for equality.
+ * This function checks if the base string starts with, includes, or is equal to the match string,
+ * based on the specified equality condition.
+ * It normalizes both strings to lowercase and ASCII format before comparison.
+ * This is useful for case-insensitive and ASCII-only comparisons,
+ * such as when filtering or searching through text data.
+ *
+ * @param {string} base - The base string to match against.
+ * @param {string} match - The string to match with the base string.
+ * @param {("start" | boolean)} equality - The type of match to perform:
+ *                   - "start": checks if the base string starts with the match string.
+ *                   - true: checks for exact equality.
+ *                   - false (default): checks if the base string includes the match string.
+ * @returns {boolean} - Returns true if the base string matches the conditions specified by the match string and equality.
  */
 var matchString = function matchString(base, match) {
   var equality = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
@@ -76,8 +101,17 @@ var matchString = function matchString(base, match) {
 };
 
 /**
- * compare values
- * @internal
+ * Compare two values for sorting.
+ * This function compares two values based on the specified order (ascending or descending).
+ * If a key is provided, it compares the values of that key in the objects.
+ * It handles various data types such as strings, numbers, booleans, and objects.
+ * It returns a comparison function that can be used with array sorting methods.
+ * * The comparison is done in a case-insensitive manner for strings,
+ *  treating special characters as their ASCII equivalents.
+ *
+ * @param {("asc" | "desc")} order - The order of comparison, either "asc" for ascending or "desc" for descending.
+ * @param {string} key - An optional key to compare values within objects.
+ * @returns {Function} A comparison function that can be used with array sorting methods.
  */
 var compareValues = function compareValues() {
   var order = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : "asc";