npm - git-remote-ops - Versions diffs - 0.1.0 - Mend

@@ -0,0 +1,40 @@
+/**
+ * When checking the values of cryptographic hashes are equal, default
+ * comparisons can be susceptible to timing based attacks, where attacker is
+ * able to find out information about the host system by repeatedly checking
+ * response times to equality comparisons of values.
+ *
+ * It is likely some form of timing safe equality will make its way to the
+ * WebCrypto standard (see:
+ * {@link https://github.com/w3c/webcrypto/issues/270 | w3c/webcrypto#270}), but until
+ * that time, `timingSafeEqual()` is provided.
+ *
+ * Note: This is a best-effort constant-time comparison implemented in
+ * JavaScript. The V8 JIT compiler does not provide formal constant-time
+ * guarantees, and inputs backed by `SharedArrayBuffer` are susceptible to
+ * concurrent modification during comparison.
+ *
+ * @example Usage
+ * ```ts
+ * import { timingSafeEqual } from "@std/crypto/timing-safe-equal";
+ * import { assert } from "@std/assert";
+ *
+ * const a = await crypto.subtle.digest(
+ *   "SHA-384",
+ *   new TextEncoder().encode("hello world"),
+ * );
+ * const b = await crypto.subtle.digest(
+ *   "SHA-384",
+ *   new TextEncoder().encode("hello world"),
+ * );
+ *
+ * assert(timingSafeEqual(a, b));
+ * ```
+ *
+ * @param a The first value to compare.
+ * @param b The second value to compare.
+ * @returns `true` if the values are equal, otherwise `false`.
+ * @throws {TypeError} If the byte lengths of the two buffers are not equal.
+ */
+export declare function timingSafeEqual(a: ArrayBufferView | ArrayBufferLike, b: ArrayBufferView | ArrayBufferLike): boolean;
+//# sourceMappingURL=timing_safe_equal.d.ts.map

@@ -0,0 +1,23 @@
+import type { Uint8Array_ } from "./_types.js";
+export type { Uint8Array_ };
+export declare const alphabet: Uint8Array<ArrayBufferLike>;
+export declare const rAlphabet: Uint8Array<ArrayBuffer>;
+/**
+ * Calculate the output size needed to encode a given input size for
+ * {@linkcode encodeIntoHex}.
+ *
+ * @param originalSize The size of the input buffer.
+ * @returns The size of the output buffer.
+ *
+ * @example Basic Usage
+ * ```ts
+ * import { assertEquals } from "@std/assert";
+ * import { calcSizeHex } from "@std/encoding/unstable-hex";
+ *
+ * assertEquals(calcSizeHex(1), 2);
+ * ```
+ */
+export declare function calcSizeHex(originalSize: number): number;
+export declare function encode(buffer: Uint8Array_, i: number, o: number, alphabet: Uint8Array): number;
+export declare function decode(buffer: Uint8Array_, i: number, o: number, alphabet: Uint8Array): number;
+//# sourceMappingURL=_common16.d.ts.map

@@ -0,0 +1,4 @@
+import type { Uint8Array_ } from "./_types.js";
+export type { Uint8Array_ };
+export declare function detach(buffer: Uint8Array_, maxSize: number): [Uint8Array_, number];
+//# sourceMappingURL=_common_detach.d.ts.map

@@ -0,0 +1,9 @@
+/**
+ * Proxy type of {@code Uint8Array<ArrayBuffer} or {@code Uint8Array} in TypeScript 5.7 or below respectively.
+ *
+ * This type is internal utility type and should not be used directly.
+ *
+ * @internal @private
+ */
+export type Uint8Array_ = ReturnType<Uint8Array["slice"]>;
+//# sourceMappingURL=_types.d.ts.map

@@ -0,0 +1,39 @@
+import type { Uint8Array_ } from "./_types.js";
+export type { Uint8Array_ };
+/**
+ * Converts data into a hex-encoded string.
+ *
+ * @param src The data to encode.
+ *
+ * @returns The hex-encoded string.
+ *
+ * @example Usage
+ * ```ts
+ * import { encodeHex } from "@std/encoding/hex";
+ * import { assertEquals } from "@std/assert";
+ *
+ * assertEquals(encodeHex("abc"), "616263");
+ * ```
+ */
+export declare function encodeHex(src: string | Uint8Array | ArrayBuffer): string;
+/**
+ * Decodes the given hex-encoded string. If the input is malformed, an error is
+ * thrown.
+ *
+ * @param src The hex-encoded string to decode.
+ *
+ * @returns The decoded data.
+ *
+ * @example Usage
+ * ```ts
+ * import { decodeHex } from "@std/encoding/hex";
+ * import { assertEquals } from "@std/assert";
+ *
+ * assertEquals(
+ *   decodeHex("616263"),
+ *   new TextEncoder().encode("abc"),
+ * );
+ * ```
+ */
+export declare function decodeHex(src: string): Uint8Array_;
+//# sourceMappingURL=hex.d.ts.map

	@@ -0,0 +1 @@
1	+ {"version":3,"file":"timing_safe_equal.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/crypto/1.1.0/timing_safe_equal.ts"],"names":[],"mappings":"AAcA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqCG;AACH,wBAAgB,eAAe,CAC7B,CAAC,EAAE,eAAe,GAAG,eAAe,EACpC,CAAC,EAAE,eAAe,GAAG,eAAe,GACnC,OAAO,CAcT"}

	@@ -0,0 +1 @@
1	+ {"version":3,"file":"_common_detach.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/encoding/1.0.10/_common_detach.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAC/C,YAAY,EAAE,WAAW,EAAE,CAAC;AAE5B,wBAAgB,MAAM,CACpB,MAAM,EAAE,WAAW,EACnB,OAAO,EAAE,MAAM,GACd,CAAC,WAAW,EAAE,MAAM,CAAC,CAWvB"}

	@@ -0,0 +1 @@
1	+ {"version":3,"file":"_types.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/encoding/1.0.10/_types.ts"],"names":[],"mappings":"AAEA;;;;;;GAMG;AAEH,MAAM,MAAM,WAAW,GAAG,UAAU,CAAC,UAAU,CAAC,OAAO,CAAC,CAAC,CAAC"}

git-remote-ops 0.1.0