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

package/src/internal/effectable.ts

@@ -1,131 +0,0 @@
-import type * as Channel from "../Channel.js"
-import type * as Effect from "../Effect.js"
-import type * as Effectable from "../Effectable.js"
-import * as Equal from "../Equal.js"
-import * as Hash from "../Hash.js"
-import { pipeArguments } from "../Pipeable.js"
-import type * as Sink from "../Sink.js"
-import type * as Stream from "../Stream.js"
-import { SingleShotGen, YieldWrap } from "../Utils.js"
-import * as OpCodes from "./opCodes/effect.js"
-import * as version from "./version.js"
-
-/** @internal */
-export const EffectTypeId: Effect.EffectTypeId = Symbol.for("effect/Effect") as Effect.EffectTypeId
-
-/** @internal */
-export const StreamTypeId: Stream.StreamTypeId = Symbol.for("effect/Stream") as Stream.StreamTypeId
-
-/** @internal */
-export const SinkTypeId: Sink.SinkTypeId = Symbol.for("effect/Sink") as Sink.SinkTypeId
-
-/** @internal */
-export const ChannelTypeId: Channel.ChannelTypeId = Symbol.for("effect/Channel") as Channel.ChannelTypeId
-
-/** @internal */
-export const effectVariance = {
-  /* c8 ignore next */
-  _R: (_: never) => _,
-  /* c8 ignore next */
-  _E: (_: never) => _,
-  /* c8 ignore next */
-  _A: (_: never) => _,
-
-  _V: version.getCurrentVersion()
-}
-
-const sinkVariance = {
-  /* c8 ignore next */
-  _A: (_: never) => _,
-  /* c8 ignore next */
-  _In: (_: unknown) => _,
-  /* c8 ignore next */
-  _L: (_: never) => _,
-  /* c8 ignore next */
-  _E: (_: never) => _,
-  /* c8 ignore next */
-  _R: (_: never) => _
-}
-
-const channelVariance = {
-  /* c8 ignore next */
-  _Env: (_: never) => _,
-  /* c8 ignore next */
-  _InErr: (_: unknown) => _,
-  /* c8 ignore next */
-  _InElem: (_: unknown) => _,
-  /* c8 ignore next */
-  _InDone: (_: unknown) => _,
-  /* c8 ignore next */
-  _OutErr: (_: never) => _,
-  /* c8 ignore next */
-  _OutElem: (_: never) => _,
-  /* c8 ignore next */
-  _OutDone: (_: never) => _
-}
-
-/** @internal */
-export const EffectPrototype: Effect.Effect<never> & Equal.Equal = {
-  [EffectTypeId]: effectVariance,
-  [StreamTypeId]: effectVariance,
-  [SinkTypeId]: sinkVariance,
-  [ChannelTypeId]: channelVariance,
-  [Equal.symbol](that: any) {
-    return this === that
-  },
-  [Hash.symbol]() {
-    return Hash.cached(this, Hash.random(this))
-  },
-  [Symbol.iterator]() {
-    return new SingleShotGen(new YieldWrap(this)) as any
-  },
-  pipe() {
-    return pipeArguments(this, arguments)
-  }
-}
-
-/** @internal */
-export const StructuralPrototype: Equal.Equal = {
-  [Hash.symbol]() {
-    return Hash.cached(this, Hash.structure(this))
-  },
-  [Equal.symbol](this: Equal.Equal, that: Equal.Equal) {
-    const selfKeys = Object.keys(this)
-    const thatKeys = Object.keys(that as object)
-    if (selfKeys.length !== thatKeys.length) {
-      return false
-    }
-    for (const key of selfKeys) {
-      if (!(key in (that as object) && Equal.equals((this as any)[key], (that as any)[key]))) {
-        return false
-      }
-    }
-    return true
-  }
-}
-
-/** @internal */
-export const CommitPrototype: Effect.Effect<never> = {
-  ...EffectPrototype,
-  _op: OpCodes.OP_COMMIT
-} as any
-
-/** @internal */
-export const StructuralCommitPrototype: Effect.Effect<never> = {
-  ...CommitPrototype,
-  ...StructuralPrototype
-} as any
-
-/** @internal */
-export const Base: Effectable.CommitPrimitive = (function() {
-  function Base() {}
-  Base.prototype = CommitPrototype
-  return Base as any
-})()
-
-/** @internal */
-export const StructuralBase: Effectable.CommitPrimitive = (function() {
-  function Base() {}
-  Base.prototype = StructuralCommitPrototype
-  return Base as any
-})()

