@zthun/trilean 2.0.15 → 2.0.18

package/dist/index.cjs

@@ -21,25 +21,7 @@ Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
  * ```ts
  * const value: indeterminate = ZTrilean.Indeterminate;
  * ```
- */ function _class_call_check(instance, Constructor) {
-    if (!(instance instanceof Constructor)) {
-        throw new TypeError("Cannot call a class as a function");
-    }
-}
-function _defineProperties(target, props) {
-    for(var i = 0; i < props.length; i++){
-        var descriptor = props[i];
-        descriptor.enumerable = descriptor.enumerable || false;
-        descriptor.configurable = true;
-        if ("value" in descriptor) descriptor.writable = true;
-        Object.defineProperty(target, descriptor.key, descriptor);
-    }
-}
-function _create_class(Constructor, protoProps, staticProps) {
-    if (staticProps) _defineProperties(Constructor, staticProps);
-    return Constructor;
-}
-function _define_property(obj, key, value) {
+ */ function _define_property(obj, key, value) {
     if (key in obj) {
         Object.defineProperty(obj, key, {
             value: value,
@@ -54,14 +36,8 @@ function _define_property(obj, key, value) {
 }
 /**
  * A utility class for trilean values.
- */ var ZTrilean = /*#__PURE__*/ function() {
-    function ZTrilean() {
-        _class_call_check(this, ZTrilean);
-    }
-    _create_class(ZTrilean, null, [
-        {
-            key: "stringify",
-            value: /**
+ */ class ZTrilean {
+    /**
    * Converts a trilean value to a string.
    *
    * @param x -
@@ -70,13 +46,10 @@ function _define_property(obj, key, value) {
    * @returns
    *        A string of true if x is true, false if x is false,
    *        and indeterminate if x is the indeterminate symbol.
-   */ function stringify(x) {
-                return String(x);
-            }
-        },
-        {
-            key: "parse",
-            value: /**
+   */ static stringify(x) {
+        return String(x);
+    }
+    /**
    * Converts a string to a trilean value.
    *
    * @param str -
@@ -87,23 +60,19 @@ function _define_property(obj, key, value) {
    * @returns
    *        The parsed trilean value or fallback if str is not a valid
    *        trilean value.
-   */ function parse(str) {
-                var fallback = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : false;
-                if ((str === null || str === void 0 ? void 0 : str.toUpperCase().localeCompare("TRUE")) === 0) {
-                    return true;
-                }
-                if ((str === null || str === void 0 ? void 0 : str.toUpperCase().localeCompare("FALSE")) === 0) {
-                    return false;
-                }
-                if ((str === null || str === void 0 ? void 0 : str.toUpperCase().localeCompare("INDETERMINATE")) === 0) {
-                    return ZTrilean.Indeterminate;
-                }
-                return fallback;
-            }
-        },
-        {
-            key: "is",
-            value: /**
+   */ static parse(str, fallback = false) {
+        if (str?.toUpperCase().localeCompare("TRUE") === 0) {
+            return true;
+        }
+        if (str?.toUpperCase().localeCompare("FALSE") === 0) {
+            return false;
+        }
+        if (str?.toUpperCase().localeCompare("INDETERMINATE") === 0) {
+            return ZTrilean.Indeterminate;
+        }
+        return fallback;
+    }
+    /**
    * Gets a value that determines if val is a trilean supported value.
    *
    * @param val -
@@ -111,21 +80,15 @@ function _define_property(obj, key, value) {
    *
    * @returns
    *        True if val is a trilean value.  False otherwise.
-   */ function is(val) {
-                return typeof val === "boolean" || ZTrilean.isIndeterminate(val);
-            }
-        },
-        {
-            key: "isIndeterminate",
-            value: /**
+   */ static is(val) {
+        return typeof val === "boolean" || ZTrilean.isIndeterminate(val);
+    }
+    /**
    * Gets whether val is the indeterminate value.
-   */ function isIndeterminate(val) {
-                return val === ZTrilean.Indeterminate;
-            }
-        },
-        {
-            key: "convert",
-            value: /**
+   */ static isIndeterminate(val) {
+        return val === ZTrilean.Indeterminate;
+    }
+    /**
    * Converts from a value to a trilean value.
    *
    * This is similar to parse, but it also supports non
@@ -144,23 +107,19 @@ function _define_property(obj, key, value) {
    *        directly returned.  If val is equal to {@link Indeterminate}, then
    *        {@link Indeterminate} will be returned.  Otherwise, the truthy
    *        nature of value will be returned.
-   */ function convert(val) {
-                var fallback = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : false;
-                if (val == null) {
-                    return fallback;
-                }
-                if (ZTrilean.is(val)) {
-                    return val;
-                }
-                if (typeof val === "string") {
-                    return ZTrilean.parse(val, fallback);
-                }
-                return !!val;
-            }
+   */ static convert(val, fallback = false) {
+        if (val == null) {
+            return fallback;
         }
-    ]);
-    return ZTrilean;
-}();
+        if (ZTrilean.is(val)) {
+            return val;
+        }
+        if (typeof val === "string") {
+            return ZTrilean.parse(val, fallback);
+        }
+        return !!val;
+    }
+}
 /**
    * A constant value that represents an indeterminate value.
    */ _define_property(ZTrilean, "Indeterminate", "indeterminate");

package/dist/index.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"index.cjs","sources":["../src/trilean.mts"],"sourcesContent":["/**\n * The indeterminate type.\n *\n * Note that the indeterminate type is officially a string\n * here instead of null.  This is by design since null\n * is considered to have no value.\n *\n * Instead of checking for the indeterminate string, always\n * make sure to use ZTrilean.isIndeterminate(val) to check\n * for this type.\n *\n * When setting the indeterminate value, use\n * ZTrilean.Indeterminate as the value to set.\n *\n * @example\n *\n * ```ts\n * const value: indeterminate = ZTrilean.Indeterminate;\n * ```\n */\nexport type indeterminate = \"indeterminate\";\n\n/**\n * Represents a tri logic state.\n *\n * See {@link indeterminate} for what the symbol value should be.\n */\nexport type trilean = boolean | indeterminate;\n\n/**\n * A utility class for trilean values.\n */\nexport abstract class ZTrilean {\n  /**\n   * A constant value that represents an indeterminate value.\n   */\n  public static readonly Indeterminate: indeterminate = \"indeterminate\";\n\n  /**\n   * Converts a trilean value to a string.\n   *\n   * @param x -\n   *        The value to convert.\n   *\n   * @returns\n   *        A string of true if x is true, false if x is false,\n   *        and indeterminate if x is the indeterminate symbol.\n   */\n  public static stringify(x: trilean): string {\n    return String(x);\n  }\n\n  /**\n   * Converts a string to a trilean value.\n   *\n   * @param str -\n   *        The text to parse.\n   * @param fallback -\n   *        The fallback in the case that str is not a parsable value.\n   *\n   * @returns\n   *        The parsed trilean value or fallback if str is not a valid\n   *        trilean value.\n   */\n  public static parse(\n    str: string | null | undefined,\n    fallback: trilean = false,\n  ): trilean {\n    if (str?.toUpperCase().localeCompare(\"TRUE\") === 0) {\n      return true;\n    }\n\n    if (str?.toUpperCase().localeCompare(\"FALSE\") === 0) {\n      return false;\n    }\n\n    if (str?.toUpperCase().localeCompare(\"INDETERMINATE\") === 0) {\n      return ZTrilean.Indeterminate;\n    }\n\n    return fallback;\n  }\n\n  /**\n   * Gets a value that determines if val is a trilean supported value.\n   *\n   * @param val -\n   *        The value to test.\n   *\n   * @returns\n   *        True if val is a trilean value.  False otherwise.\n   */\n  public static is(val: any): val is trilean {\n    return typeof val === \"boolean\" || ZTrilean.isIndeterminate(val);\n  }\n\n  /**\n   * Gets whether val is the indeterminate value.\n   */\n  public static isIndeterminate(val: trilean): val is indeterminate {\n    return val === ZTrilean.Indeterminate;\n  }\n\n  /**\n   * Converts from a value to a trilean value.\n   *\n   * This is similar to parse, but it also supports non\n   * string inputs which will be converted to a boolean.\n   *\n   * @param val -\n   *        The value to convert.\n   * @param fallback -\n   *        The fallback value in the case that val cannot be converted. This will\n   *        only be used in the case that val is a string, null, or undefined.\n   *\n   * @returns\n   *        The trilean value of val.  If val is null or undefined, then\n   *        fallback is returned.  If val is a string, then the return value of\n   *        {@link parse} will be used.  If val is a boolean, then it will be\n   *        directly returned.  If val is equal to {@link Indeterminate}, then\n   *        {@link Indeterminate} will be returned.  Otherwise, the truthy\n   *        nature of value will be returned.\n   */\n  public static convert(val: any, fallback: trilean = false): trilean {\n    if (val == null) {\n      return fallback;\n    }\n\n    if (ZTrilean.is(val)) {\n      return val;\n    }\n\n    if (typeof val === \"string\") {\n      return ZTrilean.parse(val, fallback);\n    }\n\n    return !!val;\n  }\n}\n"],"names":["ZTrilean","stringify","x","String","parse","str","fallback","toUpperCase","localeCompare","Indeterminate","is","val","isIndeterminate","convert"],"mappings":";;;;AAAA;;;;;;;;;;;;;;;;;;;AAmBC,IAAA,SAAA,iBAAA,CAAA,QAAA,EAAA,WAAA,EAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAUD;;IAGO,IAAeA,QAAAA,iBAAf,WAAA;AAAeA,IAAAA,SAAAA,QAAAA,GAAAA;AAAAA,QAAAA,iBAAAA,CAAAA,IAAAA,EAAAA,QAAAA,CAAAA;;AAAAA,IAAAA,aAAAA,CAAAA,QAAAA,EAAAA,IAAAA,EAAAA;;YAgBNC,GAAAA,EAAAA,WAAAA;;;;;;;;;;MAAd,SAAcA,UAAUC,CAAU,EAAA;AAChC,gBAAA,OAAOC,MAAAA,CAAOD,CAAAA,CAAAA;AAChB,YAAA;;;YAccE,GAAAA,EAAAA,OAAAA;;;;;;;;;;;;MAAd,SAAcA,MACZC,GAA8B,EAAA;AAC9BC,gBAAAA,IAAAA,QAAAA,GAAAA,SAAAA,CAAAA,MAAAA,GAAAA,CAAAA,IAAAA,SAAAA,CAAAA,CAAAA,CAAAA,KAAAA,MAAAA,GAAAA,SAAAA,CAAAA,CAAAA,CAAAA,GAAoB,KAAA;gBAEpB,IAAID,CAAAA,gBAAAA,GAAAA,KAAAA,MAAAA,GAAAA,MAAAA,GAAAA,GAAAA,CAAKE,WAAW,EAAA,CAAGC,aAAa,CAAC,MAAA,CAAA,MAAY,CAAA,EAAG;oBAClD,OAAO,IAAA;AACT,gBAAA;gBAEA,IAAIH,CAAAA,gBAAAA,GAAAA,KAAAA,MAAAA,GAAAA,MAAAA,GAAAA,GAAAA,CAAKE,WAAW,EAAA,CAAGC,aAAa,CAAC,OAAA,CAAA,MAAa,CAAA,EAAG;oBACnD,OAAO,KAAA;AACT,gBAAA;gBAEA,IAAIH,CAAAA,gBAAAA,GAAAA,KAAAA,MAAAA,GAAAA,MAAAA,GAAAA,GAAAA,CAAKE,WAAW,EAAA,CAAGC,aAAa,CAAC,eAAA,CAAA,MAAqB,CAAA,EAAG;oBAC3D,OA7CgBR,SA6CAS,aAAa;AAC/B,gBAAA;gBAEA,OAAOH,QAAAA;AACT,YAAA;;;YAWcI,GAAAA,EAAAA,IAAAA;;;;;;;;;MAAd,SAAcA,GAAGC,GAAQ,EAAA;AACvB,gBAAA,OAAO,OAAOA,GAAAA,KAAQ,SAAA,IAAaX,QA7DjBA,CA6D0BY,eAAe,CAACD,GAAAA,CAAAA;AAC9D,YAAA;;;YAKcC,GAAAA,EAAAA,iBAAAA;;;MAAd,SAAcA,gBAAgBD,GAAY,EAAA;gBACxC,OAAOA,GAAAA,KAAQX,QApEGA,CAoEMS,aAAa;AACvC,YAAA;;;YAsBcI,GAAAA,EAAAA,SAAAA;;;;;;;;;;;;;;;;;;;;MAAd,SAAcA,QAAQF,GAAQ,EAAA;AAAEL,gBAAAA,IAAAA,QAAAA,GAAAA,SAAAA,CAAAA,MAAAA,GAAAA,CAAAA,IAAAA,SAAAA,CAAAA,CAAAA,CAAAA,KAAAA,MAAAA,GAAAA,SAAAA,CAAAA,CAAAA,CAAAA,GAAoB,KAAA;AAClD,gBAAA,IAAIK,OAAO,IAAA,EAAM;oBACf,OAAOL,QAAAA;AACT,gBAAA;AAEA,gBAAA,IAAIN,QAhGcA,CAgGLU,EAAE,CAACC,GAAAA,CAAAA,EAAM;oBACpB,OAAOA,GAAAA;AACT,gBAAA;gBAEA,IAAI,OAAOA,QAAQ,QAAA,EAAU;AAC3B,oBAAA,OAAOX,QArGSA,CAqGAI,KAAK,CAACO,GAAAA,EAAKL,QAAAA,CAAAA;AAC7B,gBAAA;AAEA,gBAAA,OAAO,CAAC,CAACK,GAAAA;AACX,YAAA;;;AAzGoBX,IAAAA,OAAAA,QAAAA;AA0GrB,CAAA;AAzGC;;MAGA,gBAAA,CAJoBA,UAIGS,eAAAA,EAA+B,eAAA,CAAA;;;;"}
+{"version":3,"file":"index.cjs","sources":["../src/trilean.mts"],"sourcesContent":["/**\n * The indeterminate type.\n *\n * Note that the indeterminate type is officially a string\n * here instead of null.  This is by design since null\n * is considered to have no value.\n *\n * Instead of checking for the indeterminate string, always\n * make sure to use ZTrilean.isIndeterminate(val) to check\n * for this type.\n *\n * When setting the indeterminate value, use\n * ZTrilean.Indeterminate as the value to set.\n *\n * @example\n *\n * ```ts\n * const value: indeterminate = ZTrilean.Indeterminate;\n * ```\n */\nexport type indeterminate = \"indeterminate\";\n\n/**\n * Represents a tri logic state.\n *\n * See {@link indeterminate} for what the symbol value should be.\n */\nexport type trilean = boolean | indeterminate;\n\n/**\n * A utility class for trilean values.\n */\nexport abstract class ZTrilean {\n  /**\n   * A constant value that represents an indeterminate value.\n   */\n  public static readonly Indeterminate: indeterminate = \"indeterminate\";\n\n  /**\n   * Converts a trilean value to a string.\n   *\n   * @param x -\n   *        The value to convert.\n   *\n   * @returns\n   *        A string of true if x is true, false if x is false,\n   *        and indeterminate if x is the indeterminate symbol.\n   */\n  public static stringify(x: trilean): string {\n    return String(x);\n  }\n\n  /**\n   * Converts a string to a trilean value.\n   *\n   * @param str -\n   *        The text to parse.\n   * @param fallback -\n   *        The fallback in the case that str is not a parsable value.\n   *\n   * @returns\n   *        The parsed trilean value or fallback if str is not a valid\n   *        trilean value.\n   */\n  public static parse(\n    str: string | null | undefined,\n    fallback: trilean = false,\n  ): trilean {\n    if (str?.toUpperCase().localeCompare(\"TRUE\") === 0) {\n      return true;\n    }\n\n    if (str?.toUpperCase().localeCompare(\"FALSE\") === 0) {\n      return false;\n    }\n\n    if (str?.toUpperCase().localeCompare(\"INDETERMINATE\") === 0) {\n      return ZTrilean.Indeterminate;\n    }\n\n    return fallback;\n  }\n\n  /**\n   * Gets a value that determines if val is a trilean supported value.\n   *\n   * @param val -\n   *        The value to test.\n   *\n   * @returns\n   *        True if val is a trilean value.  False otherwise.\n   */\n  public static is(val: any): val is trilean {\n    return typeof val === \"boolean\" || ZTrilean.isIndeterminate(val);\n  }\n\n  /**\n   * Gets whether val is the indeterminate value.\n   */\n  public static isIndeterminate(val: trilean): val is indeterminate {\n    return val === ZTrilean.Indeterminate;\n  }\n\n  /**\n   * Converts from a value to a trilean value.\n   *\n   * This is similar to parse, but it also supports non\n   * string inputs which will be converted to a boolean.\n   *\n   * @param val -\n   *        The value to convert.\n   * @param fallback -\n   *        The fallback value in the case that val cannot be converted. This will\n   *        only be used in the case that val is a string, null, or undefined.\n   *\n   * @returns\n   *        The trilean value of val.  If val is null or undefined, then\n   *        fallback is returned.  If val is a string, then the return value of\n   *        {@link parse} will be used.  If val is a boolean, then it will be\n   *        directly returned.  If val is equal to {@link Indeterminate}, then\n   *        {@link Indeterminate} will be returned.  Otherwise, the truthy\n   *        nature of value will be returned.\n   */\n  public static convert(val: any, fallback: trilean = false): trilean {\n    if (val == null) {\n      return fallback;\n    }\n\n    if (ZTrilean.is(val)) {\n      return val;\n    }\n\n    if (typeof val === \"string\") {\n      return ZTrilean.parse(val, fallback);\n    }\n\n    return !!val;\n  }\n}\n"],"names":["ZTrilean","stringify","x","String","parse","str","fallback","toUpperCase","localeCompare","Indeterminate","is","val","isIndeterminate","convert"],"mappings":";;;;AAAA;;;;;;;;;;;;;;;;;;;AAmBC,IAAA,SAAA,gBAAA,CAAA,GAAA,EAAA,GAAA,EAAA,KAAA,EAAA;;;;;;;;;;;;;AAUD;;AAEC,IACM,MAAeA,QAAAA,CAAAA;AAMpB;;;;;;;;;MAUA,OAAcC,SAAAA,CAAUC,CAAU,EAAU;AAC1C,QAAA,OAAOC,MAAAA,CAAOD,CAAAA,CAAAA;AAChB,IAAA;AAEA;;;;;;;;;;;AAWC,MACD,OAAcE,KAAAA,CACZC,GAA8B,EAC9BC,QAAAA,GAAoB,KAAK,EAChB;AACT,QAAA,IAAID,GAAAA,EAAKE,WAAAA,EAAAA,CAAcC,aAAAA,CAAc,MAAA,CAAA,KAAY,CAAA,EAAG;YAClD,OAAO,IAAA;AACT,QAAA;AAEA,QAAA,IAAIH,GAAAA,EAAKE,WAAAA,EAAAA,CAAcC,aAAAA,CAAc,OAAA,CAAA,KAAa,CAAA,EAAG;YACnD,OAAO,KAAA;AACT,QAAA;AAEA,QAAA,IAAIH,GAAAA,EAAKE,WAAAA,EAAAA,CAAcC,aAAAA,CAAc,eAAA,CAAA,KAAqB,CAAA,EAAG;AAC3D,YAAA,OAAOR,SAASS,aAAa;AAC/B,QAAA;QAEA,OAAOH,QAAAA;AACT,IAAA;AAEA;;;;;;;;MASA,OAAcI,EAAAA,CAAGC,GAAQ,EAAkB;AACzC,QAAA,OAAO,OAAOA,GAAAA,KAAQ,SAAA,IAAaX,QAAAA,CAASY,eAAe,CAACD,GAAAA,CAAAA;AAC9D,IAAA;AAEA;;MAGA,OAAcC,eAAAA,CAAgBD,GAAY,EAAwB;QAChE,OAAOA,GAAAA,KAAQX,SAASS,aAAa;AACvC,IAAA;AAEA;;;;;;;;;;;;;;;;;;;AAmBC,MACD,OAAcI,OAAAA,CAAQF,GAAQ,EAAEL,QAAAA,GAAoB,KAAK,EAAW;AAClE,QAAA,IAAIK,OAAO,IAAA,EAAM;YACf,OAAOL,QAAAA;AACT,QAAA;QAEA,IAAIN,QAAAA,CAASU,EAAE,CAACC,GAAAA,CAAAA,EAAM;YACpB,OAAOA,GAAAA;AACT,QAAA;QAEA,IAAI,OAAOA,QAAQ,QAAA,EAAU;YAC3B,OAAOX,QAAAA,CAASI,KAAK,CAACO,GAAAA,EAAKL,QAAAA,CAAAA;AAC7B,QAAA;AAEA,QAAA,OAAO,CAAC,CAACK,GAAAA;AACX,IAAA;AACF;AAzGE;;MAGA,gBAAA,CAJoBX,UAIGS,eAAAA,EAA+B,eAAA,CAAA;;;;"}

package/dist/index.js

@@ -17,25 +17,7 @@
  * ```ts
  * const value: indeterminate = ZTrilean.Indeterminate;
  * ```
- */ function _class_call_check(instance, Constructor) {
-    if (!(instance instanceof Constructor)) {
-        throw new TypeError("Cannot call a class as a function");
-    }
-}
-function _defineProperties(target, props) {
-    for(var i = 0; i < props.length; i++){
-        var descriptor = props[i];
-        descriptor.enumerable = descriptor.enumerable || false;
-        descriptor.configurable = true;
-        if ("value" in descriptor) descriptor.writable = true;
-        Object.defineProperty(target, descriptor.key, descriptor);
-    }
-}
-function _create_class(Constructor, protoProps, staticProps) {
-    if (staticProps) _defineProperties(Constructor, staticProps);
-    return Constructor;
-}
-function _define_property(obj, key, value) {
+ */ function _define_property(obj, key, value) {
     if (key in obj) {
         Object.defineProperty(obj, key, {
             value: value,
@@ -50,14 +32,8 @@ function _define_property(obj, key, value) {
 }
 /**
  * A utility class for trilean values.
- */ var ZTrilean = /*#__PURE__*/ function() {
-    function ZTrilean() {
-        _class_call_check(this, ZTrilean);
-    }
-    _create_class(ZTrilean, null, [
-        {
-            key: "stringify",
-            value: /**
+ */ class ZTrilean {
+    /**
    * Converts a trilean value to a string.
    *
    * @param x -
@@ -66,13 +42,10 @@ function _define_property(obj, key, value) {
    * @returns
    *        A string of true if x is true, false if x is false,
    *        and indeterminate if x is the indeterminate symbol.
-   */ function stringify(x) {
-                return String(x);
-            }
-        },
-        {
-            key: "parse",
-            value: /**
+   */ static stringify(x) {
+        return String(x);
+    }
+    /**
    * Converts a string to a trilean value.
    *
    * @param str -
@@ -83,23 +56,19 @@ function _define_property(obj, key, value) {
    * @returns
    *        The parsed trilean value or fallback if str is not a valid
    *        trilean value.
-   */ function parse(str) {
-                var fallback = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : false;
-                if ((str === null || str === void 0 ? void 0 : str.toUpperCase().localeCompare("TRUE")) === 0) {
-                    return true;
-                }
-                if ((str === null || str === void 0 ? void 0 : str.toUpperCase().localeCompare("FALSE")) === 0) {
-                    return false;
-                }
-                if ((str === null || str === void 0 ? void 0 : str.toUpperCase().localeCompare("INDETERMINATE")) === 0) {
-                    return ZTrilean.Indeterminate;
-                }
-                return fallback;
-            }
-        },
-        {
-            key: "is",
-            value: /**
+   */ static parse(str, fallback = false) {
+        if (str?.toUpperCase().localeCompare("TRUE") === 0) {
+            return true;
+        }
+        if (str?.toUpperCase().localeCompare("FALSE") === 0) {
+            return false;
+        }
+        if (str?.toUpperCase().localeCompare("INDETERMINATE") === 0) {
+            return ZTrilean.Indeterminate;
+        }
+        return fallback;
+    }
+    /**
    * Gets a value that determines if val is a trilean supported value.
    *
    * @param val -
@@ -107,21 +76,15 @@ function _define_property(obj, key, value) {
    *
    * @returns
    *        True if val is a trilean value.  False otherwise.
-   */ function is(val) {
-                return typeof val === "boolean" || ZTrilean.isIndeterminate(val);
-            }
-        },
-        {
-            key: "isIndeterminate",
-            value: /**
+   */ static is(val) {
+        return typeof val === "boolean" || ZTrilean.isIndeterminate(val);
+    }
+    /**
    * Gets whether val is the indeterminate value.
-   */ function isIndeterminate(val) {
-                return val === ZTrilean.Indeterminate;
-            }
-        },
-        {
-            key: "convert",
-            value: /**
+   */ static isIndeterminate(val) {
+        return val === ZTrilean.Indeterminate;
+    }
+    /**
    * Converts from a value to a trilean value.
    *
    * This is similar to parse, but it also supports non
@@ -140,23 +103,19 @@ function _define_property(obj, key, value) {
    *        directly returned.  If val is equal to {@link Indeterminate}, then
    *        {@link Indeterminate} will be returned.  Otherwise, the truthy
    *        nature of value will be returned.
-   */ function convert(val) {
-                var fallback = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : false;
-                if (val == null) {
-                    return fallback;
-                }
-                if (ZTrilean.is(val)) {
-                    return val;
-                }
-                if (typeof val === "string") {
-                    return ZTrilean.parse(val, fallback);
-                }
-                return !!val;
-            }
+   */ static convert(val, fallback = false) {
+        if (val == null) {
+            return fallback;
         }
-    ]);
-    return ZTrilean;
-}();
+        if (ZTrilean.is(val)) {
+            return val;
+        }
+        if (typeof val === "string") {
+            return ZTrilean.parse(val, fallback);
+        }
+        return !!val;
+    }
+}
 /**
    * A constant value that represents an indeterminate value.
    */ _define_property(ZTrilean, "Indeterminate", "indeterminate");

package/dist/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sources":["../src/trilean.mts"],"sourcesContent":["/**\n * The indeterminate type.\n *\n * Note that the indeterminate type is officially a string\n * here instead of null.  This is by design since null\n * is considered to have no value.\n *\n * Instead of checking for the indeterminate string, always\n * make sure to use ZTrilean.isIndeterminate(val) to check\n * for this type.\n *\n * When setting the indeterminate value, use\n * ZTrilean.Indeterminate as the value to set.\n *\n * @example\n *\n * ```ts\n * const value: indeterminate = ZTrilean.Indeterminate;\n * ```\n */\nexport type indeterminate = \"indeterminate\";\n\n/**\n * Represents a tri logic state.\n *\n * See {@link indeterminate} for what the symbol value should be.\n */\nexport type trilean = boolean | indeterminate;\n\n/**\n * A utility class for trilean values.\n */\nexport abstract class ZTrilean {\n  /**\n   * A constant value that represents an indeterminate value.\n   */\n  public static readonly Indeterminate: indeterminate = \"indeterminate\";\n\n  /**\n   * Converts a trilean value to a string.\n   *\n   * @param x -\n   *        The value to convert.\n   *\n   * @returns\n   *        A string of true if x is true, false if x is false,\n   *        and indeterminate if x is the indeterminate symbol.\n   */\n  public static stringify(x: trilean): string {\n    return String(x);\n  }\n\n  /**\n   * Converts a string to a trilean value.\n   *\n   * @param str -\n   *        The text to parse.\n   * @param fallback -\n   *        The fallback in the case that str is not a parsable value.\n   *\n   * @returns\n   *        The parsed trilean value or fallback if str is not a valid\n   *        trilean value.\n   */\n  public static parse(\n    str: string | null | undefined,\n    fallback: trilean = false,\n  ): trilean {\n    if (str?.toUpperCase().localeCompare(\"TRUE\") === 0) {\n      return true;\n    }\n\n    if (str?.toUpperCase().localeCompare(\"FALSE\") === 0) {\n      return false;\n    }\n\n    if (str?.toUpperCase().localeCompare(\"INDETERMINATE\") === 0) {\n      return ZTrilean.Indeterminate;\n    }\n\n    return fallback;\n  }\n\n  /**\n   * Gets a value that determines if val is a trilean supported value.\n   *\n   * @param val -\n   *        The value to test.\n   *\n   * @returns\n   *        True if val is a trilean value.  False otherwise.\n   */\n  public static is(val: any): val is trilean {\n    return typeof val === \"boolean\" || ZTrilean.isIndeterminate(val);\n  }\n\n  /**\n   * Gets whether val is the indeterminate value.\n   */\n  public static isIndeterminate(val: trilean): val is indeterminate {\n    return val === ZTrilean.Indeterminate;\n  }\n\n  /**\n   * Converts from a value to a trilean value.\n   *\n   * This is similar to parse, but it also supports non\n   * string inputs which will be converted to a boolean.\n   *\n   * @param val -\n   *        The value to convert.\n   * @param fallback -\n   *        The fallback value in the case that val cannot be converted. This will\n   *        only be used in the case that val is a string, null, or undefined.\n   *\n   * @returns\n   *        The trilean value of val.  If val is null or undefined, then\n   *        fallback is returned.  If val is a string, then the return value of\n   *        {@link parse} will be used.  If val is a boolean, then it will be\n   *        directly returned.  If val is equal to {@link Indeterminate}, then\n   *        {@link Indeterminate} will be returned.  Otherwise, the truthy\n   *        nature of value will be returned.\n   */\n  public static convert(val: any, fallback: trilean = false): trilean {\n    if (val == null) {\n      return fallback;\n    }\n\n    if (ZTrilean.is(val)) {\n      return val;\n    }\n\n    if (typeof val === \"string\") {\n      return ZTrilean.parse(val, fallback);\n    }\n\n    return !!val;\n  }\n}\n"],"names":["ZTrilean","stringify","x","String","parse","str","fallback","toUpperCase","localeCompare","Indeterminate","is","val","isIndeterminate","convert"],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;AAmBC,IAAA,SAAA,iBAAA,CAAA,QAAA,EAAA,WAAA,EAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAUD;;IAGO,IAAeA,QAAAA,iBAAf,WAAA;AAAeA,IAAAA,SAAAA,QAAAA,GAAAA;AAAAA,QAAAA,iBAAAA,CAAAA,IAAAA,EAAAA,QAAAA,CAAAA;;AAAAA,IAAAA,aAAAA,CAAAA,QAAAA,EAAAA,IAAAA,EAAAA;;YAgBNC,GAAAA,EAAAA,WAAAA;;;;;;;;;;MAAd,SAAcA,UAAUC,CAAU,EAAA;AAChC,gBAAA,OAAOC,MAAAA,CAAOD,CAAAA,CAAAA;AAChB,YAAA;;;YAccE,GAAAA,EAAAA,OAAAA;;;;;;;;;;;;MAAd,SAAcA,MACZC,GAA8B,EAAA;AAC9BC,gBAAAA,IAAAA,QAAAA,GAAAA,SAAAA,CAAAA,MAAAA,GAAAA,CAAAA,IAAAA,SAAAA,CAAAA,CAAAA,CAAAA,KAAAA,MAAAA,GAAAA,SAAAA,CAAAA,CAAAA,CAAAA,GAAoB,KAAA;gBAEpB,IAAID,CAAAA,gBAAAA,GAAAA,KAAAA,MAAAA,GAAAA,MAAAA,GAAAA,GAAAA,CAAKE,WAAW,EAAA,CAAGC,aAAa,CAAC,MAAA,CAAA,MAAY,CAAA,EAAG;oBAClD,OAAO,IAAA;AACT,gBAAA;gBAEA,IAAIH,CAAAA,gBAAAA,GAAAA,KAAAA,MAAAA,GAAAA,MAAAA,GAAAA,GAAAA,CAAKE,WAAW,EAAA,CAAGC,aAAa,CAAC,OAAA,CAAA,MAAa,CAAA,EAAG;oBACnD,OAAO,KAAA;AACT,gBAAA;gBAEA,IAAIH,CAAAA,gBAAAA,GAAAA,KAAAA,MAAAA,GAAAA,MAAAA,GAAAA,GAAAA,CAAKE,WAAW,EAAA,CAAGC,aAAa,CAAC,eAAA,CAAA,MAAqB,CAAA,EAAG;oBAC3D,OA7CgBR,SA6CAS,aAAa;AAC/B,gBAAA;gBAEA,OAAOH,QAAAA;AACT,YAAA;;;YAWcI,GAAAA,EAAAA,IAAAA;;;;;;;;;MAAd,SAAcA,GAAGC,GAAQ,EAAA;AACvB,gBAAA,OAAO,OAAOA,GAAAA,KAAQ,SAAA,IAAaX,QA7DjBA,CA6D0BY,eAAe,CAACD,GAAAA,CAAAA;AAC9D,YAAA;;;YAKcC,GAAAA,EAAAA,iBAAAA;;;MAAd,SAAcA,gBAAgBD,GAAY,EAAA;gBACxC,OAAOA,GAAAA,KAAQX,QApEGA,CAoEMS,aAAa;AACvC,YAAA;;;YAsBcI,GAAAA,EAAAA,SAAAA;;;;;;;;;;;;;;;;;;;;MAAd,SAAcA,QAAQF,GAAQ,EAAA;AAAEL,gBAAAA,IAAAA,QAAAA,GAAAA,SAAAA,CAAAA,MAAAA,GAAAA,CAAAA,IAAAA,SAAAA,CAAAA,CAAAA,CAAAA,KAAAA,MAAAA,GAAAA,SAAAA,CAAAA,CAAAA,CAAAA,GAAoB,KAAA;AAClD,gBAAA,IAAIK,OAAO,IAAA,EAAM;oBACf,OAAOL,QAAAA;AACT,gBAAA;AAEA,gBAAA,IAAIN,QAhGcA,CAgGLU,EAAE,CAACC,GAAAA,CAAAA,EAAM;oBACpB,OAAOA,GAAAA;AACT,gBAAA;gBAEA,IAAI,OAAOA,QAAQ,QAAA,EAAU;AAC3B,oBAAA,OAAOX,QArGSA,CAqGAI,KAAK,CAACO,GAAAA,EAAKL,QAAAA,CAAAA;AAC7B,gBAAA;AAEA,gBAAA,OAAO,CAAC,CAACK,GAAAA;AACX,YAAA;;;AAzGoBX,IAAAA,OAAAA,QAAAA;AA0GrB,CAAA;AAzGC;;MAGA,gBAAA,CAJoBA,UAIGS,eAAAA,EAA+B,eAAA,CAAA;;;;"}
+{"version":3,"file":"index.js","sources":["../src/trilean.mts"],"sourcesContent":["/**\n * The indeterminate type.\n *\n * Note that the indeterminate type is officially a string\n * here instead of null.  This is by design since null\n * is considered to have no value.\n *\n * Instead of checking for the indeterminate string, always\n * make sure to use ZTrilean.isIndeterminate(val) to check\n * for this type.\n *\n * When setting the indeterminate value, use\n * ZTrilean.Indeterminate as the value to set.\n *\n * @example\n *\n * ```ts\n * const value: indeterminate = ZTrilean.Indeterminate;\n * ```\n */\nexport type indeterminate = \"indeterminate\";\n\n/**\n * Represents a tri logic state.\n *\n * See {@link indeterminate} for what the symbol value should be.\n */\nexport type trilean = boolean | indeterminate;\n\n/**\n * A utility class for trilean values.\n */\nexport abstract class ZTrilean {\n  /**\n   * A constant value that represents an indeterminate value.\n   */\n  public static readonly Indeterminate: indeterminate = \"indeterminate\";\n\n  /**\n   * Converts a trilean value to a string.\n   *\n   * @param x -\n   *        The value to convert.\n   *\n   * @returns\n   *        A string of true if x is true, false if x is false,\n   *        and indeterminate if x is the indeterminate symbol.\n   */\n  public static stringify(x: trilean): string {\n    return String(x);\n  }\n\n  /**\n   * Converts a string to a trilean value.\n   *\n   * @param str -\n   *        The text to parse.\n   * @param fallback -\n   *        The fallback in the case that str is not a parsable value.\n   *\n   * @returns\n   *        The parsed trilean value or fallback if str is not a valid\n   *        trilean value.\n   */\n  public static parse(\n    str: string | null | undefined,\n    fallback: trilean = false,\n  ): trilean {\n    if (str?.toUpperCase().localeCompare(\"TRUE\") === 0) {\n      return true;\n    }\n\n    if (str?.toUpperCase().localeCompare(\"FALSE\") === 0) {\n      return false;\n    }\n\n    if (str?.toUpperCase().localeCompare(\"INDETERMINATE\") === 0) {\n      return ZTrilean.Indeterminate;\n    }\n\n    return fallback;\n  }\n\n  /**\n   * Gets a value that determines if val is a trilean supported value.\n   *\n   * @param val -\n   *        The value to test.\n   *\n   * @returns\n   *        True if val is a trilean value.  False otherwise.\n   */\n  public static is(val: any): val is trilean {\n    return typeof val === \"boolean\" || ZTrilean.isIndeterminate(val);\n  }\n\n  /**\n   * Gets whether val is the indeterminate value.\n   */\n  public static isIndeterminate(val: trilean): val is indeterminate {\n    return val === ZTrilean.Indeterminate;\n  }\n\n  /**\n   * Converts from a value to a trilean value.\n   *\n   * This is similar to parse, but it also supports non\n   * string inputs which will be converted to a boolean.\n   *\n   * @param val -\n   *        The value to convert.\n   * @param fallback -\n   *        The fallback value in the case that val cannot be converted. This will\n   *        only be used in the case that val is a string, null, or undefined.\n   *\n   * @returns\n   *        The trilean value of val.  If val is null or undefined, then\n   *        fallback is returned.  If val is a string, then the return value of\n   *        {@link parse} will be used.  If val is a boolean, then it will be\n   *        directly returned.  If val is equal to {@link Indeterminate}, then\n   *        {@link Indeterminate} will be returned.  Otherwise, the truthy\n   *        nature of value will be returned.\n   */\n  public static convert(val: any, fallback: trilean = false): trilean {\n    if (val == null) {\n      return fallback;\n    }\n\n    if (ZTrilean.is(val)) {\n      return val;\n    }\n\n    if (typeof val === \"string\") {\n      return ZTrilean.parse(val, fallback);\n    }\n\n    return !!val;\n  }\n}\n"],"names":["ZTrilean","stringify","x","String","parse","str","fallback","toUpperCase","localeCompare","Indeterminate","is","val","isIndeterminate","convert"],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;AAmBC,IAAA,SAAA,gBAAA,CAAA,GAAA,EAAA,GAAA,EAAA,KAAA,EAAA;;;;;;;;;;;;;AAUD;;AAEC,IACM,MAAeA,QAAAA,CAAAA;AAMpB;;;;;;;;;MAUA,OAAcC,SAAAA,CAAUC,CAAU,EAAU;AAC1C,QAAA,OAAOC,MAAAA,CAAOD,CAAAA,CAAAA;AAChB,IAAA;AAEA;;;;;;;;;;;AAWC,MACD,OAAcE,KAAAA,CACZC,GAA8B,EAC9BC,QAAAA,GAAoB,KAAK,EAChB;AACT,QAAA,IAAID,GAAAA,EAAKE,WAAAA,EAAAA,CAAcC,aAAAA,CAAc,MAAA,CAAA,KAAY,CAAA,EAAG;YAClD,OAAO,IAAA;AACT,QAAA;AAEA,QAAA,IAAIH,GAAAA,EAAKE,WAAAA,EAAAA,CAAcC,aAAAA,CAAc,OAAA,CAAA,KAAa,CAAA,EAAG;YACnD,OAAO,KAAA;AACT,QAAA;AAEA,QAAA,IAAIH,GAAAA,EAAKE,WAAAA,EAAAA,CAAcC,aAAAA,CAAc,eAAA,CAAA,KAAqB,CAAA,EAAG;AAC3D,YAAA,OAAOR,SAASS,aAAa;AAC/B,QAAA;QAEA,OAAOH,QAAAA;AACT,IAAA;AAEA;;;;;;;;MASA,OAAcI,EAAAA,CAAGC,GAAQ,EAAkB;AACzC,QAAA,OAAO,OAAOA,GAAAA,KAAQ,SAAA,IAAaX,QAAAA,CAASY,eAAe,CAACD,GAAAA,CAAAA;AAC9D,IAAA;AAEA;;MAGA,OAAcC,eAAAA,CAAgBD,GAAY,EAAwB;QAChE,OAAOA,GAAAA,KAAQX,SAASS,aAAa;AACvC,IAAA;AAEA;;;;;;;;;;;;;;;;;;;AAmBC,MACD,OAAcI,OAAAA,CAAQF,GAAQ,EAAEL,QAAAA,GAAoB,KAAK,EAAW;AAClE,QAAA,IAAIK,OAAO,IAAA,EAAM;YACf,OAAOL,QAAAA;AACT,QAAA;QAEA,IAAIN,QAAAA,CAASU,EAAE,CAACC,GAAAA,CAAAA,EAAM;YACpB,OAAOA,GAAAA;AACT,QAAA;QAEA,IAAI,OAAOA,QAAQ,QAAA,EAAU;YAC3B,OAAOX,QAAAA,CAASI,KAAK,CAACO,GAAAA,EAAKL,QAAAA,CAAAA;AAC7B,QAAA;AAEA,QAAA,OAAO,CAAC,CAACK,GAAAA;AACX,IAAA;AACF;AAzGE;;MAGA,gBAAA,CAJoBX,UAIGS,eAAAA,EAA+B,eAAA,CAAA;;;;"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zthun/trilean",
-  "version": "2.0.15",
+  "version": "2.0.18",
   "description": "A tri state boolean logic type.",
   "author": "Anthony Bonta",
   "license": "MIT",
@@ -25,15 +25,15 @@
     "access": "public"
   },
   "devDependencies": {
-    "@zthun/janitor-build-config": "^19.4.2",
+    "@zthun/janitor-build-config": "^19.5.4",
     "typescript": "~5.9.3",
-    "vite": "^7.1.12",
-    "vitest": "^4.0.5",
+    "vite": "^7.3.0",
+    "vitest": "^4.0.16",
     "vitest-mock-extended": "^3.1.0"
   },
   "files": [
     "dist"
   ],
   "sideEffects": false,
-  "gitHead": "87427a7ff28d0a45f21aec1bb8c8a49454d0d766"
+  "gitHead": "8bc0bc00013db1d029c800e3d3cd9680d4cabedd"
 }