@unikue/ts-lang-utils 1.0.0

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

@@ -0,0 +1,137 @@
+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/index.ts
+var ObjectUtils_exports = {};
+__export(ObjectUtils_exports, {
+  allEmpty: () => import_allEmpty.allEmpty,
+  allNil: () => import_allNil.allNil,
+  allNotEmpty: () => import_allNotEmpty.allNotEmpty,
+  allNotNil: () => import_allNotNil.allNotNil,
+  anyEmpty: () => import_anyEmpty.anyEmpty,
+  anyNil: () => import_anyNil.anyNil,
+  anyNotEmpty: () => import_anyNotEmpty.anyNotEmpty,
+  anyNotNil: () => import_anyNotNil.anyNotNil,
+  clone: () => import_clone.clone,
+  cloneExclusive: () => import_cloneExclusive.cloneExclusive,
+  cloneInclusive: () => import_cloneInclusive.cloneInclusive,
+  firstNotEmpty: () => import_firstNotEmpty.firstNotEmpty,
+  firstNotNil: () => import_firstNotNil.firstNotNil,
+  forEachProp: () => import_forEachProp.forEachProp,
+  getProp: () => import_getProp.getProp,
+  getPropIgnoreCase: () => import_getPropIgnoreCase.getPropIgnoreCase,
+  hasProp: () => import_hasProp.hasProp,
+  isEmpty: () => import_isEmpty.isEmpty,
+  isNil: () => import_isNil.isNil,
+  isNotEmpty: () => import_isNotEmpty.isNotEmpty,
+  isNotNil: () => import_isNotNil.isNotNil,
+  isNotNull: () => import_isNotNull.isNotNull,
+  isNotUndefined: () => import_isNotUndefined.isNotUndefined,
+  isNull: () => import_isNull.isNull,
+  isPlain: () => import_isPlain.isPlain,
+  isPrimitive: () => import_isPrimitive.isPrimitive,
+  isPromise: () => import_isPromise.isPromise,
+  isPrototype: () => import_isPrototype.isPrototype,
+  isRegular: () => import_isRegular.isRegular,
+  isUndefined: () => import_isUndefined.isUndefined,
+  keys: () => import_keys.keys,
+  mapEachProp: () => import_mapEachProp.mapEachProp,
+  mergeProps: () => import_mergeProps.mergeProps,
+  regenProps: () => import_regenProps.regenProps,
+  setProp: () => import_setProp.setProp,
+  toString: () => import_toString.toString,
+  toStringTag: () => import_toStringTag.toStringTag
+});
+module.exports = __toCommonJS(ObjectUtils_exports);
+var import_allEmpty = require("./allEmpty");
+var import_allNil = require("./allNil");
+var import_allNotEmpty = require("./allNotEmpty");
+var import_allNotNil = require("./allNotNil");
+var import_anyEmpty = require("./anyEmpty");
+var import_anyNil = require("./anyNil");
+var import_anyNotEmpty = require("./anyNotEmpty");
+var import_anyNotNil = require("./anyNotNil");
+var import_clone = require("./clone");
+var import_cloneExclusive = require("./cloneExclusive");
+var import_cloneInclusive = require("./cloneInclusive");
+var import_firstNotEmpty = require("./firstNotEmpty");
+var import_firstNotNil = require("./firstNotNil");
+var import_forEachProp = require("./forEachProp");
+var import_getProp = require("./getProp");
+var import_getPropIgnoreCase = require("./getPropIgnoreCase");
+var import_hasProp = require("./hasProp");
+var import_isEmpty = require("./isEmpty");
+var import_isNil = require("./isNil");
+var import_isNotEmpty = require("./isNotEmpty");
+var import_isNotNil = require("./isNotNil");
+var import_isNotNull = require("./isNotNull");
+var import_isNotUndefined = require("./isNotUndefined");
+var import_isNull = require("./isNull");
+var import_isPlain = require("./isPlain");
+var import_isPrimitive = require("./isPrimitive");
+var import_isPromise = require("./isPromise");
+var import_isPrototype = require("./isPrototype");
+var import_isRegular = require("./isRegular");
+var import_isUndefined = require("./isUndefined");
+var import_keys = require("./keys");
+var import_mapEachProp = require("./mapEachProp");
+var import_mergeProps = require("./mergeProps");
+var import_regenProps = require("./regenProps");
+var import_setProp = require("./setProp");
+var import_toString = require("./toString");
+var import_toStringTag = require("./toStringTag");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  allEmpty,
+  allNil,
+  allNotEmpty,
+  allNotNil,
+  anyEmpty,
+  anyNil,
+  anyNotEmpty,
+  anyNotNil,
+  clone,
+  cloneExclusive,
+  cloneInclusive,
+  firstNotEmpty,
+  firstNotNil,
+  forEachProp,
+  getProp,
+  getPropIgnoreCase,
+  hasProp,
+  isEmpty,
+  isNil,
+  isNotEmpty,
+  isNotNil,
+  isNotNull,
+  isNotUndefined,
+  isNull,
+  isPlain,
+  isPrimitive,
+  isPromise,
+  isPrototype,
+  isRegular,
+  isUndefined,
+  keys,
+  mapEachProp,
+  mergeProps,
+  regenProps,
+  setProp,
+  toString,
+  toStringTag
+});

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

