@foxford/foxford-utils 1.0.1 → 1.1.0

package/index.cjs

@@ -0,0 +1,859 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __restKey = (key) => typeof key === "symbol" ? key : key + "";
+var __objRest = (source, exclude) => {
+  var target = {};
+  for (var prop in source)
+    if (__hasOwnProp.call(source, prop) && exclude.indexOf(prop) < 0)
+      target[prop] = source[prop];
+  if (source != null && __getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(source)) {
+      if (exclude.indexOf(prop) < 0 && __propIsEnum.call(source, prop))
+        target[prop] = source[prop];
+    }
+  return target;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  Collapse: () => Collapse,
+  TYPES: () => TYPES,
+  acceptAllExtensions: () => acceptAllExtensions,
+  acceptAllTypes: () => acceptAllTypes,
+  acceptAudioExtensions: () => acceptAudioExtensions,
+  acceptFileTypes: () => acceptFileTypes,
+  acceptFilesExtensions: () => acceptFilesExtensions,
+  acceptImagesExtensions: () => acceptImagesExtensions,
+  base64ToArrayBuffer: () => base64ToArrayBuffer,
+  capitalize: () => capitalize,
+  colorLuminance: () => colorLuminance,
+  createPath: () => createPath,
+  currencyDirectory: () => CURRENCY_DIRECTORY,
+  debounce: () => debounce,
+  detectEnterKey: () => detectEnterKey,
+  detectIE: () => detectIE,
+  extractDigits: () => extractDigits,
+  getColorByString: () => getColorByString,
+  getCurrencySymbol: () => getCurrencySymbol,
+  getFilesSize: () => getFilesSize,
+  getGradient: () => getGradient,
+  getMimeTypes: () => getMimeTypes,
+  getNextPageFromLinkHeader: () => getNextPageFromLinkHeader,
+  getNextPageURLFromLinkHeader: () => getNextPageURLFromLinkHeader,
+  getRandomInt: () => getRandomInt,
+  indexByGroupId: () => indexByGroupId,
+  indexById: () => indexById,
+  isElementInViewport: () => isElementInViewport,
+  makeLoadOptionsFunc: () => makeLoadOptionsFunc,
+  makeOption: () => makeOption,
+  makeParamString: () => makeParamString,
+  makeShortNameFromFull: () => makeShortNameFromFull,
+  matchesId: () => matchesId,
+  merge: () => merge,
+  mergeByKey: () => mergeByKey,
+  mimeAudio: () => mimeAudio,
+  mimeFiles: () => mimeFiles,
+  mimeImages: () => mimeImages,
+  outerHeight: () => outerHeight,
+  parseQueryString: () => parseQueryString,
+  parseStringListToArray: () => parseStringListToArray,
+  pickBy: () => pickBy,
+  pluralize: () => pluralize,
+  pluralizeByType: () => pluralizeByType,
+  qid: () => qid,
+  rawMarkup: () => rawMarkup,
+  removeElFromArr: () => removeElFromArr,
+  scrollToElement: () => scrollToElement,
+  serializeArray: () => serializeArray,
+  splitEvery: () => splitEvery,
+  toCamelCase: () => toCamelCase,
+  toUnderscoredCase: () => toUnderscoredCase,
+  transformOptionsForSelect: () => transformOptionsForSelect,
+  uniq: () => uniq,
+  uuid: () => uuid,
+  wrapFormFields: () => wrapFormFields
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/qid.ts
+function qid(length = 6, number = true) {
+  let text = "";
+  const possible = `ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz${number ? "0123456789" : ""}`;
+  for (let i = 0; i < length; i++) {
+    const idx = Math.floor(Math.random() * possible.length);
+    text += possible.charAt(idx);
+  }
+  return text;
+}
+
+// src/uuid.ts
+function uuid() {
+  function s4() {
+    return Math.floor((1 + Math.random()) * 65536).toString(16).substring(1);
+  }
+  return `${s4() + s4()}-${s4()}-${s4()}-${s4()}-${s4()}${s4()}${s4()}`;
+}
+
+// src/pickBy.ts
+function pickBy(obj, filterFunc) {
+  const out = {};
+  for (const [rawKey, value] of Object.entries(obj)) {
+    if (filterFunc(rawKey, value)) {
+      ;
+      out[rawKey] = value;
+    }
+  }
+  return out;
+}
+
+// src/collapse.ts
+function toggleOnClickHandler({ currentTarget }) {
+  if (!(currentTarget instanceof HTMLElement)) return false;
+  const toggleArrow = currentTarget.querySelector(".toggle_arrow");
+  if (!toggleArrow) return false;
+  const arrowClass = "down";
+  const toggleClass = "expanded";
+  if (toggleArrow.classList.contains(arrowClass)) {
+    toggleArrow.classList.remove(arrowClass);
+    currentTarget.classList.remove(toggleClass);
+  } else {
+    currentTarget.classList.add(toggleClass);
+    toggleArrow.classList.add(arrowClass);
+  }
+  return true;
+}
+var Collapse = class {
+  constructor() {
+    this._collapses = null;
+    this.init = this.init.bind(this);
+    this.makeCollapse = this.makeCollapse.bind(this);
+    this.destroy = this.destroy.bind(this);
+    this.onClickHandler = toggleOnClickHandler;
+    this._onClickEventListener = (e) => this.onClickHandler(e);
+    this._boundMakeCollapse = (el) => this.makeCollapse(el);
+  }
+  makeCollapse(collapse) {
+    if (collapse.classList.contains("js")) return false;
+    collapse.addEventListener("click", this._onClickEventListener);
+    collapse.classList.add("js");
+    return true;
+  }
+  init() {
+    setTimeout(() => {
+      if (!document.querySelectorAll || !document.body || !document.body.classList) return;
+      this._collapses = window.document.querySelectorAll(".toggle_element");
+      Array.from(this._collapses).forEach(this._boundMakeCollapse);
+    }, 0);
+  }
+  destroy() {
+    var _a;
+    const collapses = (_a = this._collapses) != null ? _a : window.document.querySelectorAll(".toggle_element");
+    Array.from(collapses).forEach((item) => {
+      item.removeEventListener("click", this._onClickEventListener);
+      item.classList.remove("js");
+    });
+    this._collapses = null;
+  }
+  reinit() {
+    this.destroy();
+    this.init();
+  }
+};
+
+// src/debounce.ts
+function debounce(f, ms) {
+  let timer = null;
+  function decoratedFunction(...args) {
+    const onComplete = () => {
+      f.apply(this, args);
+      timer = null;
+    };
+    if (timer) {
+      clearTimeout(timer);
+    }
+    timer = setTimeout(onComplete, ms);
+    return timer;
+  }
+  return decoratedFunction;
+}
+
+// src/indexById.ts
+function indexById(items) {
+  return items.reduce((acc, item) => {
+    acc[String(item.id)] = item;
+    return acc;
+  }, {});
+}
+
+// src/pluralize.ts
+function pluralize(counter, forms) {
+  const n = Math.abs(counter);
+  const id = n % 10 === 1 && n % 100 !== 11 ? 0 : n % 10 >= 2 && n % 10 <= 4 && (n % 100 < 10 || n % 100 >= 20) ? 1 : 2;
+  return forms[id];
+}
+
+// src/rawMarkup.ts
+function rawMarkup(text) {
+  return { __html: text };
+}
+
+// src/capitalize.ts
+function capitalize(str) {
+  if (!str) return "";
+  return str.charAt(0).toUpperCase() + str.slice(1);
+}
+
+// src/getFilesSize.ts
+function getFilesSize(attachments, files) {
+  let size = 0;
+  for (const f of attachments) size += f.size;
+  for (const f of files) size += f.size;
+  return size;
+}
+
+// src/getMimeTypes.ts
+function getMimeTypes(files) {
+  return files.map((f) => f.mime);
+}
+
+// src/getRandomInt.ts
+function getRandomInt(min, max) {
+  return Math.floor(Math.random() * (max - min)) + min;
+}
+
+// src/indexByGroupId.ts
+function indexByGroupId(items) {
+  return items.reduce((acc, item) => {
+    acc[String(item.group.id)] = item;
+    return acc;
+  }, {});
+}
+
+// src/scrollToElement.ts
+function getElementPosition(elem) {
+  const { top, left } = elem.getBoundingClientRect();
+  const yOffset = (typeof window.pageYOffset === "number" ? window.pageYOffset : window.scrollY) || 0;
+  const xOffset = (typeof window.pageXOffset === "number" ? window.pageXOffset : window.scrollX) || 0;
+  return {
+    left: left + xOffset,
+    top: top + yOffset
+  };
+}
+function scrollToElement(selector) {
+  const field = document.querySelector(selector);
+  if (!field) return false;
+  const { top } = getElementPosition(field);
+  window.scrollTo(0, top);
+  return void 0;
+}
+
+// src/pluralizeByType.ts
+var TYPES = {
+  days: ["\u0434\u0435\u043D\u044C", "\u0434\u043D\u044F", "\u0434\u043D\u0435\u0439"],
+  exercises: ["\u0437\u0430\u043D\u044F\u0442\u0438\u0435", "\u0437\u0430\u043D\u044F\u0442\u0438\u044F", "\u0437\u0430\u043D\u044F\u0442\u0438\u0439"],
+  hours: ["\u0447\u0430\u0441", "\u0447\u0430\u0441\u0430", "\u0447\u0430\u0441\u043E\u0432"],
+  members: ["\u0443\u0447\u0430\u0441\u0442\u043D\u0438\u043A", "\u0443\u0447\u0430\u0441\u0442\u043D\u0438\u043A\u0430", "\u0443\u0447\u0430\u0441\u0442\u043D\u0438\u043A\u043E\u0432"],
+  minutes: ["\u043C\u0438\u043D\u0443\u0442\u0430", "\u043C\u0438\u043D\u0443\u0442\u044B", "\u043C\u0438\u043D\u0443\u0442"],
+  points: ["\u0431\u0430\u043B\u043B", "\u0431\u0430\u043B\u043B\u0430", "\u0431\u0430\u043B\u043B\u043E\u0432"],
+  remains: ["\u043E\u0441\u0442\u0430\u043B\u0441\u044F", "\u043E\u0441\u0442\u0430\u043B\u043E\u0441\u044C", "\u043E\u0441\u0442\u0430\u043B\u043E\u0441\u044C"],
+  seconds: ["\u0441\u0435\u043A\u0443\u043D\u0434\u0430", "\u0441\u0435\u043A\u0443\u043D\u0434\u044B", "\u0441\u0435\u043A\u0443\u043D\u0434"],
+  students: ["\u0443\u0447\u0435\u043D\u0438\u043A", "\u0443\u0447\u0435\u043D\u0438\u043A\u0430", "\u0443\u0447\u0435\u043D\u0438\u043A\u043E\u0432"],
+  studentsParentalCase: ["\u0443\u0447\u0435\u043D\u0438\u043A\u0430", "\u0443\u0447\u0435\u043D\u0438\u043A\u043E\u0432", "\u0443\u0447\u0435\u043D\u0438\u043A\u043E\u0432"],
+  tasks: ["\u0437\u0430\u0434\u0430\u0447\u0430", "\u0437\u0430\u0434\u0430\u0447\u0438", "\u0437\u0430\u0434\u0430\u0447"]
+};
+function pluralizeByType(counter, type) {
+  const forms = TYPES[type];
+  return pluralize(counter || 0, forms);
+}
+
+// src/base64ToArrayBuffer.ts
+function base64ToArrayBuffer(base64) {
+  const binaryString = window.atob(base64);
+  const len = binaryString.length;
+  const bytes = new Uint8Array(len);
+  for (let i = 0; i < len; i++) {
+    bytes[i] = binaryString.charCodeAt(i);
+  }
+  return bytes.buffer;
+}
+
+// src/parseStringListToArray.ts
+function parseStringListToArray(input = "") {
+  if (!input) return [];
+  return input.split(/(?:^|<br\s*\/?>|\n)\s*[-\u2010-\u2015\ufe58\ufe63\uff0d]\s*/gim).map((s) => s.trim()).filter((s) => s.length > 0);
+}
+
+// src/transformOptionsForSelect.ts
+var transformOptionsForSelect = (options = []) => options.map(({ id, name, image_url }) => ({
+  image_url,
+  label: name,
+  value: id
+}));
+
+// src/objects.ts
+function isObjectLike(v) {
+  return typeof v === "object" && v !== null;
+}
+function merge(target, source) {
+  for (const key of Object.keys(source)) {
+    const srcVal = source[key];
+    const tgtHasKey = Object.prototype.hasOwnProperty.call(target, key);
+    const tgtVal = tgtHasKey ? target[key] : void 0;
+    if (isObjectLike(srcVal) && isObjectLike(tgtVal)) {
+      merge(tgtVal, srcVal);
+    } else {
+      ;
+      target[key] = srcVal;
+    }
+  }
+  return target;
+}
+
+// src/browser.ts
+function detectIE(ua) {
+  const userAgent = ua != null ? ua : typeof window !== "undefined" ? window.navigator.userAgent : "";
+  if (!userAgent) return false;
+  const msie = userAgent.indexOf("MSIE ");
+  if (msie > 0) {
+    const end = userAgent.indexOf(".", msie);
+    return parseInt(userAgent.substring(msie + 5, end), 10);
+  }
+  const trident = userAgent.indexOf("Trident/");
+  if (trident > 0) {
+    const rv = userAgent.indexOf("rv:");
+    const end = userAgent.indexOf(".", rv);
+    return parseInt(userAgent.substring(rv + 3, end), 10);
+  }
+  const edge = userAgent.indexOf("Edge/");
+  if (edge > 0) {
+    const end = userAgent.indexOf(".", edge);
+    return parseInt(userAgent.substring(edge + 5, end), 10);
+  }
+  return false;
+}
+
+// src/dom.ts
+var hasUsableName = (f) => !!f.name;
+var isDisabled = (f) => f.disabled;
+var getType = (f) => f instanceof HTMLInputElement ? f.type : f instanceof HTMLSelectElement ? f.type : f instanceof HTMLButtonElement ? f.type : "";
+var isIgnorableType = (t) => t === "file" || t === "reset" || t === "submit" || t === "button" || t === "image";
+var isSelectMultiple = (f) => f instanceof HTMLSelectElement && f.type === "select-multiple";
+var isCheckableUnchecked = (f) => f instanceof HTMLInputElement && (f.type === "checkbox" || f.type === "radio") && !f.checked;
+var pushSelectedOptions = (sel, out) => {
+  for (const opt of Array.from(sel.selectedOptions)) {
+    out.push({ name: sel.name, value: opt.value });
+  }
+};
+var getValue = (f) => f.value;
+function serializeArray(form) {
+  if (!(form instanceof HTMLFormElement)) return [];
+  const out = [];
+  const elements = Array.from(form.elements);
+  for (const field of elements) {
+    const t = getType(field);
+    if (!hasUsableName(field)) continue;
+    if (isDisabled(field)) continue;
+    if (isIgnorableType(t)) continue;
+    if (isSelectMultiple(field)) {
+      pushSelectedOptions(field, out);
+      continue;
+    }
+    if (isCheckableUnchecked(field)) continue;
+    out.push({ name: field.name, value: getValue(field) });
+  }
+  return out;
+}
+function outerHeight(el) {
+  const style = getComputedStyle(el);
+  const marginTop = parseFloat(style.marginTop) || 0;
+  const marginBottom = parseFloat(style.marginBottom) || 0;
+  return el.offsetHeight + marginTop + marginBottom;
+}
+function isElementInViewport(el) {
+  const rect = el.getBoundingClientRect();
+  const vh = window.innerHeight || document.documentElement.clientHeight;
+  const vw = window.innerWidth || document.documentElement.clientWidth;
+  return rect.top >= 0 && rect.left >= 0 && rect.bottom <= vh && rect.right <= vw;
+}
+
+// src/caseConverters.ts
+function toCamelCase(obj) {
+  const result = {};
+  Object.entries(obj).forEach(([key, value]) => {
+    const newKey = key.split("_").map((part, i) => i === 0 ? part : part.charAt(0).toUpperCase() + part.slice(1)).join("");
+    result[newKey] = value;
+  });
+  return result;
+}
+function toUnderscoredCase(obj) {
+  const result = {};
+  Object.entries(obj).forEach(([key, value]) => {
+    const newKey = key.replace(/([a-z0-9])([A-Z])/g, "$1_$2").toLowerCase();
+    result[newKey] = value;
+  });
+  return result;
+}
+
+// src/array.ts
+function splitEvery(limit = 1, arr = []) {
+  const size = Math.max(1, Math.floor(limit));
+  return arr.reduce((acc, item, index) => {
+    if (index % size === 0) acc.push([]);
+    const last = acc[acc.length - 1];
+    if (last !== void 0) last.push(item);
+    return acc;
+  }, []);
+}
+function uniq(arrArg) {
+  return Array.from(new Set(arrArg));
+}
+function removeElFromArr(arr, index) {
+  const newArr = [...arr];
+  newArr.splice(index, 1);
+  return newArr;
+}
+function mergeByKey(arr1 = [], arr2 = [], key = "id") {
+  return arr1.map((el1) => {
+    const el2 = arr2.find((el) => String(el[key]) === String(el1[key]));
+    if (!el2) return el1;
+    const _a = el2, { [key]: _ignore } = _a, rest = __objRest(_a, [__restKey(key)]);
+    return __spreadValues(__spreadValues({}, el1), rest);
+  });
+}
+
+// src/strings.ts
+var makeShortNameFromFull = (fullName = "") => {
+  const parts = fullName.trim().split(/\s+/).filter(Boolean);
+  if (parts.length === 3) {
+    const [last, first] = parts;
+    return [first, last].join(" ");
+  }
+  return parts.reverse().join(" ");
+};
+var extractDigits = (input = "") => {
+  return typeof input === "string" ? input.replace(/\D/g, "") : "";
+};
+
+// src/currency-codes.ts
+var CURRENCY_DIRECTORY = {
+  AFN: "\u060B",
+  ALL: "Lek",
+  ANG: "\u0192",
+  ARS: "$",
+  AUD: "$",
+  AWG: "\u0192",
+  AZN: "\u20BC",
+  BAM: "KM",
+  BBD: "$",
+  BGN: "\u043B\u0432",
+  BMD: "$",
+  BND: "$",
+  BOB: "$b",
+  BRL: "R$",
+  BSD: "$",
+  BWP: "P",
+  BYR: "Br",
+  BZD: "BZ$",
+  CAD: "C$",
+  CHF: "CHF",
+  CLP: "$",
+  CNY: "\xA5",
+  COP: "$",
+  CRC: "\u20A1",
+  CUP: "\u20B1",
+  CZK: "K\u010D",
+  DKK: "kr",
+  DOP: "RD$",
+  EEK: "kr",
+  EGP: "\xA3",
+  EUR: "\u20AC",
+  FJD: "$",
+  FKP: "\xA3",
+  FRF: "\u20A3",
+  GBP: "\xA3",
+  GGP: "\xA3",
+  GHC: "\xA2",
+  GIP: "\xA3",
+  GTQ: "Q",
+  GYD: "$",
+  HKD: "$",
+  HNL: "L",
+  HRK: "kn",
+  HUF: "Ft",
+  IDR: "Rp",
+  ILS: "\u20AA",
+  IMP: "\xA3",
+  INR: "\u20A8",
+  IRR: "\uFDFC",
+  ISK: "kr",
+  JEP: "\xA3",
+  JMD: "J$",
+  JPY: "\xA5",
+  KGS: "KGS",
+  KHR: "\u17DB",
+  KPW: "\u20A9",
+  KRW: "\u20A9",
+  KYD: "$",
+  KZT: "\u20B8",
+  LAK: "\u20AD",
+  LBP: "\xA3",
+  LKR: "\u20A8",
+  LRD: "$",
+  LTL: "Lt",
+  LVL: "Ls",
+  MKD: "\u0434\u0435\u043D",
+  MNT: "\u20AE",
+  MUR: "\u20A8",
+  MXN: "$",
+  MYR: "RM",
+  MZN: "MT",
+  NAD: "$",
+  NGN: "\u20A6",
+  NIO: "C$",
+  NOK: "kr",
+  NPR: "\u20A8",
+  NZD: "$",
+  OMR: "\uFDFC",
+  PAB: "B/.",
+  PEN: "S/.",
+  PHP: "\u20B1",
+  PKR: "\u20A8",
+  PLN: "z\u0142",
+  PYG: "Gs",
+  QAR: "\uFDFC",
+  RON: "lei",
+  RSD: "\u0414\u0438\u043D.",
+  RUR: "\u20BD",
+  SAR: "\uFDFC",
+  SBD: "$",
+  SCR: "\u20A8",
+  SEK: "kr",
+  SGD: "$",
+  SHP: "\xA3",
+  SOS: "S",
+  SRD: "$",
+  SVC: "$",
+  SYP: "\xA3",
+  THB: "\u0E3F",
+  TRL: "\u20A4",
+  TRY: "\u20A4",
+  TTD: "TT$",
+  TVD: "$",
+  TWD: "NT$",
+  UAH: "\u20B4",
+  USD: "$",
+  UYU: "$U",
+  UZS: "\u043B\u0432",
+  VEF: "Bs",
+  VND: "\u20AB",
+  XCD: "$",
+  YER: "\uFDFC",
+  ZAR: "R",
+  ZWD: "Z$"
+};
+var CURRENCY_INDEX = CURRENCY_DIRECTORY;
+function getCurrencySymbol(currencyCode) {
+  var _a;
+  return (_a = CURRENCY_INDEX[currencyCode]) != null ? _a : currencyCode;
+}
+
+// src/colors.ts
+function colorLuminance(rawHex, lum = 0) {
+  let hex = String(rawHex).replace(/[^0-9a-f]/gi, "").toLowerCase();
+  if (hex.length < 6) {
+    const r = hex.charAt(0);
+    const g = hex.charAt(1);
+    const b = hex.charAt(2);
+    hex = r + r + g + g + b + b;
+  }
+  let rgb = "#";
+  for (let i = 0; i < 3; i++) {
+    const chunk = hex.substring(i * 2, i * 2 + 2);
+    let c = parseInt(chunk, 16);
+    if (Number.isNaN(c)) c = 0;
+    const adjusted = Math.round(Math.min(Math.max(0, c + c * lum), 255));
+    const part = adjusted.toString(16).padStart(2, "0");
+    rgb += part;
+  }
+  return rgb;
+}
+function getGradient(degree, color) {
+  const base = `#${color}`;
+  const lighter = colorLuminance(base, 0.09);
+  const darker = colorLuminance(base, -0.09);
+  return `linear-gradient(${degree}, ${lighter}, ${darker})`;
+}
+function getColorByString(str, colors) {
+  var _a;
+  if (!colors || colors.length === 0) return null;
+  let i = str.length;
+  let sum = 0;
+  while (i--) {
+    sum += str.charCodeAt(i);
+  }
+  return (_a = colors[sum % colors.length]) != null ? _a : null;
+}
+
+// src/url.ts
+var import_query_string = __toESM(require("query-string"), 1);
+function createPath(u, query = {}) {
+  var _a;
+  let url = u;
+  const hashExist = url.includes("#");
+  const hash = hashExist ? (_a = url.split("#")[1]) != null ? _a : "" : "";
+  if (hashExist) {
+    url = url.replace("#", "");
+    url = url.replace(hash, "");
+  }
+  const [urlPath, urlQuery = ""] = url.split("?");
+  const queryParams = import_query_string.default.stringify(
+    __spreadValues(__spreadValues({}, import_query_string.default.parse(urlQuery)), query),
+    { encode: false, skipNull: true, sort: false }
+  );
+  const base = [urlPath, queryParams].filter(Boolean).join("?");
+  return base + (hashExist ? `#${hash}` : "");
+}
+function parseQueryString(query) {
+  return import_query_string.default.parse(query);
+}
+function getNextPageURLFromLinkHeader(link = "") {
+  var _a;
+  const result = /<([^>]+)>/.exec(link);
+  return (_a = result == null ? void 0 : result[1]) != null ? _a : "";
+}
+function getNextPageFromLinkHeader(link = "") {
+  if (!link) return null;
+  const m = /[?&]page=([^&>]+)[&>]/i.exec(link);
+  if (!m || !m[1]) return null;
+  const n = Number.parseInt(m[1], 10);
+  return Number.isNaN(n) ? null : n;
+}
+function makeParamString(object = {}) {
+  return Object.keys(object).map((key) => {
+    const v = object[key];
+    const str = v == null ? "" : String(v);
+    return `${encodeURIComponent(key)}=${encodeURIComponent(str)}`;
+  }).join("&");
+}
+
+// src/mime-types/audio.ts
+var audioFormats = [
+  {
+    extensions: ["mp3"],
+    mime: "audio/mpeg, audio/mp3"
+  },
+  {
+    extensions: ["wav"],
+    mime: "audio/wav"
+  }
+];
+var audio_default = audioFormats;
+
+// src/mime-types/files.ts
+var fileFormats = [
+  {
+    extensions: ["odt"],
+    mime: "application/vnd.oasis.opendocument.text"
+  },
+  {
+    extensions: ["odf"],
+    mime: "application/vnd.oasis.opendocument.formula"
+  },
+  {
+    extensions: ["odp"],
+    mime: "application/vnd.oasis.opendocument.presentation"
+  },
+  {
+    extensions: ["ppt"],
+    mime: "application/vnd.ms-powerpoint"
+  },
+  {
+    extensions: ["pptx"],
+    mime: "application/vnd.openxmlformats-officedocument.presentationml.presentation"
+  },
+  {
+    extensions: ["doc", "dot"],
+    mime: "application/msword"
+  },
+  {
+    extensions: ["docx"],
+    mime: "application/vnd.openxmlformats-officedocument.wordprocessingml.document"
+  },
+  {
+    extensions: ["pdf"],
+    mime: "application/pdf"
+  },
+  {
+    extensions: ["xls", "xlsx"],
+    mime: "application/excel, application/x-excel, application/vnd.ms-excel, application/x-msexcel, application/vnd.openxmlformats-officedocument.spreadsheetml.sheet"
+  }
+];
+var files_default = fileFormats;
+
+// src/mime-types/images.ts
+var imageFormats = [
+  {
+    extensions: ["jpg", "jpeg"],
+    mime: "image/jpeg"
+  },
+  {
+    extensions: ["png"],
+    mime: "image/png"
+  },
+  {
+    extensions: ["gif"],
+    mime: "image/gif"
+  }
+];
+var images_default = imageFormats;
+
+// src/files.ts
+var MimeTypes = {
+  audio: audio_default,
+  files: files_default,
+  images: images_default
+};
+var getExtensions = (list) => list.flatMap((file) => file.extensions);
+var mimeImages = () => getMimeTypes(MimeTypes.images);
+var mimeFiles = () => getMimeTypes(MimeTypes.files);
+var mimeAudio = () => getMimeTypes(MimeTypes.audio);
+var acceptFileTypes = () => [...mimeImages(), ...mimeFiles()];
+var acceptAllTypes = () => [...mimeImages(), ...mimeFiles(), ...mimeAudio()];
+var acceptImagesExtensions = () => getExtensions(MimeTypes.images);
+var acceptFilesExtensions = () => getExtensions(MimeTypes.files);
+var acceptAudioExtensions = () => getExtensions(MimeTypes.audio);
+var acceptAllExtensions = () => [
+  ...acceptFilesExtensions(),
+  ...acceptImagesExtensions(),
+  ...acceptAudioExtensions()
+];
+
+// src/functions.ts
+function wrapField(wrapper, field) {
+  return `${wrapper}[${field}]`;
+}
+function wrapFormFields(wrapper, formFieldsString, untouchables = []) {
+  const parts = formFieldsString.split("&");
+  const newFields = [];
+  parts.forEach((oldPart) => {
+    const eqIndex = oldPart.indexOf("=");
+    const oldField = eqIndex >= 0 ? oldPart.slice(0, eqIndex) : oldPart;
+    const newPart = untouchables.includes(oldField) ? oldPart : oldPart.replace(oldField, wrapField(wrapper, oldField));
+    newFields.push(newPart);
+  });
+  return newFields.join("&");
+}
+var matchesId = (idToMatch) => (obj) => String(obj.id) === String(idToMatch);
+function detectEnterKey(e) {
+  const ENTER = 13;
+  const charCode = typeof e.which === "number" ? e.which : e.keyCode;
+  return ENTER === charCode;
+}
+function makeOption(value, label) {
+  return value ? { label, value } : void 0;
+}
+function makeLoadOptionsFunc(func, args, defaultOptions, extras = {}) {
+  var _a;
+  const response = (_a = func == null ? void 0 : func(args)) != null ? _a : null;
+  return response ? response.then((options) => __spreadValues({ options }, extras)) : Promise.resolve(__spreadValues({ options: defaultOptions }, extras));
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Collapse,
+  TYPES,
+  acceptAllExtensions,
+  acceptAllTypes,
+  acceptAudioExtensions,
+  acceptFileTypes,
+  acceptFilesExtensions,
+  acceptImagesExtensions,
+  base64ToArrayBuffer,
+  capitalize,
+  colorLuminance,
+  createPath,
+  currencyDirectory,
+  debounce,
+  detectEnterKey,
+  detectIE,
+  extractDigits,
+  getColorByString,
+  getCurrencySymbol,
+  getFilesSize,
+  getGradient,
+  getMimeTypes,
+  getNextPageFromLinkHeader,
+  getNextPageURLFromLinkHeader,
+  getRandomInt,
+  indexByGroupId,
+  indexById,
+  isElementInViewport,
+  makeLoadOptionsFunc,
+  makeOption,
+  makeParamString,
+  makeShortNameFromFull,
+  matchesId,
+  merge,
+  mergeByKey,
+  mimeAudio,
+  mimeFiles,
+  mimeImages,
+  outerHeight,
+  parseQueryString,
+  parseStringListToArray,
+  pickBy,
+  pluralize,
+  pluralizeByType,
+  qid,
+  rawMarkup,
+  removeElFromArr,
+  scrollToElement,
+  serializeArray,
+  splitEvery,
+  toCamelCase,
+  toUnderscoredCase,
+  transformOptionsForSelect,
+  uniq,
+  uuid,
+  wrapFormFields
+});