package/src/internal/either.ts

@@ -1,110 +0,0 @@
-/**
- * @since 2.0.0
- */
-
-import type * as Either from "../Either.js"
-import * as Equal from "../Equal.js"
-import { dual } from "../Function.js"
-import * as Hash from "../Hash.js"
-import { format, NodeInspectSymbol, toJSON } from "../Inspectable.js"
-import type { Option } from "../Option.js"
-import { hasProperty } from "../Predicate.js"
-import { EffectPrototype } from "./effectable.js"
-import * as option from "./option.js"
-
-/**
- * @internal
- */
-export const TypeId: Either.TypeId = Symbol.for("effect/Either") as Either.TypeId
-
-const CommonProto = {
-  ...EffectPrototype,
-  [TypeId]: {
-    _R: (_: never) => _
-  },
-  [NodeInspectSymbol]<L, R>(this: Either.Either<R, L>) {
-    return this.toJSON()
-  },
-  toString<L, R>(this: Either.Left<L, R>) {
-    return format(this.toJSON())
-  }
-}
-
-const RightProto = Object.assign(Object.create(CommonProto), {
-  _tag: "Right",
-  _op: "Right",
-  [Equal.symbol]<L, R>(this: Either.Right<L, R>, that: unknown): boolean {
-    return isEither(that) && isRight(that) && Equal.equals(this.right, that.right)
-  },
-  [Hash.symbol]<L, R>(this: Either.Right<L, R>) {
-    return Hash.combine(Hash.hash(this._tag))(Hash.hash(this.right))
-  },
-  toJSON<L, R>(this: Either.Right<L, R>) {
-    return {
-      _id: "Either",
-      _tag: this._tag,
-      right: toJSON(this.right)
-    }
-  }
-})
-
-const LeftProto = Object.assign(Object.create(CommonProto), {
-  _tag: "Left",
-  _op: "Left",
-  [Equal.symbol]<L, R>(this: Either.Left<L, R>, that: unknown): boolean {
-    return isEither(that) && isLeft(that) && Equal.equals(this.left, that.left)
-  },
-  [Hash.symbol]<L, R>(this: Either.Left<L, R>) {
-    return Hash.combine(Hash.hash(this._tag))(Hash.hash(this.left))
-  },
-  toJSON<E, A>(this: Either.Left<E, A>) {
-    return {
-      _id: "Either",
-      _tag: this._tag,
-      left: toJSON(this.left)
-    }
-  }
-})
-
-/** @internal */
-export const isEither = (input: unknown): input is Either.Either<unknown, unknown> => hasProperty(input, TypeId)
-
-/** @internal */
-export const isLeft = <R, L>(ma: Either.Either<R, L>): ma is Either.Left<L, R> => ma._tag === "Left"
-
-/** @internal */
-export const isRight = <R, L>(ma: Either.Either<R, L>): ma is Either.Right<L, R> => ma._tag === "Right"
-
-/** @internal */
-export const left = <L>(left: L): Either.Either<never, L> => {
-  const a = Object.create(LeftProto)
-  a.left = left
-  return a
-}
-
-/** @internal */
-export const right = <R>(right: R): Either.Either<R> => {
-  const a = Object.create(RightProto)
-  a.right = right
-  return a
-}
-
-/** @internal */
-export const getLeft = <R, L>(
-  self: Either.Either<R, L>
-): Option<L> => (isRight(self) ? option.none : option.some(self.left))
-
-/** @internal */
-export const getRight = <R, L>(
-  self: Either.Either<R, L>
-): Option<R> => (isLeft(self) ? option.none : option.some(self.right))
-
-/** @internal */
-export const fromOption: {
-  <L>(onNone: () => L): <R>(self: Option<R>) => Either.Either<R, L>
-  <R, L>(self: Option<R>, onNone: () => L): Either.Either<R, L>
-} = dual(
-  2,
-  <R, L>(self: Option<R>, onNone: () => L): Either.Either<R, L> =>
-    option.isNone(self) ? left(onNone()) : right(self.value)
-)

package/src/internal/encoding/base64.ts