@@ -0,0 +1 @@
+export declare function isEmpty(object: any): boolean;

package/dist/cjs/util/ObjectUtils/isEmpty.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/isEmpty.ts
+var isEmpty_exports = {};
+__export(isEmpty_exports, {
+  isEmpty: () => isEmpty
+});
+module.exports = __toCommonJS(isEmpty_exports);
+var import_keys = require("./keys");
+function isEmpty(object) {
+  var _a;
+  if (object === void 0 || object === null) {
+    return true;
+  }
+  if (typeof object === "string" || Array.isArray(object)) {
+    return !object.length;
+  }
+  if (object instanceof Map || object instanceof Set) {
+    return !object.size;
+  }
+  if (typeof object === "object") {
+    return !((_a = (0, import_keys.keys)(object)) == null ? void 0 : _a.length);
+  }
+  return false;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  isEmpty
+});

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

@@ -0,0 +1 @@
+export declare function isNil(object: any): boolean;

package/dist/cjs/util/ObjectUtils/isNil.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/isNil.ts
+var isNil_exports = {};
+__export(isNil_exports, {
+  isNil: () => isNil
+});
+module.exports = __toCommonJS(isNil_exports);
+function isNil(object) {
+  return object === void 0 || object === null;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  isNil
+});

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

@@ -0,0 +1 @@
+export declare function isNotEmpty(object: any): boolean;

package/dist/cjs/util/ObjectUtils/isNotEmpty.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/ObjectUtils/isNotEmpty.ts
+var isNotEmpty_exports = {};
+__export(isNotEmpty_exports, {
+  isNotEmpty: () => isNotEmpty
+});
+module.exports = __toCommonJS(isNotEmpty_exports);
+var import_isEmpty = require("./isEmpty");
+function isNotEmpty(object) {
+  return !(0, import_isEmpty.isEmpty)(object);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  isNotEmpty
+});

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

@@ -0,0 +1 @@
+export declare function isNotNil(object: any): boolean;

package/dist/cjs/util/ObjectUtils/isNotNil.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/ObjectUtils/isNotNil.ts
+var isNotNil_exports = {};
+__export(isNotNil_exports, {
+  isNotNil: () => isNotNil
+});
+module.exports = __toCommonJS(isNotNil_exports);
+var import_isNil = require("./isNil");
+function isNotNil(object) {
+  return !(0, import_isNil.isNil)(object);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  isNotNil
+});

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

@@ -0,0 +1 @@
+export declare function isNotNull(object: any): boolean;

package/dist/cjs/util/ObjectUtils/isNotNull.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/ObjectUtils/isNotNull.ts
+var isNotNull_exports = {};
+__export(isNotNull_exports, {
+  isNotNull: () => isNotNull
+});
+module.exports = __toCommonJS(isNotNull_exports);
+var import_isNull = require("./isNull");
+function isNotNull(object) {
+  return !(0, import_isNull.isNull)(object);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  isNotNull
+});

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

@@ -0,0 +1 @@
+export declare function isNotUndefined(object: any): boolean;

