diginext-utils 2.1.22 → 2.1.23

package/dist/chunk-7XKT3AQX.mjs

@@ -0,0 +1,17 @@
+// src/string/makeDaySlug.ts
+import dayjs from "dayjs";
+function makeDaySlug(options = {}) {
+  const { prefix = "", surfix = "", divider = "-", useDate = true, useTime = true } = options;
+  let mainStr = "";
+  if (useDate)
+    mainStr += dayjs().format(`YYYY${divider}MM${divider}DD`);
+  if (useTime)
+    mainStr += (mainStr == "" ? "" : divider) + dayjs().format(`HH${divider}mm${divider}ss`);
+  return prefix + (prefix ? divider : "") + mainStr + (surfix ? divider : "") + surfix;
+}
+var makeDaySlug_default = { makeDaySlug };
+
+export {
+  makeDaySlug,
+  makeDaySlug_default
+};

package/dist/chunk-AT5ZUBQL.mjs

@@ -0,0 +1,151 @@
+import {
+  requestCamera
+} from "./chunk-LGBBKRBU.mjs";
+import {
+  __export
+} from "./chunk-4VQ25N7H.mjs";
+
+// src/device/camera.ts
+var camera_exports = {};
+__export(camera_exports, {
+  getWebcam: () => getWebcam
+});
+function getWebcam(params = { facingMode: "environment", audio: true }) {
+  if (typeof window == "undefined")
+    return;
+  const { container, facingMode = "environment", audio = true } = params;
+  const _container = container || document.body;
+  return new Promise(async (resolve, reject) => {
+    const video = document.createElement("video");
+    video.style.position = "absolute";
+    video.style.top = "0";
+    video.style.left = "0";
+    video.style.width = "100%";
+    video.style.height = "100%";
+    _container.append(video);
+    let inputCameras = [];
+    let currentCamera;
+    const requestedMediaConstraints = {
+      video: {
+        facingMode: { exact: facingMode }
+      },
+      audio
+    };
+    let stream;
+    let isAllowed = false;
+    console.log("[Camera.js] Requesting:", requestedMediaConstraints);
+    const res = await requestCamera({ audio });
+    if (!res) {
+      setTimeout(function() {
+        handleError({ name: "Error", message: "NotSupported" });
+      }, 50);
+    }
+    navigator.mediaDevices.enumerateDevices().then(parseDevices).catch(handleError);
+    function parseDevices(devices) {
+      inputCameras = [];
+      let backCameras = [];
+      devices.forEach(function(device) {
+        if (device.kind == "videoinput" && typeof device.deviceId != "undefined" && device.deviceId != "") {
+          inputCameras.push(device);
+        }
+      });
+      console.log("[Camera.js] inputCameras:", inputCameras);
+      if (inputCameras.length > 0) {
+        let cams = "";
+        let backCamera;
+        inputCameras.map((cam, index) => {
+          cams += `[${cam.deviceId}] ${cam.kind} | ${cam.label}
+`;
+          let label = cam.label.toLowerCase();
+          if (label.indexOf("back") > -1 || label.indexOf("facetime") > -1) {
+            backCamera = cam;
+            backCameras.push(backCamera);
+          }
+        });
+        if (backCameras.length > 1) {
+          backCamera = backCameras[backCameras.length - 1];
+        }
+        console.log(`[Camera.js] All input sources:`, cams);
+        console.log(`[Camera.js] This device has ${backCameras.length} back camera${backCameras.length > 1 ? "s" : ""}.`);
+        console.log("[Camera.js] backCameras:", JSON.stringify(backCameras));
+        currentCamera = backCamera;
+        getStreamOfCameraId(backCamera.deviceId).then(onStreamReceived).catch((e) => {
+          if (backCameras.length > 1) {
+            backCamera = backCameras[backCameras.length - 2];
+            getStreamOfCameraId(backCamera.deviceId).then(onStreamReceived).catch(handleError);
+          } else if (backCameras.length > 2) {
+            backCamera = backCameras[backCameras.length - 3];
+            getStreamOfCameraId(backCamera.deviceId).then(onStreamReceived).catch(handleError);
+          } else {
+            handleError(e);
+          }
+        });
+      } else {
+        navigator.mediaDevices.getUserMedia(requestedMediaConstraints).then(onStreamReceived).catch(handleError);
+      }
+    }
+    function onStreamReceived(stream2) {
+      if (inputCameras.length == 0) {
+        console.log("[Camera.js] Not found any back cameras, request again?");
+        navigator.mediaDevices.enumerateDevices().then(parseDevices).catch(handleError);
+        return;
+      }
+      isAllowed = true;
+      playWebcamVideo(stream2);
+    }
+    function playWebcamVideo(_stream) {
+      stream = _stream;
+      if ("srcObject" in video) {
+        video.srcObject = _stream;
+      } else {
+        video.src = window.URL.createObjectURL(_stream);
+      }
+      video.setAttribute("playsinline", "true");
+      video.setAttribute("muted", "true");
+      video.setAttribute("autoplay", "true");
+      video.muted = true;
+      video.autoplay = true;
+      video.style.objectFit = "cover";
+      video.play();
+      video.addEventListener("canplay", function(e) {
+      });
+      video.addEventListener("canplaythrough", function(e) {
+      });
+      video.addEventListener("error", (e) => console.log("[Camera.js] <video> error:", e));
+      video.addEventListener("stalled", function(e) {
+        isAllowed = false;
+        console.log("[Camera.js] <video> stalled:", e);
+        reject();
+      });
+      video.addEventListener("loadedmetadata", function(e) {
+        if (currentCamera.label.toLowerCase().indexOf("facetime") > -1) {
+          video.style.transform = "scaleX(-1)";
+          video.style.webkitTransform = "scaleX(-1)";
+        }
+        video.play();
+        resolve(video);
+      });
+    }
+    function getStreamOfCameraId(id) {
+      const constraints = {
+        video: { deviceId: { exact: id } },
+        audio: false
+      };
+      return new Promise((resolve2, reject2) => {
+        navigator.mediaDevices.getUserMedia(constraints).then(resolve2).catch(reject2);
+      });
+    }
+    function handleError(err) {
+      console.error(err);
+      const errMsg = "[Camera.js] " + err.name + ": " + err.message;
+      console.error(errMsg);
+      isAllowed = false;
+      reject();
+    }
+  });
+}
+
+export {
+  getWebcam,
+  camera_exports
+};

