effect 4.0.0-beta.65 → 4.0.0-beta.67

package/dist/LogLevel.d.ts

@@ -1,102 +1,41 @@
 /**
- * @since 2.0.0
- *
- * The `LogLevel` module provides utilities for managing log levels in Effect applications.
- * It defines a hierarchy of log levels and provides functions for comparing and filtering logs
- * based on their severity.
- *
- * ## Log Level Hierarchy
- *
- * The log levels are ordered from most severe to least severe:
- *
- * 1. **All** - Special level that allows all messages
- * 2. **Fatal** - System is unusable, immediate attention required
- * 3. **Error** - Error conditions that should be investigated
- * 4. **Warn** - Warning conditions that may indicate problems
- * 5. **Info** - Informational messages about normal operation
- * 6. **Debug** - Debug information useful during development
- * 7. **Trace** - Very detailed trace information
- * 8. **None** - Special level that suppresses all messages
- *
- * ## Basic Usage
- *
- * ```ts
- * import { Effect } from "effect"
- *
- * // Basic log level usage
- * const program = Effect.gen(function*() {
- *   yield* Effect.logFatal("System is shutting down")
- *   yield* Effect.logError("Database connection failed")
- *   yield* Effect.logWarning("Memory usage is high")
- *   yield* Effect.logInfo("User logged in")
- *   yield* Effect.logDebug("Processing request")
- *   yield* Effect.logTrace("Variable value: xyz")
- * })
- * ```
- *
- * ## Level Comparison
- *
- * ```ts
- * import { LogLevel } from "effect"
- *
- * // Check if one level is more severe than another
- * console.log(LogLevel.isGreaterThan("Error", "Info")) // true
- * console.log(LogLevel.isGreaterThan("Debug", "Error")) // false
- *
- * // Check if level meets minimum threshold
- * console.log(LogLevel.isGreaterThanOrEqualTo("Info", "Debug")) // true
- * console.log(LogLevel.isLessThan("Trace", "Info")) // true
- * ```
+ * The `LogLevel` module defines the levels used by Effect logging and the
+ * ordering operations used to compare, filter, and enable log output.
+ *
+ * **Mental model**
+ *
+ * - A `LogLevel` is one of `All`, `Fatal`, `Error`, `Warn`, `Info`, `Debug`,
+ *   `Trace`, or `None`
+ * - `Fatal` is the most severe concrete level and `Trace` is the least severe
+ * - `All` and `None` are sentinel levels: `All` enables every message and
+ *   `None` disables every message
+ * - Ordering follows logging severity, so higher levels are more important and
+ *   lower levels are more verbose
+ * - Filtering is usually expressed as "log this message when its level is
+ *   greater than or equal to the configured minimum"
+ *
+ * **Common tasks**
+ *
+ * - Enumerate levels with {@link values}
+ * - Compare exact levels with {@link Equivalence}
+ * - Sort or compare by severity with {@link Order} and {@link getOrdinal}
+ * - Check thresholds with {@link isGreaterThanOrEqualTo} and
+ *   {@link isLessThanOrEqualTo}
+ * - Test whether a level is enabled for the current fiber with
+ *   {@link isEnabled}
+ *
+ * **Gotchas**
+ *
+ * - `All` and `None` are useful for configuration boundaries, but they are not
+ *   concrete message severities; use {@link Severity} when only emitted message
+ *   levels are valid
+ * - The comparison helpers compare severity, not declaration position in source
+ *   code or alphabetical order
+ * - `isEnabled` reads the current fiber's `MinimumLogLevel` reference, so it is
+ *   context-sensitive; use the pure comparison helpers when checking an
+ *   explicit threshold
  *
- * ## Filtering by Level
- *
- * ```ts
- * import { Logger, LogLevel } from "effect"
- *
- * // Create a logger that only logs Error and above
- * const errorLogger = Logger.make((options) => {
- *   if (LogLevel.isGreaterThanOrEqualTo(options.logLevel, "Error")) {
- *     console.log(`[${options.logLevel}] ${options.message}`)
- *   }
- * })
- *
- * // Production logger - Info and above
- * const productionLogger = Logger.make((options) => {
- *   if (LogLevel.isGreaterThanOrEqualTo(options.logLevel, "Info")) {
- *     console.log(
- *       `${options.date.toISOString()} [${options.logLevel}] ${options.message}`
- *     )
- *   }
- * })
- *
- * // Development logger - Debug and above
- * const devLogger = Logger.make((options) => {
- *   if (LogLevel.isGreaterThanOrEqualTo(options.logLevel, "Debug")) {
- *     console.log(`[${options.logLevel}] ${options.message}`)
- *   }
- * })
- * ```
- *
- * ## Runtime Configuration
- *
- * ```ts
- * import { Config, Effect, Logger, LogLevel } from "effect"
- *
- * // Configure log level from environment
- * const logLevelConfig = Config.string("LOG_LEVEL").pipe(
- *   Config.withDefault("Info")
- * )
- *
- * const configurableLogger = Effect.gen(function*() {
- *   const minLevel = yield* logLevelConfig
- *
- *   return Logger.make((options) => {
- *     if (LogLevel.isGreaterThanOrEqualTo(options.logLevel, minLevel)) {
- *       console.log(`[${options.logLevel}] ${options.message}`)
- *     }
- *   })
- * })
- * ```
+ * @since 2.0.0
  */
 import type * as Effect from "./Effect.ts";
 import * as Equ from "./Equivalence.ts";
