@clayroach/effect 3.19.14-source-capture.6 → 3.19.14-source-capture.8

package/src/Encoding.ts

@@ -1,195 +0,0 @@
-/**
- * This module provides encoding & decoding functionality for:
- *
- * - base64 (RFC4648)
- * - base64 (URL)
- * - hex
- *
- * @since 2.0.0
- */
-import * as Either from "./Either.js"
-import * as Base64 from "./internal/encoding/base64.js"
-import * as Base64Url from "./internal/encoding/base64Url.js"
-import * as Common from "./internal/encoding/common.js"
-import * as Hex from "./internal/encoding/hex.js"
-
-/**
- * Encodes the given value into a base64 (RFC4648) `string`.
- *
- * @category encoding
- * @since 2.0.0
- */
-export const encodeBase64: (input: Uint8Array | string) => string = (input) =>
-  typeof input === "string" ? Base64.encode(Common.encoder.encode(input)) : Base64.encode(input)
-
-/**
- * Decodes a base64 (RFC4648) encoded `string` into a `Uint8Array`.
- *
- * @category decoding
- * @since 2.0.0
- */
-export const decodeBase64 = (str: string): Either.Either<Uint8Array, DecodeException> => Base64.decode(str)
-
-/**
- * Decodes a base64 (RFC4648) encoded `string` into a UTF-8 `string`.
- *
- * @category decoding
- * @since 2.0.0
- */
-export const decodeBase64String = (str: string) => Either.map(decodeBase64(str), (_) => Common.decoder.decode(_))
-
-/**
- * Encodes the given value into a base64 (URL) `string`.
- *
- * @category encoding
- * @since 2.0.0
- */
-export const encodeBase64Url: (input: Uint8Array | string) => string = (input) =>
-  typeof input === "string" ? Base64Url.encode(Common.encoder.encode(input)) : Base64Url.encode(input)
-
-/**
- * Decodes a base64 (URL) encoded `string` into a `Uint8Array`.
- *
- * @category decoding
- * @since 2.0.0
- */
-export const decodeBase64Url = (str: string): Either.Either<Uint8Array, DecodeException> => Base64Url.decode(str)
-
-/**
- * Decodes a base64 (URL) encoded `string` into a UTF-8 `string`.
- *
- * @category decoding
- * @since 2.0.0
- */
-export const decodeBase64UrlString = (str: string) => Either.map(decodeBase64Url(str), (_) => Common.decoder.decode(_))
-
-/**
- * Encodes the given value into a hex `string`.
- *
- * @category encoding
- * @since 2.0.0
- */
-export const encodeHex: (input: Uint8Array | string) => string = (input) =>
-  typeof input === "string" ? Hex.encode(Common.encoder.encode(input)) : Hex.encode(input)
-
-/**
- * Decodes a hex encoded `string` into a `Uint8Array`.
- *
- * @category decoding
- * @since 2.0.0
- */
-export const decodeHex = (str: string): Either.Either<Uint8Array, DecodeException> => Hex.decode(str)
-
-/**
- * Decodes a hex encoded `string` into a UTF-8 `string`.
- *
- * @category decoding
- * @since 2.0.0
- */
-export const decodeHexString = (str: string) => Either.map(decodeHex(str), (_) => Common.decoder.decode(_))
-
-/**
- * Encodes a UTF-8 `string` into a URI component `string`.
- *
- * @category encoding
- * @since 3.12.0
- */
-export const encodeUriComponent = (str: string): Either.Either<string, EncodeException> =>
-  Either.try({
-    try: () => encodeURIComponent(str),
-    catch: (e) => EncodeException(str, e instanceof Error ? e.message : "Invalid input")
-  })
-
-/**
- * Decodes a URI component `string` into a UTF-8 `string`.
- *
- * @category decoding
- * @since 3.12.0
- */
-export const decodeUriComponent = (str: string): Either.Either<string, DecodeException> =>
-  Either.try({
-    try: () => decodeURIComponent(str),
-    catch: (e) => DecodeException(str, e instanceof Error ? e.message : "Invalid input")
-  })
-
-/**
- * @since 2.0.0
- * @category symbols
- */
-export const DecodeExceptionTypeId: unique symbol = Common.DecodeExceptionTypeId
-
-/**
- * @since 2.0.0
- * @category symbols
- */
-export type DecodeExceptionTypeId = typeof DecodeExceptionTypeId
-
-/**
- * Represents a checked exception which occurs when decoding fails.
- *
- * @since 2.0.0
- * @category models
- */
-export interface DecodeException {
-  readonly _tag: "DecodeException"
-  readonly [DecodeExceptionTypeId]: DecodeExceptionTypeId
-  readonly input: string
-  readonly message?: string
-}
-
-/**
- * Creates a checked exception which occurs when decoding fails.
- *
- * @since 2.0.0
- * @category errors
- */
-export const DecodeException: (input: string, message?: string) => DecodeException = Common.DecodeException
-
-/**
- * Returns `true` if the specified value is an `DecodeException`, `false` otherwise.
- *
- * @since 2.0.0
- * @category refinements
- */
-export const isDecodeException: (u: unknown) => u is DecodeException = Common.isDecodeException
-
-/**
- * @since 3.12.0
- * @category symbols
- */
-export const EncodeExceptionTypeId: unique symbol = Common.EncodeExceptionTypeId
-
-/**
- * @since 3.12.0
- * @category symbols
- */
-export type EncodeExceptionTypeId = typeof EncodeExceptionTypeId
-
-/**
- * Represents a checked exception which occurs when encoding fails.
- *
- * @since 3.12.0
- * @category models
- */
-export interface EncodeException {
-  readonly _tag: "EncodeException"
-  readonly [EncodeExceptionTypeId]: EncodeExceptionTypeId
-  readonly input: string
-  readonly message?: string
-}
-
-/**
- * Creates a checked exception which occurs when encoding fails.
- *
- * @since 3.12.0
- * @category errors
- */
-export const EncodeException: (input: string, message?: string) => EncodeException = Common.EncodeException
-
-/**
- * Returns `true` if the specified value is an `EncodeException`, `false` otherwise.
- *
- * @since 3.12.0
- * @category refinements
- */
-export const isEncodeException: (u: unknown) => u is EncodeException = Common.isEncodeException