package/dist/chunk-CKILLYAP.mjs

@@ -0,0 +1,16 @@
+// src/string/generateUUID.ts
+var _lut = ["00", "01", "02", "03", "04", "05", "06", "07", "08", "09", "0a", "0b", "0c", "0d", "0e", "0f", "10", "11", "12", "13", "14", "15", "16", "17", "18", "19", "1a", "1b", "1c", "1d", "1e", "1f", "20", "21", "22", "23", "24", "25", "26", "27", "28", "29", "2a", "2b", "2c", "2d", "2e", "2f", "30", "31", "32", "33", "34", "35", "36", "37", "38", "39", "3a", "3b", "3c", "3d", "3e", "3f", "40", "41", "42", "43", "44", "45", "46", "47", "48", "49", "4a", "4b", "4c", "4d", "4e", "4f", "50", "51", "52", "53", "54", "55", "56", "57", "58", "59", "5a", "5b", "5c", "5d", "5e", "5f", "60", "61", "62", "63", "64", "65", "66", "67", "68", "69", "6a", "6b", "6c", "6d", "6e", "6f", "70", "71", "72", "73", "74", "75", "76", "77", "78", "79", "7a", "7b", "7c", "7d", "7e", "7f", "80", "81", "82", "83", "84", "85", "86", "87", "88", "89", "8a", "8b", "8c", "8d", "8e", "8f", "90", "91", "92", "93", "94", "95", "96", "97", "98", "99", "9a", "9b", "9c", "9d", "9e", "9f", "a0", "a1", "a2", "a3", "a4", "a5", "a6", "a7", "a8", "a9", "aa", "ab", "ac", "ad", "ae", "af", "b0", "b1", "b2", "b3", "b4", "b5", "b6", "b7", "b8", "b9", "ba", "bb", "bc", "bd", "be", "bf", "c0", "c1", "c2", "c3", "c4", "c5", "c6", "c7", "c8", "c9", "ca", "cb", "cc", "cd", "ce", "cf", "d0", "d1", "d2", "d3", "d4", "d5", "d6", "d7", "d8", "d9", "da", "db", "dc", "dd", "de", "df", "e0", "e1", "e2", "e3", "e4", "e5", "e6", "e7", "e8", "e9", "ea", "eb", "ec", "ed", "ee", "ef", "f0", "f1", "f2", "f3", "f4", "f5", "f6", "f7", "f8", "f9", "fa", "fb", "fc", "fd", "fe", "ff"];
+function generateUUID() {
+  const d0 = Math.random() * 4294967295 | 0;
+  const d1 = Math.random() * 4294967295 | 0;
+  const d2 = Math.random() * 4294967295 | 0;
+  const d3 = Math.random() * 4294967295 | 0;
+  const uuid = _lut[d0 & 255] + _lut[d0 >> 8 & 255] + _lut[d0 >> 16 & 255] + _lut[d0 >> 24 & 255] + "-" + _lut[d1 & 255] + _lut[d1 >> 8 & 255] + "-" + _lut[d1 >> 16 & 15 | 64] + _lut[d1 >> 24 & 255] + "-" + _lut[d2 & 63 | 128] + _lut[d2 >> 8 & 255] + "-" + _lut[d2 >> 16 & 255] + _lut[d2 >> 24 & 255] + _lut[d3 & 255] + _lut[d3 >> 8 & 255] + _lut[d3 >> 16 & 255] + _lut[d3 >> 24 & 255];
+  return uuid.toLowerCase();
+}
+var generateUUID_default = generateUUID;
+
+export {
+  generateUUID,
+  generateUUID_default
+};