@@ -1,286 +0,0 @@
-import * as Either from "../../Either.js"
-import type * as Encoding from "../../Encoding.js"
-import { DecodeException } from "./common.js"
-
-/** @internal */
-export const encode = (bytes: Uint8Array) => {
-  const length = bytes.length
-
-  let result = ""
-  let i: number
-
-  for (i = 2; i < length; i += 3) {
-    result += base64abc[bytes[i - 2] >> 2]
-    result += base64abc[((bytes[i - 2] & 0x03) << 4) | (bytes[i - 1] >> 4)]
-    result += base64abc[((bytes[i - 1] & 0x0f) << 2) | (bytes[i] >> 6)]
-    result += base64abc[bytes[i] & 0x3f]
-  }
-
-  if (i === length + 1) {
-    // 1 octet yet to write
-    result += base64abc[bytes[i - 2] >> 2]
-    result += base64abc[(bytes[i - 2] & 0x03) << 4]
-    result += "=="
-  }
-
-  if (i === length) {
-    // 2 octets yet to write
-    result += base64abc[bytes[i - 2] >> 2]
-    result += base64abc[((bytes[i - 2] & 0x03) << 4) | (bytes[i - 1] >> 4)]
-    result += base64abc[(bytes[i - 1] & 0x0f) << 2]
-    result += "="
-  }
-
-  return result
-}
-
-/** @internal */
-export const decode = (str: string): Either.Either<Uint8Array, Encoding.DecodeException> => {
-  const stripped = stripCrlf(str)
-  const length = stripped.length
-  if (length % 4 !== 0) {
-    return Either.left(
-      DecodeException(stripped, `Length must be a multiple of 4, but is ${length}`)
-    )
-  }
-
-  const index = stripped.indexOf("=")
-  if (index !== -1 && ((index < length - 2) || (index === length - 2 && stripped[length - 1] !== "="))) {
-    return Either.left(
-      DecodeException(stripped, "Found a '=' character, but it is not at the end")
-    )
-  }
-
-  try {
-    const missingOctets = stripped.endsWith("==") ? 2 : stripped.endsWith("=") ? 1 : 0
-    const result = new Uint8Array(3 * (length / 4) - missingOctets)
-    for (let i = 0, j = 0; i < length; i += 4, j += 3) {
-      const buffer = getBase64Code(stripped.charCodeAt(i)) << 18 |
-        getBase64Code(stripped.charCodeAt(i + 1)) << 12 |
-        getBase64Code(stripped.charCodeAt(i + 2)) << 6 |
-        getBase64Code(stripped.charCodeAt(i + 3))
-
-      result[j] = buffer >> 16
-      result[j + 1] = (buffer >> 8) & 0xff
-      result[j + 2] = buffer & 0xff
-    }
-
-    return Either.right(result)
-  } catch (e) {
-    return Either.left(
-      DecodeException(stripped, e instanceof Error ? e.message : "Invalid input")
-    )
-  }
-}
-
-/** @internal */
-export const stripCrlf = (str: string) => str.replace(/[\n\r]/g, "")
-
-/** @internal */
-function getBase64Code(charCode: number) {
-  if (charCode >= base64codes.length) {
-    throw new TypeError(`Invalid character ${String.fromCharCode(charCode)}`)
-  }
-
-  const code = base64codes[charCode]
-  if (code === 255) {
-    throw new TypeError(`Invalid character ${String.fromCharCode(charCode)}`)
-  }
-
-  return code
-}
-
-/** @internal */
-const base64abc = [
-  "A",
-  "B",
-  "C",
-  "D",
-  "E",
-  "F",
-  "G",
-  "H",
-  "I",
-  "J",
-  "K",
-  "L",
-  "M",
-  "N",
-  "O",
-  "P",
-  "Q",
-  "R",
-  "S",
-  "T",
-  "U",
-  "V",
-  "W",
-  "X",
-  "Y",
-  "Z",
-  "a",
-  "b",
-  "c",
-  "d",
-  "e",
-  "f",
-  "g",
-  "h",
-  "i",
-  "j",
-  "k",
-  "l",
-  "m",
-  "n",
-  "o",
-  "p",
-  "q",
-  "r",
-  "s",
-  "t",
-  "u",
-  "v",
-  "w",
-  "x",
-  "y",
-  "z",
-  "0",
-  "1",
-  "2",
-  "3",
-  "4",
-  "5",
-  "6",
-  "7",
-  "8",
-  "9",
-  "+",
-  "/"
-]
-
-/** @internal */
-const base64codes = [
-  255,
-  255,
-  255,
-  255,
-  255,
-  255,
-  255,
-  255,
-  255,
-  255,
-  255,
-  255,
-  255,
-  255,
-  255,
-  255,
-  255,
-  255,
-  255,
-  255,
-  255,
-  255,
-  255,
-  255,
-  255,
-  255,
-  255,
-  255,
-  255,
-  255,
-  255,
-  255,
-  255,
-  255,
-  255,
-  255,
-  255,
-  255,
-  255,
-  255,
-  255,
-  255,
-  255,
-  62,
-  255,
-  255,
-  255,
-  63,
-  52,
-  53,
-  54,
-  55,
-  56,
-  57,
-  58,
-  59,
-  60,
-  61,
-  255,
-  255,
-  255,
-  0,
-  255,
-  255,
-  255,
-  0,
-  1,
-  2,
-  3,
-  4,
-  5,
-  6,
-  7,
-  8,
-  9,
-  10,
-  11,
-  12,
-  13,
-  14,
-  15,
-  16,
-  17,
-  18,
-  19,
-  20,
-  21,
-  22,
-  23,
-  24,
-  25,
-  255,
-  255,
-  255,
-  255,
-  255,
-  255,
-  26,
-  27,
-  28,
-  29,
-  30,
-  31,
-  32,
-  33,
-  34,
-  35,
-  36,
-  37,
-  38,
-  39,
-  40,
-  41,
-  42,
-  43,
-  44,
-  45,
-  46,
-  47,
-  48,
-  49,
-  50,
-  51
-]

