effect 2.0.0-next.44 → 2.0.0-next.46

package/src/internal/Encoding/Base64.ts

@@ -0,0 +1,282 @@
+import * as Either from "../../Either"
+import type * as Encoding from "../../Encoding"
+import { DecodeException } from "../../internal/Encoding/Common"
+
+/** @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<Encoding.DecodeException, Uint8Array> => {
+  const length = str.length
+  if (length % 4 !== 0) {
+    return Either.left(
+      DecodeException(str, `Length must be a multiple of 4, but is ${length}`)
+    )
+  }
+
+  const index = str.indexOf("=")
+  if (index !== -1 && ((index < length - 2) || (index === length - 2 && str[length - 1] !== "="))) {
+    return Either.left(
+      DecodeException(str, "Found a '=' character, but it is not at the end")
+    )
+  }
+
+  try {
+    const missingOctets = str.endsWith("==") ? 2 : str.endsWith("=") ? 1 : 0
+    const result = new Uint8Array(3 * (length / 4))
+    for (let i = 0, j = 0; i < length; i += 4, j += 3) {
+      const buffer = getBase64Code(str.charCodeAt(i)) << 18 |
+        getBase64Code(str.charCodeAt(i + 1)) << 12 |
+        getBase64Code(str.charCodeAt(i + 2)) << 6 |
+        getBase64Code(str.charCodeAt(i + 3))
+
+      result[j] = buffer >> 16
+      result[j + 1] = (buffer >> 8) & 0xff
+      result[j + 2] = buffer & 0xff
+    }
+
+    return Either.right(result.subarray(0, result.length - missingOctets))
+  } catch (e) {
+    return Either.left(
+      DecodeException(str, e instanceof Error ? e.message : "Invalid input")
+    )
+  }
+}
+
+/** @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

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

package/src/internal/Encoding/Common.ts

@@ -0,0 +1,24 @@
+import type * as Encoding from "../../Encoding"
+
+/** @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 => ({
+  _tag: "DecodeException",
+  [DecodeExceptionTypeId]: DecodeExceptionTypeId,
+  input,
+  message
+})
+
+/** @internal */
+export const isDecodeException = (u: unknown): u is Encoding.DecodeException =>
+  typeof u === "object" && u != null && DecodeExceptionTypeId in u
+
+/** @interal */
+export const encoder = new TextEncoder()
+
+/** @interal */
+export const decoder = new TextDecoder()

package/src/internal/Encoding/Hex.ts

@@ -0,0 +1,315 @@
+import * as Either from "../../Either"
+import type * as Encoding from "../../Encoding"
+import { DecodeException } from "../../internal/Encoding/Common"
+
+/** @internal */
+export const encode = (bytes: Uint8Array) => {
+  let result = ""
+  for (let i = 0; i < bytes.length; ++i) {
+    result += bytesToHex[bytes[i]]
+  }
+
+  return result
+}
+
+/** @internal */
+export const decode = (str: string): Either.Either<Encoding.DecodeException, Uint8Array> => {
+  const bytes = new TextEncoder().encode(str)
+  if (bytes.length % 2 !== 0) {
+    return Either.left(DecodeException(str, `Length must be a multiple of 2, but is ${bytes.length}`))
+  }
+
+  try {
+    const length = bytes.length / 2
+    const result = new Uint8Array(length)
+    for (let i = 0; i < length; i++) {
+      const a = fromHexChar(bytes[i * 2])
+      const b = fromHexChar(bytes[i * 2 + 1])
+      result[i] = (a << 4) | b
+    }
+
+    return Either.right(result)
+  } catch (e) {
+    return Either.left(DecodeException(str, e instanceof Error ? e.message : "Invalid input"))
+  }
+}
+
+/** @internal */
+const bytesToHex = [
+  "00",
+  "01",
+  "02",
+  "03",
+  "04",
+  "05",
+  "06",
+  "07",
+  "08",
+  "09",
+  "0a",
+  "0b",
+  "0c",
+  "0d",
+  "0e",
+  "0f",
+  "10",
+  "11",
+  "12",
+  "13",
+  "14",
+  "15",
+  "16",
+  "17",
+  "18",
+  "19",
+  "1a",
+  "1b",
+  "1c",
+  "1d",
+  "1e",
+  "1f",
+  "20",
+  "21",
+  "22",
+  "23",
+  "24",
+  "25",
+  "26",
+  "27",
+  "28",
+  "29",
+  "2a",
+  "2b",
+  "2c",
+  "2d",
+  "2e",
+  "2f",
+  "30",
+  "31",
+  "32",
+  "33",
+  "34",
+  "35",
+  "36",
+  "37",
+  "38",
+  "39",
+  "3a",
+  "3b",
+  "3c",
+  "3d",
+  "3e",
+  "3f",
+  "40",
+  "41",
+  "42",
+  "43",
+  "44",
+  "45",
+  "46",
+  "47",
+  "48",
+  "49",
+  "4a",
+  "4b",
+  "4c",
+  "4d",
+  "4e",
+  "4f",
+  "50",
+  "51",
+  "52",
+  "53",
+  "54",
+  "55",
+  "56",
+  "57",
+  "58",
+  "59",
+  "5a",
+  "5b",
+  "5c",
+  "5d",
+  "5e",
+  "5f",
+  "60",
+  "61",
+  "62",
+  "63",
+  "64",
+  "65",
+  "66",
+  "67",
+  "68",
+  "69",
+  "6a",
+  "6b",
+  "6c",
+  "6d",
+  "6e",
+  "6f",
+  "70",
+  "71",
+  "72",
+  "73",
+  "74",
+  "75",
+  "76",
+  "77",
+  "78",
+  "79",
+  "7a",
+  "7b",
+  "7c",
+  "7d",
+  "7e",
+  "7f",
+  "80",
+  "81",
+  "82",
+  "83",
+  "84",
+  "85",
+  "86",
+  "87",
+  "88",
+  "89",
+  "8a",
+  "8b",
+  "8c",
+  "8d",
+  "8e",
+  "8f",
+  "90",
+  "91",
+  "92",
+  "93",
+  "94",
+  "95",
+  "96",
+  "97",
+  "98",
+  "99",
+  "9a",
+  "9b",
+  "9c",
+  "9d",
+  "9e",
+  "9f",
+  "a0",
+  "a1",
+  "a2",
+  "a3",
+  "a4",
+  "a5",
+  "a6",
+  "a7",
+  "a8",
+  "a9",
+  "aa",
+  "ab",
+  "ac",
+  "ad",
+  "ae",
+  "af",
+  "b0",
+  "b1",
+  "b2",
+  "b3",
+  "b4",
+  "b5",
+  "b6",
+  "b7",
+  "b8",
+  "b9",
+  "ba",
+  "bb",
+  "bc",
+  "bd",
+  "be",
+  "bf",
+  "c0",
+  "c1",
+  "c2",
+  "c3",
+  "c4",
+  "c5",
+  "c6",
+  "c7",
+  "c8",
+  "c9",
+  "ca",
+  "cb",
+  "cc",
+  "cd",
+  "ce",
+  "cf",
+  "d0",
+  "d1",
+  "d2",
+  "d3",
+  "d4",
+  "d5",
+  "d6",
+  "d7",
+  "d8",
+  "d9",
+  "da",
+  "db",
+  "dc",
+  "dd",
+  "de",
+  "df",
+  "e0",
+  "e1",
+  "e2",
+  "e3",
+  "e4",
+  "e5",
+  "e6",
+  "e7",
+  "e8",
+  "e9",
+  "ea",
+  "eb",
+  "ec",
+  "ed",
+  "ee",
+  "ef",
+  "f0",
+  "f1",
+  "f2",
+  "f3",
+  "f4",
+  "f5",
+  "f6",
+  "f7",
+  "f8",
+  "f9",
+  "fa",
+  "fb",
+  "fc",
+  "fd",
+  "fe",
+  "ff"
+]
+
+/** @internal */
+const fromHexChar = (byte: number) => {
+  // '0' <= byte && byte <= '9'
+  if (48 <= byte && byte <= 57) {
+    return byte - 48
+  }
+
+  // 'a' <= byte && byte <= 'f'
+  if (97 <= byte && byte <= 102) {
+    return byte - 97 + 10
+  }
+
+  // 'A' <= byte && byte <= 'F'
+  if (65 <= byte && byte <= 70) {
+    return byte - 65 + 10
+  }
+
+  throw new TypeError("Invalid input")
+}