package/dist/chunk-D5JDP7JB.mjs

@@ -0,0 +1,56 @@
+import {
+  __export,
+  __require
+} from "./chunk-4VQ25N7H.mjs";
+
+// src/file/findFilesByExt.ts
+var findFilesByExt_exports = {};
+__export(findFilesByExt_exports, {
+  default: () => findFilesByExt_default,
+  findFileByExt: () => findFileByExt,
+  forEachFileByExt: () => forEachFileByExt
+});
+var path = __require("path");
+var fs = __require("fs");
+var forEachFileByExt = (base, ext, cb) => {
+  var walk = function(directoryName) {
+    try {
+      fs.readdir(directoryName, function(e, files) {
+        if (e) {
+          console.log("Error: ", e);
+          return;
+        }
+        files.forEach(function(file) {
+          var fullPath = path.join(directoryName, file);
+          fs.stat(fullPath, function(e2, f) {
+            if (e2) {
+              console.log("Error: ", e2);
+              return;
+            }
+            if (f.isDirectory()) {
+              walk(fullPath);
+            } else {
+              if (fullPath.toLowerCase().indexOf(ext.toLowerCase()) > -1) {
+                if (cb)
+                  cb(fullPath);
+              }
+            }
+          });
+        });
+      });
+    } catch (error) {
+      console.log("error", error);
+    }
+  };
+  walk(base);
+};
+var findFileByExt = forEachFileByExt;
+var fileExt = { findFileByExt, forEachFileByExt };
+var findFilesByExt_default = fileExt;
+
+export {
+  forEachFileByExt,
+  findFileByExt,
+  findFilesByExt_default,
+  findFilesByExt_exports
+};

package/dist/chunk-DEOVENCJ.mjs

@@ -0,0 +1,15 @@
+import {
+  toInt
+} from "./chunk-6OZHYD5H.mjs";
+
+// src/string/formatNumber.ts
+function formatNumber(num, prefix = "$") {
+  const numRound = Math.round((toInt(num) + Number.EPSILON) * 100) / 100;
+  return Number.isNaN(numRound) ? "0" : "" + numRound.toString().replace(/(\d)(?=(\d{3})+(?!\d))/g, prefix + "1,");
+}
+var formatNumber_default = formatNumber;
+
+export {
+  formatNumber,
+  formatNumber_default
+};

