@chainfuse/helpers 3.2.8 → 3.2.9

package/dist/bufferInternals.d.mts

@@ -0,0 +1,12 @@
+import type { UuidExport } from '@chainfuse/types/d1';
+export declare class BufferHelpersInternals {
+    static node_hexToBuffer(hex: UuidExport['hex']): Promise<UuidExport['blob']>;
+    static node_bufferToHex(buffer: UuidExport['blob']): Promise<UuidExport['hex']>;
+    static browser_hexToBuffer(hex: UuidExport['hex']): UuidExport['blob'];
+    static browser_bufferToHex(buffer: UuidExport['blob']): UuidExport['hex'];
+    static browser_base64UrlToBuffer(base64url: string): UuidExport['blob'];
+    static node_base64ToBuffer(base64: string, isBase64Url: boolean): Promise<UuidExport['blob']>;
+    static browser_base64ToBuffer(base64: string): UuidExport['blob'];
+    static node_bufferToBase64(buffer: UuidExport['blob'], urlSafe: boolean): Promise<string>;
+    static browser_bufferToBase64(buffer: UuidExport['blob'], urlSafe: boolean): string;
+}

package/dist/bufferInternals.mjs

@@ -0,0 +1,73 @@
+export class BufferHelpersInternals {
+    static node_hexToBuffer(hex) {
+        return import('node:buffer').then(({ Buffer }) => {
+            const mainBuffer = Buffer.from(hex, 'hex');
+            return mainBuffer.buffer.slice(mainBuffer.byteOffset, mainBuffer.byteOffset + mainBuffer.byteLength);
+        });
+    }
+    static node_bufferToHex(buffer) {
+        return import('node:buffer').then(({ Buffer }) => 
+        // @ts-expect-error `ArrayBufferLike` is actually accepted and fine
+        Buffer.from(buffer).toString('hex'));
+    }
+    static browser_hexToBuffer(hex) {
+        /**
+         * @link https://jsbm.dev/NHJHj31Zwm3OP
+         */
+        return new Uint8Array(hex.length / 2).map((_, index) => parseInt(hex.slice(index * 2, index * 2 + 2), 16)).buffer;
+    }
+    static browser_bufferToHex(buffer) {
+        /**
+         * @link https://jsbm.dev/AoXo8dEke1GUg
+         */
+        // @ts-expect-error `ArrayBufferLike` is actually accepted and fine
+        return new Uint8Array(buffer).reduce((output, elem) => output + ('0' + elem.toString(16)).slice(-2), '');
+    }
+    static browser_base64UrlToBuffer(base64url) {
+        let base64 = base64url.replaceAll('-', '+').replaceAll('_', '/');
+        // Add padding back to make length a multiple of 4
+        while (base64.length % 4 !== 0) {
+            base64 += '=';
+        }
+        const binaryString = atob(base64);
+        const bytes = new Uint8Array(binaryString.length);
+        for (const [i, char] of Array.from(binaryString).entries()) {
+            bytes[i] = char.charCodeAt(0);
+        }
+        return bytes.buffer;
+    }
+    static node_base64ToBuffer(base64, isBase64Url) {
+        return import('node:buffer').then(({ Buffer }) => {
+            const mainBuffer = Buffer.from(base64, isBase64Url ? 'base64url' : 'base64');
+            return mainBuffer.buffer.slice(mainBuffer.byteOffset, mainBuffer.byteOffset + mainBuffer.byteLength);
+        });
+    }
+    static browser_base64ToBuffer(base64) {
+        const binaryString = atob(base64);
+        const bytes = new Uint8Array(binaryString.length);
+        for (const [i, char] of Array.from(binaryString).entries()) {
+            bytes[i] = char.charCodeAt(0);
+        }
+        return bytes.buffer;
+    }
+    static node_bufferToBase64(buffer, urlSafe) {
+        return import('node:buffer').then(({ Buffer }) => 
+        // @ts-expect-error `ArrayBufferLike` is actually accepted and fine
+        Buffer.from(buffer).toString(urlSafe ? 'base64url' : 'base64'));
+    }
+    static browser_bufferToBase64(buffer, urlSafe) {
+        // @ts-expect-error `ArrayBufferLike` is actually accepted and fine
+        const bytes = new Uint8Array(buffer);
+        let binaryString = '';
+        for (const byte of bytes) {
+            binaryString += String.fromCharCode(byte);
+        }
+        const raw = btoa(binaryString);
+        if (urlSafe) {
+            return raw.replaceAll('+', '-').replaceAll('/', '_').replaceAll('=', '');
+        }
+        else {
+            return raw;
+        }
+    }
+}

