@powfix/core-js 0.21.6 → 0.22.0

package/dist/index.cjs

@@ -0,0 +1,1835 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __commonJS = (cb, mod) => function __require() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+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);
+
+// node_modules/deepmerge/dist/cjs.js
+var require_cjs = __commonJS({
+  "node_modules/deepmerge/dist/cjs.js"(exports2, module2) {
+    "use strict";
+    var isMergeableObject = function isMergeableObject2(value) {
+      return isNonNullObject(value) && !isSpecial(value);
+    };
+    function isNonNullObject(value) {
+      return !!value && typeof value === "object";
+    }
+    function isSpecial(value) {
+      var stringValue = Object.prototype.toString.call(value);
+      return stringValue === "[object RegExp]" || stringValue === "[object Date]" || isReactElement(value);
+    }
+    var canUseSymbol = typeof Symbol === "function" && Symbol.for;
+    var REACT_ELEMENT_TYPE = canUseSymbol ? Symbol.for("react.element") : 60103;
+    function isReactElement(value) {
+      return value.$$typeof === REACT_ELEMENT_TYPE;
+    }
+    function emptyTarget(val) {
+      return Array.isArray(val) ? [] : {};
+    }
+    function cloneUnlessOtherwiseSpecified(value, options) {
+      return options.clone !== false && options.isMergeableObject(value) ? deepmerge2(emptyTarget(value), value, options) : value;
+    }
+    function defaultArrayMerge(target, source, options) {
+      return target.concat(source).map(function(element) {
+        return cloneUnlessOtherwiseSpecified(element, options);
+      });
+    }
+    function getMergeFunction(key, options) {
+      if (!options.customMerge) {
+        return deepmerge2;
+      }
+      var customMerge = options.customMerge(key);
+      return typeof customMerge === "function" ? customMerge : deepmerge2;
+    }
+    function getEnumerableOwnPropertySymbols(target) {
+      return Object.getOwnPropertySymbols ? Object.getOwnPropertySymbols(target).filter(function(symbol) {
+        return Object.propertyIsEnumerable.call(target, symbol);
+      }) : [];
+    }
+    function getKeys(target) {
+      return Object.keys(target).concat(getEnumerableOwnPropertySymbols(target));
+    }
+    function propertyIsOnObject(object, property) {
+      try {
+        return property in object;
+      } catch (_) {
+        return false;
+      }
+    }
+    function propertyIsUnsafe(target, key) {
+      return propertyIsOnObject(target, key) && !(Object.hasOwnProperty.call(target, key) && Object.propertyIsEnumerable.call(target, key));
+    }
+    function mergeObject(target, source, options) {
+      var destination = {};
+      if (options.isMergeableObject(target)) {
+        getKeys(target).forEach(function(key) {
+          destination[key] = cloneUnlessOtherwiseSpecified(target[key], options);
+        });
+      }
+      getKeys(source).forEach(function(key) {
+        if (propertyIsUnsafe(target, key)) {
+          return;
+        }
+        if (propertyIsOnObject(target, key) && options.isMergeableObject(source[key])) {
+          destination[key] = getMergeFunction(key, options)(target[key], source[key], options);
+        } else {
+          destination[key] = cloneUnlessOtherwiseSpecified(source[key], options);
+        }
+      });
+      return destination;
+    }
+    function deepmerge2(target, source, options) {
+      options = options || {};
+      options.arrayMerge = options.arrayMerge || defaultArrayMerge;
+      options.isMergeableObject = options.isMergeableObject || isMergeableObject;
+      options.cloneUnlessOtherwiseSpecified = cloneUnlessOtherwiseSpecified;
+      var sourceIsArray = Array.isArray(source);
+      var targetIsArray = Array.isArray(target);
+      var sourceAndTargetTypesMatch = sourceIsArray === targetIsArray;
+      if (!sourceAndTargetTypesMatch) {
+        return cloneUnlessOtherwiseSpecified(source, options);
+      } else if (sourceIsArray) {
+        return options.arrayMerge(target, source, options);
+      } else {
+        return mergeObject(target, source, options);
+      }
+    }
+    deepmerge2.all = function deepmergeAll(array, options) {
+      if (!Array.isArray(array)) {
+        throw new Error("first argument should be an array");
+      }
+      return array.reduce(function(prev, next) {
+        return deepmerge2(prev, next, options);
+      }, {});
+    };
+    var deepmerge_1 = deepmerge2;
+    module2.exports = deepmerge_1;
+  }
+});
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  ArrayUtils: () => ArrayUtils,
+  AxiosUtils: () => AxiosUtils,
+  COORDINATE: () => COORDINATE,
+  CRUD: () => CRUD,
+  Calc: () => Calc,
+  CoordinateUtils: () => CoordinateUtils,
+  DATE: () => DATE,
+  DISTANCE: () => DISTANCE,
+  DURATION: () => DURATION,
+  DateUtils: () => DateUtils,
+  Enum: () => Enum,
+  I18nUtils: () => I18nUtils,
+  JuminNumberUtils: () => JuminNumberUtils,
+  NOT_NULL: () => NOT_NULL,
+  NumberUtils: () => NumberUtils,
+  ObjectIdUtils: () => ObjectIdUtils,
+  Point3Utils: () => Point3Utils,
+  RandomUtils: () => RandomUtils,
+  Sequencer: () => Sequencer,
+  SequencerEvent: () => SequencerEvent,
+  SequencerStatus: () => SequencerStatus,
+  SessionManager: () => SessionManager,
+  StringUtils: () => StringUtils,
+  TimeService: () => TimeService,
+  TryCatch: () => TryCatch,
+  Uint8ArrayUtils: () => Uint8ArrayUtils,
+  UuidUtils: () => UuidUtils,
+  Validator: () => Validator,
+  atob: () => atob,
+  base64Polyfill: () => base64Polyfill,
+  between: () => between,
+  btoa: () => btoa,
+  castArray: () => castArray,
+  circularDistance: () => circularDistance,
+  decodeBase64: () => decodeBase64,
+  encodeBase64: () => encodeBase64,
+  fallbackIfMatch: () => fallbackIfMatch,
+  fallbackIfNull: () => fallbackIfNull,
+  fallbackIfNullish: () => fallbackIfNullish,
+  fallbackIfUndefined: () => fallbackIfUndefined,
+  firstNonNullish: () => firstNonNullish,
+  flatten: () => flatten,
+  parseBoolean: () => parseBoolean,
+  processFirstNonNullish: () => processFirstNonNullish,
+  pureEnum: () => pureEnum,
+  pureEnumKeys: () => pureEnumKeys,
+  pureEnumValues: () => pureEnumValues,
+  sleep: () => sleep,
+  unflatten: () => unflatten
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/shared/constants/COORDINATE.ts
+var COORDINATE = class {
+  static LATITUDE_MIN_LENGTH = 1;
+  static LATITUDE_MAX_LENGTH = 10;
+  static LONGITUDE_MIN_LENGTH = 1;
+  static LONGITUDE_MAX_LENGTH = 11;
+};
+
+// src/shared/constants/CRUD.ts
+var CRUD = /* @__PURE__ */ ((CRUD2) => {
+  CRUD2[CRUD2["CREATE"] = 1] = "CREATE";
+  CRUD2[CRUD2["READ"] = 2] = "READ";
+  CRUD2[CRUD2["UPDATE"] = 3] = "UPDATE";
+  CRUD2[CRUD2["DELETE"] = 4] = "DELETE";
+  return CRUD2;
+})(CRUD || {});
+((CRUD2) => {
+  function toString(crud) {
+    switch (crud) {
+      case 1 /* CREATE */:
+        return "Create";
+      case 2 /* READ */:
+        return "Read";
+      case 3 /* UPDATE */:
+        return "Update";
+      case 4 /* DELETE */:
+        return "Delete";
+      default:
+        throw new Error("Unknown crud: " + crud);
+    }
+  }
+  CRUD2.toString = toString;
+})(CRUD || (CRUD = {}));
+
+// src/shared/constants/DATE.ts
+var DATE = class {
+};
+((DATE2) => {
+  let FORMAT;
+  ((FORMAT2) => {
+    FORMAT2[FORMAT2["UNIX"] = 1] = "UNIX";
+    FORMAT2[FORMAT2["SECONDS"] = 2] = "SECONDS";
+    FORMAT2[FORMAT2["MILLISECONDS"] = 3] = "MILLISECONDS";
+    FORMAT2[FORMAT2["ISO_8601"] = 4] = "ISO_8601";
+  })(FORMAT = DATE2.FORMAT || (DATE2.FORMAT = {}));
+  ((FORMAT2) => {
+    function toString(format) {
+      switch (format) {
+        case 1 /* UNIX */:
+          return "UNIX";
+        case 2 /* SECONDS */:
+          return "SECONDS";
+        case 3 /* MILLISECONDS */:
+          return "MILLISECONDS";
+        case 4 /* ISO_8601 */:
+          return "ISO_8601";
+      }
+    }
+    FORMAT2.toString = toString;
+  })(FORMAT = DATE2.FORMAT || (DATE2.FORMAT = {}));
+})(DATE || (DATE = {}));
+
+// src/shared/constants/DISTANCE.ts
+var DISTANCE = class {
+};
+((DISTANCE2) => {
+  let UNIT;
+  ((UNIT2) => {
+    UNIT2["FEET"] = "FEET";
+    UNIT2["KILOMETERS"] = "KILOMETERS";
+    UNIT2["MILLIMETERS"] = "MILLIMETERS";
+    UNIT2["CENTIMETERS"] = "CENTIMETERS";
+    UNIT2["METERS"] = "METERS";
+    UNIT2["MILES"] = "MILES";
+    UNIT2["YARDS"] = "YARDS";
+  })(UNIT = DISTANCE2.UNIT || (DISTANCE2.UNIT = {}));
+})(DISTANCE || (DISTANCE = {}));
+
+// src/shared/constants/DURATION.ts
+var DURATION = class {
+};
+((DURATION2) => {
+  let UNIT;
+  ((UNIT2) => {
+    UNIT2["NANOSECONDS"] = "NANOSECONDS";
+    UNIT2["MICROSECONDS"] = "MICROSECONDS";
+    UNIT2["MILLISECONDS"] = "MILLISECONDS";
+    UNIT2["SECONDS"] = "SECONDS";
+    UNIT2["MINUTES"] = "MINUTES";
+    UNIT2["HOURS"] = "HOURS";
+    UNIT2["DAYS"] = "DAYS";
+    UNIT2["YEARS"] = "YEARS";
+    UNIT2["DECADES"] = "DECADES";
+    UNIT2["CENTURIES"] = "CENTURIES";
+  })(UNIT = DURATION2.UNIT || (DURATION2.UNIT = {}));
+})(DURATION || (DURATION = {}));
+
+// src/shared/constants/NOT_NULL.ts
+var NOT_NULL = Symbol("!null");
+
+// src/shared/managers/SessionManager.ts
+var import_jwt_decode = require("jwt-decode");
+var import_moment = __toESM(require("moment"), 1);
+var import_eventemitter3 = __toESM(require("eventemitter3"), 1);
+var SessionManager = class _SessionManager extends import_eventemitter3.default {
+  static DEFAULT_AUTHORIZATION_STORAGE_KEY = "AUTHORIZATION";
+  // Service parameters
+  api;
+  storageProvider;
+  constructor(options) {
+    super();
+    this.api = options.api;
+    this.storageProvider = options.storageProvider;
+    console.log("SessionManager initialized", Date.now(), options.api);
+  }
+  get key() {
+    try {
+      if (this.storageProvider.key) {
+        return this.storageProvider.key();
+      }
+    } catch (e) {
+      console.error(e);
+    }
+    return _SessionManager.DEFAULT_AUTHORIZATION_STORAGE_KEY;
+  }
+  async hasAuthorization() {
+    return !!await this.getAuthorization();
+  }
+  async getAuthorization() {
+    return this.storageProvider.get(this.key);
+  }
+  async setAuthorization(authorization) {
+    if (authorization === null) {
+      await this.removeAuthorization();
+      return null;
+    }
+    let nextAuthorization = await (async () => {
+      if (authorization === void 0) {
+        return await this.getAuthorization();
+      }
+      return authorization;
+    })();
+    if (!nextAuthorization) {
+      console.log("nextAuthorization is null or undefined");
+      return null;
+    }
+    try {
+      nextAuthorization = nextAuthorization.replace(/^Bearer\s+/, "");
+      const decoded = (0, import_jwt_decode.jwtDecode)(nextAuthorization);
+      if (!decoded) {
+        console.warn("JWT decode failed");
+        return null;
+      }
+      console.log("Session:JWT decoded");
+      (() => {
+        console.log(" - User", decoded.uuid);
+        console.log(" - IAT", ...(() => {
+          if (!decoded.iat) {
+            return [decoded.iat];
+          }
+          const iat = import_moment.default.unix(decoded.iat);
+          if (!iat.isValid()) {
+            return [decoded.iat];
+          }
+          return [decoded.iat, iat.format(), iat.diff(Date.now(), "days"), "days left"];
+        })());
+        console.log(" - NBF", ...(() => {
+          if (!decoded.nbf) {
+            return [decoded.nbf];
+          }
+          const nbf = import_moment.default.unix(decoded.nbf);
+          if (!nbf.isValid()) {
+            return [decoded.nbf];
+          }
+          return [decoded.nbf, nbf.format(), nbf.diff(Date.now(), "days"), "days left"];
+        })());
+        console.log(" - EXP", ...(() => {
+          if (!decoded.exp) {
+            return [decoded.exp];
+          }
+          const exp = import_moment.default.unix(decoded.exp);
+          if (!exp.isValid()) {
+            return [decoded.exp];
+          }
+          return [decoded.exp, exp.format(), exp.diff(Date.now(), "days"), "days left"];
+        })());
+      })();
+      await this.storageProvider.set(this.key, nextAuthorization);
+      this.api.defaults.headers.common.Authorization = `Bearer ${nextAuthorization}`;
+      this.emit("AUTHORIZATION_CHANGED", nextAuthorization);
+      return nextAuthorization;
+    } catch (e) {
+      console.error(e);
+    }
+    return null;
+  }
+  async removeAuthorization() {
+    delete this.api.defaults.headers.common.Authorization;
+    await this.storageProvider.remove(this.key);
+    this.emit("AUTHORIZATION_CHANGED", null);
+  }
+};
+
+// src/shared/scripts/base64Polyfill.ts
+var import_base_64 = __toESM(require("base-64"), 1);
+var { decode, encode } = import_base_64.default;
+var base64Polyfill = () => {
+  if (!global.btoa) {
+    global.btoa = encode;
+  }
+  if (!global.atob) {
+    global.atob = decode;
+  }
+  console.log("base64-polyfill initialized", Date.now());
+};
+
+// src/shared/services/time/TimeService.ts
+var import_eventemitter32 = __toESM(require("eventemitter3"), 1);
+var LOG_TAG = "TimeService";
+var TimeService = class _TimeService extends import_eventemitter32.default {
+  // Internal
+  syncHandler;
+  offset;
+  syncedAt;
+  // Members
+  syncInterval;
+  clientTimeProvider;
+  serverTimeProvider;
+  static calculateNTPResultOffset(ntpResult) {
+    const { t1, t2, t3, t4 } = ntpResult;
+    return (t2 - t1 + (t3 - t4)) / 2;
+  }
+  constructor(options) {
+    super();
+    this.syncInterval = options?.syncInterval;
+    this.clientTimeProvider = options?.clientTimeProvider;
+    this.serverTimeProvider = options?.serverTimeProvider;
+    this.sync = this.sync.bind(this);
+    this.fetchServerNTPResult = this.fetchServerNTPResult.bind(this);
+  }
+  getOffset(defaultValue) {
+    if (this.offset !== void 0) {
+      return this.offset;
+    }
+    if (defaultValue !== void 0) {
+      return defaultValue;
+    }
+    return void 0;
+  }
+  setOffset(offset) {
+    return this.offset = offset;
+  }
+  getSyncedAt() {
+    return this.syncedAt;
+  }
+  setSyncedAt(syncedAt) {
+    return this.syncedAt = syncedAt;
+  }
+  getSyncInterval() {
+    return this.syncInterval;
+  }
+  setSyncInterval(interval) {
+    this.syncInterval = interval;
+    this.emit("SYNC_INTERVAL_CHANGED", interval);
+    if (this.syncHandler !== void 0) {
+      this.stopSync();
+      this.startSync();
+    }
+  }
+  getClientTimeProvider() {
+    return this.clientTimeProvider;
+  }
+  setClientTimeProvider(provider) {
+    this.clientTimeProvider = provider ?? void 0;
+  }
+  getClientTime() {
+    return this.getClientTimeProvider()?.();
+  }
+  getServerTimeProvider() {
+    return this.serverTimeProvider;
+  }
+  setServerTimeProvider(provider) {
+    this.serverTimeProvider = provider ?? void 0;
+  }
+  getServerTime() {
+    const offset = this.getOffset();
+    if (offset == null) {
+      return offset;
+    }
+    const clientTime = this.getClientTime();
+    if (clientTime == null) {
+      return clientTime;
+    }
+    return clientTime + offset;
+  }
+  getTime() {
+    return this.getServerTime() ?? this.getClientTime() ?? Date.now();
+  }
+  async fetchServerNTPResult(t1) {
+    try {
+      const provider = this.getServerTimeProvider();
+      if (typeof provider === "function") {
+        return await provider(t1);
+      }
+    } catch (e) {
+      console.error(e);
+    }
+    return null;
+  }
+  async sync() {
+    try {
+      const requestedAt = Date.now();
+      const serverNtpResult = await this.fetchServerNTPResult(requestedAt);
+      if (serverNtpResult === null) {
+        console.warn(LOG_TAG, "Failed to get server time");
+        return null;
+      }
+      const { t2 } = serverNtpResult;
+      if (isNaN(Number(t2))) {
+        console.error(LOG_TAG, "invalid server time(t2), not a number", t2);
+        return null;
+      }
+      const { t3 } = serverNtpResult;
+      if (isNaN(Number(t3))) {
+        console.error(LOG_TAG, "invalid server time(t2), not a number", t2);
+        return null;
+      }
+      const receivedAt = Date.now();
+      const ntpResult = {
+        t1: requestedAt,
+        t2,
+        t3,
+        t4: receivedAt
+      };
+      const offset = _TimeService.calculateNTPResultOffset(ntpResult);
+      this.setOffset(offset);
+      const syncedAt = Date.now();
+      this.setSyncedAt(syncedAt);
+      this.emit("SYNCED", offset, syncedAt);
+    } catch (e) {
+      console.error(e);
+    }
+    return null;
+  }
+  startSync() {
+    if (this.syncHandler != null) {
+      console.warn("sync is already started");
+      return;
+    }
+    const syncInterval = this.getSyncInterval();
+    if (syncInterval == null || syncInterval <= 0) {
+      console.warn("sync is not started", "syncInterval", syncInterval);
+      return;
+    }
+    this.syncHandler = setInterval(this.sync.bind(this), syncInterval);
+  }
+  stopSync() {
+    if (this.syncHandler != null) {
+      clearInterval(this.syncHandler);
+      this.syncHandler = void 0;
+    }
+  }
+};
+
+// src/shared/utils/global/atob.ts
+var import_base_642 = __toESM(require("base-64"), 1);
+var { decode: decode2 } = import_base_642.default;
+var atob = decode2;
+
+// src/shared/utils/global/btoa.ts
+var import_base_643 = __toESM(require("base-64"), 1);
+var { decode: decode3, encode: encode2 } = import_base_643.default;
+var btoa = encode2;
+
+// src/shared/utils/global/base64.ts
+function encodeBase64(str) {
+  const encoder = new TextEncoder();
+  const bytes = encoder.encode(str);
+  let binary = "";
+  for (const byte of bytes) {
+    binary += String.fromCharCode(byte);
+  }
+  return btoa(binary);
+}
+function decodeBase64(base644) {
+  const binary = atob(base644);
+  const binaryLength = binary.length;
+  const bytes = new Uint8Array(binaryLength);
+  for (let i = 0; i < binaryLength; ++i) {
+    bytes[i] = binary.charCodeAt(i);
+  }
+  const decoder = new TextDecoder("utf-8");
+  return decoder.decode(bytes);
+}
+
+// src/shared/utils/global/between.ts
+var between = (value, from, to) => {
+  return value >= from && value <= to;
+};
+
+// src/shared/utils/global/castArray.ts
+function castArray(value) {
+  return Array.isArray(value) ? value : [value];
+}
+
+// src/shared/utils/global/circularDistance.ts
+function circularDistance(value, target, min, max) {
+  const range = max - min;
+  const from = value - min;
+  const to = target - min;
+  if (to >= from) {
+    return to - from;
+  } else {
+    return range - from + to;
+  }
+}
+
+// src/shared/utils/global/sleep.ts
+var sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+
+// src/shared/utils/global/fallbackIfMatch.ts
+function fallbackIfMatch(value, condition, fallback) {
+  if (typeof value === typeof condition && value === condition) {
+    return fallback;
+  }
+  return value;
+}
+
+// src/shared/utils/global/fallbackIfNull.ts
+function fallbackIfNull(value, fallback) {
+  return fallbackIfMatch(value, null, fallback);
+}
+
+// src/shared/utils/global/fallbackIfNullish.ts
+function fallbackIfNullish(value, fallback) {
+  if (value == null) {
+    return fallback;
+  }
+  return value;
+}
+
+// src/shared/utils/global/fallbackIfUndefined.ts
+function fallbackIfUndefined(value, fallback) {
+  return fallbackIfMatch(value, void 0, fallback);
+}
+
+// src/shared/utils/global/firstNonNullish.ts
+function firstNonNullish(...args) {
+  if (args == null || !Array.isArray(args) || args.length === 0) {
+    return void 0;
+  }
+  if (args[0] != null) {
+    return args[0];
+  }
+  return firstNonNullish(...args.slice(1));
+}
+
+// src/shared/utils/global/flat.ts
+function isBuffer(obj) {
+  return !!(obj && obj.constructor && typeof obj.constructor.isBuffer === "function" && obj.constructor.isBuffer(obj));
+}
+function keyIdentity(key) {
+  return key;
+}
+function flatten(target, opts = {}) {
+  const delimiter = opts.delimiter || ".";
+  const maxDepth = opts.maxDepth;
+  const transformKey = opts.transformKey || keyIdentity;
+  const output = {};
+  function step(object, prev, currentDepth = 1) {
+    Object.keys(object).forEach((key) => {
+      const value = object[key];
+      const isarray = opts.safe && Array.isArray(value);
+      const type = Object.prototype.toString.call(value);
+      const isbuffer = isBuffer(value);
+      const isobject = type === "[object Object]" || type === "[object Array]";
+      const newKey = prev ? `${prev}${delimiter}${transformKey(key)}` : transformKey(key);
+      if (!isarray && !isbuffer && isobject && Object.keys(value).length && (!maxDepth || currentDepth < maxDepth)) {
+        return step(value, newKey, currentDepth + 1);
+      }
+      output[newKey] = value;
+    });
+  }
+  step(target);
+  return output;
+}
+function unflatten(target, opts = {}) {
+  const delimiter = opts.delimiter || ".";
+  const overwrite = opts.overwrite || false;
+  const transformKey = opts.transformKey || keyIdentity;
+  const result = {};
+  if (isBuffer(target) || Object.prototype.toString.call(target) !== "[object Object]") {
+    return target;
+  }
+  function getkey(key) {
+    const parsedKey = Number(key);
+    return isNaN(parsedKey) || key.indexOf(".") !== -1 || opts.object ? key : parsedKey;
+  }
+  function addKeys(keyPrefix, recipient, target3) {
+    return Object.keys(target3).reduce((res, key) => {
+      res[`${keyPrefix}${delimiter}${key}`] = target3[key];
+      return res;
+    }, recipient);
+  }
+  function isEmpty(val) {
+    const type = Object.prototype.toString.call(val);
+    const isArray = type === "[object Array]";
+    const isObject = type === "[object Object]";
+    if (!val) {
+      return true;
+    } else if (isArray) {
+      return !val.length;
+    } else if (isObject) {
+      return !Object.keys(val).length;
+    }
+    return false;
+  }
+  const target2 = Object.keys(target).reduce((res, key) => {
+    const value = target[key];
+    const type = Object.prototype.toString.call(value);
+    const isObject = type === "[object Object]" || type === "[object Array]";
+    if (!isObject || isEmpty(value)) {
+      res[key] = value;
+      return res;
+    } else {
+      return addKeys(key, res, flatten(value, opts));
+    }
+  }, {});
+  Object.keys(target2).forEach((key) => {
+    const split = key.split(delimiter).map(transformKey);
+    let key1 = getkey(split.shift());
+    let key2 = getkey(split[0]);
+    let recipient = result;
+    while (key2 !== void 0) {
+      if (key1 === "__proto__") return;
+      const type = Object.prototype.toString.call(recipient[key1]);
+      const isobject = type === "[object Object]" || type === "[object Array]";
+      if (!overwrite && !isobject && typeof recipient[key1] !== "undefined") {
+        return;
+      }
+      if (overwrite && !isobject || !overwrite && recipient[key1] == null) {
+        recipient[key1] = typeof key2 === "number" && !opts.object ? [] : {};
+      }
+      recipient = recipient[key1];
+      if (split.length > 0) {
+        key1 = getkey(split.shift());
+        key2 = getkey(split[0]);
+      }
+    }
+    recipient[key1] = unflatten(target2[key], opts);
+  });
+  return result;
+}
+
+// src/shared/utils/global/processFirstNonNullish.ts
+function processFirstNonNullish(processor, ...args) {
+  const fallback = firstNonNullish(...args);
+  if (fallback == null) {
+    return void 0;
+  }
+  return processor(fallback);
+}
+
+// src/shared/utils/global/pureEnum.ts
+function pureEnum(e) {
+  return Object.entries(e).filter(([key, value]) => !/^-?\d+$/g.test(key) && typeof value !== "function");
+}
+function pureEnumKeys(e) {
+  return pureEnum(e).map(([key]) => key);
+}
+function pureEnumValues(e) {
+  return pureEnum(e).map(([, value]) => value);
+}
+
+// src/shared/utils/ArrayUtils.ts
+var ArrayUtils = class {
+  static castArray(value) {
+    return castArray(value);
+  }
+  /**
+   * 객체를 요소로 가지는 배열에서 가장 큰 값(Property)를 가지는 객체를 반환한다
+   * @param e 객체 배열
+   * @param key 값을 비교할 Property 키
+   */
+  static getGreatestObject(e, key) {
+    return e.reduce((prev, current) => prev[key] > current[key] ? prev : current);
+  }
+  static removeDuplicate(arr) {
+    return [...new Set(arr)];
+  }
+  static removeObjectDuplicate(arr, key) {
+    return arr.filter((v, i, self) => i === self.findIndex((e) => e[key] === v[key]));
+  }
+  static allValuesEqual(...values) {
+    if (values.length === 0) {
+      return true;
+    }
+    return values.every((value) => value === values[0]);
+  }
+};
+
+// src/shared/utils/AxiosUtils.ts
+var AxiosUtils = class {
+  static headerValue2String(value) {
+    if (value === void 0) {
+      return null;
+    }
+    if (value === null || typeof value === "string") {
+      return value;
+    }
+    if (Array.isArray(value)) {
+      if (value.length > 0) {
+        for (const e of value) {
+          if (typeof e === "string") {
+            return e;
+          }
+        }
+        return null;
+      } else {
+        return null;
+      }
+    }
+    return String(value);
+  }
+  static headerValue2Number(value) {
+    if (value === void 0) {
+      return null;
+    }
+    if (value === null || typeof value === "number") {
+      return value;
+    }
+    if (Array.isArray(value)) {
+      if (value.length > 0) {
+        for (const e of value) {
+          if (typeof e === "number") {
+            return e;
+          }
+        }
+        return null;
+      } else {
+        return null;
+      }
+    }
+    const result = Number(value);
+    return isNaN(result) ? null : result;
+  }
+};
+
+// src/shared/utils/StringUtils.ts
+var StringUtils = class {
+  static numberWithCommas(x) {
+    return x.toString().replace(/\B(?=(\d{3})+(?!\d))/g, ",");
+  }
+  static getByte(s) {
+    const getByteLength = (decimal) => {
+      const LINE_FEED = 10;
+      return decimal >> 7 || LINE_FEED === decimal ? 2 : 1;
+    };
+    return s.split("").map((s2) => s2.charCodeAt(0)).reduce((prev, unicodeDecimalValue) => prev + getByteLength(unicodeDecimalValue), 0);
+  }
+  static levenshteinDistance = (str1 = "", str2 = "") => {
+    const track = Array(str2.length + 1).fill(null).map(() => Array(str1.length + 1).fill(null));
+    for (let i = 0; i <= str1.length; i += 1) {
+      track[0][i] = i;
+    }
+    for (let j = 0; j <= str2.length; j += 1) {
+      track[j][0] = j;
+    }
+    for (let j = 1; j <= str2.length; j += 1) {
+      for (let i = 1; i <= str1.length; i += 1) {
+        const indicator = str1[i - 1] === str2[j - 1] ? 0 : 1;
+        track[j][i] = Math.min(
+          track[j][i - 1] + 1,
+          // deletion
+          track[j - 1][i] + 1,
+          // insertion
+          track[j - 1][i - 1] + indicator
+          // substitution
+        );
+      }
+    }
+    return track[str2.length][str1.length];
+  };
+};
+
+// src/shared/utils/Uint8ArrayUtils.ts
+var Uint8ArrayUtils = class {
+  static fromHex(hex) {
+    return Uint8Array.from(hex.match(/.{1,2}/g)?.map((byte) => parseInt(byte, 16)) ?? []);
+  }
+  static toHex(bytes) {
+    return bytes.reduce((str, byte) => str + byte.toString(16).padStart(2, "0"), "");
+  }
+};
+
+// src/shared/utils/UuidUtils.ts
+var uuid = __toESM(require("uuid"), 1);
+var UuidUtils = class _UuidUtils {
+  static v4() {
+    return uuid.v4();
+  }
+  static format(uuid2) {
+    if (uuid2.length === 32) {
+      return `${uuid2.substring(0, 8)}-${uuid2.substring(8, 12)}-${uuid2.substring(12, 16)}-${uuid2.substring(16, 20)}-${uuid2.substring(20, 32)}`.toLowerCase();
+    } else if (uuid2.length === 36) {
+      return uuid2.toLowerCase();
+    } else {
+      console.warn("Unexpected uuid length", uuid2);
+      return uuid2;
+    }
+  }
+  static toString(binary) {
+    if (!binary) return null;
+    return _UuidUtils.format(Uint8ArrayUtils.toHex(binary));
+  }
+  static toBuffer(uuid2) {
+    if (!uuid2) {
+      return null;
+    }
+    return Buffer.from(uuid2.replace(/-/g, ""), "hex");
+  }
+  static isValidUUID(uuid2) {
+    if (!uuid2) return false;
+    if (typeof uuid2 !== "string") return false;
+    return RegExp(/^[a-fA-F0-9]{8}-[a-fA-F0-9]{4}-[a-fA-F0-9]{4}-[a-fA-F0-9]{4}-[a-fA-F0-9]{12}$/i).test(uuid2);
+  }
+};
+
+// src/shared/utils/BooleanUtils.ts
+function parseBoolean(value, defaultValue) {
+  if (value === void 0 || value === null) return defaultValue;
+  return value === "true" || value === true || (value === 1 || value === "1");
+}
+
+// src/shared/utils/Calc.ts
+var Calc = class {
+  static average(...values) {
+    const length = values.length;
+    if (length === 0) {
+      return NaN;
+    }
+    let sum = 0;
+    for (let i = 0; i < length; ++i) {
+      sum += values[i];
+    }
+    return sum / length;
+  }
+  static median(...values) {
+    const len = values.length;
+    if (len === 0) return NaN;
+    const sorted = values.slice().sort((a, b) => a - b);
+    const mid = len >> 1;
+    return len % 2 === 0 ? (sorted[mid - 1] + sorted[mid]) / 2 : sorted[mid];
+  }
+};
+
+// src/shared/utils/CoordinateUtils.ts
+var CoordinateUtils = class _CoordinateUtils {
+  static isValidLatitude(latitude) {
+    return /^-?([0-8]?[0-9]|90)(\.[0-9]{1,15})$/.test(latitude.toString());
+  }
+  static isValidLongitude(longitude) {
+    return /^-?([0-9]{1,2}|1[0-7][0-9]|180)(\.[0-9]{1,14})$/.test(longitude.toString());
+  }
+  static isValidLatitudeLongitude(latitude, longitude) {
+    return _CoordinateUtils.isValidLatitude(latitude) && _CoordinateUtils.isValidLongitude(longitude);
+  }
+  static isValidCoordinate(coordinate) {
+    return this.isValidLatitudeLongitude(coordinate.latitude, coordinate.longitude);
+  }
+  static crowDistance(...coordinates) {
+    if (coordinates.length <= 2) {
+      const toRad = (value) => value * Math.PI / 180;
+      const c1 = coordinates[0];
+      const c2 = coordinates[1];
+      if (!c1 || !c2) {
+        return 0;
+      }
+      const R = 6371e3;
+      const dLat = toRad(c2.latitude - c1.latitude);
+      const dLon = toRad(c2.longitude - c1.longitude);
+      const lat1 = toRad(c1.latitude);
+      const lat2 = toRad(c2.latitude);
+      const a = Math.sin(dLat / 2) * Math.sin(dLat / 2) + Math.sin(dLon / 2) * Math.sin(dLon / 2) * Math.cos(lat1) * Math.cos(lat2);
+      const c = 2 * Math.atan2(Math.sqrt(a), Math.sqrt(1 - a));
+      return R * c;
+    }
+    let totalDistance = 0;
+    for (let i = 0; i < coordinates.length - 1; ++i) {
+      totalDistance += this.crowDistance(coordinates[i], coordinates[i + 1]);
+    }
+    return totalDistance;
+  }
+};
+
+// src/shared/utils/DateUtils.ts
+var import_moment2 = __toESM(require("moment"), 1);
+var DateUtils = class _DateUtils {
+  static isPositiveInteger(value, strict) {
+    if (strict) {
+      if (typeof value !== "number") {
+        return false;
+      }
+    }
+    if (typeof value === "bigint") {
+      return value >= 0 && value <= Number.MAX_SAFE_INTEGER;
+    }
+    if (typeof value === "number") {
+      if (!Number.isSafeInteger(value)) {
+        return false;
+      }
+      return value >= 0 && value <= Number.MAX_SAFE_INTEGER;
+    }
+    if (typeof value === "string") {
+      if (!/^(0|[1-9]\d*)$/g.test(value)) {
+        return false;
+      }
+      return _DateUtils.isPositiveInteger(Number(value), strict);
+    }
+    return false;
+  }
+  static isMilliseconds(value, strict) {
+    return _DateUtils.isPositiveInteger(value, strict);
+  }
+  static isSeconds(value, strict) {
+    return _DateUtils.isPositiveInteger(value, strict);
+  }
+  static isUnix(value, strict) {
+    return _DateUtils.isSeconds(value, strict);
+  }
+  static isISO8601(value) {
+    if (typeof value !== "string") {
+      return false;
+    }
+    if (!/(Z)|(\+\d{2}:\d{2})$/g.test(value)) {
+      return false;
+    }
+    return !Number.isNaN(new Date(value).getTime());
+  }
+  static isValid(value, format, strict) {
+    if (format === void 0) {
+      return _DateUtils.isSeconds(value, strict) || _DateUtils.isMilliseconds(value, strict) || _DateUtils.isISO8601(value);
+    } else {
+      switch (format) {
+        case DATE.FORMAT.UNIX:
+          return _DateUtils.isUnix(value, strict);
+        case DATE.FORMAT.SECONDS:
+          return _DateUtils.isSeconds(value, strict);
+        case DATE.FORMAT.MILLISECONDS:
+          return _DateUtils.isMilliseconds(value, strict);
+        case DATE.FORMAT.ISO_8601:
+          return _DateUtils.isISO8601(value);
+        default: {
+          throw new Error(`unknown format: ${format}(${DATE.FORMAT.toString(format) ?? "unknown"})`);
+        }
+      }
+    }
+  }
+  static from(value, format, strict) {
+    if (value instanceof Date) {
+      return value;
+    }
+    if (!_DateUtils.isValid(value, format, strict)) {
+      throw new Error("invalid date");
+    }
+    if (format === void 0) {
+      if (_DateUtils.isMilliseconds(value, strict)) {
+        return _DateUtils.from(value, DATE.FORMAT.MILLISECONDS);
+      }
+      if (_DateUtils.isISO8601(value)) {
+        return _DateUtils.from(value, DATE.FORMAT.ISO_8601);
+      }
+      throw new Error(`no option to convert value to date`);
+    }
+    switch (format) {
+      case DATE.FORMAT.UNIX:
+        return new Date(Number(value) * 1e3);
+      case DATE.FORMAT.SECONDS:
+        return new Date(Number(value) * 1e3);
+      case DATE.FORMAT.MILLISECONDS:
+        return new Date(Number(value));
+      case DATE.FORMAT.ISO_8601:
+        return new Date(value);
+      default: {
+        throw new Error(`unknown format: ${format}(${DATE.FORMAT.toString(format) ?? "unknown"})`);
+      }
+    }
+  }
+  static fromUnix(value, strict) {
+    return _DateUtils.from(value, DATE.FORMAT.UNIX, strict);
+  }
+  static fromSeconds(value, strict) {
+    return _DateUtils.from(value, DATE.FORMAT.SECONDS, strict);
+  }
+  static fromMilliseconds(value, strict) {
+    return _DateUtils.from(value, DATE.FORMAT.MILLISECONDS, strict);
+  }
+  static fromISO8601(value) {
+    return _DateUtils.from(value, DATE.FORMAT.ISO_8601);
+  }
+  static relativeDate = (input, base = Date.now()) => {
+    const datetime = import_moment2.default.isMoment(input) ? (0, import_moment2.default)(input.toDate()) : (0, import_moment2.default)(input);
+    if (!datetime.isValid()) {
+      console.error("core-js:DateUtils.relativeDate() datetime is invalid", datetime);
+      return "<INVALID DATE>";
+    }
+    return datetime.from(base);
+  };
+  static setLocale = (language) => {
+    const relativeTime = _DateUtils.getRelativeTimeSpec(language);
+    if (relativeTime !== void 0) {
+      import_moment2.default.updateLocale(language, { relativeTime });
+    }
+    import_moment2.default.locale(language);
+  };
+  static getRelativeTimeSpec = (locale) => {
+    if (locale in _DateUtils.relativeTimeSpecs) {
+      return _DateUtils.relativeTimeSpecs[locale];
+    }
+    return void 0;
+  };
+};
+((DateUtils2) => {
+  DateUtils2.relativeTimeSpecs = {
+    ko: {
+      future: "%s \uD6C4",
+      past: "%s \uC804",
+      s: (number) => `${number}\uCD08`,
+      ss: (number) => `${number}\uCD08`,
+      m: (number) => `${number}\uBD84`,
+      mm: (number) => `${number}\uBD84`,
+      h: (number) => `${number}\uC2DC\uAC04`,
+      hh: (number) => `${number}\uC2DC\uAC04`,
+      d: (number) => `${number}\uC77C`,
+      dd: (number) => `${number}\uC77C`,
+      M: (number) => `${number}\uAC1C\uC6D4`,
+      MM: (number) => `${number}\uAC1C\uC6D4`,
+      y: (number) => `${number}\uB144`,
+      yy: (number) => `${number}\uB144`
+    },
+    en: {
+      future: "in %s",
+      past: "%s ago",
+      s: (number) => number === 1 ? `${number} second` : `${number} seconds`,
+      ss: (number) => `${number} seconds`,
+      m: (number) => number === 1 ? `${number} minute` : `${number} minutes`,
+      mm: (number) => `${number} minutes`,
+      h: (number) => number === 1 ? `${number} hour` : `${number} hours`,
+      hh: (number) => `${number} hours`,
+      d: (number) => number === 1 ? `${number} day` : `${number} days`,
+      dd: (number) => `${number} days`,
+      M: (number) => number === 1 ? `${number} month` : `${number} months`,
+      MM: (number) => `${number} months`,
+      y: (number) => number === 1 ? `${number} year` : `${number} years`,
+      yy: (number) => `${number} years`
+    },
+    ja: {
+      future: "%s\u5F8C",
+      past: "%s\u524D",
+      s: (number) => `${number}\u79D2`,
+      ss: (number) => `${number}\u79D2`,
+      m: (number) => `${number}\u5206`,
+      mm: (number) => `${number}\u5206`,
+      h: (number) => `${number}\u6642`,
+      hh: (number) => `${number}\u6642`,
+      d: (number) => `${number}\u65E5`,
+      dd: (number) => `${number}\u65E5`,
+      M: (number) => `${number}\u6708`,
+      MM: (number) => `${number}\u6708`,
+      y: (number) => `${number}\u5E74`,
+      yy: (number) => `${number}\u5E74`
+    },
+    zh: {
+      future: "%s\u540E",
+      past: "%s\u524D",
+      s: (number) => `${number}\u79D2`,
+      ss: (number) => `${number}\u79D2`,
+      m: (number) => `${number}\u5206\u949F`,
+      mm: (number) => `${number}\u5206\u949F`,
+      h: (number) => `${number}\u4E2A\u5C0F\u65F6`,
+      hh: (number) => `${number}\u4E2A\u5C0F\u65F6`,
+      d: (number) => `${number}\u5929`,
+      dd: (number) => `${number}\u5929`,
+      M: (number) => `${number}\u4E2A\u6708`,
+      MM: (number) => `${number}\u4E2A\u6708`,
+      y: (number) => `${number}\u5E74`,
+      yy: (number) => `${number}\u5E74`
+    },
+    ru: {
+      future: "\u0447\u0435\u0440\u0435\u0437 %s",
+      past: "%s \u043D\u0430\u0437\u0430\u0434",
+      s: (number) => `${number} \u0441\u0435\u043A\u0443\u043D\u0434`,
+      ss: (number) => `${number} \u0441\u0435\u043A\u0443\u043D\u0434`,
+      m: (number) => `${number} \u043C\u0438\u043D\u0443\u0442\u0430`,
+      mm: (number) => `${number} \u043C\u0438\u043D\u0443\u0442`,
+      h: (number) => `${number} \u0447\u0430\u0441`,
+      hh: (number) => `${number} \u0447\u0430\u0441\u043E\u0432`,
+      d: (number) => `${number} \u0434\u0435\u043D\u044C`,
+      dd: (number) => `${number} \u0434\u043D\u0435\u0439`,
+      M: (number) => `${number} \u043C\u0435\u0441\u044F\u0446`,
+      MM: (number) => `${number} \u043C\u0435\u0441\u044F\u0446\u0435\u0432`,
+      y: (number) => `${number} \u0433\u043E\u0434`,
+      yy: (number) => `${number} \u043B\u0435\u0442`
+    },
+    uz: {
+      future: "%sdan keyin",
+      past: "%s avval",
+      s: (number) => `${number} soniya`,
+      ss: (number) => `${number} soniya`,
+      m: (number) => `${number} daqiqa`,
+      mm: (number) => `${number} daqiqa`,
+      h: (number) => `${number} soat`,
+      hh: (number) => `${number} soat`,
+      d: (number) => `${number} kun`,
+      dd: (number) => `${number} kun`,
+      M: (number) => `${number} oy`,
+      MM: (number) => `${number} oy`,
+      y: (number) => `${number} yil`,
+      yy: (number) => `${number} yil`
+    },
+    de: {
+      future: "in %s",
+      past: "vor %s",
+      s: (number) => `${number === 1 ? "einer" : number} Sekunde${number === 1 ? "" : "n"}`,
+      ss: (number) => `${number} Sekunde${number === 1 ? "" : "n"}`,
+      m: (number) => `${number === 1 ? "einer" : number} Minute${number === 1 ? "" : "n"}`,
+      mm: (number) => `${number} Minute${number === 1 ? "" : "n"}`,
+      h: (number) => `${number === 1 ? "einer" : number} Stunde${number === 1 ? "" : "n"}`,
+      hh: (number) => `${number} Stunde${number === 1 ? "" : "n"}`,
+      d: (number) => `${number === 1 ? "einem" : number} Tag${number === 1 ? "" : "en"}`,
+      dd: (number) => `${number} Tag${number === 1 ? "" : "en"}`,
+      M: (number) => `${number === 1 ? "einem" : number} Monat${number === 1 ? "" : "en"}`,
+      MM: (number) => `${number} Monat${number === 1 ? "" : "en"}`,
+      y: (number) => `${number === 1 ? "einem" : number} Jahr${number === 1 ? "" : "en"}`,
+      yy: (number) => `${number} Jahr${number === 1 ? "" : "en"}`
+    },
+    fr: {
+      future: "dans %s",
+      past: "il y a %s",
+      s: (number) => `quelques secondes`,
+      ss: (number) => `${number} secondes`,
+      m: (number) => `une minute`,
+      mm: (number) => `${number} minutes`,
+      h: (number) => `une heure`,
+      hh: (number) => `${number} heures`,
+      d: (number) => `un jour`,
+      dd: (number) => `${number} jours`,
+      M: (number) => `un mois`,
+      MM: (number) => `${number} mois`,
+      y: (number) => `un an`,
+      yy: (number) => `${number} ans`
+    },
+    vi: {
+      future: "sau %s",
+      past: "%s tr\u01B0\u1EDBc",
+      s: (number) => `${number} gi\xE2y`,
+      ss: (number) => `${number} gi\xE2y`,
+      m: (number) => `${number} ph\xFAt`,
+      mm: (number) => `${number} ph\xFAt`,
+      h: (number) => `${number} gi\u1EDD`,
+      hh: (number) => `${number} gi\u1EDD`,
+      d: (number) => `${number} ng\xE0y`,
+      dd: (number) => `${number} ng\xE0y`,
+      M: (number) => `${number} th\xE1ng`,
+      MM: (number) => `${number} th\xE1ng`,
+      y: (number) => `${number} n\u0103m`,
+      yy: (number) => `${number} n\u0103m`
+    },
+    th: {
+      future: "\u0E43\u0E19 %s",
+      past: "%s \u0E17\u0E35\u0E48\u0E41\u0E25\u0E49\u0E27",
+      s: (number) => `${number} \u0E27\u0E34\u0E19\u0E32\u0E17\u0E35`,
+      ss: (number) => `${number} \u0E27\u0E34\u0E19\u0E32\u0E17\u0E35`,
+      m: (number) => `${number} \u0E19\u0E32\u0E17\u0E35`,
+      mm: (number) => `${number} \u0E19\u0E32\u0E17\u0E35`,
+      h: (number) => `${number} \u0E0A\u0E31\u0E48\u0E27\u0E42\u0E21\u0E07`,
+      hh: (number) => `${number} \u0E0A\u0E31\u0E48\u0E27\u0E42\u0E21\u0E07`,
+      d: (number) => `${number} \u0E27\u0E31\u0E19`,
+      dd: (number) => `${number} \u0E27\u0E31\u0E19`,
+      M: (number) => `${number} \u0E40\u0E14\u0E37\u0E2D\u0E19`,
+      MM: (number) => `${number} \u0E40\u0E14\u0E37\u0E2D\u0E19`,
+      y: (number) => `${number} \u0E1B\u0E35`,
+      yy: (number) => `${number} \u0E1B\u0E35`
+    },
+    fil: {
+      future: "sa loob ng %s",
+      past: "%s ang nakalipas",
+      s: (number) => `${number} segundo`,
+      ss: (number) => `${number} segundo`,
+      m: (number) => `${number} minuto`,
+      mm: (number) => `${number} minuto`,
+      h: (number) => `${number} oras`,
+      hh: (number) => `${number} oras`,
+      d: (number) => `${number} araw`,
+      dd: (number) => `${number} araw`,
+      M: (number) => `${number} buwan`,
+      MM: (number) => `${number} buwan`,
+      y: (number) => `${number} taon`,
+      yy: (number) => `${number} taon`
+    }
+  };
+})(DateUtils || (DateUtils = {}));
+
+// src/shared/utils/Enum.ts
+var Enum = class _Enum {
+  static entries(e) {
+    return Object.entries(e).filter(([key, value]) => !/^-?\d+$/g.test(key) && typeof value !== "function");
+  }
+  static keys(e) {
+    return _Enum.entries(e).map(([key]) => key);
+  }
+  static values(e) {
+    return _Enum.entries(e).map(([, value]) => value);
+  }
+  static from(e) {
+    return new _Enum(e);
+  }
+  _e;
+  _entries;
+  _keys;
+  _values;
+  constructor(e) {
+    this._e = e;
+    this._entries = _Enum.entries(e);
+    this._keys = _Enum.keys(e);
+    this._values = _Enum.values(e);
+  }
+  value() {
+    return this._e;
+  }
+  entries() {
+    return this._entries;
+  }
+  keys() {
+    return this._keys;
+  }
+  values() {
+    return this._values;
+  }
+};
+
+// src/shared/utils/I18nUtils.ts
+var import_deepmerge = __toESM(require_cjs(), 1);
+var I18nUtils = class {
+  static mergeResources(...resources) {
+    return resources.reduce((acc, resource) => (0, import_deepmerge.default)(acc, resource), {});
+  }
+};
+
+// src/shared/utils/NumberUtils.ts
+var NumberUtils = class {
+  static formatWithThousandsSeparator(value, separator = ",") {
+    return value.toString().replace(/\B(?=(\d{3})+(?!\d))/g, separator);
+  }
+  static formatBigNumber(value, precision = 2) {
+    const map = [
+      { suffix: "Qi", threshold: 1e18 },
+      { suffix: "Q", threshold: 1e15 },
+      { suffix: "T", threshold: 1e12 },
+      { suffix: "B", threshold: 1e9 },
+      { suffix: "M", threshold: 1e6 },
+      { suffix: "K", threshold: 1e3 },
+      { suffix: "", threshold: 1 }
+    ];
+    const found = map.find((e) => Math.abs(value) >= e.threshold);
+    if (found) {
+      return Number((value / found.threshold).toFixed(precision)) + found.suffix;
+    }
+    return value.toString();
+  }
+};
+
+// src/shared/utils/ObjectIdUtils.ts
+var ObjectIdUtils = class {
+  static toUuid(objectId, pad = "start") {
+    const src = Uint8ArrayUtils.fromHex(objectId);
+    if (src.length !== 12) {
+      throw new Error(`objectId must be 12 bytes (24 hex), got ${src.length} bytes`);
+    }
+    const result = new Uint8Array(16);
+    const offset = pad === "start" ? 4 : 0;
+    result.set(src, offset);
+    return UuidUtils.toString(result);
+  }
+  static fromUuid(uuid2, pad) {
+    const buffer = UuidUtils.toBuffer(uuid2);
+    const isPadEnd = buffer.subarray(buffer.length - 4).every((byte) => byte === 0);
+    if (isPadEnd || pad === "end") {
+      return buffer.subarray(0, buffer.length - 4).toString("hex");
+    }
+    const isPadStart = buffer.subarray(0, 4).every((byte) => byte === 0);
+    if (!isPadStart) {
+      console.warn("buffer is not pad start and pad end");
+    }
+    return buffer.subarray(4).toString("hex");
+  }
+};
+
+// src/shared/utils/Point3Utils.ts
+var Point3Utils = class {
+  static distance(p1, p2) {
+    const dx = p1.x - p2.x;
+    const dy = p1.y - p2.y;
+    const dz = p1.z - p2.z;
+    return Math.sqrt(dx * dx + dy * dy + dz * dz);
+  }
+};
+
+// src/shared/utils/RandomUtils.ts
+var RandomUtils = class _RandomUtils {
+  static randomNumber(min, max) {
+    min = Math.ceil(min);
+    max = Math.floor(max);
+    return Math.floor(Math.random() * (max - min + 1) + min);
+  }
+  static randomLatinStrings(length) {
+    const strings = [];
+    for (let i = 0; i < length; ++i) {
+      const isLowerCase = _RandomUtils.randomNumber(0, 1);
+      if (isLowerCase) {
+        strings.push(String.fromCharCode(_RandomUtils.randomNumber(97, 122)));
+      } else {
+        strings.push(String.fromCharCode(_RandomUtils.randomNumber(65, 90)));
+      }
+    }
+    return strings.join("");
+  }
+  static randomLatinLowercaseStrings(length) {
+    const strings = [];
+    for (let i = 0; i < length; ++i) {
+      strings.push(String.fromCharCode(_RandomUtils.randomNumber(97, 122)));
+    }
+    return strings.join("");
+  }
+  static randomLatinUppercaseStrings(length) {
+    const strings = [];
+    for (let i = 0; i < length; ++i) {
+      strings.push(String.fromCharCode(_RandomUtils.randomNumber(65, 90)));
+    }
+    return strings.join("");
+  }
+  static randomNumberStrings(length) {
+    const strings = [];
+    for (let i = 0; i < length; ++i) {
+      strings.push(String.fromCharCode(_RandomUtils.randomNumber(48, 57)));
+    }
+    return strings.join("");
+  }
+  static randomStrings(length) {
+    const strings = [];
+    for (let i = 0; i < length; ++i) {
+      const isNumber = _RandomUtils.randomNumber(0, 1);
+      if (isNumber) {
+        strings.push(String.fromCharCode(_RandomUtils.randomNumber(48, 57)));
+      } else {
+        const isLowerCase = _RandomUtils.randomNumber(0, 1);
+        if (isLowerCase) {
+          strings.push(String.fromCharCode(_RandomUtils.randomNumber(97, 122)));
+        } else {
+          strings.push(String.fromCharCode(_RandomUtils.randomNumber(65, 90)));
+        }
+      }
+    }
+    return strings.join("");
+  }
+};
+
+// src/shared/utils/Validator.ts
+var Validator = class _Validator {
+  static validate(value, options) {
+    value = value || "";
+    const validations = [];
+    const errors = [];
+    const { length } = value;
+    const spaceCount = (value.match(/\s/g) || []).length;
+    const numberCount = (value.match(/\d/g) || []).length;
+    const alphabetCount = (value.match(/[A-Za-z]/g) || []).length;
+    const alphabetLowerCaseCount = (value.match(/[a-z]/g) || []).length;
+    const alphabetUpperCaseCount = (value.match(/[A-Z]/g) || []).length;
+    const specialCount = (value.match(/[~`!@#$%^&*()\-+={[}\]|\\:;"'<,>.?/]/g) || []).length;
+    const startsWithNumber = /^\d/.test(value);
+    const startsWithAlphabet = /^[A-Za-z]/.test(value);
+    const startsWithSpecialCharacter = /^[~`!@#$%^&*()\-+={[}\]|\\:;"'<,>.?/]/.test(value);
+    if (options.minLength !== void 0 && options.minLength > -1) {
+      validations.push(_Validator.VALIDATION.MIN_LENGTH);
+      if (length < options.minLength) {
+        errors.push(_Validator.VALIDATION.MIN_LENGTH);
+      }
+    }
+    if (options.maxLength !== void 0 && options.maxLength > -1) {
+      validations.push(_Validator.VALIDATION.MAX_LENGTH);
+      if (length > options.maxLength) {
+        errors.push(_Validator.VALIDATION.MAX_LENGTH);
+      }
+    }
+    const validateMin = (option, value2, validation) => {
+      if (option !== void 0 && option > -1) {
+        validations.push(validation);
+        if (value2 < option) {
+          errors.push(validation);
+        }
+      }
+    };
+    const validateMax = (option, value2, validation) => {
+      if (option !== void 0 && option > -1) {
+        validations.push(validation);
+        if (value2 > option) {
+          errors.push(validation);
+        }
+      }
+    };
+    validateMin(options.spaceMinCount, spaceCount, _Validator.VALIDATION.SPACE_MIN_COUNT);
+    validateMax(options.spaceMaxCount, spaceCount, _Validator.VALIDATION.SPACE_MAX_COUNT);
+    validateMin(options.numberMinCount, numberCount, _Validator.VALIDATION.NUMBER_MIN_COUNT);
+    validateMax(options.numberMaxCount, numberCount, _Validator.VALIDATION.NUMBER_MAX_COUNT);
+    validateMin(options.alphabetMinCount, alphabetCount, _Validator.VALIDATION.ALPHABET_MIN_COUNT);
+    validateMax(options.alphabetMaxCount, alphabetCount, _Validator.VALIDATION.ALPHABET_MAX_COUNT);
+    validateMin(options.alphabetLowerCaseMinCount, alphabetLowerCaseCount, _Validator.VALIDATION.ALPHABET_LOWER_CASE_MIN_COUNT);
+    validateMax(options.alphabetLowerCaseMaxCount, alphabetLowerCaseCount, _Validator.VALIDATION.ALPHABET_LOWER_CASE_MAX_COUNT);
+    validateMin(options.alphabetUpperCaseMinCount, alphabetUpperCaseCount, _Validator.VALIDATION.ALPHABET_UPPER_CASE_MIN_COUNT);
+    validateMax(options.alphabetUpperCaseMaxCount, alphabetUpperCaseCount, _Validator.VALIDATION.ALPHABET_UPPER_CASE_MAX_COUNT);
+    validateMin(options.specialCharacterMinCount, specialCount, _Validator.VALIDATION.SPECIAL_CHARACTER_MIN_COUNT);
+    validateMax(options.specialCharacterMaxCount, specialCount, _Validator.VALIDATION.SPECIAL_CHARACTER_MAX_COUNT);
+    if (options.startsWithNumber) {
+      validations.push(_Validator.VALIDATION.STARTS_WITH_NUMBER);
+      if (!startsWithNumber) {
+        errors.push(_Validator.VALIDATION.STARTS_WITH_NUMBER);
+      }
+    }
+    if (options.startsWithAlphabet) {
+      validations.push(_Validator.VALIDATION.STARTS_WITH_ALPHABET);
+      if (!startsWithAlphabet) {
+        errors.push(_Validator.VALIDATION.STARTS_WITH_ALPHABET);
+      }
+    }
+    if (options.startsWithSpecialCharacter) {
+      validations.push(_Validator.VALIDATION.STARTS_WITH_SPECIAL_CHARACTER);
+      if (!startsWithSpecialCharacter) {
+        errors.push(_Validator.VALIDATION.STARTS_WITH_SPECIAL_CHARACTER);
+      }
+    }
+    return {
+      result: errors.length === 0,
+      validations,
+      passes: validations.filter((e) => !errors.includes(e)),
+      errors
+    };
+  }
+};
+((Validator2) => {
+  let VALIDATION;
+  ((VALIDATION2) => {
+    VALIDATION2["MIN_LENGTH"] = "MIN_LENGTH";
+    VALIDATION2["MAX_LENGTH"] = "MAX_LENGTH";
+    VALIDATION2["SPACE_MIN_COUNT"] = "SPACE_MIN_COUNT";
+    VALIDATION2["SPACE_MAX_COUNT"] = "SPACE_MAX_COUNT";
+    VALIDATION2["NUMBER_MIN_COUNT"] = "NUMBER_MIN_COUNT";
+    VALIDATION2["NUMBER_MAX_COUNT"] = "NUMBER_MAX_COUNT";
+    VALIDATION2["ALPHABET_MIN_COUNT"] = "ALPHABET_MIN_COUNT";
+    VALIDATION2["ALPHABET_MAX_COUNT"] = "ALPHABET_MAX_COUNT";
+    VALIDATION2["ALPHABET_LOWER_CASE_MIN_COUNT"] = "ALPHABET_LOWER_CASE_MIN_COUNT";
+    VALIDATION2["ALPHABET_LOWER_CASE_MAX_COUNT"] = "ALPHABET_LOWER_CASE_MAX_COUNT";
+    VALIDATION2["ALPHABET_UPPER_CASE_MIN_COUNT"] = "ALPHABET_UPPER_CASE_MIN_COUNT";
+    VALIDATION2["ALPHABET_UPPER_CASE_MAX_COUNT"] = "ALPHABET_UPPER_CASE_MAX_COUNT";
+    VALIDATION2["SPECIAL_CHARACTER_MIN_COUNT"] = "SPECIAL_CHARACTER_MIN_COUNT";
+    VALIDATION2["SPECIAL_CHARACTER_MAX_COUNT"] = "SPECIAL_CHARACTER_MAX_COUNT";
+    VALIDATION2["STARTS_WITH_ALPHABET"] = "STARTS_WITH_ALPHABET";
+    VALIDATION2["STARTS_WITH_NUMBER"] = "STARTS_WITH_NUMBER";
+    VALIDATION2["STARTS_WITH_SPECIAL_CHARACTER"] = "STARTS_WITH_SPECIAL_CHARACTER";
+  })(VALIDATION = Validator2.VALIDATION || (Validator2.VALIDATION = {}));
+})(Validator || (Validator = {}));
+
+// src/shared/utils/JuminNumberUtils.ts
+var JuminNumberUtils = class _JuminNumberUtils {
+  static calculateX(juminNumber) {
+    const replacedJuminNumber = juminNumber.replace(/\D/g, "");
+    if (!between(replacedJuminNumber.length, 12, 13)) {
+      throw new Error("Jumin number length must be 12 to 13(without dash)");
+    }
+    const numbers = replacedJuminNumber.split("").map((e) => parseInt(e, 10));
+    const sum = 2 * numbers[0] + 3 * numbers[1] + 4 * numbers[2] + 5 * numbers[3] + 6 * numbers[4] + 7 * numbers[5] + 8 * numbers[6] + 9 * numbers[7] + 2 * numbers[8] + 3 * numbers[9] + 4 * numbers[10] + 5 * numbers[11];
+    return (11 - sum % 11) % 10;
+  }
+  static isValid(juminNumber) {
+    const replacedJuminNumber = juminNumber.replace(/\D/g, "");
+    if (replacedJuminNumber.length !== 13) {
+      return false;
+    }
+    const TODAY_YEAR = parseInt((/* @__PURE__ */ new Date()).getFullYear().toString().slice(-2), 10);
+    const yearNum = parseInt(replacedJuminNumber.slice(0, 2), 10);
+    const sexNum = replacedJuminNumber.slice(6, 7);
+    if (sexNum === "1" || sexNum === "2") {
+      if (yearNum < TODAY_YEAR) return false;
+    } else if (sexNum === "3" || sexNum === "4") {
+      if (yearNum > TODAY_YEAR) return false;
+    } else return false;
+    const regex = /^\d{2}(0[1-9]|1[0-2])(0[1-9]|[1-2][0-9]|3[0-1])\d{7}$/;
+    if (!regex.test(replacedJuminNumber)) return false;
+    const currentX = parseInt(replacedJuminNumber.slice(-1), 10);
+    const calculatedX = _JuminNumberUtils.calculateX(replacedJuminNumber);
+    if (currentX !== calculatedX) {
+      console.log("Invalid X", currentX, calculatedX);
+      return false;
+    }
+    return true;
+  }
+};
+
+// src/shared/utils/Sequencer.ts
+var import_moment3 = __toESM(require("moment"), 1);
+var import_eventemitter33 = __toESM(require("eventemitter3"), 1);
+var SequencerStatus = /* @__PURE__ */ ((SequencerStatus2) => {
+  SequencerStatus2[SequencerStatus2["IDLE"] = 0] = "IDLE";
+  SequencerStatus2[SequencerStatus2["RUNNING"] = 1] = "RUNNING";
+  SequencerStatus2[SequencerStatus2["ERROR"] = 2] = "ERROR";
+  SequencerStatus2[SequencerStatus2["DONE"] = 3] = "DONE";
+  return SequencerStatus2;
+})(SequencerStatus || {});
+var SequencerEvent = /* @__PURE__ */ ((SequencerEvent2) => {
+  SequencerEvent2["START"] = "START";
+  SequencerEvent2["END"] = "END";
+  SequencerEvent2["SEQUENCE_START"] = "SEQUENCE_START";
+  SequencerEvent2["SEQUENCE_END"] = "SEQUENCE_END";
+  return SequencerEvent2;
+})(SequencerEvent || {});
+var Sequencer = class {
+  sequences = [];
+  status = 0 /* IDLE */;
+  minimumExecutionTime = 0;
+  // Reset variables task is done
+  currentSequence = null;
+  startTimestamp = null;
+  endTimestamp = null;
+  // Emitter
+  eventEmitter = new import_eventemitter33.default();
+  constructor(option) {
+    if (option?.sequences) {
+      this.sequences.push(...option.sequences);
+    }
+  }
+  get getCurrentTimeStamp() {
+    return parseInt((0, import_moment3.default)().format("x"), 10);
+  }
+  get executionTime() {
+    if (this.status === 0 /* IDLE */) {
+      return null;
+    }
+    if (!this.startTimestamp) {
+      return null;
+    }
+    if (this.startTimestamp && this.endTimestamp) {
+      return this.endTimestamp - this.startTimestamp;
+    }
+    return this.getCurrentTimeStamp - this.startTimestamp;
+  }
+  pushSequence = (sequence) => {
+    this.sequences.push(sequence);
+  };
+  start = async () => {
+    if (this.status === 1 /* RUNNING */) {
+      console.warn("Sequencer status is", this.status);
+      return;
+    }
+    this.status = 1 /* RUNNING */;
+    this.currentSequence = null;
+    this.startTimestamp = this.getCurrentTimeStamp;
+    this.endTimestamp = null;
+    console.log(`Sequence started, started at ${this.startTimestamp}, MINIMUM_EXECUTION_TIME is ${this.minimumExecutionTime}`);
+    for (let sequence of this.sequences) {
+      console.log("Currently total execution time", this.executionTime);
+      const sequenceStartTimeStamp = this.getCurrentTimeStamp;
+      this.currentSequence = sequence;
+      this.eventEmitter.emit("SEQUENCE_START" /* SEQUENCE_START */, sequence);
+      try {
+        await new Promise(async (resolve, reject) => {
+          try {
+            console.log(`Sequence ${sequence.key} start`);
+            await sequence.task?.();
+            const sequenceEndTimeStamp = this.getCurrentTimeStamp;
+            const sequenceExecutionTime = sequenceEndTimeStamp - sequenceStartTimeStamp;
+            console.log(`\u2705 Sequence ${sequence.key} done at`, sequenceEndTimeStamp);
+            console.log("Sequence execution time", sequenceExecutionTime, "ms");
+            if (sequence.minimumExecutionTime) {
+              console.log(`Sequence has minimumExecutionTime`, sequence.minimumExecutionTime, "ms");
+              if (sequenceExecutionTime < sequence.minimumExecutionTime) {
+                const delay = sequence.minimumExecutionTime - sequenceExecutionTime;
+                console.log(`Sequence will delay`, delay, "ms");
+                let dotInterpreterBlocked = false;
+                const dotInterpreter = setInterval(() => {
+                  if (dotInterpreterBlocked) {
+                    console.log("!");
+                    return;
+                  }
+                  console.log(".");
+                }, 100);
+                setTimeout(() => {
+                  dotInterpreterBlocked = true;
+                  clearInterval(dotInterpreter);
+                  console.log("done");
+                  resolve();
+                }, delay);
+                return;
+              }
+              console.log("Sequence execution time is greater than minimum execution time");
+              resolve();
+              return;
+            }
+            resolve();
+          } catch (e) {
+            reject(e);
+          }
+        });
+        console.log("Out of Promise");
+        this.eventEmitter.emit("SEQUENCE_END" /* SEQUENCE_END */, sequence);
+      } catch (e) {
+        if (sequence.required) {
+          console.error(`\u{1F6AB} Sequence ${sequence.key} failed`, e);
+          this.status = 2 /* ERROR */;
+          this.currentSequence = null;
+          this.endTimestamp = this.currentSequence;
+          return Promise.reject({
+            sequence,
+            reason: e
+          });
+        }
+        console.log(`Sequence ${sequence.key} failed`, e);
+        this.eventEmitter.emit("SEQUENCE_END" /* SEQUENCE_END */, sequence);
+      }
+    }
+    this.status = 3 /* DONE */;
+    this.currentSequence = null;
+    this.endTimestamp = this.currentSequence;
+  };
+};
+
+// src/shared/utils/try-catch/TryCatch.ts
+var TryCatch = class {
+  /**
+   * Executes a synchronous function within a try-catch block.
+   * @template T The return type of the function.
+   * @template E The type of the error that might be thrown (defaults to Error).
+   * @param fn The synchronous function to execute.
+   *@param disableLogging console.error is default way of logging on error. You can disable it by setting it true
+   * @returns A tuple containing the result of the function and an error (null if successful).
+   */
+  static function(fn, disableLogging) {
+    try {
+      return [
+        null,
+        fn()
+      ];
+    } catch (e) {
+      if (!disableLogging) {
+        console.error("ERROR in TryCatch: ", e);
+      }
+      if (e == null) {
+        e = new Error("Unknown error");
+      }
+      return [
+        e,
+        void 0
+      ];
+    }
+  }
+  /**
+   * Executes an asynchronous function (Promise) within a try-catch block.
+   * @template T The resolved value type of the Promise.
+   * @template E The type of the error that might be rejected (defaults to Error).
+   * @param fn The Promise to await.
+   * @param disableLogging console.error is default way of logging on error. You can disable it by setting it true
+   * @returns A tuple containing the resolved value of the Promise and an error (null if successful).
+   */
+  static async asyncFunction(fn, disableLogging) {
+    try {
+      const data = await fn;
+      return [
+        null,
+        data
+      ];
+    } catch (e) {
+      if (!disableLogging) {
+        console.error("ERROR in TryCatch: ", e);
+      }
+      if (e == null) {
+        e = new Error("Unknown error");
+      }
+      return [
+        e,
+        void 0
+      ];
+    }
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ArrayUtils,
+  AxiosUtils,
+  COORDINATE,
+  CRUD,
+  Calc,
+  CoordinateUtils,
+  DATE,
+  DISTANCE,
+  DURATION,
+  DateUtils,
+  Enum,
+  I18nUtils,
+  JuminNumberUtils,
+  NOT_NULL,
+  NumberUtils,
+  ObjectIdUtils,
+  Point3Utils,
+  RandomUtils,
+  Sequencer,
+  SequencerEvent,
+  SequencerStatus,
+  SessionManager,
+  StringUtils,
+  TimeService,
+  TryCatch,
+  Uint8ArrayUtils,
+  UuidUtils,
+  Validator,
+  atob,
+  base64Polyfill,
+  between,
+  btoa,
+  castArray,
+  circularDistance,
+  decodeBase64,
+  encodeBase64,
+  fallbackIfMatch,
+  fallbackIfNull,
+  fallbackIfNullish,
+  fallbackIfUndefined,
+  firstNonNullish,
+  flatten,
+  parseBoolean,
+  processFirstNonNullish,
+  pureEnum,
+  pureEnumKeys,
+  pureEnumValues,
+  sleep,
+  unflatten
+});