package/dist/chunk-FILFH56Y.mjs

@@ -0,0 +1,21 @@
+import {
+  isNull
+} from "./chunk-6OZHYD5H.mjs";
+
+// src/math/positiveNumber.ts
+function positiveNumber(number) {
+  if (isNull(number))
+    return 0;
+  if (!Number.isFinite(Number(number)))
+    return 0;
+  number = Number(number);
+  if (number < 0)
+    return 0;
+  return number;
+}
+var positiveNumber_default = positiveNumber;
+
+export {
+  positiveNumber,
+  positiveNumber_default
+};

package/dist/chunk-FTXB3IBS.mjs

@@ -0,0 +1,20 @@
+import {
+  __export
+} from "./chunk-4VQ25N7H.mjs";
+
+// src/Timer.ts
+var Timer_exports = {};
+__export(Timer_exports, {
+  default: () => Timer_default
+});
+var Timer = {
+  wait: async (ms) => {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+  }
+};
+var Timer_default = Timer;
+
+export {
+  Timer_default,
+  Timer_exports
+};

package/dist/chunk-GJMNV2OC.mjs

@@ -0,0 +1,35 @@
+// src/images/resize.ts
+import loadImage from "blueimp-load-image";
+var resize = async (file) => {
+  if (!file) {
+    console.error("NO FILE AVAIABLE!");
+    return;
+  }
+  const { type } = file;
+  const data = await loadImage(file, {
+    //
+    meta: false,
+    canvas: true,
+    maxWidth: 2048,
+    maxHeight: 2048
+  });
+  const blob = await new Promise(function(resolve) {
+    try {
+      const canvas = data.image;
+      canvas.toBlob(function(blob2) {
+        resolve(blob2);
+      }, type);
+    } catch (error) {
+      console.error(`diginext-utils/src/images/resize.ts canvas.toBlob error`, error);
+    }
+  });
+  if (blob)
+    return blob;
+  return data;
+};
+var resize_default = resize;
+
+export {
+  resize,
+  resize_default
+};

package/dist/chunk-GNJDIUYM.mjs

@@ -0,0 +1,40 @@
+// src/console/log.ts
+import chalk from "chalk";
+import dayjs from "dayjs";
+var log = (...msg) => {
+  console.log(chalk.bgBlue.white(`[LOGGING ${dayjs().format("YYYY-MM-DD HH:mm:ss")}]`), ...msg);
+  return msg;
+};
+var logFull = (data = {}) => {
+  console.dir(data, { depth: null, colors: true, maxArrayLength: null });
+  return data;
+};
+var logRes = (res, ...msg) => {
+  var _a, _b;
+  console.warn(chalk.blue(`[${res.statusCode}] ${((_a = res.locals.req) == null ? void 0 : _a.originalUrl) || "UNKNOWN_PATH"} >> ${(_b = res.locals.req) == null ? void 0 : _b.method} >>`), ...msg);
+  return msg;
+};
+var logError = (...msg) => {
+  console.error(chalk.bgRed.white(`[ERROR ${dayjs().format("YYYY-MM-DD HH:mm:ss")}]`), chalk.red(...msg));
+  return msg;
+};
+var logWarn = (...msg) => {
+  console.warn(chalk.bgYellow.black(`[WARNING ${dayjs().format("YYYY-MM-DD HH:mm:ss")}]`), ...msg);
+  return msg;
+};
+var logSuccess = (...msg) => {
+  console.info(chalk.bgGreen.black(`[SUCCESS ${dayjs().format("YYYY-MM-DD HH:mm:ss")}]`), ...msg);
+  return msg;
+};
+var xlog = { log, logFull, logRes, logError, logWarn, logSuccess };
+var log_default = xlog;
+
+export {
+  log,
+  logFull,
+  logRes,
+  logError,
+  logWarn,
+  logSuccess,
+  log_default
+};

package/dist/chunk-HN4EHJ2H.mjs