@@ -114,7 +53,8 @@ import * as Ord from "./Order.ts";
  * - `Trace` - Very detailed trace information
  * - `None` - Special level that suppresses all messages
  *
- * @example
+ * **Example** (Using log levels)
+ *
  * ```ts
  * import { Effect } from "effect"
  *
@@ -133,18 +73,24 @@ import * as Ord from "./Order.ts";
  * const debugLevel = "Debug" // LogLevel
  * ```
  *
- * @since 4.0.0
  * @category models
+ * @since 4.0.0
  */
 export type LogLevel = "All" | "Fatal" | "Error" | "Warn" | "Info" | "Debug" | "Trace" | "None";
 /**
- * @since 4.0.0
+ * Log levels that represent actual message severities, excluding the `All` and
+ * `None` sentinel levels.
+ *
  * @category models
+ * @since 4.0.0
  */
 export type Severity = "Fatal" | "Error" | "Warn" | "Info" | "Debug" | "Trace";
 /**
- * @since 4.0.0
+ * All `LogLevel` values in order from `All` through the concrete severities to
+ * `None`.
+ *
  * @category models
+ * @since 4.0.0
  */
 export declare const values: ReadonlyArray<LogLevel>;
 /**
@@ -153,7 +99,8 @@ export declare const values: ReadonlyArray<LogLevel>;
  * This order treats "All" as the least restrictive level and "None" as the most restrictive,
  * with Fatal being the most severe actual log level.
  *
- * @example
+ * **Example** (Ordering log levels)
+ *
  * ```ts
  * import { LogLevel } from "effect"
  *
@@ -163,14 +110,15 @@ export declare const values: ReadonlyArray<LogLevel>;
  * console.log(LogLevel.Order("Info", "Info")) // 0 (Info == Info)
  * ```
  *
- * @since 2.0.0
  * @category ordering
+ * @since 2.0.0
  */
 export declare const Order: Ord.Order<LogLevel>;
 /**
  * An `Equivalence` instance for log levels using strict equality (`===`).
  *
- * @example
+ * **Example** (Comparing log levels)
+ *
  * ```ts
  * import { LogLevel } from "effect"
  *
@@ -185,8 +133,8 @@ export declare const Equivalence: Equ.Equivalence<LogLevel>;
 /**
  * Returns the ordinal value of the log level.
  *
- * @since 4.0.0
  * @category ordering
+ * @since 4.0.0
  */
 export declare const getOrdinal: (self: LogLevel) => number;
 /**
@@ -195,7 +143,8 @@ export declare const getOrdinal: (self: LogLevel) => number;
  * Returns `true` if `self` represents a more severe level than `that`.
  * This is useful for filtering logs based on minimum severity requirements.
  *
- * @example
+ * **Example** (Checking higher severity)
+ *
  * ```ts
  * import { LogLevel } from "effect"
  *
@@ -217,8 +166,8 @@ export declare const getOrdinal: (self: LogLevel) => number;
  * console.log(isMoreSevereThanInfo("Debug")) // false
  * ```
  *
- * @since 2.0.0
  * @category ordering
+ * @since 2.0.0
  */
 export declare const isGreaterThan: {
     /**
@@ -227,7 +176,8 @@ export declare const isGreaterThan: {
      * Returns `true` if `self` represents a more severe level than `that`.
      * This is useful for filtering logs based on minimum severity requirements.
      *
-     * @example
+     * **Example** (Checking higher severity)
+     *
      * ```ts
      * import { LogLevel } from "effect"
      *
@@ -249,8 +199,8 @@ export declare const isGreaterThan: {
      * console.log(isMoreSevereThanInfo("Debug")) // false
      * ```
      *
-     * @since 2.0.0
      * @category ordering
+     * @since 2.0.0
      */
     (that: LogLevel): (self: LogLevel) => boolean;
     /**
@@ -259,7 +209,8 @@ export declare const isGreaterThan: {
      * Returns `true` if `self` represents a more severe level than `that`.
      * This is useful for filtering logs based on minimum severity requirements.
      *
-     * @example
+     * **Example** (Checking higher severity)
+     *
      * ```ts
      * import { LogLevel } from "effect"
      *
@@ -281,8 +232,8 @@ export declare const isGreaterThan: {
      * console.log(isMoreSevereThanInfo("Debug")) // false
      * ```
      *
-     * @since 2.0.0
      * @category ordering
+     * @since 2.0.0
      */
     (self: LogLevel, that: LogLevel): boolean;
 };
