@unikue/ts-lang-utils 1.0.0

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

@@ -0,0 +1,113 @@
+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/ArrayUtils/index.ts
+var ArrayUtils_exports = {};
+__export(ArrayUtils_exports, {
+  add: () => import_add.add,
+  addAll: () => import_addAll.addAll,
+  count: () => import_count.count,
+  emptyAsNull: () => import_emptyAsNull.emptyAsNull,
+  emptyAsUndefined: () => import_emptyAsUndefined.emptyAsUndefined,
+  equals: () => import_equals.equals,
+  equalsAny: () => import_equalsAny.equalsAny,
+  firstNotEmpty: () => import_firstNotEmpty.firstNotEmpty,
+  firstNotNil: () => import_firstNotNil.firstNotNil,
+  fixLength: () => import_fixLength.fixLength,
+  get: () => import_get.get,
+  getFirst: () => import_getFirst.getFirst,
+  getLast: () => import_getLast.getLast,
+  getLength: () => import_getLength.getLength,
+  getTypeof: () => import_getTypeof.getTypeof,
+  includes: () => import_includes.includes,
+  includesAll: () => import_includesAll.includesAll,
+  includesAny: () => import_includesAny.includesAny,
+  insert: () => import_insert.insert,
+  isEmpty: () => import_isEmpty.isEmpty,
+  isNotEmpty: () => import_isNotEmpty.isNotEmpty,
+  isTypeof: () => import_isTypeof.isTypeof,
+  maxLength: () => import_maxLength.maxLength,
+  minLength: () => import_minLength.minLength,
+  readonly: () => import_readonly.readonly,
+  remove: () => import_remove.remove,
+  removeAll: () => import_removeAll.removeAll,
+  reverse: () => import_reverse.reverse,
+  singleton: () => import_singleton.singleton
+});
+module.exports = __toCommonJS(ArrayUtils_exports);
+var import_add = require("./add");
+var import_addAll = require("./addAll");
+var import_count = require("./count");
+var import_emptyAsNull = require("./emptyAsNull");
+var import_emptyAsUndefined = require("./emptyAsUndefined");
+var import_equals = require("./equals");
+var import_equalsAny = require("./equalsAny");
+var import_firstNotEmpty = require("./firstNotEmpty");
+var import_firstNotNil = require("./firstNotNil");
+var import_fixLength = require("./fixLength");
+var import_get = require("./get");
+var import_getFirst = require("./getFirst");
+var import_getLast = require("./getLast");
+var import_getLength = require("./getLength");
+var import_getTypeof = require("./getTypeof");
+var import_includes = require("./includes");
+var import_includesAll = require("./includesAll");
+var import_includesAny = require("./includesAny");
+var import_insert = require("./insert");
+var import_isEmpty = require("./isEmpty");
+var import_isNotEmpty = require("./isNotEmpty");
+var import_isTypeof = require("./isTypeof");
+var import_maxLength = require("./maxLength");
+var import_minLength = require("./minLength");
+var import_readonly = require("./readonly");
+var import_remove = require("./remove");
+var import_removeAll = require("./removeAll");
+var import_reverse = require("./reverse");
+var import_singleton = require("./singleton");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  add,
+  addAll,
+  count,
+  emptyAsNull,
+  emptyAsUndefined,
+  equals,
+  equalsAny,
+  firstNotEmpty,
+  firstNotNil,
+  fixLength,
+  get,
+  getFirst,
+  getLast,
+  getLength,
+  getTypeof,
+  includes,
+  includesAll,
+  includesAny,
+  insert,
+  isEmpty,
+  isNotEmpty,
+  isTypeof,
+  maxLength,
+  minLength,
+  readonly,
+  remove,
+  removeAll,
+  reverse,
+  singleton
+});

package/dist/cjs/util/ArrayUtils/insert.d.ts

@@ -0,0 +1 @@
+export declare function insert<E>(array?: E[] | null, index?: number, elements?: E[] | null): E[] | null | undefined;