package/dist/cjs/util/ObjectUtils/isNotUndefined.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/ObjectUtils/isNotUndefined.ts
+var isNotUndefined_exports = {};
+__export(isNotUndefined_exports, {
+  isNotUndefined: () => isNotUndefined
+});
+module.exports = __toCommonJS(isNotUndefined_exports);
+var import_isUndefined = require("./isUndefined");
+function isNotUndefined(object) {
+  return !(0, import_isUndefined.isUndefined)(object);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  isNotUndefined
+});

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

@@ -0,0 +1 @@
+export declare function isNull(object: any): boolean;

package/dist/cjs/util/ObjectUtils/isNull.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/isNull.ts
+var isNull_exports = {};
+__export(isNull_exports, {
+  isNull: () => isNull
+});
+module.exports = __toCommonJS(isNull_exports);
+function isNull(object) {
+  return object === null;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  isNull
+});

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

@@ -0,0 +1 @@
+export declare function isPlain(object: any): boolean;

package/dist/cjs/util/ObjectUtils/isPlain.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/isPlain.ts
+var isPlain_exports = {};
+__export(isPlain_exports, {
+  isPlain: () => isPlain
+});
+module.exports = __toCommonJS(isPlain_exports);
+function isPlain(object) {
+  return typeof object === "object" && Object.prototype.toString.call(object) === "[object Object]";
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  isPlain
+});

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

@@ -0,0 +1 @@
+export declare function isPrimitive(object: any): boolean;

package/dist/cjs/util/ObjectUtils/isPrimitive.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/isPrimitive.ts
+var isPrimitive_exports = {};
+__export(isPrimitive_exports, {
+  isPrimitive: () => isPrimitive
+});
+module.exports = __toCommonJS(isPrimitive_exports);
+function isPrimitive(object) {
+  return object === void 0 || object === null || typeof object === "string" || typeof object === "boolean" || typeof object === "number" || typeof object === "symbol" || typeof object === "bigint" || typeof object === "function";
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  isPrimitive
+});

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

@@ -0,0 +1 @@
+export declare function isPromise(object: any): boolean;

package/dist/cjs/util/ObjectUtils/isPromise.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/isPromise.ts
+var isPromise_exports = {};
+__export(isPromise_exports, {
+  isPromise: () => isPromise
+});
+module.exports = __toCommonJS(isPromise_exports);
+function isPromise(object) {
+  return typeof object === "object" && Object.prototype.toString.call(object) === "[object Promise]";
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  isPromise
+});

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

@@ -0,0 +1 @@
+export declare function isPrototype(object: any): boolean;

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

@@ -0,0 +1,36 @@
+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/isPrototype.ts
+var isPrototype_exports = {};
+__export(isPrototype_exports, {
+  isPrototype: () => isPrototype
+});
+module.exports = __toCommonJS(isPrototype_exports);
+function isPrototype(object) {
+  if (typeof object !== "object") {
+    return false;
+  }
+  const constructor = object.constructor;
+  const prototype = typeof constructor === "function" ? constructor.prototype : object.prototype;
+  return object === prototype;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  isPrototype
+});

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

@@ -0,0 +1 @@
+export declare function isRegular(object: any): boolean;

package/dist/cjs/util/ObjectUtils/isRegular.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/isRegular.ts
+var isRegular_exports = {};
+__export(isRegular_exports, {
+  isRegular: () => isRegular
+});
+module.exports = __toCommonJS(isRegular_exports);
+function isRegular(object) {
+  return object instanceof RegExp || typeof object === "object" && Object.prototype.toString.call(object) === "[object RegExp]";
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  isRegular
+});

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

@@ -0,0 +1 @@
+export declare function isUndefined(object: any): boolean;

package/dist/cjs/util/ObjectUtils/isUndefined.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/isUndefined.ts
+var isUndefined_exports = {};
+__export(isUndefined_exports, {
+  isUndefined: () => isUndefined
+});
+module.exports = __toCommonJS(isUndefined_exports);
+function isUndefined(object) {
+  return object === void 0;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  isUndefined
+});

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

@@ -0,0 +1 @@
+export declare function keys(object: any): string[];