effect 4.0.0-beta.99 → 4.0.0-rc.109

package/dist/References.js

@@ -104,51 +104,6 @@ PreventSchedulerYield,
  * @since 4.0.0
  */
 Tracer };
-/**
- * Context reference for controlling the current concurrency limit. Can be set to "unbounded"
- * for unlimited concurrency or a specific number to limit concurrent operations.
- *
- * **When to use**
- *
- * Use to configure the default concurrency limit for operations that read
- * concurrency from the current context.
- *
- * **Example** (Setting current concurrency)
- *
- * ```ts
- * import { Effect, References } from "effect"
- *
- * const limitConcurrency = Effect.gen(function*() {
- *   // Get current setting
- *   const current = yield* References.CurrentConcurrency
- *   console.log(current) // "unbounded" (default)
- *
- *   // Run with limited concurrency
- *   yield* Effect.provideService(
- *     Effect.gen(function*() {
- *       const limited = yield* References.CurrentConcurrency
- *       console.log(limited) // 10
- *     }),
- *     References.CurrentConcurrency,
- *     10
- *   )
- *
- *   // Run with unlimited concurrency
- *   yield* Effect.provideService(
- *     Effect.gen(function*() {
- *       const unlimited = yield* References.CurrentConcurrency
- *       console.log(unlimited) // "unbounded"
- *     }),
- *     References.CurrentConcurrency,
- *     "unbounded"
- *   )
- * })
- * ```
- *
- * @category references
- * @since 4.0.0
- */
-export const CurrentConcurrency = references.CurrentConcurrency;
 /**
  * Context reference for managing log annotations that are automatically added to all log entries.
  * These annotations provide contextual metadata that appears in every log message.
@@ -160,23 +115,19 @@ export const CurrentConcurrency = references.CurrentConcurrency;
  *
  * **Example** (Managing log annotations)
  *
- * ```ts
- * import { Console, Effect, References } from "effect"
+ * ```ts import.meta.vitest
+ * import { Effect, References } from "effect"
  *
  * const logAnnotationExample = Effect.gen(function*() {
  *   // Get current annotations (empty by default)
  *   const current = yield* References.CurrentLogAnnotations
- *   console.log(current) // {}
+ *   const defaultCount = Object.keys(current).length
  *
  *   // Run with custom log annotations
- *   yield* Effect.provideService(
+ *   const custom = yield* Effect.provideService(
  *     Effect.gen(function*() {
  *       const annotations = yield* References.CurrentLogAnnotations
- *       console.log(annotations) // { requestId: "req-123", userId: "user-456", version: "1.0.0" }
- *
- *       // All log entries will include these annotations
- *       yield* Console.log("Starting operation")
- *       yield* Console.info("Processing data")
+ *       return [annotations.requestId, annotations.userId, annotations.version]
  *     }),
  *     References.CurrentLogAnnotations,
  *     {
@@ -187,12 +138,10 @@ export const CurrentConcurrency = references.CurrentConcurrency;
  *   )
  *
  *   // Run with extended annotations
- *   yield* Effect.provideService(
+ *   const extended = yield* Effect.provideService(
  *     Effect.gen(function*() {
- *       const extended = yield* References.CurrentLogAnnotations
- *       console.log(extended) // { requestId: "req-123", userId: "user-456", version: "1.0.0", operation: "data-sync", timestamp: 1234567890 }
- *
- *       yield* Console.log("Operation completed with extended context")
+ *       const annotations = yield* References.CurrentLogAnnotations
+ *       return [annotations.operation, annotations.timestamp]
  *     }),
  *     References.CurrentLogAnnotations,
  *     {
@@ -203,7 +152,11 @@ export const CurrentConcurrency = references.CurrentConcurrency;
  *       timestamp: 1234567890
  *     }
  *   )
+ *
+ *   return [defaultCount, custom, extended]
  * })
+ *
+ * await Effect.runPromise(logAnnotationExample) // => [0, ["req-123", "user-456", "1.0.0"], ["data-sync", 1234567890]]
  * ```
  *
  * @category references
@@ -223,39 +176,25 @@ export const CurrentLogAnnotations = references.CurrentLogAnnotations;
  *
  * Use `MinimumLogLevel` to control which log entries are filtered out.
  *
- * **Example** (Changing the current log level)
- *
- * ```ts
- * import { Console, Effect, References } from "effect"
+ * **Example** (Changing the level of an unqualified log)
  *
- * const dynamicLogging = Effect.gen(function*() {
- *   // Get current log level (default is "Info")
- *   const current = yield* References.CurrentLogLevel
- *   console.log(current) // "Info"
+ * ```ts import.meta.vitest
+ * import { Effect, Logger, References } from "effect"
  *
- *   // Set log level to Debug for detailed logging
- *   yield* Effect.provideService(
- *     Effect.gen(function*() {
- *       const level = yield* References.CurrentLogLevel
- *       console.log(level) // "Debug"
- *       yield* Console.debug("This debug message will be shown")
- *     }),
- *     References.CurrentLogLevel,
- *     "Debug"
- *   )
+ * const levels: Array<string> = []
+ * const logger = Logger.make<unknown, void>(({ logLevel }) => {
+ *   levels.push(logLevel)
+ * })
  *
- *   // Change to Error level to reduce noise
- *   yield* Effect.provideService(
- *     Effect.gen(function*() {
- *       const level = yield* References.CurrentLogLevel
- *       console.log(level) // "Error"
- *       yield* Console.info("This info message will be filtered out")
- *       yield* Console.error("This error message will be shown")
- *     }),
- *     References.CurrentLogLevel,
- *     "Error"
+ * const program = Effect.gen(function*() {
+ *   yield* Effect.log("uses the default level")
+ *   yield* Effect.log("uses the provided level").pipe(
+ *     Effect.provideService(References.CurrentLogLevel, "Error")
  *   )
  * })
+ *
+ * await Effect.runPromise(program.pipe(Effect.provide(Logger.layer([logger]))))
+ * levels // => ["Info", "Error"]
  * ```
  *
  * @category references
@@ -273,24 +212,20 @@ export const CurrentLogLevel = references.CurrentLogLevel;
  *
  * **Example** (Tracking log spans)
  *
- * ```ts
- * import { Console, Effect, References } from "effect"
+ * ```ts import.meta.vitest
+ * import { Effect, References } from "effect"
  *
  * const logSpanExample = Effect.gen(function*() {
  *   // Get current spans (empty by default)
  *   const current = yield* References.CurrentLogSpans
- *   console.log(current.length) // 0
+ *   const defaultCount = current.length
  *
  *   // Add a log span manually
  *   const databaseConnectionStartedAt = 0
- *   yield* Effect.provideService(
+ *   const database = yield* Effect.provideService(
  *     Effect.gen(function*() {
- *       // Simulate some work
- *       yield* Effect.sleep("100 millis")
- *       yield* Console.log("Database operation in progress")
- *
  *       const spans = yield* References.CurrentLogSpans
- *       console.log("Active spans:", spans.map(([label]) => label)) // ["database-connection"]
+ *       return spans.map(([label]) => label)
  *     }),
  *     References.CurrentLogSpans,
  *     [["database-connection", databaseConnectionStartedAt]]
@@ -298,12 +233,10 @@ export const CurrentLogLevel = references.CurrentLogLevel;
  *
  *   // Add another span
  *   const dataProcessingStartedAt = 100
- *   yield* Effect.provideService(
+ *   const processing = yield* Effect.provideService(
  *     Effect.gen(function*() {
  *       const spans = yield* References.CurrentLogSpans
- *       console.log("Active spans:", spans.map(([label]) => label)) // ["database-connection", "data-processing"]
- *
- *       yield* Console.log("Multiple operations in progress")
+ *       return spans.map(([label]) => label)
  *     }),
  *     References.CurrentLogSpans,
  *     [
@@ -313,15 +246,19 @@ export const CurrentLogLevel = references.CurrentLogLevel;
  *   )
  *
  *   // Clear spans when operations complete
- *   yield* Effect.provideService(
+ *   const cleared = yield* Effect.provideService(
  *     Effect.gen(function*() {
  *       const spans = yield* References.CurrentLogSpans
- *       console.log("Active spans:", spans.length) // 0
+ *       return spans.length
  *     }),
  *     References.CurrentLogSpans,
  *     []
  *   )
+ *
+ *   return [defaultCount, database, processing, cleared]
  * })
+ *
+ * await Effect.runPromise(logSpanExample) // => [0, ["database-connection"], ["database-connection", "data-processing"], 0]
  * ```
  *
  * @category references
@@ -357,47 +294,27 @@ export const CurrentStackFrame = references.CurrentStackFrame;
  *
  * Use to filter out log entries below a severity threshold.
  *
- * **Example** (Setting the minimum log level)
- *
- * ```ts
- * import { Console, Effect, References } from "effect"
+ * **Example** (Filtering logs below the minimum level)
  *
- * const configureMinimumLogging = Effect.gen(function*() {
- *   // Get current minimum level (default is "Info")
- *   const current = yield* References.MinimumLogLevel
- *   console.log(current) // "Info"
+ * ```ts import.meta.vitest
+ * import { Effect, Logger, References } from "effect"
  *
- *   // Set minimum level to Warn - Debug and Info will be filtered
- *   yield* Effect.provideService(
- *     Effect.gen(function*() {
- *       const minLevel = yield* References.MinimumLogLevel
- *       console.log(minLevel) // "Warn"
- *
- *       // These won't be processed at all
- *       yield* Console.debug("Debug message") // Filtered out
- *       yield* Console.info("Info message") // Filtered out
- *
- *       // These will be processed
- *       yield* Console.warn("Warning message") // Shown
- *       yield* Console.error("Error message") // Shown
- *     }),
- *     References.MinimumLogLevel,
- *     "Warn"
- *   )
- *
- *   // Reset to default Info level
- *   yield* Effect.provideService(
- *     Effect.gen(function*() {
- *       const minLevel = yield* References.MinimumLogLevel
- *       console.log(minLevel) // "Info"
+ * const levels: Array<string> = []
+ * const logger = Logger.make<unknown, void>(({ logLevel }) => {
+ *   levels.push(logLevel)
+ * })
  *
- *       // Now info messages will be processed
- *       yield* Console.info("Info message") // Shown
- *     }),
- *     References.MinimumLogLevel,
- *     "Info"
- *   )
+ * const program = Effect.gen(function*() {
+ *   yield* Effect.logInfo("filtered out")
+ *   yield* Effect.logWarning("included at the threshold")
+ *   yield* Effect.logError("included above the threshold")
  * })
+ *
+ * await Effect.runPromise(program.pipe(
+ *   Effect.provideService(References.MinimumLogLevel, "Warn"),
+ *   Effect.provide(Logger.layer([logger]))
+ * ))
+ * levels // => ["Warn", "Error"]
  * ```
  *
  * @category references
@@ -414,40 +331,31 @@ export const MinimumLogLevel = references.MinimumLogLevel;
  *
  * **Example** (Toggling tracing)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Effect, References } from "effect"
  *
  * const tracingControl = Effect.gen(function*() {
  *   // Check if tracing is enabled (default is true)
  *   const current = yield* References.TracerEnabled
- *   console.log(current) // true
  *
  *   // Disable tracing globally
- *   yield* Effect.provideService(
- *     Effect.gen(function*() {
- *       const isEnabled = yield* References.TracerEnabled
- *       console.log(isEnabled) // false
- *
- *       // Spans will not be traced in this context
- *       yield* Effect.log("This will not be traced")
- *     }),
+ *   const disabled = yield* Effect.provideService(
+ *     References.TracerEnabled,
  *     References.TracerEnabled,
  *     false
  *   )
  *
  *   // Re-enable tracing
- *   yield* Effect.provideService(
- *     Effect.gen(function*() {
- *       const isEnabled = yield* References.TracerEnabled
- *       console.log(isEnabled) // true
- *
- *       // All subsequent spans will be traced
- *       yield* Effect.log("This will be traced")
- *     }),
+ *   const enabled = yield* Effect.provideService(
+ *     References.TracerEnabled,
  *     References.TracerEnabled,
  *     true
  *   )
+ *
+ *   return [current, disabled, enabled]
  * })
+ *
+ * await Effect.runPromise(tracingControl) // => [true, false, true]
  * ```
  *
  * @category references
@@ -464,27 +372,20 @@ export const TracerEnabled = references.TracerEnabled;
  *
  * **Example** (Managing span annotations)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Effect, References } from "effect"
  *
  * const spanAnnotationExample = Effect.gen(function*() {
  *   // Get current annotations (empty by default)
  *   const current = yield* References.TracerSpanAnnotations
- *   console.log(current) // {}
+ *   const defaultCount = Object.keys(current).length
  *
  *   // Set global span annotations
- *   yield* Effect.provideService(
+ *   const configured = yield* Effect.provideService(
  *     Effect.gen(function*() {
  *       // Get current annotations
  *       const annotations = yield* References.TracerSpanAnnotations
- *       console.log(annotations) // { service: "user-service", version: "1.2.3", environment: "production" }
- *
- *       // All spans created will include these annotations
- *       yield* Effect.gen(function*() {
- *         // Add more specific annotations for this span
- *         yield* Effect.annotateCurrentSpan("userId", "123")
- *         yield* Effect.log("Processing user")
- *       })
+ *       return [annotations.service, annotations.version, annotations.environment]
  *     }),
  *     References.TracerSpanAnnotations,
  *     {
@@ -495,15 +396,19 @@ export const TracerEnabled = references.TracerEnabled;
  *   )
  *
  *   // Clear annotations
- *   yield* Effect.provideService(
+ *   const cleared = yield* Effect.provideService(
  *     Effect.gen(function*() {
  *       const annotations = yield* References.TracerSpanAnnotations
- *       console.log(annotations) // {}
+ *       return Object.keys(annotations).length
  *     }),
  *     References.TracerSpanAnnotations,
  *     {}
  *   )
+ *
+ *   return [defaultCount, configured, cleared]
  * })
+ *
+ * await Effect.runPromise(spanAnnotationExample) // => [0, ["user-service", "1.2.3", "production"], 0]
  * ```
  *
  * @category references
@@ -520,13 +425,13 @@ export const TracerSpanAnnotations = references.TracerSpanAnnotations;
  *
  * **Example** (Managing span links)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Effect, References, Tracer } from "effect"
  *
  * const spanLinksExample = Effect.gen(function*() {
  *   // Get current links (empty by default)
  *   const current = yield* References.TracerSpanLinks
- *   console.log(current.length) // 0
+ *   const defaultCount = current.length
  *
  *   // Create an external span for the example
  *   const externalSpan = Tracer.externalSpan({
@@ -544,32 +449,23 @@ export const TracerSpanAnnotations = references.TracerSpanAnnotations;
  *   }
  *
  *   // Set global span links
- *   yield* Effect.provideService(
- *     Effect.gen(function*() {
- *       // Get current links
- *       const links = yield* References.TracerSpanLinks
- *       console.log(links.length) // 1
- *
- *       // All new spans will include these links
- *       yield* Effect.gen(function*() {
- *         yield* Effect.log("This span will have linked spans")
- *         return "operation complete"
- *       })
- *     }),
+ *   const configuredCount = yield* Effect.provideService(
+ *     Effect.map(References.TracerSpanLinks, (links) => links.length),
  *     References.TracerSpanLinks,
  *     [spanLink]
  *   )
  *
  *   // Clear links
- *   yield* Effect.provideService(
- *     Effect.gen(function*() {
- *       const links = yield* References.TracerSpanLinks
- *       console.log(links.length) // 0
- *     }),
+ *   const clearedCount = yield* Effect.provideService(
+ *     Effect.map(References.TracerSpanLinks, (links) => links.length),
  *     References.TracerSpanLinks,
  *     []
  *   )
+ *
+ *   return [defaultCount, configuredCount, clearedCount]
  * })
+ *
+ * await Effect.runPromise(spanLinksExample) // => [0, 1, 0]
  * ```
  *
  * @category references
@@ -587,36 +483,31 @@ export const TracerSpanLinks = references.TracerSpanLinks;
  *
  * **Example** (Toggling trace timing)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Effect, References } from "effect"
  *
  * const tracingControl = Effect.gen(function*() {
  *   // Check if trace timing is enabled (default is true)
  *   const current = yield* References.TracerTimingEnabled
- *   console.log(current) // true
  *
  *   // Disable trace timing globally
- *   yield* Effect.provideService(
- *     Effect.gen(function*() {
- *       // Spans will not having timing information in this context
- *       const isEnabled = yield* References.TracerTimingEnabled
- *       console.log(isEnabled) // false
- *     }),
+ *   const disabled = yield* Effect.provideService(
+ *     References.TracerTimingEnabled,
  *     References.TracerTimingEnabled,
  *     false
  *   )
  *
  *   // Re-enable trace timing
- *   yield* Effect.provideService(
- *     Effect.gen(function*() {
- *       // Spans will have timing information in this context
- *       const isEnabled = yield* References.TracerTimingEnabled
- *       console.log(isEnabled) // true
- *     }),
+ *   const enabled = yield* Effect.provideService(
+ *     References.TracerTimingEnabled,
  *     References.TracerTimingEnabled,
  *     true
  *   )
+ *
+ *   return [current, disabled, enabled]
  * })
+ *
+ * await Effect.runPromise(tracingControl) // => [true, false, true]
  * ```
  *
  * @category references
@@ -696,27 +587,25 @@ export {
  *
  * **Example** (Providing a custom scheduler)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Effect, References, Scheduler } from "effect"
  *
  * const customScheduling = Effect.gen(function*() {
  *   // Get current scheduler (default is MixedScheduler)
  *   const current = yield* References.Scheduler
- *   console.log(current) // MixedScheduler instance
+ *   const isDefaultMixed = current instanceof Scheduler.MixedScheduler
  *
  *   // Use a custom scheduler
- *   yield* Effect.provideService(
- *     Effect.gen(function*() {
- *       const scheduler = yield* References.Scheduler
- *       console.log(scheduler) // Custom scheduler instance
- *
- *       // Effects will use the custom scheduler in this context
- *       yield* Effect.log("Using custom scheduler")
- *     }),
+ *   const isCustomMixed = yield* Effect.provideService(
+ *     Effect.map(References.Scheduler, (scheduler) => scheduler instanceof Scheduler.MixedScheduler),
  *     References.Scheduler,
  *     new Scheduler.MixedScheduler()
  *   )
+ *
+ *   return [isDefaultMixed, isCustomMixed]
  * })
+ *
+ * await Effect.runPromise(customScheduling) // => [true, true]
  * ```
  *
  * @category references

package/dist/References.js.map

@@ -1 +1 @@
-{"version":3,"file":"References.js","names":["internalEffect","references","MaxOpsBeforeYield","PreventSchedulerYield","CurrentTraceLevel","DisablePropagation","MinimumTraceLevel","Tracer","CurrentConcurrency","CurrentLogAnnotations","CurrentLogLevel","CurrentLogSpans","CurrentStackFrame","MinimumLogLevel","TracerEnabled","TracerSpanAnnotations","TracerSpanLinks","TracerTimingEnabled","UnhandledLogLevel","CurrentLoggers","LogToStderr","Scheduler"],"sources":["../src/References.ts"],"sourcesContent":[null],"mappings":"AAcA,OAAO,KAAKA,cAAc,MAAM,sBAAsB;AACtD,OAAO,KAAKC,UAAU,MAAM,0BAA0B;AAItD,SAASC,iBAAiB,EAAEC,qBAAqB,QAAQ,gBAAgB;AACzE,SAASC,iBAAiB,EAAEC,kBAAkB,EAAEC,iBAAiB,EAAiBC,MAAM,QAAQ,aAAa;AAE7G;AACE;;;;;;;;;;;;;AAaAH,iBAAiB;AACjB;;;;;;;;;;;;;;;;;;AAkBAC,kBAAkB;AAClB;;;;;;;;;;;;;;;;;AAiBAH,iBAAiB;AACjB;;;;;;;;;;;;;AAaAI,iBAAiB;AACjB;;;;;;;;;;;;;;;;;;;;;;;AAuBAH,qBAAqB;AACrB;;;;;;;;;;;AAWAI,MAAM;AAGR;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA4CA,OAAO,MAAMC,kBAAkB,GAA4CP,UAAU,CAACO,kBAAkB;AAExG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA4DA,OAAO,MAAMC,qBAAqB,GAChCR,UAAU,CAACQ,qBAAqB;AAElC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAmDA,OAAO,MAAMC,eAAe,GAAgCT,UAAU,CAACS,eAAe;AAEtF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAiEA,OAAO,MAAMC,eAAe,GAC1BV,UAAU,CAACU,eAAe;AAE5B;;;;;;;;;;;;;;;;;;;;AAoBA,OAAO,MAAMC,iBAAiB,GAA8CX,UAAU,CAACW,iBAAiB;AAExG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAsDA,OAAO,MAAMC,eAAe,GAAgCZ,UAAU,CAACY,eAAe;AAEtF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAiDA,OAAO,MAAMC,aAAa,GAA+Bb,UAAU,CAACa,aAAa;AAEjF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAuDA,OAAO,MAAMC,qBAAqB,GAChCd,UAAU,CAACc,qBAAqB;AAElC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAiEA,OAAO,MAAMC,eAAe,GAA+Cf,UAAU,CAACe,eAAe;AAErG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA8CA,OAAO,MAAMC,mBAAmB,GAA+BhB,UAAU,CAACgB,mBAAmB;AAE7F;;;;;;;;;;;;;;;;;;;;;;;;AAwBA,OAAO,MAAMC,iBAAiB,GAA4CjB,UAAU,CAACiB,iBAAiB;AA0BtG;;;;;;;;;;;;;;;;;;AAkBA,OAAO,MAAMC,cAAc,GAAyDnB,cAAc,CAACmB,cAAc;AAEjH;;;;;;;;;;;;;;;;AAgBA,OAAO,MAAMC,WAAW,GAA+BpB,cAAc,CAACoB,WAAW;AAEjF;AACE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAqCAC,SAAS,QACJ,gBAAgB","ignoreList":[]}
+{"version":3,"file":"References.js","names":[],"sources":["../src/References.ts"],"sourcesContent":[null],"mappings":"AAcA,OAAO,KAAK,cAAc,MAAM,sBAAsB;AACtD,OAAO,KAAK,UAAU,MAAM,0BAA0B;AAItD,SAAS,iBAAiB,EAAE,qBAAqB,QAAQ,gBAAgB;AACzE,SAAS,iBAAiB,EAAE,kBAAkB,EAAE,iBAAiB,EAAiB,MAAM,QAAQ,aAAa;AAE7G;AACE;;;;;;;;;;;;;AAaA,iBAAiB;AACjB;;;;;;;;;;;;;;;;;;AAkBA,kBAAkB;AAClB;;;;;;;;;;;;;;;;;AAiBA,iBAAiB;AACjB;;;;;;;;;;;;;AAaA,iBAAiB;AACjB;;;;;;;;;;;;;;;;;;;;;;;AAuBA,qBAAqB;AACrB;;;;;;;;;;;AAWA,MAAM;AAGR;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA0DA,OAAO,MAAM,qBAAqB,GAChC,UAAU,CAAC,qBAAqB;AAElC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAqCA,OAAO,MAAM,eAAe,GAAgC,UAAU,CAAC,eAAe;AAEtF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA+DA,OAAO,MAAM,eAAe,GAC1B,UAAU,CAAC,eAAe;AAE5B;;;;;;;;;;;;;;;;;;;;AAoBA,OAAO,MAAM,iBAAiB,GAA8C,UAAU,CAAC,iBAAiB;AAExG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAkCA,OAAO,MAAM,eAAe,GAAgC,UAAU,CAAC,eAAe;AAEtF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAwCA,OAAO,MAAM,aAAa,GAA+B,UAAU,CAAC,aAAa;AAEjF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAoDA,OAAO,MAAM,qBAAqB,GAChC,UAAU,CAAC,qBAAqB;AAElC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAwDA,OAAO,MAAM,eAAe,GAA+C,UAAU,CAAC,eAAe;AAErG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAyCA,OAAO,MAAM,mBAAmB,GAA+B,UAAU,CAAC,mBAAmB;AAE7F;;;;;;;;;;;;;;;;;;;;;;;;AAwBA,OAAO,MAAM,iBAAiB,GAA4C,UAAU,CAAC,iBAAiB;AA0BtG;;;;;;;;;;;;;;;;;;AAkBA,OAAO,MAAM,cAAc,GAAyD,cAAc,CAAC,cAAc;AAEjH;;;;;;;;;;;;;;;;AAgBA,OAAO,MAAM,WAAW,GAA+B,cAAc,CAAC,WAAW;AAEjF;AACE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAmCA,SAAS,QACJ,gBAAgB","ignoreList":[]}

package/dist/RegExp.d.ts

@@ -8,15 +8,13 @@
  *
  * **Example** (Creating a regular expression)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { RegExp } from "effect"
  *
- * // Create a regular expression using Effect's RegExp constructor
  * const pattern = new RegExp.RegExp("hello", "i")
- *
- * // Test the pattern
- * console.log(pattern.test("Hello World")) // true
- * console.log(pattern.test("goodbye")) // false
+ * pattern // => /hello/i
+ * pattern.test("Hello World") // => true
+ * pattern.test("goodbye") // => false
  * ```
  *
  * @category constructors
@@ -32,12 +30,11 @@ export declare const RegExp: RegExpConstructor;
  *
  * **Example** (Checking for regular expressions)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { RegExp } from "effect"
- * import * as assert from "node:assert"
  *
- * assert.deepStrictEqual(RegExp.isRegExp(/a/), true)
- * assert.deepStrictEqual(RegExp.isRegExp("a"), false)
+ * RegExp.isRegExp(/a/) // => true
+ * RegExp.isRegExp("a") // => false
  * ```
  *
  * @category guards
@@ -53,14 +50,13 @@ export declare const isRegExp: (input: unknown) => input is RegExp;
  *
  * **Example** (Escaping a pattern string)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { RegExp } from "effect"
- * import * as assert from "node:assert"
  *
- * assert.deepStrictEqual(RegExp.escape("a*b"), "a\\*b")
+ * RegExp.escape("a*b") // => "a\\*b"
  * ```
  *
- * @category RegExp
+ * @category transforming
  * @since 2.0.0
  */
 export declare const escape: (string: string) => string;

