@unikue/ts-lang-utils 1.0.0

package/dist/cjs/util/ObjectUtils/keys.js

@@ -0,0 +1,45 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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 = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/util/ObjectUtils/keys.ts
+var keys_exports = {};
+__export(keys_exports, {
+  keys: () => keys
+});
+module.exports = __toCommonJS(keys_exports);
+var import_isPrototype = require("./isPrototype");
+var import_hasProp = require("./hasProp");
+function keys(object) {
+  if (!object) {
+    return [];
+  }
+  if (!(0, import_isPrototype.isPrototype)(object)) {
+    return Object.keys(object);
+  }
+  const result = [];
+  for (const key in Object(object)) {
+    if (key !== "constructor" && (0, import_hasProp.hasProp)(object, key)) {
+      result.push(key);
+    }
+  }
+  return result;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  keys
+});

package/dist/cjs/util/ObjectUtils/mapEachProp.d.ts

@@ -0,0 +1 @@
+export declare function mapEachProp(object: any, callback?: (key: string, index: number) => any): any[] | undefined;

package/dist/cjs/util/ObjectUtils/mapEachProp.js

@@ -0,0 +1,37 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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 = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/util/ObjectUtils/mapEachProp.ts
+var mapEachProp_exports = {};
+__export(mapEachProp_exports, {
+  mapEachProp: () => mapEachProp
+});
+module.exports = __toCommonJS(mapEachProp_exports);
+var import_isPlain = require("./isPlain");
+function mapEachProp(object, callback) {
+  if (!object || !(0, import_isPlain.isPlain)(object) || !callback) {
+    return void 0;
+  }
+  return Object.keys(object).filter((key) => Object.prototype.hasOwnProperty.call(object, key)).map((key, index) => {
+    return callback(key, index);
+  });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  mapEachProp
+});

package/dist/cjs/util/ObjectUtils/mergeProps.d.ts

@@ -0,0 +1 @@
+export declare function mergeProps(target?: object, source?: object, overrideNil?: boolean): object | undefined;

package/dist/cjs/util/ObjectUtils/mergeProps.js

@@ -0,0 +1,43 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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 = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/util/ObjectUtils/mergeProps.ts
+var mergeProps_exports = {};
+__export(mergeProps_exports, {
+  mergeProps: () => mergeProps
+});
+module.exports = __toCommonJS(mergeProps_exports);
+var import_isPlain = require("./isPlain");
+var import_setProp = require("./setProp");
+function mergeProps(target, source, overrideNil = true) {
+  if (!target || !(0, import_isPlain.isPlain)(target)) {
+    return source;
+  }
+  if (!source || !(0, import_isPlain.isPlain)(source)) {
+    return target;
+  }
+  const attributes = {};
+  Object.entries(source).filter((item) => {
+    return !Object.prototype.hasOwnProperty.call(target, item[0]) || overrideNil && (target[item[0]] === void 0 || target[item[0]] === null);
+  }).forEach((item) => (0, import_setProp.setProp)(attributes, item[0], item[1]));
+  return Object.assign(target, attributes);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  mergeProps
+});

package/dist/cjs/util/ObjectUtils/regenProps.d.ts

@@ -0,0 +1 @@
+export declare function regenProps(object: any, callback?: (key?: string, index?: number) => any): object | undefined;

package/dist/cjs/util/ObjectUtils/regenProps.js

@@ -0,0 +1,40 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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 = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/util/ObjectUtils/regenProps.ts
+var regenProps_exports = {};
+__export(regenProps_exports, {
+  regenProps: () => regenProps
+});
+module.exports = __toCommonJS(regenProps_exports);
+var import_isPlain = require("./isPlain");
+var import_setProp = require("./setProp");
+function regenProps(object, callback) {
+  if (!object || !(0, import_isPlain.isPlain)(object) || !callback) {
+    return object;
+  }
+  const result = {};
+  Object.keys(object).filter((key) => Object.prototype.hasOwnProperty.call(object, key)).forEach((key, index) => {
+    (0, import_setProp.setProp)(result, key, callback(key, index));
+  });
+  return result;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  regenProps
+});

package/dist/cjs/util/ObjectUtils/setProp.d.ts

@@ -0,0 +1 @@
+export declare function setProp(object: any, prop?: string | null, value?: any): void;

package/dist/cjs/util/ObjectUtils/setProp.js

@@ -0,0 +1,34 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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 = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/util/ObjectUtils/setProp.ts
+var setProp_exports = {};
+__export(setProp_exports, {
+  setProp: () => setProp
+});
+module.exports = __toCommonJS(setProp_exports);
+var import_isPlain = require("./isPlain");
+function setProp(object, prop, value) {
+  if ((0, import_isPlain.isPlain)(object) && prop) {
+    object[prop] = value;
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  setProp
+});

