effect 2.4.18 → 3.0.0

package/src/{ReadonlyRecord.ts → Record.ts}

@@ -11,7 +11,6 @@ import type { Equivalence } from "./Equivalence.js"
 import { dual, identity } from "./Function.js"
 import type { TypeLambda } from "./HKT.js"
 import * as Option from "./Option.js"
-import type { NoInfer } from "./Types.js"
 
 /**
  * @category models
@@ -69,7 +68,7 @@ export const empty = <K extends string | symbol = never, V = never>(): Record<
  * @param self - record to test for emptiness.
  *
  * @example
- * import { isEmptyRecord } from "effect/ReadonlyRecord"
+ * import { isEmptyRecord } from "effect/Record"
  *
  * assert.deepStrictEqual(isEmptyRecord({}), true);
  * assert.deepStrictEqual(isEmptyRecord({ a: 3 }), false);
@@ -86,7 +85,7 @@ export const isEmptyRecord = <K extends string, A>(self: Record<K, A>): self is
  * @param self - record to test for emptiness.
  *
  * @example
- * import { isEmptyReadonlyRecord } from "effect/ReadonlyRecord"
+ * import { isEmptyReadonlyRecord } from "effect/Record"
  *
  * assert.deepStrictEqual(isEmptyReadonlyRecord({}), true);
  * assert.deepStrictEqual(isEmptyReadonlyRecord({ a: 3 }), false);
@@ -106,7 +105,7 @@ export const isEmptyReadonlyRecord: <K extends string, A>(
  * @param f - A projection function that maps values of the iterable to a tuple of a key and a value.
  *
  * @example
- * import { fromIterableWith } from "effect/ReadonlyRecord"
+ * import { fromIterableWith } from "effect/Record"
  *
  * const input = [1, 2, 3, 4]
  *
@@ -148,7 +147,7 @@ export const fromIterableWith: {
  * @param f - A function that extracts the key for each element.
  *
  * @example
- * import { fromIterableBy } from "effect/ReadonlyRecord"
+ * import { fromIterableBy } from "effect/Record"
  *
  * const users = [
  *   { id: "2", name: "name2" },
@@ -180,7 +179,7 @@ export const fromIterableBy = <A, K extends string | symbol>(
  * @param self - The iterable of key-value pairs.
  *
  * @example
- * import { fromEntries } from "effect/ReadonlyRecord"
+ * import { fromEntries } from "effect/Record"
  *
  * const input: Array<[string, number]> = [["a", 1], ["b", 2]]
  *
@@ -200,7 +199,7 @@ export const fromEntries: <Entry extends readonly [string | symbol, any]>(
  * @param f - The custom mapping function to apply to each key/value of the record.
  *
  * @example
- * import { collect } from "effect/ReadonlyRecord"
+ * import { collect } from "effect/Record"
  *
  * const x = { a: 1, b: 2, c: 3 }
  * assert.deepStrictEqual(collect(x, (key, n) => [key, n]), [["a", 1], ["b", 2], ["c", 3]])
@@ -228,7 +227,7 @@ export const collect: {
  * @param self - The record to transform.
  *
  * @example
- * import { toEntries } from "effect/ReadonlyRecord"
+ * import { toEntries } from "effect/Record"
  *
  * const x = { a: 1, b: 2, c: 3 }
  * assert.deepStrictEqual(toEntries(x), [["a", 1], ["b", 2], ["c", 3]])
@@ -247,7 +246,7 @@ export const toEntries: <K extends string, A>(self: ReadonlyRecord<K, A>) => Arr
  * @param self - A record to calculate the number of key/value pairs in.
  *
  * @example
- * import { size } from "effect/ReadonlyRecord";
+ * import { size } from "effect/Record";
  *
  * assert.deepStrictEqual(size({ a: "a", b: 1, c: true }), 3);
  *
@@ -262,7 +261,7 @@ export const size = <K extends string, A>(self: ReadonlyRecord<K, A>): number =>
  * @param key - the key to look for in the record.
  *
  * @example
- * import { empty, has } from "effect/ReadonlyRecord"
+ * import { empty, has } from "effect/Record"
  *
  * assert.deepStrictEqual(has({ a: 1, b: 2 }, "a"), true);
  * assert.deepStrictEqual(has(empty<string>(), "c"), false);
@@ -292,7 +291,7 @@ export const has: {
  * @param key - Key to retrieve from record.
  *
  * @example
- * import { get } from "effect/ReadonlyRecord"
+ * import { get } from "effect/Record"
  * import { some, none } from "effect/Option"
  *
  * const person: Record<string, unknown> = { name: "John Doe", age: 35 }
@@ -320,7 +319,7 @@ export const get: {
  * @param f - The function to apply to the element.
  *
  * @example
- * import { modify } from "effect/ReadonlyRecord"
+ * import { modify } from "effect/Record"
  * import { some, none } from "effect/Option"
  *
  * const f = (x: number) => x * 2
@@ -361,7 +360,7 @@ export const modify: {
  * @param f - The function to apply to the element.
  *
  * @example
- * import { modifyOption } from "effect/ReadonlyRecord"
+ * import { modifyOption } from "effect/Record"
  * import { some, none } from "effect/Option"
  *
  * const f = (x: number) => x * 2
@@ -409,7 +408,7 @@ export const modifyOption: {
  * @param b - The new value to replace the existing value with.
  *
  * @example
- * import { empty, replaceOption } from "effect/ReadonlyRecord"
+ * import { empty, replaceOption } from "effect/Record"
  * import { some, none } from "effect/Option"
  *
  * assert.deepStrictEqual(
@@ -447,7 +446,7 @@ export const replaceOption: {
  * @param key - the key to remove from the record.
  *
  * @example
- * import { remove } from "effect/ReadonlyRecord"
+ * import { remove } from "effect/Record"
  *
  * assert.deepStrictEqual(remove({ a: 1, b: 2 }, "a"), { b: 2 })
  *
@@ -477,7 +476,7 @@ export const remove: {
  * @param key - The key of the property to retrieve.
  *
  * @example
- * import { pop } from "effect/ReadonlyRecord"
+ * import { pop } from "effect/Record"
  * import { some, none } from 'effect/Option'
  *
  * assert.deepStrictEqual(pop({ a: 1, b: 2 }, "a"), some([1, { b: 2 }]))
@@ -507,7 +506,7 @@ export const pop: {
  * @param f - A transformation function that will be applied to each of the values in the record.
  *
  * @example
- * import { map } from "effect/ReadonlyRecord"
+ * import { map } from "effect/Record"
  *
  * const f = (n: number) => `-${n}`
  *
@@ -538,7 +537,7 @@ export const map: {
  * Maps the keys of a `ReadonlyRecord` while preserving the corresponding values.
  *
  * @example
- * import { mapKeys } from "effect/ReadonlyRecord"
+ * import { mapKeys } from "effect/Record"
  *
  * assert.deepStrictEqual(mapKeys({ a: 3, b: 5 }, (key) => key.toUpperCase()), { A: 3, B: 5 })
  *
@@ -572,7 +571,7 @@ export const mapKeys: {
  * Maps entries of a `ReadonlyRecord` using the provided function, allowing modification of both keys and corresponding values.
  *
  * @example
- * import { mapEntries } from "effect/ReadonlyRecord"
+ * import { mapEntries } from "effect/Record"
  *
  * assert.deepStrictEqual(mapEntries({ a: 3, b: 5 }, (a, key) => [key.toUpperCase(), a + 1]), { A: 4, B: 6 })
  *
@@ -610,7 +609,7 @@ export const mapEntries: {
  * @param f - The transformation function.
  *
  * @example
- * import { filterMap } from "effect/ReadonlyRecord"
+ * import { filterMap } from "effect/Record"
  * import { some, none } from 'effect/Option'
  *
  * const x = { a: 1, b: 2, c: 3 }
@@ -651,7 +650,7 @@ export const filterMap: {
  * @param predicate - A function that returns a `boolean` value to determine if the entry should be included in the new record.
  *
  * @example
- * import { filter } from "effect/ReadonlyRecord"
+ * import { filter } from "effect/Record"
  *
  * const x = { a: 1, b: 2, c: 3, d: 4 }
  * assert.deepStrictEqual(filter(x, (n) => n > 2), { c: 3, d: 4 })
@@ -696,7 +695,7 @@ export const filter: {
  * @param self - A record with `Option` values.
  *
  * @example
- * import { getSomes } from "effect/ReadonlyRecord"
+ * import { getSomes } from "effect/Record"
  * import { some, none } from "effect/Option"
  *
  * assert.deepStrictEqual(
@@ -717,7 +716,7 @@ export const getSomes: <K extends string, A>(
  * Given a record with `Either` values, returns a new record containing only the `Left` values, preserving the original keys.
  *
  * @example
- * import { getLefts } from "effect/ReadonlyRecord"
+ * import { getLefts } from "effect/Record"
  * import { right, left } from "effect/Either"
  *
  * assert.deepStrictEqual(
@@ -746,7 +745,7 @@ export const getLefts = <K extends string, R, L>(
  * Given a record with `Either` values, returns a new record containing only the `Right` values, preserving the original keys.
  *
  * @example
- * import { getRights } from "effect/ReadonlyRecord"
+ * import { getRights } from "effect/Record"
  * import { right, left } from "effect/Either"
  *
  * assert.deepStrictEqual(
@@ -778,7 +777,7 @@ export const getRights = <K extends string, R, L>(
  * @param f - The predicate function to apply to each element.
  *
  * @example
- * import { partitionMap } from "effect/ReadonlyRecord"
+ * import { partitionMap } from "effect/Record"
  * import { left, right } from 'effect/Either'
  *
  * const x = { a: 1, b: 2, c: 3 }
@@ -825,7 +824,7 @@ export const partitionMap: {
  * @param self - the record to partition.
  *
  * @example
- * import { separate } from "effect/ReadonlyRecord"
+ * import { separate } from "effect/Record"
  * import { left, right } from 'effect/Either'
  *
  * assert.deepStrictEqual(
@@ -847,7 +846,7 @@ export const separate: <K extends string, A, B>(
  * @param predicate - The partitioning function to determine the partitioning of each value of the record.
  *
  * @example
- * import { partition } from "effect/ReadonlyRecord"
+ * import { partition } from "effect/Record"
  *
  * assert.deepStrictEqual(
  *   partition({ a: 1, b: 3 }, (n) => n > 2),
@@ -925,7 +924,7 @@ export const values = <K extends string, A>(self: ReadonlyRecord<K, A>): Array<A
  * @param values - The value you want to associate with the key.
  *
  * @example
- * import { set } from "effect/ReadonlyRecord"
+ * import { set } from "effect/Record"
  *
  * assert.deepStrictEqual(set("a", 5)({ a: 1, b: 2 }), { a: 5, b: 2 });
  * assert.deepStrictEqual(set("c", 5)({ a: 1, b: 2 }), { a: 1, b: 2, c: 5 });
@@ -962,7 +961,7 @@ export const set: {
  * @param value - The new value to associate with the key.
  *
  * @example
- * import { replace } from "effect/ReadonlyRecord"
+ * import { replace } from "effect/Record"
  * import { some, none } from "effect/Option"
  *
  * assert.deepStrictEqual(replace("a", 3)({ a: 1, b: 2 }), { a: 3, b: 2 });

package/src/Ref.ts

@@ -4,7 +4,7 @@
 import type * as Effect from "./Effect.js"
 import * as internal from "./internal/ref.js"
 import type * as Option from "./Option.js"
-import type { Pipeable } from "./Pipeable.js"
+import type { Readable } from "./Readable.js"
 import type * as Types from "./Types.js"
 
 /**
@@ -23,7 +23,7 @@ export type RefTypeId = typeof RefTypeId
  * @since 2.0.0
  * @category models
  */