package/src/Equal.ts

@@ -1,98 +0,0 @@
-/**
- * @since 2.0.0
- */
-import type { Equivalence } from "./Equivalence.js"
-import * as Hash from "./Hash.js"
-import { hasProperty } from "./Predicate.js"
-import { structuralRegionState } from "./Utils.js"
-
-/**
- * @since 2.0.0
- * @category symbols
- */
-export const symbol: unique symbol = Symbol.for("effect/Equal")
-
-/**
- * @since 2.0.0
- * @category models
- */
-export interface Equal extends Hash.Hash {
-  [symbol](that: Equal): boolean
-}
-
-/**
- * @since 2.0.0
- * @category equality
- */
-export function equals<B>(that: B): <A>(self: A) => boolean
-export function equals<A, B>(self: A, that: B): boolean
-export function equals(): any {
-  if (arguments.length === 1) {
-    return (self: unknown) => compareBoth(self, arguments[0])
-  }
-  return compareBoth(arguments[0], arguments[1])
-}
-
-function compareBoth(self: unknown, that: unknown): boolean {
-  if (self === that) {
-    return true
-  }
-  const selfType = typeof self
-  if (selfType !== typeof that) {
-    return false
-  }
-  if (selfType === "object" || selfType === "function") {
-    if (self !== null && that !== null) {
-      if (isEqual(self) && isEqual(that)) {
-        if (Hash.hash(self) === Hash.hash(that) && self[symbol](that)) {
-          return true
-        } else {
-          return structuralRegionState.enabled && structuralRegionState.tester
-            ? structuralRegionState.tester(self, that)
-            : false
-        }
-      } else if (self instanceof Date && that instanceof Date) {
-        const t1 = self.getTime()
-        const t2 = that.getTime()
-        return t1 === t2 || (Number.isNaN(t1) && Number.isNaN(t2))
-      } else if (self instanceof URL && that instanceof URL) {
-        return self.href === that.href
-      }
-    }
-    if (structuralRegionState.enabled) {
-      if (Array.isArray(self) && Array.isArray(that)) {
-        return self.length === that.length && self.every((v, i) => compareBoth(v, that[i]))
-      }
-      if (Object.getPrototypeOf(self) === Object.prototype && Object.getPrototypeOf(self) === Object.prototype) {
-        const keysSelf = Object.keys(self as any)
-        const keysThat = Object.keys(that as any)
-        if (keysSelf.length === keysThat.length) {
-          for (const key of keysSelf) {
-            // @ts-expect-error
-            if (!(key in that && compareBoth(self[key], that[key]))) {
-              return structuralRegionState.tester ? structuralRegionState.tester(self, that) : false
-            }
-          }
-          return true
-        }
-      }
-      return structuralRegionState.tester ? structuralRegionState.tester(self, that) : false
-    }
-  }
-
-  return structuralRegionState.enabled && structuralRegionState.tester
-    ? structuralRegionState.tester(self, that)
-    : false
-}
-
-/**
- * @since 2.0.0
- * @category guards
- */
-export const isEqual = (u: unknown): u is Equal => hasProperty(u, symbol)
-
-/**
- * @since 2.0.0
- * @category instances
- */
-export const equivalence: <A>() => Equivalence<A> = () => equals