package/dist/cjs/util/ArrayUtils/insert.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/ArrayUtils/insert.ts
+var insert_exports = {};
+__export(insert_exports, {
+  insert: () => insert
+});
+module.exports = __toCommonJS(insert_exports);
+function insert(array, index, elements) {
+  if (index === void 0 || !elements || !elements.length) {
+    return array;
+  }
+  if (!array || !array.length) {
+    return elements;
+  }
+  if (index < 0 || index >= array.length) {
+    return array.concat(elements);
+  } else if (index === 0) {
+    return elements.concat(array);
+  }
+  const order = Math.min(index, array.length);
+  return array.slice(0, order).concat(elements).concat(array.slice(order));
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  insert
+});

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

@@ -0,0 +1 @@
+export declare function isEmpty(array?: any[] | readonly any[] | null): boolean;

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

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

@@ -0,0 +1 @@
+export declare function isNotEmpty(array?: any[] | readonly any[] | null): boolean;

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

package/dist/cjs/util/ArrayUtils/isTypeof.d.ts

@@ -0,0 +1 @@
+export declare function isTypeof(array?: any[] | readonly any[] | null, type?: string, relaxed?: boolean): boolean;

package/dist/cjs/util/ArrayUtils/isTypeof.js

@@ -0,0 +1,39 @@
+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/ArrayUtils/isTypeof.ts
+var isTypeof_exports = {};
+__export(isTypeof_exports, {
+  isTypeof: () => isTypeof
+});
+module.exports = __toCommonJS(isTypeof_exports);
+var import_equalsAny = require("../StringUtils/equalsAny");
+var import_isBlank = require("../StringUtils/isBlank");
+var import_isEmpty = require("./isEmpty");
+function isTypeof(array, type, relaxed = false) {
+  if ((0, import_isEmpty.isEmpty)(array) || (0, import_isBlank.isBlank)(type)) {
+    return false;
+  }
+  return array == null ? void 0 : array.every((item) => {
+    return typeof item === type || relaxed && item === null && (0, import_equalsAny.equalsAny)(type, ["string", "object"]);
+  });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  isTypeof
+});

package/dist/cjs/util/ArrayUtils/maxLength.d.ts

@@ -0,0 +1 @@
+export declare function maxLength(...arrays: (any[] | readonly any[])[]): number;

package/dist/cjs/util/ArrayUtils/maxLength.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/ArrayUtils/maxLength.ts
+var maxLength_exports = {};
+__export(maxLength_exports, {
+  maxLength: () => maxLength
+});
+module.exports = __toCommonJS(maxLength_exports);
+var import_getLength = require("./getLength");
+var import_isEmpty = require("./isEmpty");
+function maxLength(...arrays) {
+  if ((0, import_isEmpty.isEmpty)(arrays)) {
+    return 0;
+  }
+  let result = 0;
+  for (const array of arrays) {
+    result = Math.max(result, (0, import_getLength.getLength)(array));
+  }
+  return result;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  maxLength
+});

package/dist/cjs/util/ArrayUtils/minLength.d.ts

@@ -0,0 +1 @@
+export declare function minLength(...arrays: (any[] | readonly any[])[]): number;

package/dist/cjs/util/ArrayUtils/minLength.js

@@ -0,0 +1,44 @@
+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/ArrayUtils/minLength.ts
+var minLength_exports = {};
+__export(minLength_exports, {
+  minLength: () => minLength
+});
+module.exports = __toCommonJS(minLength_exports);
+var import_getLength = require("./getLength");
+var import_isEmpty = require("./isEmpty");
+function minLength(...arrays) {
+  var _a;
+  if ((0, import_isEmpty.isEmpty)(arrays)) {
+    return 0;
+  }
+  let result = (_a = arrays[0]) == null ? void 0 : _a.length;
+  for (const array of arrays.slice(1)) {
+    result = Math.min(result, (0, import_getLength.getLength)(array));
+    if (result === 0) {
+      break;
+    }
+  }
+  return result;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  minLength
+});

package/dist/cjs/util/ArrayUtils/readonly.d.ts

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

package/dist/cjs/util/ArrayUtils/readonly.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/ArrayUtils/readonly.ts
+var readonly_exports = {};
+__export(readonly_exports, {
+  readonly: () => readonly
+});
+module.exports = __toCommonJS(readonly_exports);
+function readonly(array) {
+  return !array ? array : Object.freeze(array);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  readonly
+});

package/dist/cjs/util/ArrayUtils/remove.d.ts

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