@@ -292,7 +243,8 @@ export declare const isGreaterThan: {
  * Returns `true` if `self` represents a level that is more severe than or equal to `that`.
  * This is the most common function for implementing minimum log level filtering.
  *
- * @example
+ * **Example** (Filtering by minimum log level)
+ *
  * ```ts
  * import { Logger, LogLevel } from "effect"
  *
@@ -322,8 +274,8 @@ export declare const isGreaterThan: {
  * const shouldLog = isInfoOrAbove("Error") // true
  * ```
  *
- * @since 2.0.0
  * @category ordering
+ * @since 2.0.0
  */
 export declare const isGreaterThanOrEqualTo: {
     /**
@@ -332,7 +284,8 @@ export declare const isGreaterThanOrEqualTo: {
      * Returns `true` if `self` represents a level that is more severe than or equal to `that`.
      * This is the most common function for implementing minimum log level filtering.
      *
-     * @example
+     * **Example** (Filtering by minimum log level)
+     *
      * ```ts
      * import { Logger, LogLevel } from "effect"
      *
@@ -362,8 +315,8 @@ export declare const isGreaterThanOrEqualTo: {
      * const shouldLog = isInfoOrAbove("Error") // true
      * ```
      *
-     * @since 2.0.0
      * @category ordering
+     * @since 2.0.0
      */
     (that: LogLevel): (self: LogLevel) => boolean;
     /**
@@ -372,7 +325,8 @@ export declare const isGreaterThanOrEqualTo: {
      * Returns `true` if `self` represents a level that is more severe than or equal to `that`.
      * This is the most common function for implementing minimum log level filtering.
      *
-     * @example
+     * **Example** (Filtering by minimum log level)
+     *
      * ```ts
      * import { Logger, LogLevel } from "effect"
      *
@@ -402,8 +356,8 @@ export declare const isGreaterThanOrEqualTo: {
      * const shouldLog = isInfoOrAbove("Error") // true
      * ```
      *
-     * @since 2.0.0
      * @category ordering
+     * @since 2.0.0
      */
     (self: LogLevel, that: LogLevel): boolean;
 };
@@ -413,7 +367,8 @@ export declare const isGreaterThanOrEqualTo: {
  * Returns `true` if `self` represents a less severe level than `that`.
  * This is useful for filtering out logs that are too verbose.
  *
- * @example
+ * **Example** (Checking lower severity)
+ *
  * ```ts
  * import { LogLevel } from "effect"
  *
@@ -435,8 +390,8 @@ export declare const isGreaterThanOrEqualTo: {
  * console.log(isLessSevereThanError("Fatal")) // false
  * ```
  *
- * @since 2.0.0
  * @category ordering
+ * @since 2.0.0
  */
 export declare const isLessThan: {
     /**
@@ -445,7 +400,8 @@ export declare const isLessThan: {
      * Returns `true` if `self` represents a less severe level than `that`.
      * This is useful for filtering out logs that are too verbose.
      *
-     * @example
+     * **Example** (Checking lower severity)
+     *
      * ```ts
      * import { LogLevel } from "effect"
      *
@@ -467,8 +423,8 @@ export declare const isLessThan: {
      * console.log(isLessSevereThanError("Fatal")) // false
      * ```
      *
-     * @since 2.0.0
      * @category ordering
+     * @since 2.0.0
      */
     (that: LogLevel): (self: LogLevel) => boolean;
     /**
@@ -477,7 +433,8 @@ export declare const isLessThan: {
      * Returns `true` if `self` represents a less severe level than `that`.
      * This is useful for filtering out logs that are too verbose.
      *
-     * @example
+     * **Example** (Checking lower severity)
+     *
      * ```ts
      * import { LogLevel } from "effect"
      *
@@ -499,8 +456,8 @@ export declare const isLessThan: {
      * console.log(isLessSevereThanError("Fatal")) // false
      * ```
      *
-     * @since 2.0.0
      * @category ordering
+     * @since 2.0.0
      */
     (self: LogLevel, that: LogLevel): boolean;
 };
@@ -510,7 +467,8 @@ export declare const isLessThan: {
  * Returns `true` if `self` represents a level that is less severe than or equal to `that`.
  * This is useful for implementing maximum log level filtering.
  *
- * @example
+ * **Example** (Filtering by maximum log level)
+ *
  * ```ts
  * import { Logger, LogLevel } from "effect"
  *
@@ -538,8 +496,8 @@ export declare const isLessThan: {
  * const shouldLog = isInfoOrBelow("Debug") // true
  * ```
  *
- * @since 2.0.0
  * @category ordering
+ * @since 2.0.0
  */
 export declare const isLessThanOrEqualTo: {
     /**
@@ -548,7 +506,8 @@ export declare const isLessThanOrEqualTo: {
      * Returns `true` if `self` represents a level that is less severe than or equal to `that`.
      * This is useful for implementing maximum log level filtering.
      *
-     * @example
+     * **Example** (Filtering by maximum log level)
+     *
      * ```ts
      * import { Logger, LogLevel } from "effect"
      *
@@ -576,8 +535,8 @@ export declare const isLessThanOrEqualTo: {
      * const shouldLog = isInfoOrBelow("Debug") // true
      * ```
      *
-     * @since 2.0.0
      * @category ordering
+     * @since 2.0.0
      */
     (that: LogLevel): (self: LogLevel) => boolean;
     /**
@@ -586,7 +545,8 @@ export declare const isLessThanOrEqualTo: {
      * Returns `true` if `self` represents a level that is less severe than or equal to `that`.
      * This is useful for implementing maximum log level filtering.
      *
-     * @example
+     * **Example** (Filtering by maximum log level)
+     *
      * ```ts
      * import { Logger, LogLevel } from "effect"
      *
@@ -614,8 +574,8 @@ export declare const isLessThanOrEqualTo: {
      * const shouldLog = isInfoOrBelow("Debug") // true
      * ```
      *
-     * @since 2.0.0
      * @category ordering
+     * @since 2.0.0
      */
     (self: LogLevel, that: LogLevel): boolean;
 };
@@ -625,7 +585,8 @@ export declare const isLessThanOrEqualTo: {
  * A log level is enabled when it is greater than or equal to
  * `References.MinimumLogLevel`.
  *
- * @example
+ * **Example** (Checking current fiber log level)
+ *
  * ```ts
  * import { Effect, LogLevel, References } from "effect"
  *
@@ -641,8 +602,8 @@ export declare const isLessThanOrEqualTo: {
  * )
  * ```
  *
- * @since 4.0.0
  * @category filtering
+ * @since 4.0.0
  */
 export declare const isEnabled: (self: LogLevel) => Effect.Effect<boolean>;
 //# sourceMappingURL=LogLevel.d.ts.map

package/dist/LogLevel.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"LogLevel.d.ts","sourceRoot":"","sources":["../src/LogLevel.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"LogLevel.d.ts","sourceRoot":"","sources":["../src/LogLevel.ts"],"names":[],"mappings":"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"}

package/dist/LogLevel.js

@@ -4,8 +4,11 @@ import * as effect from "./internal/effect.js";
 import * as Ord from "./Order.js";
 import * as References from "./References.js";
 /**
- * @since 4.0.0
+ * All `LogLevel` values in order from `All` through the concrete severities to
+ * `None`.
+ *
  * @category models
+ * @since 4.0.0
  */
 export const values = ["All", "Fatal", "Error", "Warn", "Info", "Debug", "Trace", "None"];
 /**
@@ -14,7 +17,8 @@ export const values = ["All", "Fatal", "Error", "Warn", "Info", "Debug", "Trace"
  * This order treats "All" as the least restrictive level and "None" as the most restrictive,
  * with Fatal being the most severe actual log level.
  *
- * @example
+ * **Example** (Ordering log levels)
+ *
  * ```ts
  * import { LogLevel } from "effect"
  *
@@ -24,14 +28,15 @@ export const values = ["All", "Fatal", "Error", "Warn", "Info", "Debug", "Trace"
  * console.log(LogLevel.Order("Info", "Info")) // 0 (Info == Info)
  * ```
  *
- * @since 2.0.0
  * @category ordering
+ * @since 2.0.0
  */
 export const Order = effect.LogLevelOrder;
 /**
  * An `Equivalence` instance for log levels using strict equality (`===`).
  *
- * @example
+ * **Example** (Comparing log levels)
+ *
  * ```ts
  * import { LogLevel } from "effect"
  *
@@ -46,8 +51,8 @@ export const Equivalence = /*#__PURE__*/Equ.strictEqual();
 /**
  * Returns the ordinal value of the log level.
  *
- * @since 4.0.0
  * @category ordering
+ * @since 4.0.0
  */
 export const getOrdinal = self => effect.logLevelToOrder(self);
 /**
@@ -56,7 +61,8 @@ export const getOrdinal = self => effect.logLevelToOrder(self);
  * Returns `true` if `self` represents a more severe level than `that`.
  * This is useful for filtering logs based on minimum severity requirements.
  *
- * @example
+ * **Example** (Checking higher severity)
+ *
  * ```ts
  * import { LogLevel } from "effect"
  *
@@ -78,8 +84,8 @@ export const getOrdinal = self => effect.logLevelToOrder(self);
  * console.log(isMoreSevereThanInfo("Debug")) // false
  * ```
  *
- * @since 2.0.0
  * @category ordering
+ * @since 2.0.0
  */
 export const isGreaterThan = effect.isLogLevelGreaterThan;
 /**
@@ -88,7 +94,8 @@ export const isGreaterThan = effect.isLogLevelGreaterThan;
  * Returns `true` if `self` represents a level that is more severe than or equal to `that`.
  * This is the most common function for implementing minimum log level filtering.
  *
- * @example
+ * **Example** (Filtering by minimum log level)
+ *
  * ```ts
  * import { Logger, LogLevel } from "effect"
  *
@@ -118,8 +125,8 @@ export const isGreaterThan = effect.isLogLevelGreaterThan;
  * const shouldLog = isInfoOrAbove("Error") // true
  * ```
  *
- * @since 2.0.0
  * @category ordering
+ * @since 2.0.0
  */
 export const isGreaterThanOrEqualTo = /*#__PURE__*/Ord.isGreaterThanOrEqualTo(Order);
 /**
@@ -128,7 +135,8 @@ export const isGreaterThanOrEqualTo = /*#__PURE__*/Ord.isGreaterThanOrEqualTo(Or
  * Returns `true` if `self` represents a less severe level than `that`.
  * This is useful for filtering out logs that are too verbose.
  *
- * @example
+ * **Example** (Checking lower severity)
+ *
  * ```ts
  * import { LogLevel } from "effect"
  *
@@ -150,8 +158,8 @@ export const isGreaterThanOrEqualTo = /*#__PURE__*/Ord.isGreaterThanOrEqualTo(Or
  * console.log(isLessSevereThanError("Fatal")) // false
  * ```
  *
- * @since 2.0.0
  * @category ordering
+ * @since 2.0.0
  */
 export const isLessThan = /*#__PURE__*/Ord.isLessThan(Order);
 /**
@@ -160,7 +168,8 @@ export const isLessThan = /*#__PURE__*/Ord.isLessThan(Order);
  * Returns `true` if `self` represents a level that is less severe than or equal to `that`.
  * This is useful for implementing maximum log level filtering.
  *
- * @example
+ * **Example** (Filtering by maximum log level)
+ *
  * ```ts
  * import { Logger, LogLevel } from "effect"
  *
@@ -188,8 +197,8 @@ export const isLessThan = /*#__PURE__*/Ord.isLessThan(Order);
  * const shouldLog = isInfoOrBelow("Debug") // true
  * ```
  *
- * @since 2.0.0
  * @category ordering
+ * @since 2.0.0
  */
 export const isLessThanOrEqualTo = /*#__PURE__*/Ord.isLessThanOrEqualTo(Order);
 /**
@@ -198,7 +207,8 @@ export const isLessThanOrEqualTo = /*#__PURE__*/Ord.isLessThanOrEqualTo(Order);
  * A log level is enabled when it is greater than or equal to
  * `References.MinimumLogLevel`.
  *
- * @example
+ * **Example** (Checking current fiber log level)
+ *
  * ```ts
  * import { Effect, LogLevel, References } from "effect"
  *
@@ -214,8 +224,8 @@ export const isLessThanOrEqualTo = /*#__PURE__*/Ord.isLessThanOrEqualTo(Order);
  * )
  * ```
  *
- * @since 4.0.0
  * @category filtering
+ * @since 4.0.0
  */
 export const isEnabled = self => core.withFiber(fiber => effect.succeed(!isGreaterThan(fiber.getRef(References.MinimumLogLevel), self)));
 //# sourceMappingURL=LogLevel.js.map

package/dist/LogLevel.js.map

@@ -1 +1 @@
-{"version":3,"file":"LogLevel.js","names":["Equ","core","effect","Ord","References","values","Order","LogLevelOrder","Equivalence","strictEqual","getOrdinal","self","logLevelToOrder","isGreaterThan","isLogLevelGreaterThan","isGreaterThanOrEqualTo","isLessThan","isLessThanOrEqualTo","isEnabled","withFiber","fiber","succeed","getRef","MinimumLogLevel"],"sources":["../src/LogLevel.ts"],"sourcesContent":[null],"mappings":"AAqGA,OAAO,KAAKA,GAAG,MAAM,kBAAkB;AACvC,OAAO,KAAKC,IAAI,MAAM,oBAAoB;AAC1C,OAAO,KAAKC,MAAM,MAAM,sBAAsB;AAC9C,OAAO,KAAKC,GAAG,MAAM,YAAY;AACjC,OAAO,KAAKC,UAAU,MAAM,iBAAiB;AA6C7C;;;;AAIA,OAAO,MAAMC,MAAM,GAA4B,CAAC,KAAK,EAAE,OAAO,EAAE,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,OAAO,EAAE,OAAO,EAAE,MAAM,CAAC;AAElH;;;;;;;;;;;;;;;;;;;AAmBA,OAAO,MAAMC,KAAK,GAAwBJ,MAAM,CAACK,aAAa;AAE9D;;;;;;;;;;;;;;AAcA,OAAO,MAAMC,WAAW,gBAA8BR,GAAG,CAACS,WAAW,EAAY;AAEjF;;;;;;AAMA,OAAO,MAAMC,UAAU,GAAIC,IAAc,IAAaT,MAAM,CAACU,eAAe,CAACD,IAAI,CAAC;AAElF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA+BA,OAAO,MAAME,aAAa,GAiEtBX,MAAM,CAACY,qBAAqB;AAEhC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAuCA,OAAO,MAAMC,sBAAsB,gBAiF/BZ,GAAG,CAACY,sBAAsB,CAACT,KAAK,CAAC;AAErC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA+BA,OAAO,MAAMU,UAAU,gBAiEnBb,GAAG,CAACa,UAAU,CAACV,KAAK,CAAC;AAEzB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAqCA,OAAO,MAAMW,mBAAmB,gBA6E5Bd,GAAG,CAACc,mBAAmB,CAACX,KAAK,CAAC;AAElC;;;;;;;;;;;;;;;;;;;;;;;;;AAyBA,OAAO,MAAMY,SAAS,GAAIP,IAAc,IACtCV,IAAI,CAACkB,SAAS,CAAEC,KAAK,IAAKlB,MAAM,CAACmB,OAAO,CAAC,CAACR,aAAa,CAACO,KAAK,CAACE,MAAM,CAAClB,UAAU,CAACmB,eAAe,CAAC,EAAEZ,IAAI,CAAC,CAAC,CAAC","ignoreList":[]}
+{"version":3,"file":"LogLevel.js","names":["Equ","core","effect","Ord","References","values","Order","LogLevelOrder","Equivalence","strictEqual","getOrdinal","self","logLevelToOrder","isGreaterThan","isLogLevelGreaterThan","isGreaterThanOrEqualTo","isLessThan","isLessThanOrEqualTo","isEnabled","withFiber","fiber","succeed","getRef","MinimumLogLevel"],"sources":["../src/LogLevel.ts"],"sourcesContent":[null],"mappings":"AAwCA,OAAO,KAAKA,GAAG,MAAM,kBAAkB;AACvC,OAAO,KAAKC,IAAI,MAAM,oBAAoB;AAC1C,OAAO,KAAKC,MAAM,MAAM,sBAAsB;AAC9C,OAAO,KAAKC,GAAG,MAAM,YAAY;AACjC,OAAO,KAAKC,UAAU,MAAM,iBAAiB;AAiD7C;;;;;;;AAOA,OAAO,MAAMC,MAAM,GAA4B,CAAC,KAAK,EAAE,OAAO,EAAE,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,OAAO,EAAE,OAAO,EAAE,MAAM,CAAC;AAElH;;;;;;;;;;;;;;;;;;;;AAoBA,OAAO,MAAMC,KAAK,GAAwBJ,MAAM,CAACK,aAAa;AAE9D;;;;;;;;;;;;;;;AAeA,OAAO,MAAMC,WAAW,gBAA8BR,GAAG,CAACS,WAAW,EAAY;AAEjF;;;;;;AAMA,OAAO,MAAMC,UAAU,GAAIC,IAAc,IAAaT,MAAM,CAACU,eAAe,CAACD,IAAI,CAAC;AAElF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAgCA,OAAO,MAAME,aAAa,GAmEtBX,MAAM,CAACY,qBAAqB;AAEhC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAwCA,OAAO,MAAMC,sBAAsB,gBAmF/BZ,GAAG,CAACY,sBAAsB,CAACT,KAAK,CAAC;AAErC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAgCA,OAAO,MAAMU,UAAU,gBAmEnBb,GAAG,CAACa,UAAU,CAACV,KAAK,CAAC;AAEzB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAsCA,OAAO,MAAMW,mBAAmB,gBA+E5Bd,GAAG,CAACc,mBAAmB,CAACX,KAAK,CAAC;AAElC;;;;;;;;;;;;;;;;;;;;;;;;;;AA0BA,OAAO,MAAMY,SAAS,GAAIP,IAAc,IACtCV,IAAI,CAACkB,SAAS,CAAEC,KAAK,IAAKlB,MAAM,CAACmB,OAAO,CAAC,CAACR,aAAa,CAACO,KAAK,CAACE,MAAM,CAAClB,UAAU,CAACmB,eAAe,CAAC,EAAEZ,IAAI,CAAC,CAAC,CAAC","ignoreList":[]}