@@ -0,0 +1,39 @@
+import {
+  __export,
+  __require
+} from "./chunk-4VQ25N7H.mjs";
+
+// src/file/fileMove.ts
+var fileMove_exports = {};
+__export(fileMove_exports, {
+  fileMove: () => fileMove
+});
+var fs = __require("fs");
+function fileMove(oldPath, newPath, callback) {
+  fs.rename(oldPath, newPath, function(err) {
+    if (err) {
+      if (err.code === "EXDEV") {
+        copy();
+      } else {
+        callback(err);
+      }
+      return;
+    }
+    callback();
+  });
+  function copy() {
+    var readStream = fs.createReadStream(oldPath);
+    var writeStream = fs.createWriteStream(newPath);
+    readStream.on("error", callback);
+    writeStream.on("error", callback);
+    readStream.on("close", function() {
+      fs.unlink(oldPath, callback);
+    });
+    readStream.pipe(writeStream);
+  }
+}
+
+export {
+  fileMove,
+  fileMove_exports
+};

package/dist/chunk-HTAKHCLC.mjs

@@ -0,0 +1,43 @@
+// src/string/random.ts
+var textLowCase = "abcdefghijklmnopqrstuvwxyz";
+var numeric = "0123456789";
+var punctuation = "!@#$%^&*()_+~|}{[];?><,./-=";
+var allCharacter = `\u0111\u0110a\xE1\xE0\u1EA3\xE3\u1EA1\u0103\u1EAF\u1EB1\u1EB3\u1EB5\u1EB7\xE2\u1EA5\u1EA7\u1EA9\u1EAB\u1EADe\xE9\xE8\u1EBB\u1EBD\u1EB9\xEA\u1EBF\u1EC1\u1EC3\u1EC5\u1EC7o\xF3\xF2\u1ECF\xF5\u1ECD\xF4\u1ED1\u1ED3\u1ED5\u1ED7\u1ED9\u01A1\u1EDB\u1EDD\u1EDF\u1EE1\u1EE3i\xED\xEC\u1EC9\u0129\u1ECBu\xFA\xF9\u1EE7\u0169\u1EE5\u01B0\u1EE9\u1EEB\u1EED\u1EEF\u1EF1y\xFD\u1EF3\u1EF7\u1EF9\u1EF5A\xC1\xC0\u1EA2\xC3\u1EA0\u0102\u1EAE\u1EB0\u1EB2\u1EB4\u1EB6\xC2\u1EA4\u1EA6\u1EA8\u1EAA\u1EACE\xC9\xC8\u1EBA\u1EBC\u1EB8\xCA\u1EBE\u1EC0\u1EC2\u1EC4\u1EC6O\xD3\xD2\u1ECE\xD5\u1ECC\xD4\u1ED0\u1ED2\u1ED4\u1ED6\u1ED8\u01A0\u1EDA\u1EDC\u1EDE\u1EE0\u1EE2I\xCD\xCC\u1EC8\u0128\u1ECAU\xDA\xD9\u1EE6\u0168\u1EE4\u01AF\u1EE8\u1EEA\u1EEC\u1EEE\u1EF0Y\xDD\u1EF2 !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[]^_\`abcdefghijklmnopqrstuvwxyz{|}`;
+var randAllCharacterByLength = (length = 0) => {
+  return randomStringByLength(length, allCharacter);
+};
+var randomStringByLength = (length, str = textLowCase) => {
+  let result = "";
+  for (let i = 0; i < length; i++) {
+    result += str.charAt(Math.floor(Math.random() * str.length));
+  }
+  return result;
+};
+var randomStringAndNumberByLength = (length, str = `${textLowCase}${numeric}`) => {
+  let result = "";
+  for (let i = 0; i < length; i++) {
+    result += str.charAt(Math.floor(Math.random() * str.length));
+  }
+  return result;
+};
+var uniqueSortByTime = (length = 6, str = `${textLowCase}${numeric}`) => {
+  let result = `${+/* @__PURE__ */ new Date()}-`;
+  for (let i = 0; i < length; i++) {
+    result += str.charAt(Math.floor(Math.random() * str.length));
+  }
+  return result;
+};
+var random = { randAllCharacterByLength, randomStringByLength, randomStringAndNumberByLength, uniqueSortByTime };
+var random_default = random;
+
+export {
+  textLowCase,
+  numeric,
+  punctuation,
+  allCharacter,
+  randAllCharacterByLength,
+  randomStringByLength,
+  randomStringAndNumberByLength,
+  uniqueSortByTime,
+  random_default
+};