package/dist/RegExp.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"RegExp.d.ts","sourceRoot":"","sources":["../src/RegExp.ts"],"names":[],"mappings":"AAcA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,eAAO,MAAM,MAAM,mBAAoB,CAAA;AAEvC;;;;;;;;;;;;;;;;;;;GAmBG;AACH,eAAO,MAAM,QAAQ,EAAE,CAAC,KAAK,EAAE,OAAO,KAAK,KAAK,IAAI,MAA2B,CAAA;AAE/E;;;;;;;;;;;;;;;;;;GAkBG;AACH,eAAO,MAAM,MAAM,WAAY,MAAM,KAAG,MAAwD,CAAA"}
+{"version":3,"file":"RegExp.d.ts","sourceRoot":"","sources":["../src/RegExp.ts"],"names":[],"mappings":"AAcA;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,eAAO,MAAM,MAAM,mBAAoB,CAAA;AAEvC;;;;;;;;;;;;;;;;;;GAkBG;AACH,eAAO,MAAM,QAAQ,EAAE,CAAC,KAAK,EAAE,OAAO,KAAK,KAAK,IAAI,MAA2B,CAAA;AAE/E;;;;;;;;;;;;;;;;;GAiBG;AACH,eAAO,MAAM,MAAM,WAAY,MAAM,KAAG,MAAwD,CAAA"}