package/src/internal/HashMap/array.ts

@@ -0,0 +1,49 @@
+/** @internal */
+export function arrayUpdate<A>(mutate: boolean, at: number, v: A, arr: Array<A>) {
+  let out = arr
+  if (!mutate) {
+    const len = arr.length
+    out = new Array(len)
+    for (let i = 0; i < len; ++i) out[i] = arr[i]!
+  }
+  out[at] = v
+  return out
+}
+
+/** @internal */
+export function arraySpliceOut<A>(mutate: boolean, at: number, arr: Array<A>) {
+  const newLen = arr.length - 1
+  let i = 0
+  let g = 0
+  let out = arr
+  if (mutate) {
+    i = g = at
+  } else {
+    out = new Array(newLen)
+    while (i < at) out[g++] = arr[i++]!
+  }
+  ;++i
+  while (i <= newLen) out[g++] = arr[i++]!
+  if (mutate) {
+    out.length = newLen
+  }
+  return out
+}
+
+/** @internal */
+export function arraySpliceIn<A>(mutate: boolean, at: number, v: A, arr: Array<A>) {
+  const len = arr.length
+  if (mutate) {
+    let i = len
+    while (i >= at) arr[i--] = arr[i]!
+    arr[at] = v
+    return arr
+  }
+  let i = 0,
+    g = 0
+  const out = new Array<A>(len + 1)
+  while (i < at) out[g++] = arr[i++]!
+  out[at] = v
+  while (i < len) out[++g] = arr[i++]!
+  return out
+}

package/src/internal/HashMap/bitwise.ts

@@ -0,0 +1,32 @@
+import { MASK } from "../../internal/HashMap/config"
+
+/**
+ * Hamming weight.
+ *
+ * Taken from: http://jsperf.com/hamming-weight
+ *
+ * @internal
+ */
+export function popcount(x: number) {
+  x -= (x >> 1) & 0x55555555
+  x = (x & 0x33333333) + ((x >> 2) & 0x33333333)
+  x = (x + (x >> 4)) & 0x0f0f0f0f
+  x += x >> 8
+  x += x >> 16
+  return x & 0x7f
+}
+
+/** @internal */
+export function hashFragment(shift: number, h: number) {
+  return (h >>> shift) & MASK
+}
+
+/** @internal */
+export function toBitmap(x: number) {
+  return 1 << x
+}
+
+/** @internal */
+export function fromBitmap(bitmap: number, bit: number) {
+  return popcount(bitmap & (bit - 1))
+}