-export interface Ref<in out A> extends Ref.Variance<A>, Pipeable {
+export interface Ref<in out A> extends Ref.Variance<A>, Readable<A> {
   modify<B>(f: (a: A) => readonly [B, A]): Effect.Effect<B>
 }
 

package/src/RegExp.ts

@@ -0,0 +1,17 @@
+/**
+ * This module provides utility functions for working with RegExp in TypeScript.
+ *
+ * @since 2.0.0
+ */
+
+/**
+ * Escapes special characters in a regular expression pattern.
+ *
+ * @example
+ * import * as RegExp from "effect/RegExp"
+ *
+ * assert.deepStrictEqual(RegExp.escape("a*b"), "a\\*b")
+ *
+ * @since 2.0.0
+ */
+export const escape = (string: string): string => string.replace(/[/\\^$*+?.()|[\]{}]/g, "\\$&")

package/src/Request.ts

@@ -257,7 +257,7 @@ export interface Listeners {
  * @since 2.0.0
  */
 export interface Cache extends
-  _Cache.ConsumerCache<Request<any, any>, never, {
+  _Cache.ConsumerCache<Request<any, any>, {
     listeners: Listeners
     handle: Deferred<unknown, unknown>
   }>

package/src/RequestResolver.ts

@@ -187,13 +187,13 @@ export const around: {
  */
 export const aroundRequests: {
   <A, A2, R2, X, R3>(
-    before: (requests: ReadonlyArray<Types.NoInfer<A>>) => Effect.Effect<A2, never, R2>,
-    after: (requests: ReadonlyArray<Types.NoInfer<A>>, _: A2) => Effect.Effect<X, never, R3>
+    before: (requests: ReadonlyArray<NoInfer<A>>) => Effect.Effect<A2, never, R2>,
+    after: (requests: ReadonlyArray<NoInfer<A>>, _: A2) => Effect.Effect<X, never, R3>
   ): <R>(self: RequestResolver<A, R>) => RequestResolver<A, R2 | R3 | R>
   <A, R, A2, R2, X, R3>(
     self: RequestResolver<A, R>,
-    before: (requests: ReadonlyArray<Types.NoInfer<A>>) => Effect.Effect<A2, never, R2>,
-    after: (requests: ReadonlyArray<Types.NoInfer<A>>, _: A2) => Effect.Effect<X, never, R3>
+    before: (requests: ReadonlyArray<NoInfer<A>>) => Effect.Effect<A2, never, R2>,
+    after: (requests: ReadonlyArray<NoInfer<A>>, _: A2) => Effect.Effect<X, never, R3>
   ): RequestResolver<A, R | R2 | R3>
 } = internal.aroundRequests
 

package/src/STM.ts

@@ -14,7 +14,7 @@ import * as stm from "./internal/stm/stm.js"
 import type * as Option from "./Option.js"
 import type { Pipeable } from "./Pipeable.js"
 import type { Predicate, Refinement } from "./Predicate.js"
-import type { Covariant, MergeRecord, NoInfer } from "./Types.js"
+import type { Covariant, MergeRecord } from "./Types.js"
 import type * as Unify from "./Unify.js"
 
 /**
@@ -295,7 +295,7 @@ export const asSomeError: <A, E, R>(self: STM<A, E, R>) => STM<A, Option.Option<
  * @since 2.0.0
  * @category mapping
  */
-export const asUnit: <A, E, R>(self: STM<A, E, R>) => STM<void, E, R> = stm.asUnit
+export const asVoid: <A, E, R>(self: STM<A, E, R>) => STM<void, E, R> = stm.asVoid
 
 /**
  * Creates an `STM` value from a partial (but pure) function.
@@ -1860,13 +1860,16 @@ export const unlessSTM: {
  */
 export const unsome: <A, E, R>(self: STM<A, Option.Option<E>, R>) => STM<Option.Option<A>, E, R> = stm.unsome
 
-/**
- * Returns an `STM` effect that succeeds with `Unit`.
- *
- * @since 2.0.0
- * @category constructors
- */
-export const unit: STM<void> = stm.unit
+const void_: STM<void> = stm.void
+export {
+  /**
+   * Returns an `STM` effect that succeeds with `void`.
+   *
+   * @since 2.0.0
+   * @category constructors
+   */
+  void_ as void
+}
 
 /**
  * Feeds elements of type `A` to `f` and accumulates all errors in error

package/src/Schedule.ts

@@ -218,7 +218,7 @@ export const as: {
  * @since 2.0.0
  * @category constructors
  */
-export const asUnit: <Out, In, R>(self: Schedule<Out, In, R>) => Schedule<void, In, R> = internal.asUnit
+export const asVoid: <Out, In, R>(self: Schedule<Out, In, R>) => Schedule<void, In, R> = internal.asVoid
 
 /**
  * Returns a new schedule that has both the inputs and outputs of this and the

package/src/ScopedCache.ts

@@ -27,7 +27,9 @@ export type ScopedCacheTypeId = typeof ScopedCacheTypeId
  * @since 2.0.0
  * @category models
  */
-export interface ScopedCache<in Key, out Error, out Value> extends ScopedCache.Variance<Key, Error, Value>, Pipeable {
+export interface ScopedCache<in Key, out Value, out Error = never>
+  extends ScopedCache.Variance<Key, Value, Error>, Pipeable
+{
   /**
    * Retrieves the value associated with the specified key if it exists.
    * Otherwise returns `Option.none`.
@@ -98,7 +100,7 @@ export declare namespace ScopedCache {
    * @since 2.0.0
    * @category models
    */
-  export interface Variance<in Key, out Error, out Value> {
+  export interface Variance<in Key, out Value, out Error> {
     readonly [ScopedCacheTypeId]: {
       _Key: Types.Contravariant<Key>
       _Error: Types.Covariant<Error>
@@ -114,13 +116,13 @@ export declare namespace ScopedCache {
  * @since 2.0.0
  * @category constructors
  */
-export const make: <Key, Environment, Error, Value>(
+export const make: <Key, Value, Error = never, Environment = never>(
   options: {
-    readonly lookup: Lookup<Key, Environment, Error, Value>
+    readonly lookup: Lookup<Key, Value, Error, Environment>
     readonly capacity: number
     readonly timeToLive: Duration.DurationInput
   }
-) => Effect.Effect<ScopedCache<Key, Error, Value>, never, Scope.Scope | Environment> = internal.make
+) => Effect.Effect<ScopedCache<Key, Value, Error>, never, Scope.Scope | Environment> = internal.make
 
 /**
  * Constructs a new cache with the specified capacity, time to live, and
@@ -130,13 +132,13 @@ export const make: <Key, Environment, Error, Value>(
  * @since 2.0.0
  * @category constructors
  */
-export const makeWith: <Key, Environment, Error, Value>(
+export const makeWith: <Key, Value, Error = never, Environment = never>(
   options: {
     readonly capacity: number
-    readonly lookup: Lookup<Key, Environment, Error, Value>
+    readonly lookup: Lookup<Key, Value, Error, Environment>
     readonly timeToLive: (exit: Exit.Exit<Value, Error>) => Duration.DurationInput
   }
-) => Effect.Effect<ScopedCache<Key, Error, Value>, never, Scope.Scope | Environment> = internal.makeWith
+) => Effect.Effect<ScopedCache<Key, Value, Error>, never, Scope.Scope | Environment> = internal.makeWith
 
 /**
  * Similar to `Cache.Lookup`, but executes the lookup function within a `Scope`.
@@ -144,6 +146,6 @@ export const makeWith: <Key, Environment, Error, Value>(
  * @since 2.0.0
  * @category models
  */
-export type Lookup<Key, Environment, Error, Value> = (
+export type Lookup<Key, Value, Error = never, Environment = never> = (
   key: Key
 ) => Effect.Effect<Value, Error, Environment | Scope.Scope>

package/src/SortedSet.ts

@@ -14,7 +14,7 @@ import { pipeArguments } from "./Pipeable.js"
 import type { Predicate } from "./Predicate.js"
 import { hasProperty } from "./Predicate.js"
 import * as RBT from "./RedBlackTree.js"
-import type { Invariant, NoInfer } from "./Types.js"
+import type { Invariant } from "./Types.js"
 
 const TypeId: unique symbol = Symbol.for("effect/SortedSet")
 

package/src/Stream.ts

@@ -29,7 +29,7 @@ import type * as Emit from "./StreamEmit.js"
 import type * as HaltStrategy from "./StreamHaltStrategy.js"
 import type * as Take from "./Take.js"
 import type * as Tracer from "./Tracer.js"
-import type { Covariant, MergeRecord, NoInfer } from "./Types.js"
+import type { Covariant, MergeRecord } from "./Types.js"
 import type * as Unify from "./Unify.js"
 
 /**
@@ -3707,7 +3707,7 @@ export const throttleEffect: {
 } = internal.throttleEffect
 
 /**
- * A stream that emits Unit values spaced by the specified duration.
+ * A stream that emits void values spaced by the specified duration.
  *
  * @since 2.0.0
  * @category constructors
@@ -3915,13 +3915,16 @@ export const unfoldEffect: <S, A, E, R>(
   f: (s: S) => Effect.Effect<Option.Option<readonly [A, S]>, E, R>
 ) => Stream<A, E, R> = internal.unfoldEffect
 
-/**
- * A stream that contains a single `Unit` value.
- *
- * @since 2.0.0
- * @category constructors
- */
-export const unit: Stream<void> = internal.unit
+const void_: Stream<void> = internal.void
+export {
+  /**
+   * A stream that contains a single `void` value.
+   *
+   * @since 2.0.0
+   * @category constructors
+   */
+  void_ as void
+}
 
 /**
  * Creates a stream produced from an `Effect`.
@@ -4025,7 +4028,7 @@ export const withSpan: {
     options?: {
       readonly attributes?: Record<string, unknown> | undefined
       readonly links?: ReadonlyArray<Tracer.SpanLink> | undefined
-      readonly parent?: Tracer.ParentSpan | undefined
+      readonly parent?: Tracer.AnySpan | undefined
       readonly root?: boolean | undefined
       readonly context?: Context.Context<never> | undefined
     } | undefined
@@ -4036,7 +4039,7 @@ export const withSpan: {
     options?: {
       readonly attributes?: Record<string, unknown> | undefined
       readonly links?: ReadonlyArray<Tracer.SpanLink> | undefined
-      readonly parent?: Tracer.ParentSpan | undefined
+      readonly parent?: Tracer.AnySpan | undefined
       readonly root?: boolean | undefined
       readonly context?: Context.Context<never> | undefined
     } | undefined

package/src/StreamHaltStrategy.ts

@@ -102,10 +102,22 @@ export const isBoth: (self: HaltStrategy) => self is Both = internal.isBoth
 export const isEither: (self: HaltStrategy) => self is Either = internal.isEither
 
 /**
+ * Folds over the specified `HaltStrategy` using the provided case functions.
+ *
  * @since 2.0.0
  * @category folding
  */
 export const match: {
-  <Z>(onLeft: () => Z, onRight: () => Z, onBoth: () => Z, onEither: () => Z): (self: HaltStrategy) => Z
-  <Z>(self: HaltStrategy, onLeft: () => Z, onRight: () => Z, onBoth: () => Z, onEither: () => Z): Z
+  <Z>(options: {
+    readonly onLeft: () => Z
+    readonly onRight: () => Z
+    readonly onBoth: () => Z
+    readonly onEither: () => Z
+  }): (self: HaltStrategy) => Z
+  <Z>(self: HaltStrategy, options: {
+    readonly onLeft: () => Z
+    readonly onRight: () => Z
+    readonly onBoth: () => Z
+    readonly onEither: () => Z
+  }): Z
 } = internal.match

package/src/String.ts

@@ -6,16 +6,16 @@
  * @since 2.0.0
  */
 
+import type { NonEmptyArray } from "./Array.js"
 import * as equivalence from "./Equivalence.js"
 import { dual } from "./Function.js"
-import * as readonlyArray from "./internal/readonlyArray.js"
+import * as readonlyArray from "./internal/array.js"
 import * as number from "./Number.js"
 import * as Option from "./Option.js"
 import * as order from "./Order.js"
 import type * as Ordering from "./Ordering.js"
 import type { Refinement } from "./Predicate.js"
 import * as predicate from "./Predicate.js"
-import type { NonEmptyArray } from "./ReadonlyArray.js"
 
 /**
  * Tests if a value is a `string`.
@@ -624,6 +624,49 @@ export const stripMarginWith: {
  */
 export const stripMargin = (self: string): string => stripMarginWith(self, "|")
 
+/**
+ * @since 2.0.0
+ */
+export const snakeToCamel = (self: string): string => {
+  let str = self[0]
+  for (let i = 1; i < self.length; i++) {
+    str += self[i] === "_" ? self[++i].toUpperCase() : self[i]
+  }
+  return str
+}
+
+/**
+ * @since 2.0.0
+ */
+export const snakeToPascal = (self: string): string => {
+  let str = self[0].toUpperCase()
+  for (let i = 1; i < self.length; i++) {
+    str += self[i] === "_" ? self[++i].toUpperCase() : self[i]
+  }
+  return str
+}
+
+/**
+ * @since 2.0.0
+ */
+export const snakeToKebab = (self: string): string => self.replace(/_/g, "-")
+
+/**
+ * @since 2.0.0
+ */
+export const camelToSnake = (self: string): string => self.replace(/([A-Z])/g, "_$1").toLowerCase()
+
+/**
+ * @since 2.0.0
+ */
+export const pascalToSnake = (self: string): string =>
+  (self.slice(0, 1) + self.slice(1).replace(/([A-Z])/g, "_$1")).toLowerCase()
+
+/**
+ * @since 2.0.0
+ */
+export const kebabToSnake = (self: string): string => self.replace(/-/g, "_")
+
 class LinesIterator implements IterableIterator<string> {
   private index: number
   private readonly length: number