package/dist/cjs/util/ObjectUtils/toString.d.ts

@@ -0,0 +1 @@
+export declare function toString(object: any, nil?: string | null): string | null | undefined;

package/dist/cjs/util/ObjectUtils/toString.js

@@ -0,0 +1,31 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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 = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/util/ObjectUtils/toString.ts
+var toString_exports = {};
+__export(toString_exports, {
+  toString: () => toString
+});
+module.exports = __toCommonJS(toString_exports);
+function toString(object, nil) {
+  return object ? object.toString() : nil;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  toString
+});

package/dist/cjs/util/ObjectUtils/toStringTag.d.ts

@@ -0,0 +1 @@
+export declare function toStringTag(object: any, nil?: string | null): string | null | undefined;

package/dist/cjs/util/ObjectUtils/toStringTag.js

@@ -0,0 +1,31 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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 = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/util/ObjectUtils/toStringTag.ts
+var toStringTag_exports = {};
+__export(toStringTag_exports, {
+  toStringTag: () => toStringTag
+});
+module.exports = __toCommonJS(toStringTag_exports);
+function toStringTag(object, nil) {
+  return object ? object[Symbol.toStringTag] : nil;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  toStringTag
+});

package/dist/cjs/util/RandomUtils/index.d.ts

@@ -0,0 +1,9 @@
+export { randomBoolean } from './randomBoolean';
+export { randomElement } from './randomElement';
+export { randomElements } from './randomElements';
+export { randomInteger } from './randomInteger';
+export { randomIntegers } from './randomIntegers';
+export { randomNumber } from './randomNumber';
+export { randomNumbers } from './randomNumbers';
+export { randomString } from './randomString';
+export { randomStrings } from './randomStrings';

package/dist/cjs/util/RandomUtils/index.js

@@ -0,0 +1,53 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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 = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/util/RandomUtils/index.ts
+var RandomUtils_exports = {};
+__export(RandomUtils_exports, {
+  randomBoolean: () => import_randomBoolean.randomBoolean,
+  randomElement: () => import_randomElement.randomElement,
+  randomElements: () => import_randomElements.randomElements,
+  randomInteger: () => import_randomInteger.randomInteger,
+  randomIntegers: () => import_randomIntegers.randomIntegers,
+  randomNumber: () => import_randomNumber.randomNumber,
+  randomNumbers: () => import_randomNumbers.randomNumbers,
+  randomString: () => import_randomString.randomString,
+  randomStrings: () => import_randomStrings.randomStrings
+});
+module.exports = __toCommonJS(RandomUtils_exports);
+var import_randomBoolean = require("./randomBoolean");
+var import_randomElement = require("./randomElement");
+var import_randomElements = require("./randomElements");
+var import_randomInteger = require("./randomInteger");
+var import_randomIntegers = require("./randomIntegers");
+var import_randomNumber = require("./randomNumber");
+var import_randomNumbers = require("./randomNumbers");
+var import_randomString = require("./randomString");
+var import_randomStrings = require("./randomStrings");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  randomBoolean,
+  randomElement,
+  randomElements,
+  randomInteger,
+  randomIntegers,
+  randomNumber,
+  randomNumbers,
+  randomString,
+  randomStrings
+});

package/dist/cjs/util/RandomUtils/randomBoolean.d.ts

@@ -0,0 +1 @@
+export declare function randomBoolean(): boolean;

package/dist/cjs/util/RandomUtils/randomBoolean.js

@@ -0,0 +1,31 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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 = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/util/RandomUtils/randomBoolean.ts
+var randomBoolean_exports = {};
+__export(randomBoolean_exports, {
+  randomBoolean: () => randomBoolean
+});
+module.exports = __toCommonJS(randomBoolean_exports);
+function randomBoolean() {
+  return Math.random() >= 0.5;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  randomBoolean
+});

package/dist/cjs/util/RandomUtils/randomElement.d.ts

@@ -0,0 +1 @@
+export declare function randomElement<E>(array?: E[]): E | undefined;

package/dist/cjs/util/RandomUtils/randomElement.js

@@ -0,0 +1,32 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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 = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/util/RandomUtils/randomElement.ts
+var randomElement_exports = {};
+__export(randomElement_exports, {
+  randomElement: () => randomElement
+});
+module.exports = __toCommonJS(randomElement_exports);
+var import_randomInteger = require("./randomInteger");
+function randomElement(array) {
+  return !array || !array.length ? void 0 : array.at((0, import_randomInteger.randomInteger)(0, array.length));
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  randomElement
+});

package/dist/cjs/util/RandomUtils/randomElements.d.ts

@@ -0,0 +1 @@
+export declare function randomElements<E>(array?: E[], size?: number): E[] | undefined;

package/dist/cjs/util/RandomUtils/randomElements.js