package/dist/buffers.d.mts

@@ -1,16 +1,6 @@
 import type { UndefinedProperties } from '@chainfuse/types';
 import type { PrefixedUuid, UuidExport } from '@chainfuse/types/d1';
 export declare class BufferHelpers {
-    static readonly utf8Regex: RegExp;
-    static readonly hexRegex: RegExp;
-    /**
-     * @link https://base64.guru/learn/base64-characters
-     */
-    static readonly base64Regex: RegExp;
-    /**
-     * @link https://base64.guru/standards/base64url
-     */
-    static readonly base64urlRegex: RegExp;
     static bigintToBuffer(number: bigint): Promise<UuidExport['blob']>;
     static bigintToHex(number: bigint): UuidExport['hex'];
     static bufferToBigint(buffer: UuidExport['blob']): Promise<bigint>;

package/dist/buffers.mjs

@@ -1,15 +1,6 @@
+import { BufferHelpersInternals } from "./bufferInternals.mjs";
 import { CryptoHelpers } from './crypto.mjs';
 export class BufferHelpers {
-    static utf8Regex = new RegExp(/^((d|t|u)_)?[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}(_p)?$/i);
-    static hexRegex = new RegExp(/^[0-9a-f]{32}$/i);
-    /**
-     * @link https://base64.guru/learn/base64-characters
-     */
-    static base64Regex = new RegExp(/^[a-z\d+/]+={0,2}$/i);
-    /**
-     * @link https://base64.guru/standards/base64url
-     */
-    static base64urlRegex = new RegExp(/^[a-z\d_-]+$/i);
     static bigintToBuffer(number) {
         const hexString = number.toString(16);
         return this.hexToBuffer(hexString.length % 2 === 0 ? hexString : `0${hexString}`);
@@ -21,70 +12,29 @@ export class BufferHelpers {
         return this.bufferToHex(buffer).then((hex) => BigInt(`0x${hex}`));
     }
     static hexToBuffer(hex) {
-        return (import('node:buffer')
-            .then(({ Buffer }) => {
-            const mainBuffer = Buffer.from(hex, 'hex');
-            return mainBuffer.buffer.slice(mainBuffer.byteOffset, mainBuffer.byteOffset + mainBuffer.byteLength);
-        })
-            /**
-             * @link https://jsbm.dev/NHJHj31Zwm3OP
-             */
-            .catch(() => new Uint8Array(hex.length / 2).map((_, index) => parseInt(hex.slice(index * 2, index * 2 + 2), 16)).buffer));
+        return BufferHelpersInternals.node_hexToBuffer(hex).catch(() => BufferHelpersInternals.browser_hexToBuffer(hex));
     }
     static bufferToHex(buffer) {
-        return (import('node:buffer')
-            // @ts-expect-error `ArrayBufferLike` is actually accepted and fine
-            .then(({ Buffer }) => Buffer.from(buffer).toString('hex'))
-            /**
-             * @link https://jsbm.dev/AoXo8dEke1GUg
-             */
-            // @ts-expect-error `ArrayBufferLike` is actually accepted and fine
-            .catch(() => new Uint8Array(buffer).reduce((output, elem) => output + ('0' + elem.toString(16)).slice(-2), '')));
+        return BufferHelpersInternals.node_bufferToHex(buffer).catch(() => BufferHelpersInternals.browser_bufferToHex(buffer));
     }
     static base64ToBuffer(rawBase64) {
-        if (this.base64Regex.test(rawBase64)) {
-            return import('node:buffer')
-                .then(({ Buffer }) => {
-                const mainBuffer = Buffer.from(rawBase64, 'base64');
-                return mainBuffer.buffer.slice(mainBuffer.byteOffset, mainBuffer.byteOffset + mainBuffer.byteLength);
-            })
-                .catch(() => {
-                return new TextEncoder().encode(atob(rawBase64)).buffer;
-            });
-        }
-        else if (this.base64urlRegex.test(rawBase64)) {
-            return import('node:buffer')
-                .then(({ Buffer }) => {
-                const mainBuffer = Buffer.from(rawBase64, 'base64url');
-                return mainBuffer.buffer.slice(mainBuffer.byteOffset, mainBuffer.byteOffset + mainBuffer.byteLength);
-            })
-                .catch(() => {
-                let base64 = rawBase64.replaceAll('-', '+').replaceAll('_', '/');
-                // Add padding back to make length a multiple of 4
-                while (base64.length % 4 !== 0) {
-                    base64 += '=';
-                }
-                return new TextEncoder().encode(atob(base64)).buffer;
-            });
-        }
-        else {
-            throw new Error('Invalid base64 or base64url string');
-        }
+        return import('zod/v4').then(({ z }) => Promise.any([
+            z
+                .base64()
+                .trim()
+                .nonempty()
+                .parseAsync(rawBase64)
+                .then((base64) => BufferHelpersInternals.node_base64ToBuffer(base64, false).catch(() => BufferHelpersInternals.browser_base64ToBuffer(base64))),
+            z
+                .base64url()
+                .trim()
+                .nonempty()
+                .parseAsync(rawBase64)
+                .then((base64url) => BufferHelpersInternals.node_base64ToBuffer(base64url, true).catch(() => BufferHelpersInternals.browser_base64UrlToBuffer(base64url))),
+        ]));
     }
     static bufferToBase64(buffer, urlSafe) {
-        return (import('node:buffer')
-            // @ts-expect-error `ArrayBufferLike` is actually accepted and fine
-            .then(({ Buffer }) => Buffer.from(buffer).toString(urlSafe ? 'base64url' : 'base64'))
-            .catch(() => {
-            // @ts-expect-error `ArrayBufferLike` is actually accepted and fine
-            const raw = btoa(new Uint8Array(buffer).reduce((acc, byte) => acc + String.fromCharCode(byte), ''));
-            if (urlSafe) {
-                return raw.replaceAll('+', '-').replaceAll('/', '_').replaceAll('=', '');
-            }
-            else {
-                return raw;
-            }
-        }));
+        return BufferHelpersInternals.node_bufferToBase64(buffer, urlSafe).catch(() => BufferHelpersInternals.browser_bufferToBase64(buffer, urlSafe));
     }
     static get generateUuid() {
         return Promise.all([CryptoHelpers.secretBytes(16), import('uuid')]).then(([random, { v7: uuidv7 }]) => {
@@ -103,50 +53,66 @@ export class BufferHelpers {
     static uuidConvert(input) {
         if (input) {
             if (typeof input === 'string') {
-                if (this.utf8Regex.test(input)) {
-                    let hex = input.replaceAll('-', '');
-                    if (input.includes('_')) {
-                        input = input.split('_')[1];
-                        hex = hex.split('_')[1];
-                    }
-                    return this.hexToBuffer(hex).then((blob) => Promise.all([this.bufferToBase64(blob, false), this.bufferToBase64(blob, true)]).then(([base64, base64url]) => ({
-                        utf8: input,
-                        hex,
-                        blob,
-                        base64,
-                        base64url,
-                    })));
-                }
-                else if (this.hexRegex.test(input)) {
-                    const hex = input;
-                    return this.hexToBuffer(hex).then((blob) => Promise.all([this.bufferToBase64(blob, false), this.bufferToBase64(blob, true)]).then(([base64, base64url]) => ({
+                return import('zod/v4').then(({ z }) => Promise.any([
+                    //
+                    import('@chainfuse/types/d0').then(({ PrefixedUuidRaw }) => z
+                        .union([
+                        //
+                        PrefixedUuidRaw.transform((prefixedUtf8) => prefixedUtf8.split('_')[1]),
+                        z.uuid().trim().nonempty().toLowerCase(),
+                    ])
+                        .transform((value) => value)
+                        .parseAsync(input)
+                        .then((utf8) => {
+                        const hex = utf8.replaceAll('-', '');
+                        return this.hexToBuffer(hex).then((blob) => Promise.all([this.bufferToBase64(blob, false), this.bufferToBase64(blob, true)]).then(([base64, base64url]) => ({
+                            utf8,
+                            hex,
+                            blob,
+                            base64,
+                            base64url,
+                        })));
+                    })),
+                    z
+                        .string()
+                        .trim()
+                        .toLowerCase()
+                        .length(32)
+                        .refine((value) => import('validator/es/lib/isHexadecimal').then(({ default: isHexadecimal }) => isHexadecimal(value)).catch(() => import('validator').then(({ default: validator }) => validator.isHexadecimal(value))))
+                        .parseAsync(input)
+                        .then((hex) => this.hexToBuffer(hex).then((blob) => Promise.all([this.bufferToBase64(blob, false), this.bufferToBase64(blob, true)]).then(([base64, base64url]) => ({
                         utf8: `${hex.substring(0, 8)}-${hex.substring(8, 12)}-${hex.substring(12, 16)}-${hex.substring(16, 20)}-${hex.substring(20)}`,
                         hex,
                         blob,
                         base64,
                         base64url,
-                    })));
-                }
-                else if (this.base64Regex.test(input) && input.length % 4 === 0) {
-                    const base64 = input;
-                    return this.base64ToBuffer(base64).then((blob) => Promise.all([this.bufferToHex(blob), this.bufferToBase64(blob, true)]).then(([hex, base64url]) => ({
+                    })))),
+                ]).catch(() => Promise.any([
+                    z
+                        .base64()
+                        .trim()
+                        .nonempty()
+                        .parseAsync(input)
+                        .then((base64) => this.base64ToBuffer(base64).then((blob) => Promise.all([this.bufferToHex(blob), this.bufferToBase64(blob, true)]).then(([hex, base64url]) => ({
                         utf8: `${hex.substring(0, 8)}-${hex.substring(8, 12)}-${hex.substring(12, 16)}-${hex.substring(16, 20)}-${hex.substring(20)}`,
                         hex,
                         blob,
                         base64,
                         base64url,
-                    })));
-                }
-                else if (this.base64urlRegex.test(input)) {
-                    const base64url = input;
-                    return this.base64ToBuffer(base64url).then((blob) => Promise.all([this.bufferToHex(blob), this.bufferToBase64(blob, false)]).then(([hex, base64]) => ({
+                    })))),
+                    z
+                        .base64url()
+                        .trim()
+                        .nonempty()
+                        .parseAsync(input)
+                        .then((base64url) => this.base64ToBuffer(base64url).then((blob) => Promise.all([this.bufferToHex(blob), this.bufferToBase64(blob, false)]).then(([hex, base64]) => ({
                         utf8: `${hex.substring(0, 8)}-${hex.substring(8, 12)}-${hex.substring(12, 16)}-${hex.substring(16, 20)}-${hex.substring(20)}`,
                         hex,
                         blob,
                         base64,
                         base64url,
-                    })));
-                }
+                    })))),
+                ])));
             }
             else {
                 return Promise.all([this.bufferToHex(input), this.bufferToBase64(input, false), this.bufferToBase64(input, true)]).then(([hex, base64, base64url]) => ({

package/dist/crypto.d.mts

@@ -1,5 +1,5 @@
 export declare class CryptoHelpers {
-    static secretBytes(byteSize: number): Promise<Uint8Array<ArrayBuffer | SharedArrayBuffer> | Uint8Array<ArrayBuffer>>;
+    static secretBytes(byteSize: number): Promise<Uint8Array<ArrayBufferLike>>;
     static base16secret(secretLength: number): Promise<string>;
     static base62secret(secretLength: number): Promise<string>;
     static getHash(algorithm: 'SHA-1' | 'SHA-256' | 'SHA-384' | 'SHA-512', input: string | ArrayBufferLike): Promise<string>;

package/dist/crypto.mjs

@@ -1,16 +1,8 @@
 import { BufferHelpers } from './buffers.mjs';
+import { CryptoHelpersInternals } from "./cryptoInternals.mjs";
 export class CryptoHelpers {
     static secretBytes(byteSize) {
-        return import('node:crypto')
-            .then(({ randomBytes }) => {
-            const mainBuffer = randomBytes(byteSize);
-            return new Uint8Array(mainBuffer.buffer.slice(mainBuffer.byteOffset, mainBuffer.byteOffset + mainBuffer.byteLength));
-        })
-            .catch(() => {
-            const randomBytes = new Uint8Array(byteSize);
-            crypto.getRandomValues(randomBytes);
-            return randomBytes;
-        });
+        return CryptoHelpersInternals.node_secretBytes(byteSize).catch(() => CryptoHelpersInternals.browser_secretBytes(byteSize));
     }
     static base16secret(secretLength) {
         return this.secretBytes(secretLength / 2).then((bytes) => BufferHelpers.bufferToHex(bytes.buffer));
@@ -33,19 +25,7 @@ export class CryptoHelpers {
         });
     }
     static getHash(algorithm, input) {
-        return (import('node:crypto')
-            .then(async ({ createHash }) => {
-            const hash = createHash(algorithm.replace('-', '').toLowerCase());
-            if (typeof input === 'string') {
-                hash.update(input);
-            }
-            else {
-                await import('node:buffer').then(({ Buffer }) => hash.update(Buffer.from(input)));
-            }
-            return hash.digest('hex');
-        })
-            // @ts-expect-error `ArrayBufferLike` is actually accepted and fine
-            .catch(() => crypto.subtle.digest(algorithm, typeof input === 'string' ? new TextEncoder().encode(input) : input).then((hashBuffer) => BufferHelpers.bufferToHex(hashBuffer))));
+        return CryptoHelpersInternals.node_getHash(algorithm, input).catch(() => CryptoHelpersInternals.browser_getHash(algorithm, input));
     }
     /**
      * @returns Fully formatted (double quote encapsulated) `ETag` header value

package/dist/cryptoInternals.d.mts

@@ -0,0 +1,6 @@
+export declare class CryptoHelpersInternals {
+    static node_secretBytes(byteSize: number): Promise<Uint8Array>;
+    static browser_secretBytes(byteSize: number): Uint8Array;
+    static node_getHash(algorithm: 'SHA-1' | 'SHA-256' | 'SHA-384' | 'SHA-512', input: string | ArrayBufferLike): Promise<string>;
+    static browser_getHash(algorithm: 'SHA-1' | 'SHA-256' | 'SHA-384' | 'SHA-512', input: string | ArrayBufferLike): Promise<string>;
+}

package/dist/cryptoInternals.mjs

@@ -0,0 +1,30 @@
+import { BufferHelpers } from './buffers.mjs';
+export class CryptoHelpersInternals {
+    static node_secretBytes(byteSize) {
+        return import('node:crypto').then(({ randomBytes }) => {
+            const mainBuffer = randomBytes(byteSize);
+            return new Uint8Array(mainBuffer.buffer.slice(mainBuffer.byteOffset, mainBuffer.byteOffset + mainBuffer.byteLength));
+        });
+    }
+    static browser_secretBytes(byteSize) {
+        const randomBytes = new Uint8Array(byteSize);
+        crypto.getRandomValues(randomBytes);
+        return randomBytes;
+    }
+    static node_getHash(algorithm, input) {
+        return import('node:crypto').then(async ({ createHash }) => {
+            const hash = createHash(algorithm.replace('-', '').toLowerCase());
+            if (typeof input === 'string') {
+                hash.update(input);
+            }
+            else {
+                await import('node:buffer').then(({ Buffer }) => hash.update(Buffer.from(input)));
+            }
+            return hash.digest('hex');
+        });
+    }
+    static browser_getHash(algorithm, input) {
+        // @ts-expect-error `ArrayBufferLike` is actually accepted and fine
+        return crypto.subtle.digest(algorithm, typeof input === 'string' ? new TextEncoder().encode(input) : input).then((hashBuffer) => BufferHelpers.bufferToHex(hashBuffer));
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@chainfuse/helpers",
-	"version": "3.2.8",
+	"version": "3.2.9",
 	"description": "",
 	"author": "ChainFuse",
 	"homepage": "https://github.com/ChainFuse/packages/tree/main/packages/helpers#readme",
@@ -48,19 +48,19 @@
 	},
 	"prettier": "@demosjarco/prettier-config",
 	"dependencies": {
+		"@chainfuse/types": "^2.10.17",
 		"@discordjs/rest": "^2.5.0",
 		"chalk": "^5.4.1",
 		"cloudflare": "^4.3.0",
 		"strip-ansi": "^7.1.0",
 		"uuid": "^11.1.0",
-		"zod": "^3.25.32"
+		"zod": "^3.25.42"
 	},
 	"devDependencies": {
 		"@builder.io/qwik-city": "^1.14.1",
-		"@chainfuse/types": "^2.10.16",
-		"@cloudflare/workers-types": "^4.20250528.0",
-		"@types/node": "^22.15.24",
-		"wrangler": "^4.17.0"
+		"@cloudflare/workers-types": "^4.20250529.0",
+		"@types/node": "^22.15.26",
+		"wrangler": "^4.18.0"
 	},
-	"gitHead": "ca4f41b9b4c1c95e8f1e3cdaedd74327c29e947c"
+	"gitHead": "de5849c32295d792c79cae920c3751daf9aa581c"
 }