package/dist/chunk-JAP2EUEW.mjs

@@ -0,0 +1,86 @@
+import {
+  __export
+} from "./chunk-4VQ25N7H.mjs";
+
+// src/string/url.ts
+var url_exports = {};
+__export(url_exports, {
+  addQueryParam: () => addQueryParam,
+  default: () => url_default,
+  getFileExtension: () => getFileExtension,
+  getFileNameWithExtension: () => getFileNameWithExtension,
+  getFileNameWithoutExtension: () => getFileNameWithoutExtension,
+  getUrlParams: () => getUrlParams,
+  isImage: () => isImage,
+  isLink: () => isLink
+});
+var urlRegex = /(https?:\/\/[^\s]+)/g;
+var addQueryParam = (_url, key, value) => {
+  _url += (_url.split("?")[1] ? "&" : "?") + `${key}=${value}`;
+  return _url;
+};
+var getUrlParams = (parameter, staticURL, decode = true) => {
+  if (typeof window == "undefined")
+    return "";
+  staticURL = staticURL == void 0 ? window.location.host : staticURL;
+  var currLocation = staticURL.length > 0 ? staticURL : window.location.search;
+  if (currLocation.split("?").length < 2)
+    return "";
+  var parArr = currLocation.split("?")[1].split("&"), returnBool = true;
+  for (var i = 0; i < parArr.length; i++) {
+    var parr = parArr[i].split("=");
+    if (parr[0] == parameter) {
+      return decode ? decodeURIComponent(parr[1]) : parr[1];
+      returnBool = true;
+    } else {
+      returnBool = false;
+    }
+  }
+  if (!returnBool)
+    return false;
+};
+var isLink = (str) => {
+  return urlRegex.test(str);
+};
+var getFileNameWithoutExtension = (url) => {
+  var _a, _b;
+  return ((_b = (_a = getFileNameWithExtension(url)) == null ? void 0 : _a.split(".")) == null ? void 0 : _b[0]) || "";
+};
+var getFileNameWithExtension = (url) => {
+  url = url.replaceAll("\\", "/");
+  const _url = decodeURIComponent(url);
+  const m = `${_url.toString().match(/(?:.*\/)?([^\/]+)/)}`;
+  if (m && m.split(",").length > 1) {
+    return m.split(",")[1].replace(/(\?.*)|(\&.*)/, "");
+  }
+  return "";
+};
+var getFileExtension = (url) => {
+  const arr = getFileNameWithExtension(url).split(".");
+  if (arr.length > 1)
+    return getFileNameWithExtension(url).split(".").pop();
+  return null;
+};
+var isImage = (url) => {
+  if (!url)
+    return false;
+  const arr = [".png", ".jpg", ".jpeg", ".jpe", ".jif", ".jfif", ".gif", ".svg"];
+  const index = arr.findIndex((item) => {
+    return url.indexOf(item) >= 0;
+  });
+  return index >= 0;
+};
+var xurl = { addQueryParam, getUrlParams, isLink, getFileNameWithoutExtension, getFileNameWithExtension, getFileExtension, isImage };
+var url_default = xurl;
+
+export {
+  addQueryParam,
+  getUrlParams,
+  isLink,
+  getFileNameWithoutExtension,
+  getFileNameWithExtension,
+  getFileExtension,
+  isImage,
+  url_default,
+  url_exports
+};

package/dist/chunk-JFASFX5Y.mjs