package/dist/cjs/util/ArrayUtils/remove.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/ArrayUtils/remove.ts
+var remove_exports = {};
+__export(remove_exports, {
+  remove: () => remove
+});
+module.exports = __toCommonJS(remove_exports);
+function remove(array, element) {
+  return !array || !element ? array : array.filter((item) => item !== element);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  remove
+});

package/dist/cjs/util/ArrayUtils/removeAll.d.ts

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

package/dist/cjs/util/ArrayUtils/removeAll.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/ArrayUtils/removeAll.ts
+var removeAll_exports = {};
+__export(removeAll_exports, {
+  removeAll: () => removeAll
+});
+module.exports = __toCommonJS(removeAll_exports);
+function removeAll(array, elements) {
+  return !array || !elements ? array : array.filter((item) => !elements.includes(item));
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  removeAll
+});

package/dist/cjs/util/ArrayUtils/reverse.d.ts

@@ -0,0 +1 @@
+export declare function reverse<E>(array?: E[] | null, startInclusive?: number, endExclusive?: number): E[] | null | undefined;

package/dist/cjs/util/ArrayUtils/reverse.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/ArrayUtils/reverse.ts
+var reverse_exports = {};
+__export(reverse_exports, {
+  reverse: () => reverse
+});
+module.exports = __toCommonJS(reverse_exports);
+function reverse(array, startInclusive, endExclusive) {
+  if (!array) {
+    return array;
+  }
+  const subarray = array.slice(startInclusive, endExclusive);
+  subarray.reverse();
+  return subarray;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  reverse
+});

package/dist/cjs/util/ArrayUtils/singleton.d.ts

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

package/dist/cjs/util/ArrayUtils/singleton.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/ArrayUtils/singleton.ts
+var singleton_exports = {};
+__export(singleton_exports, {
+  singleton: () => singleton
+});
+module.exports = __toCommonJS(singleton_exports);
+function singleton(element) {
+  return !element ? void 0 : [element];
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  singleton
+});

package/dist/cjs/util/BooleanUtils/allFalse.d.ts

@@ -0,0 +1 @@
+export declare function allFalse(values?: Array<boolean | number | string | null | undefined>): boolean;

package/dist/cjs/util/BooleanUtils/allFalse.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/BooleanUtils/allFalse.ts
+var allFalse_exports = {};
+__export(allFalse_exports, {
+  allFalse: () => allFalse
+});
+module.exports = __toCommonJS(allFalse_exports);
+var import_isFalse = require("./isFalse");
+function allFalse(values) {
+  return !!values && values.length > 0 && values.every((item) => (0, import_isFalse.isFalse)(item));
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  allFalse
+});

package/dist/cjs/util/BooleanUtils/allNotFalse.d.ts

@@ -0,0 +1 @@
+export declare function allNotFalse(values?: Array<boolean | number | string | null | undefined>): boolean;

package/dist/cjs/util/BooleanUtils/allNotFalse.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/BooleanUtils/allNotFalse.ts
+var allNotFalse_exports = {};
+__export(allNotFalse_exports, {
+  allNotFalse: () => allNotFalse
+});
+module.exports = __toCommonJS(allNotFalse_exports);
+var import_isNotFalse = require("./isNotFalse");
+function allNotFalse(values) {
+  return !values || !values.length || values.every((item) => (0, import_isNotFalse.isNotFalse)(item));
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  allNotFalse
+});

package/dist/cjs/util/BooleanUtils/allNotTrue.d.ts

@@ -0,0 +1 @@
+export declare function allNotTrue(values?: Array<boolean | number | string | null | undefined>): boolean;

package/dist/cjs/util/BooleanUtils/allNotTrue.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/BooleanUtils/allNotTrue.ts
+var allNotTrue_exports = {};
+__export(allNotTrue_exports, {
+  allNotTrue: () => allNotTrue
+});
+module.exports = __toCommonJS(allNotTrue_exports);
+var import_isNotTrue = require("./isNotTrue");
+function allNotTrue(values) {
+  return !values || !values.length || values.every((item) => (0, import_isNotTrue.isNotTrue)(item));
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  allNotTrue
+});

package/dist/cjs/util/BooleanUtils/allTrue.d.ts

@@ -0,0 +1 @@
+export declare function allTrue(values?: Array<boolean | number | string | null | undefined>): boolean;