package/src/Equivalence.ts

@@ -1,235 +0,0 @@
-/**
- * This module provides an implementation of the `Equivalence` type class, which defines a binary relation
- * that is reflexive, symmetric, and transitive. In other words, it defines a notion of equivalence between values of a certain type.
- * These properties are also known in mathematics as an "equivalence relation".
- *
- * @since 2.0.0
- */
-import { dual } from "./Function.js"
-import type { TypeLambda } from "./HKT.js"
-
-/**
- * @category type class
- * @since 2.0.0
- */
-export interface Equivalence<in A> {
-  (self: A, that: A): boolean
-}
-
-/**
- * @category type lambdas
- * @since 2.0.0
- */
-export interface EquivalenceTypeLambda extends TypeLambda {
-  readonly type: Equivalence<this["Target"]>
-}
-
-/**
- * @category constructors
- * @since 2.0.0
- */
-export const make = <A>(isEquivalent: (self: A, that: A) => boolean): Equivalence<A> => (self: A, that: A): boolean =>
-  self === that || isEquivalent(self, that)
-
-const isStrictEquivalent = (x: unknown, y: unknown) => x === y
-
-/**
- * Return an `Equivalence` that uses strict equality (===) to compare values.
- *
- * @since 2.0.0
- * @category constructors
- */
-export const strict: <A>() => Equivalence<A> = () => isStrictEquivalent
-
-/**
- * @category instances
- * @since 2.0.0
- */
-export const string: Equivalence<string> = strict()
-
-/**
- * @category instances
- * @since 2.0.0
- */
-export const number: Equivalence<number> = strict()
-
-/**
- * @category instances
- * @since 2.0.0
- */
-export const boolean: Equivalence<boolean> = strict()
-
-/**
- * @category instances
- * @since 2.0.0
- */
-export const bigint: Equivalence<bigint> = strict()
-
-/**
- * @category instances
- * @since 2.0.0
- */
-export const symbol: Equivalence<symbol> = strict()
-
-/**
- * @category combining
- * @since 2.0.0
- */
-export const combine: {
-  <A>(that: Equivalence<A>): (self: Equivalence<A>) => Equivalence<A>
-  <A>(self: Equivalence<A>, that: Equivalence<A>): Equivalence<A>
-} = dual(2, <A>(self: Equivalence<A>, that: Equivalence<A>): Equivalence<A> => make((x, y) => self(x, y) && that(x, y)))
-
-/**
- * @category combining
- * @since 2.0.0
- */
-export const combineMany: {
-  <A>(collection: Iterable<Equivalence<A>>): (self: Equivalence<A>) => Equivalence<A>
-  <A>(self: Equivalence<A>, collection: Iterable<Equivalence<A>>): Equivalence<A>
-} = dual(2, <A>(self: Equivalence<A>, collection: Iterable<Equivalence<A>>): Equivalence<A> =>
-  make((x, y) => {
-    if (!self(x, y)) {
-      return false
-    }
-    for (const equivalence of collection) {
-      if (!equivalence(x, y)) {
-        return false
-      }
-    }
-    return true
-  }))
-
-const isAlwaysEquivalent: Equivalence<unknown> = (_x, _y) => true
-
-/**
- * @category combining
- * @since 2.0.0
- */
-export const combineAll = <A>(collection: Iterable<Equivalence<A>>): Equivalence<A> =>
-  combineMany(isAlwaysEquivalent, collection)
-
-/**
- * @category mapping
- * @since 2.0.0
- */
-export const mapInput: {
-  <B, A>(f: (b: B) => A): (self: Equivalence<A>) => Equivalence<B>
-  <A, B>(self: Equivalence<A>, f: (b: B) => A): Equivalence<B>
-} = dual(
-  2,
-  <A, B>(self: Equivalence<A>, f: (b: B) => A): Equivalence<B> => make((x, y) => self(f(x), f(y)))
-)
-
-/**
- * @category instances
- * @since 2.0.0
- */
-export const Date: Equivalence<Date> = mapInput(number, (date) => date.getTime())
-
-/**
- * @category combining
- * @since 2.0.0
- */
-export const product: {
-  <B>(that: Equivalence<B>): <A>(self: Equivalence<A>) => Equivalence<readonly [A, B]> // readonly because invariant
-  <A, B>(self: Equivalence<A>, that: Equivalence<B>): Equivalence<readonly [A, B]> // readonly because invariant
-} = dual(
-  2,
-  <A, B>(self: Equivalence<A>, that: Equivalence<B>): Equivalence<readonly [A, B]> =>
-    make(([xa, xb], [ya, yb]) => self(xa, ya) && that(xb, yb))
-)
-
-/**
- * @category combining
- * @since 2.0.0
- */
-export const all = <A>(collection: Iterable<Equivalence<A>>): Equivalence<ReadonlyArray<A>> => {
-  return make((x, y) => {
-    const len = Math.min(x.length, y.length)
-
-    let collectionLength = 0
-    for (const equivalence of collection) {
-      if (collectionLength >= len) {
-        break
-      }
-      if (!equivalence(x[collectionLength], y[collectionLength])) {
-        return false
-      }
-      collectionLength++
-    }
-    return true
-  })
-}
-
-/**
- * @category combining
- * @since 2.0.0
- */
-export const productMany = <A>(
-  self: Equivalence<A>,
-  collection: Iterable<Equivalence<A>>
-): Equivalence<readonly [A, ...Array<A>]> /* readonly because invariant */ => {
-  const equivalence = all(collection)
-  return make((x, y) => !self(x[0], y[0]) ? false : equivalence(x.slice(1), y.slice(1)))
-}
-
-/**
- * Similar to `Promise.all` but operates on `Equivalence`s.
- *
- * ```ts skip-type-checking
- * [Equivalence<A>, Equivalence<B>, ...] -> Equivalence<[A, B, ...]>
- * ```
- *
- * Given a tuple of `Equivalence`s returns a new `Equivalence` that compares values of a tuple
- * by applying each `Equivalence` to the corresponding element of the tuple.
- *
- * @category combinators
- * @since 2.0.0
- */
-export const tuple = <T extends ReadonlyArray<Equivalence<any>>>(
-  ...elements: T
-): Equivalence<Readonly<{ [I in keyof T]: [T[I]] extends [Equivalence<infer A>] ? A : never }>> => all(elements) as any
-
-/**
- * Creates a new `Equivalence` for an array of values based on a given `Equivalence` for the elements of the array.
- *
- * @category combinators
- * @since 2.0.0
- */
-export const array = <A>(item: Equivalence<A>): Equivalence<ReadonlyArray<A>> =>
-  make((self, that) => {
-    if (self.length !== that.length) {
-      return false
-    }
-
-    for (let i = 0; i < self.length; i++) {
-      const isEq = item(self[i], that[i])
-      if (!isEq) {
-        return false
-      }
-    }
-
-    return true
-  })
-
-/**
- * Given a struct of `Equivalence`s returns a new `Equivalence` that compares values of a struct
- * by applying each `Equivalence` to the corresponding property of the struct.
- *
- * @category combinators
- * @since 2.0.0
- */
-export const struct = <R extends Record<string, Equivalence<any>>>(
-  fields: R
-): Equivalence<{ readonly [K in keyof R]: [R[K]] extends [Equivalence<infer A>] ? A : never }> => {
-  const keys = Object.keys(fields)
-  return make((self, that) => {
-    for (const key of keys) {
-      if (!fields[key](self[key], that[key])) {
-        return false
-      }
-    }
-    return true
-  })
-}