@tspro/ts-utils-lib 1.0.1 → 1.2.0

package/dist/index.js

@@ -0,0 +1,1104 @@
+/* TsUtilsLib v1.2.0 | (c) 2023 PahkaSoft | Licensed under the MIT License */
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+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 __toCommonJS = (mod2) => __copyProps(__defProp({}, "__esModule", { value: true }), mod2);
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  Assert: () => Assert,
+  Cookies: () => Cookies,
+  Device: () => Device,
+  LRUCache: () => LRUCache,
+  SmallIntCache: () => SmallIntCache,
+  Stack: () => Stack,
+  Utils: () => utils_exports,
+  Vec2: () => Vec2
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/utils/index.ts
+var utils_exports = {};
+__export(utils_exports, {
+  Arr: () => arr_exports,
+  Dom: () => dom_exports,
+  Enum: () => enum_exports,
+  Map: () => map_exports,
+  Math: () => math_exports,
+  Obj: () => obj_exports,
+  Str: () => str_exports
+});
+
+// src/utils/arr/index.ts
+var arr_exports = {};
+__export(arr_exports, {
+  arrayContains: () => arrayContains,
+  chunckArray: () => chunckArray,
+  duplicate: () => duplicate,
+  fillArray: () => fillArray,
+  getRangeArray: () => getRangeArray,
+  getSequenceArray: () => getSequenceArray,
+  isArray: () => isArray,
+  mapRangeArray: () => mapRangeArray,
+  mapSequenceArray: () => mapSequenceArray,
+  removeDuplicates: () => removeDuplicates,
+  removeDuplicatesCmp: () => removeDuplicatesCmp,
+  toArray: () => toArray
+});
+
+// src/utils/math/index.ts
+var math_exports = {};
+__export(math_exports, {
+  calcNormal: () => calcNormal,
+  clamp: () => clamp,
+  interpolateCoord: () => interpolateCoord,
+  interpolateY: () => interpolateY,
+  isInteger: () => isInteger,
+  linearToDecibels: () => linearToDecibels,
+  mod: () => mod,
+  romanize: () => romanize,
+  sum: () => sum,
+  toOrdinalNumber: () => toOrdinalNumber
+});
+function isInteger(n) {
+  return typeof n === "number" && isFinite(n) && n === Math.trunc(n);
+}
+function linearToDecibels(linearVolume) {
+  if (!isFinite(linearVolume)) {
+    throw new Error("linearToDecibel: Invalid linearVolume = " + linearVolume);
+  } else if (linearVolume <= 0) {
+    return -Infinity;
+  } else {
+    return 20 * Math.log10(linearVolume);
+  }
+}
+function mod(m, n) {
+  return (m % n + n) % n;
+}
+function romanize(n) {
+  if (!isInteger(n) || n < 0) {
+    throw new Error("romanize: Invalid n = " + n);
+  }
+  var digits = String(+n).split("");
+  var key = [
+    "",
+    "C",
+    "CC",
+    "CCC",
+    "CD",
+    "D",
+    "DC",
+    "DCC",
+    "DCCC",
+    "CM",
+    "",
+    "X",
+    "XX",
+    "XXX",
+    "XL",
+    "L",
+    "LX",
+    "LXX",
+    "LXXX",
+    "XC",
+    "",
+    "I",
+    "II",
+    "III",
+    "IV",
+    "V",
+    "VI",
+    "VII",
+    "VIII",
+    "IX"
+  ];
+  var roman = "", i = 3;
+  while (i--) roman = (key[+digits.pop() + i * 10] || "") + roman;
+  return Array(+digits.join("") + 1).join("M") + roman;
+}
+function toOrdinalNumber(n) {
+  if (!isInteger(n)) {
+    throw new Error("toOrdinalNumber: Invalid n = " + n);
+  }
+  const nStr = n.toString();
+  const lastDigit = Number(nStr.charAt(nStr.length - 1));
+  if (n === 1 || n >= 20 && lastDigit === 1) {
+    return nStr + "st";
+  } else if (n === 2 || n >= 20 && lastDigit === 2) {
+    return nStr + "nd";
+  } else if (n === 3 || n >= 20 && lastDigit === 3) {
+    return nStr + "rd";
+  } else {
+    return nStr + "th";
+  }
+}
+function interpolateCoord(startX, startY, endX, endY, t) {
+  return {
+    x: startX + (endX - startX) * t,
+    y: startY + (endY - startY) * t
+  };
+}
+function interpolateY(startX, startY, endX, endY, x) {
+  let t = (x - startX) / (endX - startX);
+  return startY + (endY - startY) * t;
+}
+function clamp(num, min, max) {
+  return Math.min(Math.max(num, min), max);
+}
+function calcNormal(x1, y1, x2, y2) {
+  let dx = x2 - x1;
+  let dy = y2 - y1;
+  let nx = -dy;
+  let ny = dx;
+  let len = Math.sqrt(nx * nx + ny * ny);
+  if (len > 0) {
+    nx /= len;
+    ny /= len;
+  } else {
+    nx = 0;
+    ny = 1;
+  }
+  return { nx, ny };
+}
+function sum(arr) {
+  return arr.reduce((prev, cur) => cur + prev, 0);
+}
+
+// src/utils/arr/index.ts
+function isArray(a) {
+  return !!a && Object.prototype.toString.call(a) === "[object Array]";
+}
+function toArray(a) {
+  return isArray(a) ? a : [a];
+}
+function duplicate(a) {
+  return a === void 0 ? a : a.slice();
+}
+function removeDuplicates(a) {
+  return a.filter((item, pos, arr) => arr.indexOf(item) === pos);
+}
+function removeDuplicatesCmp(arr, cmp) {
+  return arr.filter((t1, index, self) => index === self.findIndex((t2) => cmp(t1, t2)));
+}
+function fillArray(fillValue, fillCount) {
+  if (!isInteger(fillCount) || fillCount < 0) {
+    throw new Error("fillArray: Invalid fillCount = " + fillCount);
+  }
+  return new Array(fillCount).fill(fillValue);
+}
+function mapSequenceArray(len, fn) {
+  if (!isInteger(len) || len < 0) {
+    throw new Error("mapSequenceArray: Invalid len = " + len);
+  }
+  let arr = new Array(len);
+  for (let i = 0; i < len; i++) {
+    arr[i] = fn(i);
+  }
+  return arr;
+}
+function getSequenceArray(len) {
+  return mapSequenceArray(len, (i) => i);
+}
+function mapRangeArray(start, end, fn) {
+  if (!isInteger(start)) {
+    throw new Error("mapRangeArray: Invalid start = " + end);
+  }
+  if (!isInteger(end)) {
+    throw new Error("mapRangeArray: Invalid end = " + end);
+  }
+  let len = Math.abs(end - start) + 1;
+  let arr = new Array(len);
+  for (let i = 0, s = start, inc = Math.sign(end - start); i < len; s += inc, i++) {
+    arr[i] = fn(s);
+  }
+  return arr;
+}
+function getRangeArray(start, end) {
+  return mapRangeArray(start, end, (i) => i);
+}
+function arrayContains(arg, item) {
+  return arg.indexOf(item) >= 0;
+}
+function chunckArray(arr, chunckSize) {
+  if (!isInteger(chunckSize) || chunckSize < 1) {
+    throw new Error("chunckArray: Invalid chunckSize = " + chunckSize);
+  }
+  let result = [];
+  for (let i = 0; i < arr.length; i += chunckSize) {
+    result.push(arr.slice(i, i + chunckSize));
+  }
+  return result;
+}
+
+// src/utils/dom/index.ts
+var dom_exports = {};
+__export(dom_exports, {
+  addClass: () => addClass,
+  appendTo: () => appendTo,
+  getButton: () => getButton,
+  getCanvas: () => getCanvas,
+  getCanvasTextWidth: () => getCanvasTextWidth,
+  getDimension: () => getDimension,
+  getHeight: () => getHeight,
+  getOffset: () => getOffset,
+  getPadding: () => getPadding,
+  getWidth: () => getWidth,
+  hasClass: () => hasClass,
+  removeClass: () => removeClass,
+  removeFromParent: () => removeFromParent,
+  setHeight: () => setHeight,
+  setOffset: () => setOffset,
+  setRect: () => setRect,
+  setVisibility: () => setVisibility,
+  setWidth: () => setWidth,
+  styleLayoutChanged: () => styleLayoutChanged
+});
+
+// src/utils/enum/index.ts
+var enum_exports = {};
+__export(enum_exports, {
+  getEnumValues: () => getEnumValues
+});
+function getEnumValues(e) {
+  return Object.keys(e).filter((key) => Number.isNaN(Number(key))).map((key) => e[key]);
+}
+
+// src/modules/assert.ts
+var Assert;
+((Assert2) => {
+  let errorConstructor = Error;
+  function setErrorClass(ec) {
+    errorConstructor = ec ?? Error;
+  }
+  Assert2.setErrorClass = setErrorClass;
+  function throwError(errorMsg, userMsg) {
+    throw new errorConstructor("Assertion Error: " + errorMsg + (userMsg ? " " + userMsg : ""));
+  }
+  function is_int(a) {
+    return typeof a === "number" && isFinite(a) && a === Math.trunc(a);
+  }
+  function is_number(a) {
+    return typeof a === "number";
+  }
+  function assert(a, userMsg) {
+    if (!a) {
+      throwError(userMsg ?? "Assertion failed!");
+    }
+  }
+  Assert2.assert = assert;
+  function assertEnum(value, enumObj, name = "value") {
+    if (!getEnumValues(enumObj).some((v) => v === value)) {
+      throw new TypeError(`Invalid ${name} enum value: ${value}`);
+    }
+  }
+  Assert2.assertEnum = assertEnum;
+  function interrupt(userMsg) {
+    throwError(userMsg ?? "Interrupted!");
+  }
+  Assert2.interrupt = interrupt;
+  function int(a, userMsg) {
+    if (!is_int(a)) {
+      throwError(`Expected ${a} to be integer.`, userMsg);
+    }
+    return a;
+  }
+  Assert2.int = int;
+  function eq(a, b, userMsg) {
+    if (a !== b) {
+      throwError(`Expected ${a} to equal ${b}.`, userMsg);
+    }
+    return a;
+  }
+  Assert2.eq = eq;
+  function int_eq(a, b, userMsg) {
+    if (!(is_int(a) && is_number(b) && a === b)) {
+      throwError(`Expected ${a} to be integer equal to ${b}.`, userMsg);
+    }
+    return a;
+  }
+  Assert2.int_eq = int_eq;
+  function int_lt(a, b, userMsg) {
+    if (!(is_int(a) && is_number(b) && a < b)) {
+      throwError(`Expected ${a} to be integer less than ${b}.`, userMsg);
+    }
+    return a;
+  }
+  Assert2.int_lt = int_lt;
+  function int_lte(a, b, userMsg) {
+    if (!(is_int(a) && is_number(b) && a <= b)) {
+      throwError(`Expected ${a} to be integer less than or equal to ${b}.`, userMsg);
+    }
+    return a;
+  }
+  Assert2.int_lte = int_lte;
+  function int_gt(a, b, userMsg) {
+    if (!(is_int(a) && is_number(b) && a > b)) {
+      throwError(`Expected ${a} to be integer greater than ${b}.`, userMsg);
+    }
+    return a;
+  }
+  Assert2.int_gt = int_gt;
+  function int_gte(a, b, userMsg) {
+    if (!(is_int(a) && is_number(b) && a >= b)) {
+      throwError(`Expected ${a} to be integer greater than or equal to ${b}.`, userMsg);
+    }
+    return a;
+  }
+  Assert2.int_gte = int_gte;
+  function int_between(a, min, max, userMsg) {
+    if (!(is_int(a) && is_number(min) && is_number(max) && a >= min && a <= max)) {
+      throwError(`Expected ${a} to be integer between ${min} and ${max}.`, userMsg);
+    }
+    return a;
+  }
+  Assert2.int_between = int_between;
+  function odd(a, userMsg) {
+    if (!(is_int(a) && a % 2 === 1)) {
+      throwError(`Expected ${a} to be odd number.`, userMsg);
+    }
+    return a;
+  }
+  Assert2.odd = odd;
+  function even(a, userMsg) {
+    if (!(is_int(a) && a % 2 === 0)) {
+      throwError(`Expected ${a} to be even number.`, userMsg);
+    }
+    return a;
+  }
+  Assert2.even = even;
+  function in_group(a, group, userMsg) {
+    if (!group.some((e) => e === a)) {
+      let strGroup = group.map((v) => String(v)).join(", ");
+      throwError(`Expected ${a} to be in group [${strGroup}].`, userMsg);
+    }
+    return a;
+  }
+  Assert2.in_group = in_group;
+  function finite(a, userMsg) {
+    if (!(is_number(a) && isFinite(a))) {
+      throwError(`Expected ${a} to be finite number.`, userMsg);
+    }
+    return a;
+  }
+  Assert2.finite = finite;
+  function array_id(arr, id, userMsg) {
+    if (!(is_int(id) && id >= 0 && id < arr.length)) {
+      throwError(`Expected ${id} to be array index in bounds [0..${arr.length - 1}].`, userMsg);
+    }
+    return id;
+  }
+  Assert2.array_id = array_id;
+  function array_elem(arr, id, userMsg) {
+    return arr[array_id(arr, id, userMsg)];
+  }
+  Assert2.array_elem = array_elem;
+  function require2(arg, userMsg) {
+    if (arg === void 0) {
+      throwError("Required value is undefined.", userMsg);
+    } else {
+      return arg;
+    }
+  }
+  Assert2.require = require2;
+})(Assert || (Assert = {}));
+
+// src/modules/device.ts
+var Device;
+((Device2) => {
+  function getDPI() {
+    let el = document.createElement("div");
+    el.style.width = "1in";
+    document.body.appendChild(el);
+    let dpi = el.offsetWidth;
+    el.remove();
+    return dpi || 96;
+  }
+  function getScrollBarWidth() {
+    try {
+      let outer = document.createElement("div");
+      outer.style.visibility = "hidden";
+      outer.style.width = "100px";
+      document.body.appendChild(outer);
+      let widthNoScroll = outer.offsetWidth;
+      outer.style.overflow = "scroll";
+      let inner = document.createElement("div");
+      inner.style.width = "100%";
+      outer.appendChild(inner);
+      let widthWithScroll = inner.offsetWidth;
+      if (outer.parentNode) {
+        outer.parentNode.removeChild(outer);
+      }
+      return widthNoScroll - widthWithScroll;
+    } catch (e) {
+      return 0;
+    }
+  }
+  function getSystemFontSize() {
+    let tmpDiv = document.createElement("div");
+    tmpDiv.style.cssText = "display:inline-block; padding:0; line-height:1; position:absolute; visibility:hidden; font-size:1em";
+    tmpDiv.appendChild(document.createTextNode("M"));
+    document.body.appendChild(tmpDiv);
+    let fontsize = tmpDiv.offsetHeight;
+    document.body.removeChild(tmpDiv);
+    return fontsize;
+  }
+  function getIsTouchDevice() {
+    if ("ontouchstart" in window || "DocumentTouch" in window || "createTouch" in document && "createTouchList" in document) {
+      return true;
+    }
+    var prefixes = " -webkit- -moz- -o- -ms- ".split(" ");
+    var mq = function(query2) {
+      return window.matchMedia(query2).matches;
+    };
+    var query = ["(", prefixes.join("touch-enabled),("), "heartz", ")"].join("");
+    return mq(query);
+  }
+  function getIsMobileDevice() {
+    let a = navigator.userAgent || navigator.vendor || window.opera;
+    return /(android|bb\d+|meego).+mobile|avantgo|bada\/|blackberry|blazer|compal|elaine|fennec|hiptop|iemobile|ip(hone|od)|iris|kindle|lge |maemo|midp|mmp|mobile.+firefox|netfront|opera m(ob|in)i|palm( os)?|phone|p(ixi|re)\/|plucker|pocket|psp|series(4|6)0|symbian|treo|up\.(browser|link)|vodafone|wap|windows ce|xda|xiino/i.test(a) || /1207|6310|6590|3gso|4thp|50[1-6]i|770s|802s|a wa|abac|ac(er|oo|s\-)|ai(ko|rn)|al(av|ca|co)|amoi|an(ex|ny|yw)|aptu|ar(ch|go)|as(te|us)|attw|au(di|\-m|r |s )|avan|be(ck|ll|nq)|bi(lb|rd)|bl(ac|az)|br(e|v)w|bumb|bw\-(n|u)|c55\/|capi|ccwa|cdm\-|cell|chtm|cldc|cmd\-|co(mp|nd)|craw|da(it|ll|ng)|dbte|dc\-s|devi|dica|dmob|do(c|p)o|ds(12|\-d)|el(49|ai)|em(l2|ul)|er(ic|k0)|esl8|ez([4-7]0|os|wa|ze)|fetc|fly(\-|_)|g1 u|g560|gene|gf\-5|g\-mo|go(\.w|od)|gr(ad|un)|haie|hcit|hd\-(m|p|t)|hei\-|hi(pt|ta)|hp( i|ip)|hs\-c|ht(c(\-| |_|a|g|p|s|t)|tp)|hu(aw|tc)|i\-(20|go|ma)|i230|iac( |\-|\/)|ibro|idea|ig01|ikom|im1k|inno|ipaq|iris|ja(t|v)a|jbro|jemu|jigs|kddi|keji|kgt( |\/)|klon|kpt |kwc\-|kyo(c|k)|le(no|xi)|lg( g|\/(k|l|u)|50|54|\-[a-w])|libw|lynx|m1\-w|m3ga|m50\/|ma(te|ui|xo)|mc(01|21|ca)|m\-cr|me(rc|ri)|mi(o8|oa|ts)|mmef|mo(01|02|bi|de|do|t(\-| |o|v)|zz)|mt(50|p1|v )|mwbp|mywa|n10[0-2]|n20[2-3]|n30(0|2)|n50(0|2|5)|n7(0(0|1)|10)|ne((c|m)\-|on|tf|wf|wg|wt)|nok(6|i)|nzph|o2im|op(ti|wv)|oran|owg1|p800|pan(a|d|t)|pdxg|pg(13|\-([1-8]|c))|phil|pire|pl(ay|uc)|pn\-2|po(ck|rt|se)|prox|psio|pt\-g|qa\-a|qc(07|12|21|32|60|\-[2-7]|i\-)|qtek|r380|r600|raks|rim9|ro(ve|zo)|s55\/|sa(ge|ma|mm|ms|ny|va)|sc(01|h\-|oo|p\-)|sdk\/|se(c(\-|0|1)|47|mc|nd|ri)|sgh\-|shar|sie(\-|m)|sk\-0|sl(45|id)|sm(al|ar|b3|it|t5)|so(ft|ny)|sp(01|h\-|v\-|v )|sy(01|mb)|t2(18|50)|t6(00|10|18)|ta(gt|lk)|tcl\-|tdg\-|tel(i|m)|tim\-|t\-mo|to(pl|sh)|ts(70|m\-|m3|m5)|tx\-9|up(\.b|g1|si)|utst|v400|v750|veri|vi(rg|te)|vk(40|5[0-3]|\-v)|vm40|voda|vulc|vx(52|53|60|61|70|80|81|83|85|98)|w3c(\-| )|webc|whit|wi(g |nc|nw)|wmlb|wonu|x700|yas\-|your|zeto|zte\-/i.test(a.substr(0, 4));
+  }
+  function getHostAddress() {
+    return location.protocol + "//" + location.host;
+  }
+  const UnitRegExp = /^(mm|cm|in|inch|px|em)$/;
+  const ValueUnitRegExp = /^([0-9\\.]+)(.*)$/;
+  Device2.DPI = getDPI();
+  Device2.PxPerMm = Device2.DPI / 25.4;
+  Device2.ScrollbarWidth = getScrollBarWidth();
+  Device2.FontSize = getSystemFontSize();
+  Device2.IsTouchDevice = getIsTouchDevice();
+  Device2.IsMobileDevice = getIsMobileDevice();
+  Device2.HostAddress = getHostAddress();
+  function pxToMm(px) {
+    return px / Device2.PxPerMm;
+  }
+  Device2.pxToMm = pxToMm;
+  function mmToPx(mm) {
+    return mm * Device2.PxPerMm;
+  }
+  Device2.mmToPx = mmToPx;
+  function toPx2(input) {
+    if (typeof input === "number") {
+      return input;
+    }
+    let value = NaN;
+    let unit = void 0;
+    let match = input.toString().match(ValueUnitRegExp);
+    if (match && match[1]) {
+      value = parseFloat(match[1]);
+      let unitStr = match[2] ? match[2].toLowerCase() : "undefined";
+      let unitStrOk = UnitRegExp.test(unitStr);
+      unit = unitStrOk ? unitStr : void 0;
+      if (!unit) {
+        console.log("Unknown unit '" + unitStr + "' => using 'px'.");
+      }
+    } else {
+      value = parseFloat(input);
+    }
+    Assert.finite(value, "value in function toPx");
+    switch (unit) {
+      case "mm":
+        return mmToPx(value);
+      case "cm":
+        return mmToPx(value) * 10;
+      case "in":
+      case "inch":
+        return mmToPx(value) * 25.4;
+      case "em":
+        return Device2.FontSize * value;
+      default:
+      case "px":
+        return value;
+    }
+  }
+  Device2.toPx = toPx2;
+})(Device || (Device = {}));
+
+// src/utils/dom/index.ts
+function toPx(value) {
+  return value === void 0 ? void 0 : Device.toPx(value);
+}
+function hasClass(el, className) {
+  if (className.length === 0) {
+    return false;
+  } else if (el.classList) {
+    return el.classList.contains(className);
+  } else {
+    return !!el.className.match(new RegExp("(\\s|^)" + className + "(\\s|$)"));
+  }
+}
+function addClass(el, className) {
+  if (className.length === 0) {
+    return;
+  } else if (el.classList) {
+    el.classList.add(className);
+  } else if (!hasClass(el, className)) {
+    el.className += " " + className;
+  }
+}
+function removeClass(el, className) {
+  if (className.length === 0) {
+    return;
+  } else if (el.classList) {
+    el.classList.remove(className);
+  } else if (hasClass(el, className)) {
+    var reg = new RegExp("(\\s|^)" + className + "(\\s|$)");
+    el.className = el.className.replace(reg, " ");
+  }
+}
+function setOffset(el, left, top, unit = "px") {
+  el.style.left = left + unit;
+  el.style.top = top + unit;
+}
+function getOffset(el) {
+  let box = el.getBoundingClientRect();
+  let docElem = document.documentElement;
+  return {
+    top: box.top + window.pageYOffset - docElem.clientTop,
+    left: box.left + window.pageXOffset - docElem.clientLeft
+  };
+}
+function getWidth(el) {
+  if (el instanceof Window) {
+    return el.innerWidth;
+  } else {
+    let w = parseFloat(getComputedStyle(el, null).width.replace("px", ""));
+    return isNaN(w) ? 0 : w;
+  }
+}
+function setWidth(el, val) {
+  el.style.width = val + "px";
+}
+function getHeight(el) {
+  if (el instanceof Window) {
+    return el.innerHeight;
+  } else {
+    let h = parseFloat(getComputedStyle(el, null).height.replace("px", ""));
+    return isNaN(h) ? 0 : h;
+  }
+}
+function setHeight(el, val) {
+  el.style.height = val + "px";
+}
+function appendTo(el, to) {
+  to.appendChild(el);
+}
+function removeFromParent(el) {
+  el.remove();
+}
+function setVisibility(el, visible) {
+  el.style.display = visible ? "block" : "none";
+}
+function setRect(el, left, top, width, height, unit = "px") {
+  el.style.left = left + unit;
+  el.style.top = top + unit;
+  el.style.width = width + unit;
+  el.style.height = height + unit;
+}
+function getButton(btn) {
+  let el = typeof btn === "string" ? document.getElementById(btn) : btn;
+  return el instanceof HTMLButtonElement ? el : void 0;
+}
+function getCanvas(canvas2) {
+  let el = typeof canvas2 === "string" ? document.getElementById(canvas2) : canvas2;
+  return el instanceof HTMLCanvasElement ? el : void 0;
+}
+function getPadding(style) {
+  if (!style) {
+    return { top: 0, right: 0, bottom: 0, left: 0 };
+  }
+  let top = toPx(style.paddingTop);
+  let right = toPx(style.paddingRight);
+  let bottom = toPx(style.paddingBottom);
+  let left = toPx(style.paddingLeft);
+  let padding = (style.padding ?? "").toString().split(" ").filter((s) => s.length > 0);
+  switch (padding.length) {
+    case 0:
+      break;
+    case 1:
+      top ?? (top = toPx(padding[0]));
+      right ?? (right = toPx(padding[0]));
+      bottom ?? (bottom = toPx(padding[0]));
+      left ?? (left = toPx(padding[0]));
+      break;
+    case 2:
+      top ?? (top = toPx(padding[0]));
+      right ?? (right = toPx(padding[1]));
+      bottom ?? (bottom = toPx(padding[0]));
+      left ?? (left = toPx(padding[1]));
+      break;
+    case 3:
+      top ?? (top = toPx(padding[0]));
+      right ?? (right = toPx(padding[1]));
+      bottom ?? (bottom = toPx(padding[2]));
+      left ?? (left = toPx(padding[1]));
+      break;
+    case 4:
+    default:
+      top ?? (top = toPx(padding[0]));
+      right ?? (right = toPx(padding[1]));
+      bottom ?? (bottom = toPx(padding[2]));
+      left ?? (left = toPx(padding[3]));
+      break;
+  }
+  top ?? (top = 0);
+  right ?? (right = 0);
+  bottom ?? (bottom = 0);
+  left ?? (left = 0);
+  return { top, right, bottom, left };
+}
+function getDimension(style) {
+  let left = toPx(style?.left);
+  let right = toPx(style?.right);
+  let top = toPx(style?.top);
+  let bottom = toPx(style?.bottom);
+  let width = toPx(style?.width);
+  let height = toPx(style?.height);
+  if (width === void 0 && left !== void 0 && right !== void 0) {
+    width = right - left;
+  }
+  if (height === void 0 && top !== void 0 && bottom !== void 0) {
+    height = bottom - top;
+  }
+  return { left, top, width, height };
+}
+function styleLayoutChanged(style1, style2) {
+  if (!style1 && !style2) {
+    return false;
+  } else if (!style1 || !style2) {
+    return true;
+  } else {
+    return style1.left !== style2.left || style1.top !== style2.top || style1.right !== style2.right || style1.bottom !== style2.bottom || style1.width !== style2.width || style1.height !== style2.height;
+  }
+}
+var canvas;
+function getCanvasTextWidth(text, font) {
+  canvas ?? (canvas = document.createElement("canvas"));
+  let ctx = canvas.getContext("2d");
+  if (!ctx) {
+    return 0;
+  }
+  ctx.font = font;
+  return ctx.measureText(text).width;
+}
+
+// src/utils/map/index.ts
+var map_exports = {};
+__export(map_exports, {
+  getMapKeys: () => getMapKeys
+});
+function getMapKeys(map) {
+  let keys = [];
+  map.forEach((value, key) => keys.push(key));
+  return keys;
+}
+
+// src/utils/obj/index.ts
+var obj_exports = {};
+__export(obj_exports, {
+  isObject: () => isObject
+});
+function isObject(value) {
+  return typeof value === "object" && value !== null && !isArray(value);
+}
+
+// src/utils/str/index.ts
+var str_exports = {};
+__export(str_exports, {
+  chunkString: () => chunkString,
+  insertAt: () => insertAt,
+  makeSentenceFromPascal: () => makeSentenceFromPascal,
+  removeAt: () => removeAt,
+  repeatString: () => repeatString,
+  replaceAt: () => replaceAt,
+  toCharArray: () => toCharArray
+});
+function toCharArray(str) {
+  return str.split("");
+}
+function repeatString(repeatString2, repeatCount) {
+  if (!isInteger(repeatCount) || repeatCount < 0) {
+    throw new Error("repeatStr: Invalid repeatCount = " + repeatCount);
+  }
+  return new Array(repeatCount + 1).join(repeatString2);
+}
+function chunkString(str, chunkSize) {
+  if (!isInteger(chunkSize) || chunkSize < 1) {
+    throw new Error("chunckString: Invalid chuckSize = " + chunkSize);
+  }
+  let result = [];
+  for (let i = 0; i < str.length; i += chunkSize) {
+    result.push(str.slice(i, i + chunkSize));
+  }
+  return result;
+}
+function replaceAt(str, pos, removeCount, insert) {
+  if (!isInteger(removeCount) || removeCount < 0) {
+    throw new Error("replaceAt: Invalid removeCount = " + removeCount);
+  } else if (!isInteger(pos) || pos < 0 || pos + removeCount > str.length) {
+    throw new Error("replaceAt: Invalid pos = " + pos + ", removeCount = " + removeCount + ", str.length = " + str.length);
+  } else {
+    return str.substring(0, pos) + insert + str.substring(pos + removeCount);
+  }
+}
+function insertAt(str, pos, insertStr) {
+  return replaceAt(str, pos, 0, insertStr);
+}
+function removeAt(str, pos, removeCount) {
+  return replaceAt(str, pos, removeCount, "");
+}
+function makeSentenceFromPascal(PascalString) {
+  if (PascalString === "") {
+    return "";
+  }
+  let word = PascalString.charAt(0);
+  let sentence = "";
+  const addWord = () => {
+    if (word !== "") {
+      if (sentence === "") {
+        sentence += word.charAt(0).toUpperCase() + word.substring(1);
+      } else {
+        sentence += " " + word;
+      }
+      word = "";
+    }
+  };
+  const isLetterAndCapital = (c) => {
+    return c.toUpperCase() !== c.toLowerCase() && c === c.toUpperCase();
+  };
+  for (let i = 1; i < PascalString.length; i++) {
+    let c = PascalString.charAt(i);
+    if (isLetterAndCapital(c)) {
+      addWord();
+    }
+    word += c.toLowerCase();
+  }
+  addWord();
+  return sentence;
+}
+
+// src/modules/cookies.ts
+var Cookies;
+((Cookies2) => {
+  const ConsentCookieName = "ConsentCookie";
+  let ConsentState;
+  ((ConsentState2) => {
+    ConsentState2["Accept"] = "accept";
+    ConsentState2["Decline"] = "decline";
+  })(ConsentState || (ConsentState = {}));
+  let _consent;
+  let _expires;
+  let str = _read(ConsentCookieName);
+  _consent = str === "accept" /* Accept */ || str === "decline" /* Decline */ ? str : void 0;
+  function setExpireDays(days) {
+    _expires = /* @__PURE__ */ new Date();
+    _expires.setDate(_expires.getDate() + days);
+  }
+  Cookies2.setExpireDays = setExpireDays;
+  function isConsentPending() {
+    return _consent === void 0;
+  }
+  Cookies2.isConsentPending = isConsentPending;
+  function accept() {
+    _consent = "accept" /* Accept */;
+    _save(ConsentCookieName, _consent);
+  }
+  Cookies2.accept = accept;
+  function decline() {
+    _consent = "decline" /* Decline */;
+    _save(ConsentCookieName, _consent);
+  }
+  Cookies2.decline = decline;
+  function _getList() {
+    let s = document.cookie;
+    return s.split(";").map((c) => c.trim());
+  }
+  function _save(name, value) {
+    let cookie = name + "=" + value.toString() + ";sameSite=Lax;";
+    if (_expires) {
+      cookie += "expires=" + _expires.toUTCString() + ";";
+    }
+    document.cookie = cookie;
+    return value;
+  }
+  function _read(name, defaultValue) {
+    let str2 = _getList().find((c) => c.startsWith(name + "="));
+    return str2 === void 0 ? defaultValue : str2.substring(name.length + 1);
+  }
+  function _erase(name) {
+    document.cookie = name + "=;expires=Thu, 01 Jan 1970 00:00:00 UTC;";
+  }
+  function save(name, value) {
+    if (_consent === "accept" /* Accept */) {
+      _save(name, value);
+    }
+    return value;
+  }
+  Cookies2.save = save;
+  function read(name, defaultValue) {
+    if (_consent === "accept" /* Accept */) {
+      return _read(name, defaultValue) || defaultValue;
+    } else {
+      return defaultValue;
+    }
+  }
+  Cookies2.read = read;
+  function readInt(name, defaultValue) {
+    if (_consent === "accept" /* Accept */) {
+      let str2 = _read(name);
+      return str2 === void 0 ? defaultValue : parseInt(str2);
+    } else {
+      return defaultValue;
+    }
+  }
+  Cookies2.readInt = readInt;
+  function readBool(name, defaultValue) {
+    if (_consent === "accept" /* Accept */) {
+      let str2 = _read(name);
+      return str2 === void 0 ? defaultValue : /true|1/i.test(str2);
+    } else {
+      return defaultValue;
+    }
+  }
+  Cookies2.readBool = readBool;
+  function erase(name) {
+    if (_consent === "accept" /* Accept */ || name === ConsentCookieName) {
+      _erase(name);
+    }
+  }
+  Cookies2.erase = erase;
+  function eraseAll() {
+    document.cookie.split(";").forEach((c) => erase(c.trim().split("=")[0]));
+  }
+  Cookies2.eraseAll = eraseAll;
+})(Cookies || (Cookies = {}));
+
+// src/core/stack.ts
+var Stack = class {
+  constructor() {
+    __publicField(this, "list", []);
+  }
+  push(e) {
+    this.list.push(e);
+    return e;
+  }
+  pop() {
+    Assert.int_gt(this.list.length, 0);
+    return this.list.pop();
+  }
+  top() {
+    return Assert.array_elem(this.list, this.list.length - 1, "Stack is empty!");
+  }
+  toArray() {
+    return this.list;
+  }
+  get length() {
+    return this.list.length;
+  }
+  clear() {
+    this.list.length = 0;
+  }
+};
+
+// src/core/vec2.ts
+var Vec2 = class _Vec2 {
+  constructor(x, y) {
+    __publicField(this, "x");
+    __publicField(this, "y");
+    this.x = x ?? 0;
+    this.y = y ?? 0;
+  }
+  length() {
+    return Math.sqrt(this.x * this.x + this.y * this.y);
+  }
+  add(a) {
+    return new _Vec2(this.x + a.x, this.y + a.y);
+  }
+  sub(a) {
+    return new _Vec2(this.x - a.x, this.y - a.y);
+  }
+  mul(a) {
+    return new _Vec2(this.x * a, this.y * a);
+  }
+  div(a) {
+    return new _Vec2(this.x / a, this.y / a);
+  }
+};
+
+// src/core/LRU-cache.ts
+var LRUCache = class {
+  // Maximum key length.
+  constructor(maxSize, maxKeyLength = Infinity) {
+    __publicField(this, "cache");
+    // Stores the actual key-value pairs
+    __publicField(this, "next");
+    // Linked list: points to the next newer key
+    __publicField(this, "prev");
+    // Linked list: points to the previous older key
+    __publicField(this, "head");
+    // The least recently used key (oldest)
+    __publicField(this, "tail");
+    // The most recently used key (newest)
+    __publicField(this, "capacity");
+    // Maximum number of items allowed
+    __publicField(this, "size");
+    // Current number of items
+    __publicField(this, "maxKeyLength");
+    this.cache = /* @__PURE__ */ Object.create(null);
+    this.next = /* @__PURE__ */ Object.create(null);
+    this.prev = /* @__PURE__ */ Object.create(null);
+    this.head = null;
+    this.tail = null;
+    this.capacity = maxSize;
+    this.size = 0;
+    this.maxKeyLength = maxKeyLength;
+  }
+  // Retrieves a value from the cache
+  get(key) {
+    if (key.length > this.maxKeyLength) return void 0;
+    if (this.cache[key] !== void 0) {
+      this.touch(key);
+      return this.cache[key];
+    }
+    return void 0;
+  }
+  set(key, value) {
+    if (key.length > this.maxKeyLength) {
+      return;
+    }
+    if (this.cache[key] !== void 0) {
+      this.cache[key] = value;
+      this.touch(key);
+      return;
+    }
+    if (this.size >= this.capacity) {
+      this.evict();
+    }
+    this.cache[key] = value;
+    this.addToTail(key);
+    this.size++;
+  }
+  // Marks a key as most recently used
+  touch(key) {
+    if (this.tail === key) return;
+    this.removeKey(key);
+    this.addToTail(key);
+  }
+  // Evicts the least recently used item (at the head)
+  evict() {
+    if (this.head !== null) {
+      const oldestKey = this.head;
+      this.removeKey(oldestKey);
+      delete this.cache[oldestKey];
+      this.size--;
+    }
+  }
+  // Removes a key from the linked list
+  removeKey(key) {
+    const prevKey = this.prev[key];
+    const nextKey = this.next[key];
+    if (prevKey !== void 0) {
+      this.next[prevKey] = nextKey;
+    } else {
+      this.head = nextKey ?? null;
+    }
+    if (nextKey !== void 0) {
+      this.prev[nextKey] = prevKey;
+    } else {
+      this.tail = prevKey ?? null;
+    }
+    delete this.prev[key];
+    delete this.next[key];
+  }
+  // Adds a key to the tail (most recently used position)
+  addToTail(key) {
+    if (this.tail !== null) {
+      this.next[this.tail] = key;
+      this.prev[key] = this.tail;
+    } else {
+      this.head = key;
+    }
+    this.tail = key;
+  }
+};
+
+// src/core/small-int-cache.ts
+var SmallIntCache = class {
+  // for keys < 0
+  constructor() {
+    __publicField(this, "pos");
+    // for keys >= 0
+    __publicField(this, "neg");
+    this.pos = [];
+    this.neg = [];
+  }
+  set(key, value) {
+    if (!isInteger(key)) {
+      throw new Error("Key must be an integer");
+    } else if (key >= 0) {
+      this.pos[key] = value;
+    } else {
+      this.neg[-key - 1] = value;
+    }
+  }
+  get(key) {
+    if (!isInteger(key)) {
+      throw new Error("Key must be an integer");
+    } else if (key >= 0) {
+      return this.pos[key];
+    } else {
+      return this.neg[-key - 1];
+    }
+  }
+  has(key) {
+    if (!isInteger(key)) {
+      return false;
+    } else if (key >= 0) {
+      return key in this.pos;
+    } else {
+      return -key - 1 in this.neg;
+    }
+  }
+  delete(key) {
+    if (!isInteger(key)) {
+      return;
+    } else if (key >= 0) {
+      delete this.pos[key];
+    } else {
+      delete this.neg[-key - 1];
+    }
+  }
+  clear() {
+    this.pos = [];
+    this.neg = [];
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Assert,
+  Cookies,
+  Device,
+  LRUCache,
+  SmallIntCache,
+  Stack,
+  Utils,
+  Vec2
+});
+//# sourceMappingURL=index.js.map