@@ -0,0 +1,42 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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 = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/util/RandomUtils/randomElements.ts
+var randomElements_exports = {};
+__export(randomElements_exports, {
+  randomElements: () => randomElements
+});
+module.exports = __toCommonJS(randomElements_exports);
+var import_randomInteger = require("./randomInteger");
+function randomElements(array, size) {
+  if (!array || !array.length || !size || size <= 0 || size > Number.MAX_SAFE_INTEGER) {
+    return void 0;
+  }
+  if (array.length <= size) {
+    return array;
+  }
+  const indexes = /* @__PURE__ */ new Set();
+  while (indexes.size < size) {
+    indexes.add((0, import_randomInteger.randomInteger)(0, array.length));
+  }
+  return array.filter((_value, index) => indexes.has(index));
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  randomElements
+});

package/dist/cjs/util/RandomUtils/randomInteger.d.ts

@@ -0,0 +1 @@
+export declare function randomInteger(minValue?: number, maxValue?: number): number | undefined;

package/dist/cjs/util/RandomUtils/randomInteger.js

@@ -0,0 +1,33 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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 = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/util/RandomUtils/randomInteger.ts
+var randomInteger_exports = {};
+__export(randomInteger_exports, {
+  randomInteger: () => randomInteger
+});
+module.exports = __toCommonJS(randomInteger_exports);
+var import_randomNumber = require("./randomNumber");
+function randomInteger(minValue, maxValue) {
+  const value = (0, import_randomNumber.randomNumber)(minValue, maxValue);
+  return !value ? void 0 : Math.floor(value);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  randomInteger
+});

package/dist/cjs/util/RandomUtils/randomIntegers.d.ts

@@ -0,0 +1 @@
+export declare function randomIntegers(size?: number, minValue?: number, maxValue?: number): number[] | undefined;

package/dist/cjs/util/RandomUtils/randomIntegers.js

@@ -0,0 +1,43 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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 = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/util/RandomUtils/randomIntegers.ts
+var randomIntegers_exports = {};
+__export(randomIntegers_exports, {
+  randomIntegers: () => randomIntegers
+});
+module.exports = __toCommonJS(randomIntegers_exports);
+var import_randomInteger = require("./randomInteger");
+function randomIntegers(size, minValue, maxValue) {
+  if (!size || size <= 0 || size > Number.MAX_SAFE_INTEGER) {
+    return void 0;
+  }
+  const result = [];
+  for (let i = 0; i < size; i++) {
+    const value = (0, import_randomInteger.randomInteger)(minValue, maxValue);
+    if (!value) {
+      break;
+    }
+    result.push(value);
+  }
+  return result;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  randomIntegers
+});

package/dist/cjs/util/RandomUtils/randomNumber.d.ts

@@ -0,0 +1 @@
+export declare function randomNumber(minValue?: number, maxValue?: number): number | undefined;

package/dist/cjs/util/RandomUtils/randomNumber.js

@@ -0,0 +1,33 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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 = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/util/RandomUtils/randomNumber.ts
+var randomNumber_exports = {};
+__export(randomNumber_exports, {
+  randomNumber: () => randomNumber
+});
+module.exports = __toCommonJS(randomNumber_exports);
+function randomNumber(minValue, maxValue) {
+  const min = minValue !== void 0 ? minValue : Number.MIN_SAFE_INTEGER;
+  const max = maxValue !== void 0 ? maxValue : Number.MAX_SAFE_INTEGER;
+  return min > max ? void 0 : min + (max - min) * Math.random();
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  randomNumber
+});

package/dist/cjs/util/RandomUtils/randomNumbers.d.ts

@@ -0,0 +1 @@
+export declare function randomNumbers(size?: number, minValue?: number, maxValue?: number): number[] | undefined;

package/dist/cjs/util/RandomUtils/randomNumbers.js

@@ -0,0 +1,43 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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 = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/util/RandomUtils/randomNumbers.ts
+var randomNumbers_exports = {};
+__export(randomNumbers_exports, {
+  randomNumbers: () => randomNumbers
+});
+module.exports = __toCommonJS(randomNumbers_exports);
+var import_randomNumber = require("./randomNumber");
+function randomNumbers(size, minValue, maxValue) {
+  if (!size || size <= 0 || size > Number.MAX_SAFE_INTEGER) {
+    return void 0;
+  }
+  const result = [];
+  for (let i = 0; i < size; i++) {
+    const value = (0, import_randomNumber.randomNumber)(minValue, maxValue);
+    if (!value) {
+      break;
+    }
+    result.push(value);
+  }
+  return result;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  randomNumbers
+});

package/dist/cjs/util/RandomUtils/randomString.d.ts

@@ -0,0 +1 @@
+export declare function randomString(minLength?: number, maxLength?: number, characters?: string): string | undefined;