package/dist/RegExp.js

@@ -21,15 +21,13 @@ import * as predicate from "./Predicate.js";
  *
  * **Example** (Creating a regular expression)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { RegExp } from "effect"
  *
- * // Create a regular expression using Effect's RegExp constructor
  * const pattern = new RegExp.RegExp("hello", "i")
- *
- * // Test the pattern
- * console.log(pattern.test("Hello World")) // true
- * console.log(pattern.test("goodbye")) // false
+ * pattern // => /hello/i
+ * pattern.test("Hello World") // => true
+ * pattern.test("goodbye") // => false
  * ```
  *
  * @category constructors
@@ -45,12 +43,11 @@ export const RegExp = globalThis.RegExp;
  *
  * **Example** (Checking for regular expressions)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { RegExp } from "effect"
- * import * as assert from "node:assert"
  *
- * assert.deepStrictEqual(RegExp.isRegExp(/a/), true)
- * assert.deepStrictEqual(RegExp.isRegExp("a"), false)
+ * RegExp.isRegExp(/a/) // => true
+ * RegExp.isRegExp("a") // => false
  * ```
  *
  * @category guards
@@ -66,14 +63,13 @@ export const isRegExp = predicate.isRegExp;
  *
  * **Example** (Escaping a pattern string)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { RegExp } from "effect"
