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

package/dist/esm/_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/esm/_fileType.js

@@ -27,7 +27,20 @@ import _slicedToArray from '@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/esm/_format.js

@@ -30,10 +30,13 @@ import { isEmpty, isNil } from './_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
 var Format;
 (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 = parsePhoneNumberFromString(phone, country);
@@ -45,8 +48,6 @@ var Format;
       }
     };
   };
-
-  /** ***************** 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 (isNil(number)) {
@@ -66,7 +67,19 @@ var Format;
     }
   };
 
-  /** ***************** 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 @@ var Format;
     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 ? format(new Date(date), fmt) : "";
+    var format$1 = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : "d-M-y";
+    return date ? format(new Date(date), format$1) : "";
   };
   _Format.duration = function (number, isFraction) {
     if (isNil(number)) {

package/dist/esm/_getByPath.js

@@ -36,7 +36,7 @@ var _get = function _get(hit, field) {
   if (isNil(field)) {
     return hit;
   }
-  if (isObject(hit)) {
+  if (isObject(hit) || isArray(hit)) {
     /** ***************** return value if object.property is not empty *******************/
     if (!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/esm/_hash.js

@@ -27,9 +27,11 @@ import { isEmpty } from './_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/esm/_interpolate.js

@@ -27,8 +27,13 @@ import { getByPath } from './_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(model, b);

package/dist/esm/_isEqual.js

@@ -1,7 +1,7 @@
 'use client';
 
 import { ascii } from './_ascii.js';
-import { isString, isNumber, isBoolean, isObject } from './_isType.js';
+import { isNil, isString, isNumber, isBoolean, isObject } from './_isType.js';
 
 /*
  * React Fabric
@@ -28,10 +28,23 @@ import { isString, isNumber, isBoolean, isObject } from './_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 (isNil(obj) && isNil(test)) {
+    return true;
+  }
   if (isString(obj) || isNumber(obj) || 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";

package/dist/esm/_isType.js

@@ -25,15 +25,46 @@ import _typeof from '@babel/runtime/helpers/typeof';
  * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  */
 
+/**
+ * Check if a value is undefined.
+ * @param value - The value to check.
+ * @returns true if the value is undefined, false otherwise.
+ */
 var isUndefined = function isUndefined(value) {
   return value === undefined;
 };
+
+/**
+ * Check if a value is null.
+ * @param value - The value to check.
+ * @returns true if the value is null, false otherwise.
+ */
 var isNull = function isNull(value) {
   return value === null;
 };
+
+/**
+ * Check if a value is either null or undefined.
+ * @param val - The value to check.
+ * @returns true if the value is null or undefined, false otherwise.
+ */
 var isNil = function isNil(val) {
   return val === undefined || val === null;
 };
+
+/**
+ * Check if a value is empty.
+ * A value is considered empty if it is:
+ * - undefined
+ * - null
+ * - an empty string
+ * - an empty array
+ * - an empty object
+ * - an empty Map or Set
+ * - a boolean, number, or bigint (not empty)
+ * @param val - The value to check.
+ * @returns true if the value is empty, false otherwise.
+ */
 var isEmpty = function isEmpty(val) {
   if (val instanceof Date) return false;
   if (isNil(val) || val === "") {
@@ -48,36 +79,126 @@ var isEmpty = function isEmpty(val) {
   }
   return !!val && _typeof(val) === "object" && Object.entries(val).length === 0;
 };
+
+/**
+ * Check if a value is an object.
+ * An object is considered valid if it is:
+ * - not null or undefined
+ * - not a Date instance
+ * - of type 'object'
+ * - not an array
+ * @param val - The value to check.
+ * @returns true if the value is an object, false otherwise.
+ */
 var isObject = function isObject(val) {
   return !isNil(val) && !(val instanceof Date) && _typeof(val) === "object" && !Array.isArray(val);
 };
+
+/**
+ * Check if a value is an array.
+ * An array is considered valid if it is:
+ * - not null or undefined
+ * - an instance of Array
+ * @param val - The value to check.
+ * @returns true if the value is an array, false otherwise.
+ */
 var isArray = function isArray(val) {
   return Array.isArray(val);
 };
+
+/**
+ * Check if a value is a string.
+ * A string is considered valid if it is:
+ * - not null or undefined
+ * - of type 'string'
+ * @param value - The value to check.
+ * @returns true if the value is a string, false otherwise.
+ */
 var isString = function isString(value) {
   return typeof value === "string";
 };
+
+/**
+ * Check if a value is a number.
+ * A number is considered valid if it is:
+ * - not null or undefined
+ * - of type 'number'
+ * @param value - The value to check.
+ * @returns true if the value is a number, false otherwise.
+ */
 var isNumber = function isNumber(value) {
   return typeof value === "number";
 };
+
+/**
+ * Check if a value is a boolean.
+ * A boolean is considered valid if it is:
+ * - not null or undefined
+ * - of type 'boolean'
+ */
 var isBoolean = function isBoolean(value) {
   return typeof value === "boolean";
 };
+
+/**
+ * Check if a value is a true.
+ * A value is considered true if it is:
+ * - strictly equal to true
+ * - equal to 1
+ * - a string that is "yes" or "true" (case insensitive)
+ */
 var isTrue = function isTrue() {
   var value = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : "";
   return value === true || value === 1 || (value === null || value === void 0 ? void 0 : value.toString().toLowerCase()) === "yes" || (value === null || value === void 0 ? void 0 : value.toString().toLowerCase()) === "true";
 };
+
+/**
+ * Check if a value is false.
+ * A value is considered false if it is:
+ * - strictly equal to false
+ * - equal to 0
+ * - a string that is "no" or "false" (case insensitive)
+ */
 var isFalse = function isFalse() {
   var value = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : "";
   return value === false || value === 0 || (value === null || value === void 0 ? void 0 : value.toString().toLowerCase()) === "no" || (value === null || value === void 0 ? void 0 : value.toString().toLowerCase()) === "false";
 };
+
+/**
+ * Check if a value is a valid color.
+ * A color is considered valid if it:
+ * - starts with a '#' (hex color)
+ * - starts with 'rgb' (RGB color)
+ * - starts with 'hsl' (HSL color)
+ * - starts with 'lab' (Lab color)
+ * - is equal to 'transparent'
+ * @param color - The value to check.
+ * @returns true if the value is a valid color, false otherwise.
+ */
 var isColor = function isColor(color) {
   var _color$startsWith, _color$startsWith2, _color$startsWith3, _color$startsWith4;
   return ((_color$startsWith = color.startsWith) === null || _color$startsWith === void 0 ? void 0 : _color$startsWith.call(color, "#")) || ((_color$startsWith2 = color.startsWith) === null || _color$startsWith2 === void 0 ? void 0 : _color$startsWith2.call(color, "rgb")) || ((_color$startsWith3 = color.startsWith) === null || _color$startsWith3 === void 0 ? void 0 : _color$startsWith3.call(color, "hsl")) || ((_color$startsWith4 = color.startsWith) === null || _color$startsWith4 === void 0 ? void 0 : _color$startsWith4.call(color, "lab")) || color === "transparent";
 };
+
+/**
+ * Check if a value is a valid SVG path.
+ * A valid SVG path is a string that:
+ * - starts with 'M' or 'm' (move to command)
+ * - contains at least one digit or decimal point
+ * - ends with 'Z' or 'z' (close path command)
+ * @param value - The value to check.
+ * @returns true if the value is a valid SVG path, false otherwise.
+ */
 var isSvgPath = function isSvgPath(value) {
   return typeof value === "string" && value.match(/^[Mm][\d.].*[\dzZ]$/) !== null;
 };
+
+/**
+ * Check if the document is in RTL (Right-to-Left) mode.
+ * This function checks the computed style of the document's root element
+ * to determine if the direction is set to 'rtl'.
+ * @returns true if the document is in RTL mode, false otherwise.
+ */
 var isRtl = function isRtl() {
   return getComputedStyle(document.documentElement).direction === "rtl";
 };

package/dist/esm/_lonlat.js

@@ -0,0 +1,86 @@
+'use client';
+
+import _slicedToArray from '@babel/runtime/helpers/slicedToArray';
+import { isArray, isObject, isString } from './_isType.js';
+
+/**
+ * Convert various formats of longitude and latitude to a tuple of [lon, lat].
+ * This function supports:
+ * - Arrays with two or three elements (e.g., [lon, lat] or [lon, lat, alt])
+ * - Objects with properties `lng`, `lat`, `lon`, or `longitude` and `latitude`
+ * - Strings in the format "lat,lon"
+ * The function will return a tuple of numbers [lon, lat].
+ *
+ * @param {LngLatLike} lonLat - The input longitude and latitude in various formats.
+ * @returns { [lon: number, lat: number] } A tuple of [lon, lat] where lon and lat are numbers.
+ * @throws Error if the input is not a valid format.
+ */
+var convertLatLng = function convertLatLng(lonLat) {
+  if (isArray(lonLat) && lonLat.length === 2 || isArray(lonLat) && lonLat.length === 3) {
+    return [Number(lonLat[0]), Number(lonLat[1])];
+  }
+  if (isObject(lonLat)) {
+    if ("longitude" in lonLat) {
+      return [lonLat.longitude, lonLat.latitude];
+    }
+    return ["lon" in lonLat ? lonLat.lon : lonLat.lng, lonLat.lat];
+  }
+  if (isString(lonLat)) {
+    var _lonLat$split = lonLat.split(","),
+      _lonLat$split2 = _slicedToArray(_lonLat$split, 2),
+      _lat = _lonLat$split2[0],
+      _lon = _lonLat$split2[1];
+    return [+_lon, +_lat];
+  }
+  throw Error("Invalid geo coordinates");
+};
+
+/**
+ * Convert a coordinate to Degrees, Minutes, Seconds (DMS) format.
+ * This function takes a coordinate and returns a string in the format "degrees˚minutes'seconds" with direction (N/S or E/W).
+ * It handles both latitude and longitude coordinates.
+ * This function assumes that the input coordinate is in decimal degrees format.
+ * It converts the coordinate to DMS format by calculating the degrees, minutes, and seconds,
+ * and then formatting the result as a string.
+ *
+ * @param {number} coord - The coordinate to convert.
+ * @param {boolean} isLat - Whether the coordinate is latitude (default is false for longitude).
+ * @returns {string} A string representation of the coordinate in DMS format.
+ */
+var convertToDMS = function convertToDMS(coord) {
+  var isLat = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
+  var degree = Math.floor(coord);
+  var hour = (coord - degree) * 60;
+  var minute = (hour - Math.floor(hour)) * 60;
+  return "".concat(degree, "\u02DA").concat(Math.floor(hour), "'").concat(minute.toFixed(2), "\"").concat(coord < 0 ? isLat ? "S" : "W" : isLat ? "N" : "E");
+};
+
+/**
+ * Convert a latitude and longitude to a human-readable text format.
+ * This function takes a latitude and longitude in various formats and
+ * returns a string in the format "degrees˚minutes'seconds" with direction (N/S, E/W).
+ *
+ * This function supports:
+ *
+ * - Objects with properties `lng`, `lat`, `lon`, or `longitude` and `latitude`
+ * - Arrays with two or three elements (e.g., [lon, lat] or [lon, lat, alt])
+ * - Strings in the format "lat,lon"
+ *
+ * @param {LngLatLike} latlon - The latitude and longitude in various formats.
+ * @returns {string} A string representation of the location in DMS format.
+ *
+ * @example
+ * ```jsx
+ * const location = getLocationAsText({ lat: 40.7128, lng: -74.0060 });
+ * console.log(location); // "40˚42'51.36"N, 74˚0'21.60"W"
+ * ```
+ */
+var getLocationAsText = function getLocationAsText(latlon) {
+  var _convertLatLng = convertLatLng(latlon),
+    _convertLatLng2 = _slicedToArray(_convertLatLng, 2),
+    lon = _convertLatLng2[0],
+    lat = _convertLatLng2[1];
+  return "".concat(convertToDMS(lat, true), ", ").concat(convertToDMS(lon));
+};
+
+export { convertLatLng, getLocationAsText };

package/dist/esm/_mergeRefs.js

@@ -25,6 +25,17 @@
 
 /* istanbul ignore file */
 
+/**
+ * Merge multiple refs into a single ref callback.
+ * This function allows you to combine multiple refs (either callback refs or React refs)
+ * into a single ref callback that can be used in React components.
+ * This is particularly useful when you want to assign a single element to multiple refs,
+ * such as when using third-party libraries that require refs or when you want to share refs between components.
+ * The function iterates over the provided refs and assigns the element to each ref.
+ *
+ * @param {AnyObject[]} refs - An array of refs to merge.
+ * @returns {function} A function that takes an element and assigns it to all provided refs.
+ */
 var mergeRefs = function mergeRefs() {
   for (var _len = arguments.length, refs = new Array(_len), _key = 0; _key < _len; _key++) {
     refs[_key] = arguments[_key];

package/dist/esm/_tokenize.js

@@ -27,10 +27,14 @@ import { isEmpty, isArray } from './_isType.js';
 
 
 /**
- * split text into array of tokens by word boundaries
- * @param str
- * @param keywords
- * @internal
+ * Tokenize a string based on provided keywords.
+ * This function splits the input string into tokens, where each token is an array containing
+ * the substring before the keyword and the keyword itself.
+ * If no keywords are provided, it returns the entire string as a single token.
+ *
+ * @param {string} str - The string to tokenize.
+ * @param {string | string[]} keywords - A string or an array of strings to use as keywords for tokenization.
+ * @returns {Array<[string, string]>} An array of tokens, where each token is an array of [substring, keyword].
  */
 var tokenize = function tokenize(str, keywords) {
   if (isEmpty(keywords)) {
@@ -56,6 +60,15 @@ var tokenize = function tokenize(str, keywords) {
   tokens.push([str.substring(lastIndex), ""]);
   return tokens;
 };
+
+/**
+ * Generate a token from a string.
+ * This function creates a token by taking the first letter of the first word and the first letter of the last word,
+ * or the first two letters of the first word if there is no last word.
+ *
+ * @param {string} str - The string to tokenize.
+ * @returns {string} A string token consisting of the first letters of the first and last words, or the first two letters of the first word.
+ */
 var iconToken = function iconToken(str) {
   var split = str.trim().split(" ");
   var first = split[0];

package/dist/esm/getImageColorset.js

@@ -25,6 +25,21 @@
 
 /* istanbul ignore file */
 
+/**
+ * Get the color set of an image element.
+ * This function analyzes the pixel data of an image to determine if it is predominantly light or dark.
+ * It returns "light", "dark", or "light_transparent"/"dark_transparent" based on the pixel analysis.
+ * It uses a canvas to draw the image and extract pixel data for analysis.
+ * * The function calculates the brightness of each pixel using the formula:
+ *  brightness = 0.2126 * R + 0.7152 * G + 0.0722 * B
+ * * It counts the number of light and dark pixels, and determines the overall color set based on the ratio of light to dark pixels.
+ * * If the image has transparent pixels, it appends "_transparent" to the result.
+ * * This function is useful for determining the color scheme of an image, which can be helpful for UI design,
+ *   theming, and accessibility considerations.
+ *
+ * @param {HTMLImageElement} el - The HTMLImageElement to analyze.
+ * @returns {string} A string indicating the color set of the image.
+ */
 var getImageColorset = function getImageColorset(el) {
   // create canvas
   var canvas = document.createElement("canvas");
@@ -45,8 +60,8 @@ var getImageColorset = function getImageColorset(el) {
         transparent = true;
         continue;
       }
-      if (transparent && data[x - 1] === 1) {
-        continue;
+      if (data[x + 3] < 1) {
+        transparent = true;
       }
       r = data[x];
       g = data[x + 1];

package/dist/esm/index.js

@@ -13,6 +13,7 @@ export { hash, shortHash, uuid } from './_hash.js';
 export { interpolate, renderTemplate } from './_interpolate.js';
 export { compareValues, isEqual, matchString } from './_isEqual.js';
 export { isArray, isBoolean, isColor, isEmpty, isFalse, isNil, isNull, isNumber, isObject, isRtl, isString, isSvgPath, isTrue, isUndefined } from './_isType.js';
+export { convertLatLng, getLocationAsText } from './_lonlat.js';
 export { mergeRefs } from './_mergeRefs.js';
 export { iconToken, tokenize } from './_tokenize.js';
 export { getImageColorset } from './getImageColorset.js';