package/src/internal/encoding/base64Url.ts

@@ -1,29 +0,0 @@
-import * as Either from "../../Either.js"
-import type * as Encoding from "../../Encoding.js"
-import * as Base64 from "./base64.js"
-import { DecodeException } from "./common.js"
-
-/** @internal */
-export const encode = (data: Uint8Array) =>
-  Base64.encode(data).replace(/=/g, "").replace(/\+/g, "-").replace(/\//g, "_")
-
-/** @internal */
-export const decode = (str: string): Either.Either<Uint8Array, Encoding.DecodeException> => {
-  const stripped = Base64.stripCrlf(str)
-  const length = stripped.length
-  if (length % 4 === 1) {
-    return Either.left(
-      DecodeException(stripped, `Length should be a multiple of 4, but is ${length}`)
-    )
-  }
-
-  if (!/^[-_A-Z0-9]*?={0,2}$/i.test(stripped)) {
-    return Either.left(DecodeException(stripped, "Invalid input"))
-  }
-
-  // Some variants allow or require omitting the padding '=' signs
-  let sanitized = length % 4 === 2 ? `${stripped}==` : length % 4 === 3 ? `${stripped}=` : stripped
-  sanitized = sanitized.replace(/-/g, "+").replace(/_/g, "/")
-
-  return Base64.decode(sanitized)
-}

package/src/internal/encoding/common.ts

@@ -1,51 +0,0 @@
-import type * as Encoding from "../../Encoding.js"
-import { hasProperty, isString } from "../../Predicate.js"
-import type { Mutable } from "../../Types.js"
-
-/** @internal */
-export const DecodeExceptionTypeId: Encoding.DecodeExceptionTypeId = Symbol.for(
-  "effect/Encoding/errors/Decode"
-) as Encoding.DecodeExceptionTypeId
-
-/** @internal */
-export const DecodeException = (input: string, message?: string): Encoding.DecodeException => {
-  const out: Mutable<Encoding.DecodeException> = {
-    _tag: "DecodeException",
-    [DecodeExceptionTypeId]: DecodeExceptionTypeId,
-    input
-  }
-  if (isString(message)) {
-    out.message = message
-  }
-  return out
-}
-
-/** @internal */
-export const isDecodeException = (u: unknown): u is Encoding.DecodeException => hasProperty(u, DecodeExceptionTypeId)
-
-/** @internal */
-export const EncodeExceptionTypeId: Encoding.EncodeExceptionTypeId = Symbol.for(
-  "effect/Encoding/errors/Encode"
-) as Encoding.EncodeExceptionTypeId
-
-/** @internal */
-export const EncodeException = (input: string, message?: string): Encoding.EncodeException => {
-  const out: Mutable<Encoding.EncodeException> = {
-    _tag: "EncodeException",
-    [EncodeExceptionTypeId]: EncodeExceptionTypeId,
-    input
-  }
-  if (isString(message)) {
-    out.message = message
-  }
-  return out
-}
-
-/** @internal */
-export const isEncodeException = (u: unknown): u is Encoding.EncodeException => hasProperty(u, EncodeExceptionTypeId)
-
-/** @interal */
-export const encoder = new TextEncoder()
-
-/** @interal */
-export const decoder = new TextDecoder()