@@ -0,0 +1,16 @@
+// src/string/indexesOf.ts
+function indexesOf(str, regex) {
+  let match, indexes = {};
+  const list = [];
+  regex = new RegExp(regex);
+  while (match = regex.exec(str)) {
+    if (!indexes[match[0]])
+      indexes[match[0]] = [];
+    list.push(match.index);
+  }
+  return list;
+}
+
+export {
+  indexesOf
+};

package/dist/chunk-JIMOWRMS.mjs

@@ -0,0 +1,118 @@
+import {
+  diffDate
+} from "./chunk-7SOQVGCL.mjs";
+import {
+  positiveNumber
+} from "./chunk-FILFH56Y.mjs";
+import {
+  __export
+} from "./chunk-4VQ25N7H.mjs";
+
+// src/math/index.ts
+var math_exports = {};
+__export(math_exports, {
+  angleBetweenPoints: () => angleBetweenPoints,
+  clamp: () => clamp,
+  default: () => math_default,
+  degBetweenPoints: () => degBetweenPoints,
+  degBetweenPoints360: () => degBetweenPoints360,
+  degToRad: () => degToRad,
+  distance2Point: () => distance2Point,
+  radToDeg: () => radToDeg,
+  rand: () => rand,
+  randFloat: () => randFloat,
+  randHalt: () => randHalt,
+  randInt: () => randInt,
+  randRound: () => randRound
+});
+var DEG2RAD = Math.PI / 180;
+var RAD2DEG = 180 / Math.PI;
+var randRound = (number) => {
+  return Math.round(Math.random() * number);
+};
+var rand = (number) => {
+  return (Math.random() - Math.random()) * number;
+};
+var randHalt = (number) => {
+  var rand2 = Math.random() - Math.random();
+  var res;
+  if (rand2 > 0) {
+    res = rand2 * (number / 2) + number / 2;
+  } else {
+    res = rand2 * (number / 2) - number / 2;
+  }
+  return Math.abs(res);
+};
+var randInt = (low, high) => {
+  return low + Math.floor(Math.random() * (high - low + 1));
+};
+var randFloat = (low, high) => {
+  return low + Math.random() * (high - low);
+};
+var degToRad = (degrees) => {
+  return degrees * DEG2RAD;
+};
+var radToDeg = (radians) => {
+  return radians * RAD2DEG;
+};
+var clamp = (value, min, max) => {
+  const result = Math.max(min, Math.min(max, value));
+  return Number.isFinite(result) ? result : 0;
+};
+var degBetweenPoints360 = (cx, cy, ex, ey) => {
+  let theta = degBetweenPoints(cx, cy, ex, ey);
+  if (theta < 0)
+    theta = 360 + theta;
+  return Number.isFinite(theta) ? theta : 0;
+};
+var degBetweenPoints = (cx, cy, ex, ey) => {
+  const dy = ey - cy;
+  const dx = ex - cx;
+  let theta = Math.atan2(dy, dx);
+  theta *= 180 / Math.PI;
+  return Number.isFinite(theta) ? theta : 0;
+};
+var angleBetweenPoints = (cx, cy, ex, ey) => {
+  const dy = ey - cy;
+  const dx = ex - cx;
+  let theta = Math.atan2(dy, dx);
+  theta *= 180 / Math.PI;
+  return Number.isFinite(theta) ? theta : 0;
+};
+var distance2Point = (x1, y1, x2, y2) => {
+  const dist = Math.sqrt(Math.pow(x1 - x2, 2) + Math.pow(y1 - y2, 2));
+  return Number.isFinite(dist) ? dist : 0;
+};
+var xmath = {
+  rand,
+  randRound,
+  randHalt,
+  randInt,
+  randFloat,
+  degToRad,
+  radToDeg,
+  degBetweenPoints360,
+  degBetweenPoints,
+  angleBetweenPoints,
+  distance2Point,
+  diffDate,
+  positiveNumber
+};
+var math_default = xmath;
+
+export {
+  randRound,
+  rand,
+  randHalt,
+  randInt,
+  randFloat,
+  degToRad,
+  radToDeg,
+  clamp,
+  degBetweenPoints360,
+  degBetweenPoints,
+  angleBetweenPoints,
+  distance2Point,
+  math_default,
+  math_exports
+};