@unikue/ts-lang-utils 1.0.0

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

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

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

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

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

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

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

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

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

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

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

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

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

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

@@ -0,0 +1,19 @@
+export { allFalse } from './allFalse';
+export { allNotFalse } from './allNotFalse';
+export { allNotTrue } from './allNotTrue';
+export { allTrue } from './allTrue';
+export { anyFalse } from './anyFalse';
+export { anyNotFalse } from './anyNotFalse';
+export { anyNotTrue } from './anyNotTrue';
+export { anyTrue } from './anyTrue';
+export { isFalse } from './isFalse';
+export { isNotFalse } from './isNotFalse';
+export { isNotTrue } from './isNotTrue';
+export { isTrue } from './isTrue';
+export { toString } from './toString';
+export { toString10 } from './toString10';
+export { toStringOnOff } from './toStringOnOff';
+export { toStringTF } from './toStringTF';
+export { toStringTrueFalse } from './toStringTrueFalse';
+export { toStringYesNo } from './toStringYesNo';
+export { toStringYN } from './toStringYN';

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

@@ -0,0 +1,83 @@
+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/index.ts
+var BooleanUtils_exports = {};
+__export(BooleanUtils_exports, {
+  allFalse: () => import_allFalse.allFalse,
+  allNotFalse: () => import_allNotFalse.allNotFalse,
+  allNotTrue: () => import_allNotTrue.allNotTrue,
+  allTrue: () => import_allTrue.allTrue,
+  anyFalse: () => import_anyFalse.anyFalse,
+  anyNotFalse: () => import_anyNotFalse.anyNotFalse,
+  anyNotTrue: () => import_anyNotTrue.anyNotTrue,
+  anyTrue: () => import_anyTrue.anyTrue,
+  isFalse: () => import_isFalse.isFalse,
+  isNotFalse: () => import_isNotFalse.isNotFalse,
+  isNotTrue: () => import_isNotTrue.isNotTrue,
+  isTrue: () => import_isTrue.isTrue,
+  toString: () => import_toString.toString,
+  toString10: () => import_toString10.toString10,
+  toStringOnOff: () => import_toStringOnOff.toStringOnOff,
+  toStringTF: () => import_toStringTF.toStringTF,
+  toStringTrueFalse: () => import_toStringTrueFalse.toStringTrueFalse,
+  toStringYN: () => import_toStringYN.toStringYN,
+  toStringYesNo: () => import_toStringYesNo.toStringYesNo
+});
+module.exports = __toCommonJS(BooleanUtils_exports);
+var import_allFalse = require("./allFalse");
+var import_allNotFalse = require("./allNotFalse");
+var import_allNotTrue = require("./allNotTrue");
+var import_allTrue = require("./allTrue");
+var import_anyFalse = require("./anyFalse");
+var import_anyNotFalse = require("./anyNotFalse");
+var import_anyNotTrue = require("./anyNotTrue");
+var import_anyTrue = require("./anyTrue");
+var import_isFalse = require("./isFalse");
+var import_isNotFalse = require("./isNotFalse");
+var import_isNotTrue = require("./isNotTrue");
+var import_isTrue = require("./isTrue");
+var import_toString = require("./toString");
+var import_toString10 = require("./toString10");
+var import_toStringOnOff = require("./toStringOnOff");
+var import_toStringTF = require("./toStringTF");
+var import_toStringTrueFalse = require("./toStringTrueFalse");
+var import_toStringYesNo = require("./toStringYesNo");
+var import_toStringYN = require("./toStringYN");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  allFalse,
+  allNotFalse,
+  allNotTrue,
+  allTrue,
+  anyFalse,
+  anyNotFalse,
+  anyNotTrue,
+  anyTrue,
+  isFalse,
+  isNotFalse,
+  isNotTrue,
+  isTrue,
+  toString,
+  toString10,
+  toStringOnOff,
+  toStringTF,
+  toStringTrueFalse,
+  toStringYN,
+  toStringYesNo
+});

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

@@ -0,0 +1 @@
+export declare function isFalse(value?: boolean | number | string | null | (() => boolean)): boolean;

package/dist/cjs/util/BooleanUtils/isFalse.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/BooleanUtils/isFalse.ts
+var isFalse_exports = {};
+__export(isFalse_exports, {
+  isFalse: () => isFalse
+});
+module.exports = __toCommonJS(isFalse_exports);
+function isFalse(value) {
+  if (typeof value === "boolean") {
+    return !value;
+  } else if (typeof value === "number") {
+    return value <= 0;
+  } else if (typeof value === "string") {
+    return ["false", "no", "off", "n", "f", "0"].some((item) => item === value.toLowerCase());
+  } else if (typeof value === "function") {
+    return !value();
+  }
+  return false;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  isFalse
+});

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

