effect 4.1.0 → 4.1.2

package/src/crypto/Signature.ts

@@ -48,7 +48,7 @@ import * as Asymmetric from "./internal/asymmetric.ts"
 import * as KeyModel from "./internal/key.ts"
 import * as internal from "./internal/webCrypto.ts"
 import * as SecureRandom from "./SecureRandom.ts"
-import { WebCrypto } from "./WebCrypto.ts"
+import * as WebCrypto from "./WebCrypto.ts"
 
 const PrivateKeyTypeId = "~effect/crypto/Signature/PrivateKey" as const
 const PublicKeyTypeId = "~effect/crypto/Signature/PublicKey" as const
@@ -513,7 +513,7 @@ export const layerWebCrypto: Layer.Layer<Signature, never, SecureRandom.SecureRa
   Signature,
   Effect.gen(function*() {
     const random = yield* SecureRandom.SecureRandom
-    const crypto = yield* WebCrypto
+    const crypto = yield* WebCrypto.WebCrypto
     const caches = Asymmetric.makeCaches(family)
     return Signature.of({
       generateKeyPair: <A extends Algorithm>(algorithm: A) =>
@@ -630,7 +630,7 @@ export const publicKey = <
  */
 export const privateKeyFromCryptoKey = <A extends Algorithm>(
   algorithm: A,
-  cryptoKey: CryptoKey
+  cryptoKey: WebCrypto.CryptoKey
 ): Effect.Effect<PrivateKey<A>, CryptoError.CryptoError> =>
   Asymmetric.fromCryptoKey(family, "privateKeyFromCryptoKey", algorithm, "private", cryptoKey)
 
@@ -650,7 +650,7 @@ export const privateKeyFromCryptoKey = <A extends Algorithm>(
  */
 export const publicKeyFromCryptoKey = <A extends Algorithm>(
   algorithm: A,
-  cryptoKey: CryptoKey
+  cryptoKey: WebCrypto.CryptoKey
 ): Effect.Effect<PublicKey<A>, CryptoError.CryptoError> =>
   Asymmetric.fromCryptoKey(family, "publicKeyFromCryptoKey", algorithm, "public", cryptoKey)
 

package/src/crypto/WebCrypto.ts

@@ -20,6 +20,10 @@
 import * as Context from "../Context.ts"
 import * as Layer from "../Layer.ts"
 
+// The type of `globalThis.crypto`, which, unlike the global `Crypto` type,
+// every `@types/node` version declares.
+type Crypto = typeof globalThis.crypto
+
 /**
  * Reference to the WebCrypto `Crypto` object, defaulting to
  * `globalThis.crypto`.
@@ -62,3 +66,19 @@ export const WebCrypto: Context.Reference<Crypto> = Context.Reference<Crypto>("e
  * @since 4.0.0
  */
 export const layer = (crypto: Crypto): Layer.Layer<never> => Layer.succeed(WebCrypto, crypto)
+
+/**
+ * A WebCrypto `CryptoKey`, declared structurally so the `effect` declarations
+ * type-check without the DOM library and with any `@types/node` version.
+ * Keys from `crypto.subtle` and Node's `webcrypto` are assignable to it.
+ *
+ * @stability unstable
+ * @category models
+ * @since 4.1.1
+ */
+export interface CryptoKey {
+  readonly algorithm: { readonly name: string }
+  readonly extractable: boolean
+  readonly type: "private" | "public" | "secret"
+  readonly usages: ReadonlyArray<string>
+}

package/src/crypto/internal/asymmetric.ts

@@ -2,6 +2,7 @@ import * as Effect from "../../Effect.ts"
 import * as Predicate from "../../Predicate.ts"
 import * as CryptoError from "../CryptoError.ts"
 import type * as SecureRandom from "../SecureRandom.ts"
+import type * as WebCrypto from "../WebCrypto.ts"
 import * as KeyModel from "./key.ts"
 import * as internal from "./webCrypto.ts"
 
@@ -121,7 +122,7 @@ export const fromCryptoKey = <K>(
   method: string,
   algorithm: unknown,
   role: Role,
-  cryptoKey: CryptoKey
+  cryptoKey: WebCrypto.CryptoKey
 ): Effect.Effect<K, CryptoError.CryptoError> => {
   const spec = family.specOf(algorithm)
   return KeyModel.fromCryptoKey(

package/src/crypto/internal/key.ts

@@ -4,6 +4,7 @@ import { format } from "../../Formatter.ts"
 import { NodeInspectSymbol } from "../../Inspectable.ts"
 import * as Predicate from "../../Predicate.ts"
 import type * as CryptoError from "../CryptoError.ts"
+import type * as WebCrypto from "../WebCrypto.ts"
 import * as internal from "./webCrypto.ts"
 
 /**
@@ -131,7 +132,7 @@ export const checkAesLength = (name: string, keyLength: number) => (algorithm: K
   return length === keyLength * 8 ? undefined : `Expected a ${keyLength * 8}-bit ${name} key, not ${length} bits`
 }
 
-const checkCryptoKey = (cryptoKey: CryptoKey, expected: ExpectedCryptoKey): string | undefined => {
+const checkCryptoKey = (cryptoKey: WebCrypto.CryptoKey, expected: ExpectedCryptoKey): string | undefined => {
   if (
     !Predicate.hasProperty(cryptoKey, "type") || !Predicate.hasProperty(cryptoKey, "algorithm") ||
     !Predicate.hasProperty(cryptoKey, "usages") || !Array.isArray(cryptoKey.usages)
@@ -162,7 +163,7 @@ const checkCryptoKey = (cryptoKey: CryptoKey, expected: ExpectedCryptoKey): stri
  *
  * @internal
  */
-export const importedAlgorithm = (algorithm: unknown, cryptoKey: CryptoKey): unknown => {
+export const importedAlgorithm = (algorithm: unknown, cryptoKey: WebCrypto.CryptoKey): unknown => {
   const modulusLength = (cryptoKey.algorithm as Partial<RsaKeyAlgorithm>).modulusLength
   return Predicate.hasProperty(algorithm, "modulusLength") && modulusLength !== undefined &&
       algorithm.modulusLength !== modulusLength
@@ -171,7 +172,8 @@ export const importedAlgorithm = (algorithm: unknown, cryptoKey: CryptoKey): unk
 }
 
 /**
- * Synchronously validates and wraps a `CryptoKey`.
+ * Synchronously validates and wraps a `CryptoKey`. The structural key only
+ * becomes the native `CryptoKey` once it passes the check.
  *
  * @internal
  */
@@ -180,13 +182,18 @@ export const fromCryptoKey = <K>(
   method: string,
   proto: object,
   algorithm: unknown,
-  cryptoKey: CryptoKey,
+  cryptoKey: WebCrypto.CryptoKey,
   expected: ExpectedCryptoKey
 ): Effect.Effect<K, CryptoError.CryptoError> =>
   Effect.suspend(() => {
     const problem = checkCryptoKey(cryptoKey, expected)
     return problem === undefined
-      ? Effect.succeed(make<K>(proto, importedAlgorithm(algorithm, cryptoKey), { _tag: "CryptoKey", cryptoKey }))
+      ? Effect.succeed(
+        make<K>(proto, importedAlgorithm(algorithm, cryptoKey), {
+          _tag: "CryptoKey",
+          cryptoKey: cryptoKey as CryptoKey
+        })
+      )
       : internal.invalidKey(module, method, problem)
   })
 

package/src/encoding/Base64Url.ts

@@ -115,6 +115,7 @@ export const decode = (str: string): Result.Result<Uint8Array, EncodingError> =>
       })
     )
   }
+  // Validating up front keeps failures as cheap as the scan, without allocating the output.
   if (!/^[-_A-Z0-9]*?={0,2}$/i.test(stripped)) {
     return Result.fail(
       new EncodingError({
@@ -125,11 +126,34 @@ export const decode = (str: string): Result.Result<Uint8Array, EncodingError> =>
       })
     )
   }
-  let sanitized = length % 4 === 2 ? `${stripped}==` : length % 4 === 3 ? `${stripped}=` : stripped
-  sanitized = sanitized.replace(/-/g, "+").replace(/_/g, "/")
-  return Base64.decode(sanitized)
+  const end = !padded ? length : stripped.charCodeAt(length - 2) === 61 ? length - 2 : length - 1
+  const fullEnd = end & ~3
+  // Not `(end * 3) >> 2`: engines that allow strings over 2^31 / 3 characters would overflow int32.
+  const result = new Uint8Array(Math.floor(end * 3 / 4))
+  let j = 0
+  for (let i = 0; i < fullEnd; i += 4) {
+    const a = codes[stripped.charCodeAt(i)]
+    const b = codes[stripped.charCodeAt(i + 1)]
+    const c = codes[stripped.charCodeAt(i + 2)]
+    const d = codes[stripped.charCodeAt(i + 3)]
+    result[j++] = (a << 2) | (b >> 4)
+    result[j++] = (b << 4) | (c >> 2)
+    result[j++] = (c << 6) | d
+  }
+  // Non-zero trailing bits in the final character are ignored.
+  if (end > fullEnd) {
+    const a = codes[stripped.charCodeAt(fullEnd)]
+    const b = codes[stripped.charCodeAt(fullEnd + 1)]
+    result[j++] = (a << 2) | (b >> 4)
+    if (end - fullEnd === 3) result[j] = (b << 4) | (codes[stripped.charCodeAt(fullEnd + 2)] >> 2)
+  }
+  return Result.succeed(result)
 }
 
+const alphabet = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_"
+const codes = new Uint8Array(128)
+for (let i = 0; i < alphabet.length; i++) codes[alphabet.charCodeAt(i)] = i
+
 /**
  * Decodes a padded or unpadded URL-safe Base64 string into UTF-8 text safely.
  *

package/src/encoding/Json5.ts

@@ -0,0 +1,59 @@
+/**
+ * Parses JSON5 configuration files without external dependencies.
+ *
+ * The compatibility target is [JSON5 1.0.0](https://spec.json5.org/) and the
+ * value-parsing behavior of `json5` 2.2.3, without its optional reviver.
+ * Identifier names use the runtime's Unicode property tables.
+ *
+ * @stability unstable
+ * @since 4.1.2
+ */
+
+import * as internal from "../internal/jsonParser.ts"
+import * as Result from "../Result.ts"
+import { EncodingError } from "./EncodingError.ts"
+
+/**
+ * Parses a JSON5 document into a JavaScript value.
+ *
+ * **Details**
+ *
+ * Returns `Result.succeed` with the parsed value, or `Result.fail` with an
+ * `EncodingError` when the input is not valid JSON5. Accepts comments,
+ * trailing commas, unquoted identifier keys, single-quoted strings,
+ * hexadecimal numbers, `Infinity`, and `NaN`. Duplicate keys use the last
+ * value; `__proto__` is preserved as an own data property.
+ *
+ * **Gotchas**
+ *
+ * Error messages give a line and column but do not include the input text.
+ * Unlike `JSON.parse`, this function has no reviver.
+ *
+ * **Example** (Parsing a JSON5 document)
+ *
+ * ```ts import.meta.vitest
+ * import { Result } from "effect"
+ * import { Json5 } from "effect/encoding"
+ *
+ * Json5.parse("{ port: 8080, }") // => Result.succeed({ port: 8080 })
+ * Result.isFailure(Json5.parse("{ port: }")) // => true
+ * ```
+ *
+ * @stability unstable
+ * @category decoding
+ * @since 4.1.2
+ */
+export const parse = (input: string): Result.Result<unknown, EncodingError> => {
+  try {
+    return Result.succeed(internal.parse(input, "JSON5"))
+  } catch (e) {
+    return Result.fail(
+      new EncodingError({
+        module: "Json5",
+        kind: "Decode",
+        input,
+        message: e instanceof Error ? e.message : "Invalid input"
+      })
+    )
+  }
+}

package/src/encoding/Jsonc.ts

@@ -0,0 +1,126 @@
+/**
+ * Parses JSON with JavaScript-style comments without external dependencies.
+ *
+ * The syntax target is the [JSONC draft specification](https://jsonc.org/)
+ * with `jsonc-parser` 3.3.1's default profile: JSON plus line and block comments,
+ * with trailing commas disabled. One leading BOM is accepted, matching the
+ * TOML and YAML parsers. Decoded values follow `JSON.parse` semantics; invalid
+ * documents fail instead of returning a partial result.
+ *
+ * @stability unstable
+ * @since 4.1.2
+ */
+
+import * as internal from "../internal/jsonParser.ts"
+import * as Result from "../Result.ts"
+import { EncodingError } from "./EncodingError.ts"
+
+const fail = (input: string): never => {
+  // Native errors differ across engines and may quote the input, so the strict parser
+  // locates the error. It accepts exactly what JSON.parse accepts once comments are
+  // removed; the final throw only guards against an engine that disagrees.
+  internal.parse(input, "JSONC")
+  throw internal.syntaxError(input, input.length, "JSONC")
+}
+
+const lineEnd = /[\r\n]/g
+
+const parseUnsafe = (input: string): unknown => {
+  // Ignore one leading BOM without shifting original-input error positions.
+  if (input.charCodeAt(0) === 0xfeff) input = " " + input.slice(1)
+  let slash = input.indexOf("/")
+  let json = input
+  if (slash !== -1) {
+    let stripped = ""
+    let start = 0
+    let quote = input.indexOf("\"")
+    while (slash !== -1) {
+      if (quote !== -1 && quote < slash) {
+        // Skip the string; a quote after an odd run of backslashes is escaped.
+        let end = quote
+        for (;;) {
+          end = input.indexOf("\"", end + 1)
+          if (end === -1) break
+          let backslash = end - 1
+          while (input.charCodeAt(backslash) === 92) backslash--
+          if ((end - backslash) % 2 === 1) break
+        }
+        if (end === -1) break
+        quote = input.indexOf("\"", end + 1)
+        if (slash < end) slash = input.indexOf("/", end + 1)
+        continue
+      }
+      const next = input.charCodeAt(slash + 1)
+      let index: number
+      if (next === 47) {
+        lineEnd.lastIndex = slash + 2
+        index = lineEnd.test(input) ? lineEnd.lastIndex - 1 : input.length
+      } else if (next === 42) {
+        const end = input.indexOf("*/", slash + 2)
+        if (end === -1) fail(input)
+        index = end + 2
+      } else {
+        // Not a comment; JSON.parse rejects it below.
+        slash = input.indexOf("/", slash + 1)
+        continue
+      }
+      // A space prevents comments inside invalid tokens from joining those tokens.
+      stripped += input.slice(start, slash) + " "
+      start = index
+      slash = input.indexOf("/", index)
+      if (quote !== -1 && quote < index) quote = input.indexOf("\"", index)
+    }
+    json = stripped + input.slice(start)
+  }
+  try {
+    return JSON.parse(json)
+  } catch {
+    return fail(input)
+  }
+}
+
+/**
+ * Parses a JSONC document into a JavaScript value.
+ *
+ * **Details**
+ *
+ * Returns `Result.succeed` with the parsed value, or `Result.fail` with an
+ * `EncodingError` when the input is not valid JSONC. Accepts one leading BOM
+ * and line and block comments wherever JSON permits whitespace. All other
+ * syntax follows `JSON.parse`, including duplicate keys and `__proto__`
+ * handling.
+ *
+ * **Gotchas**
+ *
+ * Error messages give a 1-based line and column, counted in UTF-16 code units,
+ * but do not include the input text. Trailing commas and JSON5 extensions are
+ * not accepted. Unlike `JSON.parse`, this function has no reviver.
+ *
+ * **Example** (Parsing a JSONC document)
+ *
+ * ```ts import.meta.vitest
+ * import { Result } from "effect"
+ * import { Jsonc } from "effect/encoding"
+ *
+ * Jsonc.parse("{ \"port\": 8080 } // comment") // => Result.succeed({ port: 8080 })
+ * Result.isFailure(Jsonc.parse("{ \"port\": 8080, }")) // => true
+ * ```
+ *
+ * @stability unstable
+ * @category decoding
+ * @since 4.1.2
+ */
+export const parse = (input: string): Result.Result<unknown, EncodingError> => {
+  try {
+    return Result.succeed(parseUnsafe(input))
+  } catch (e) {
+    return Result.fail(
+      new EncodingError({
+        module: "Jsonc",
+        kind: "Decode",
+        input,
+        message: e instanceof Error ? e.message : "Invalid input"
+      })
+    )
+  }
+}

package/src/encoding/Ndjson.ts

@@ -236,7 +236,7 @@ const parseLine = (
   ignoreEmptyLines: boolean,
   unterminated: boolean
 ): NdjsonError | undefined => {
-  if (ignoreEmptyLines && line.length === 0) return
+  if (ignoreEmptyLines && /^[ \t]*$/.test(line)) return
   try {
     out.push(JSON.parse(line))
   } catch (cause) {
@@ -262,8 +262,9 @@ const flushNothing = () => undefined
  *
  * **Gotchas**
  *
- * Set `ignoreEmptyLines` to skip blank lines before calling `JSON.parse`;
- * otherwise blank lines are parsed and fail as invalid JSON.
+ * Set `ignoreEmptyLines` to skip empty lines and lines containing only spaces
+ * or tabs before calling `JSON.parse`; otherwise these lines fail as invalid
+ * JSON.
  *
  * @stability unstable
  * @category constructors
@@ -314,8 +315,8 @@ const emptyBytes = new Uint8Array(0)
  * **Details**
  *
  * Lines may span input chunks. `\n`, `\r\n` and a bare `\r` end a line, and a
- * leading UTF-8 BOM is skipped. `ignoreEmptyLines` controls whether blank lines
- * are skipped before JSON parsing.
+ * leading UTF-8 BOM is skipped. `ignoreEmptyLines` skips empty lines and lines
+ * containing only spaces or tabs before JSON parsing.
  *
  * The first bad line fails the channel after the lines before it have been
  * emitted. A line that is not valid UTF-8 fails with `reason: "InvalidUtf8"`