- * import * as assert from "node:assert"
  *
- * assert.deepStrictEqual(RegExp.escape("a*b"), "a\\*b")
+ * RegExp.escape("a*b") // => "a\\*b"
  * ```
  *
- * @category RegExp
+ * @category transforming
  * @since 2.0.0
  */
 export const escape = string => string.replace(/[/\\^$*+?.()|[\]{}]/g, "\\$&");

package/dist/RegExp.js.map

@@ -1 +1 @@
-{"version":3,"file":"RegExp.js","names":["predicate","RegExp","globalThis","isRegExp","escape","string","replace"],"sources":["../src/RegExp.ts"],"sourcesContent":[null],"mappings":"AAAA;;;;;;;;;;;;AAYA,OAAO,KAAKA,SAAS,MAAM,gBAAgB;AAE3C;;;;;;;;;;;;;;;;;;;;;;;;AAwBA,OAAO,MAAMC,MAAM,GAAGC,UAAU,CAACD,MAAM;AAEvC;;;;;;;;;;;;;;;;;;;;AAoBA,OAAO,MAAME,QAAQ,GAAwCH,SAAS,CAACG,QAAQ;AAE/E;;;;;;;;;;;;;;;;;;;AAmBA,OAAO,MAAMC,MAAM,GAAIC,MAAc,IAAaA,MAAM,CAACC,OAAO,CAAC,sBAAsB,EAAE,MAAM,CAAC","ignoreList":[]}
+{"version":3,"file":"RegExp.js","names":[],"sources":["../src/RegExp.ts"],"sourcesContent":[null],"mappings":"AAAA;;;;;;;;;;;;AAYA,OAAO,KAAK,SAAS,MAAM,gBAAgB;AAE3C;;;;;;;;;;;;;;;;;;;;;;AAsBA,OAAO,MAAM,MAAM,GAAG,UAAU,CAAC,MAAM;AAEvC;;;;;;;;;;;;;;;;;;;AAmBA,OAAO,MAAM,QAAQ,GAAwC,SAAS,CAAC,QAAQ;AAE/E;;;;;;;;;;;;;;;;;;AAkBA,OAAO,MAAM,MAAM,GAAI,MAAc,IAAa,MAAM,CAAC,OAAO,CAAC,sBAAsB,EAAE,MAAM,CAAC","ignoreList":[]}