@@ -0,0 +1 @@
+export declare function isNotFalse(value?: boolean | number | string | null | (() => boolean)): boolean;

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

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

@@ -0,0 +1 @@
+export declare function isNotTrue(value?: boolean | number | string | null | (() => boolean)): boolean;

package/dist/cjs/util/BooleanUtils/isNotTrue.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/isNotTrue.ts
+var isNotTrue_exports = {};
+__export(isNotTrue_exports, {
+  isNotTrue: () => isNotTrue
+});
+module.exports = __toCommonJS(isNotTrue_exports);
+var import_isTrue = require("./isTrue");
+function isNotTrue(value) {
+  return value === void 0 || value === null || !(0, import_isTrue.isTrue)(value);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  isNotTrue
+});

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

@@ -0,0 +1 @@
+export declare function isTrue(value?: boolean | number | string | null | (() => boolean)): boolean;

package/dist/cjs/util/BooleanUtils/isTrue.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/BooleanUtils/isTrue.ts
+var isTrue_exports = {};
+__export(isTrue_exports, {
+  isTrue: () => isTrue
+});
+module.exports = __toCommonJS(isTrue_exports);
+function isTrue(value) {
+  if (typeof value === "boolean") {
+    return value;
+  } else if (typeof value === "number") {
+    return value > 0;
+  } else if (typeof value === "string") {
+    return ["true", "yes", "on", "y", "t", "1"].some((item) => item === value.toLowerCase());
+  } else if (typeof value === "function") {
+    return value();
+  }
+  return false;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  isTrue
+});

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

@@ -0,0 +1 @@
+export declare function toString(value?: boolean, truthy?: string, falsy?: string, nil?: string): string | undefined;

package/dist/cjs/util/BooleanUtils/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/BooleanUtils/toString.ts
+var toString_exports = {};
+__export(toString_exports, {
+  toString: () => toString
+});
+module.exports = __toCommonJS(toString_exports);
+function toString(value, truthy, falsy, nil) {
+  return value === void 0 ? nil : value ? truthy : falsy;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  toString
+});

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

@@ -0,0 +1 @@
+export declare function toString10(value?: boolean): string | undefined;

package/dist/cjs/util/BooleanUtils/toString10.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/toString10.ts
+var toString10_exports = {};
+__export(toString10_exports, {
+  toString10: () => toString10
+});
+module.exports = __toCommonJS(toString10_exports);
+var import_toString = require("./toString");
+function toString10(value) {
+  return (0, import_toString.toString)(value, "1", "0", void 0);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  toString10
+});

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

@@ -0,0 +1 @@
+export declare function toStringOnOff(value?: boolean): string | undefined;

package/dist/cjs/util/BooleanUtils/toStringOnOff.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/toStringOnOff.ts
+var toStringOnOff_exports = {};
+__export(toStringOnOff_exports, {
+  toStringOnOff: () => toStringOnOff
+});
+module.exports = __toCommonJS(toStringOnOff_exports);
+var import_toString = require("./toString");
+function toStringOnOff(value) {
+  return (0, import_toString.toString)(value, "on", "off", void 0);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  toStringOnOff
+});

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

@@ -0,0 +1 @@
+export declare function toStringTF(value?: boolean): string | undefined;

package/dist/cjs/util/BooleanUtils/toStringTF.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/toStringTF.ts
+var toStringTF_exports = {};
+__export(toStringTF_exports, {
+  toStringTF: () => toStringTF
+});
+module.exports = __toCommonJS(toStringTF_exports);
+var import_toString = require("./toString");
+function toStringTF(value) {
+  return (0, import_toString.toString)(value, "T", "F", void 0);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  toStringTF
+});

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

@@ -0,0 +1 @@
+export declare function toStringTrueFalse(value?: boolean): string | undefined;

package/dist/cjs/util/BooleanUtils/toStringTrueFalse.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/toStringTrueFalse.ts
+var toStringTrueFalse_exports = {};
+__export(toStringTrueFalse_exports, {
+  toStringTrueFalse: () => toStringTrueFalse
+});
+module.exports = __toCommonJS(toStringTrueFalse_exports);
+var import_toString = require("./toString");
+function toStringTrueFalse(value) {
+  return (0, import_toString.toString)(value, "true", "false", void 0);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  toStringTrueFalse
+});

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

@@ -0,0 +1 @@
+export declare function toStringYN(value?: boolean): string | undefined;