@zudojs/crypto 0.1.0 → 1.1.0

package/dist/cryptoConstants/cryptoConstants.type.js

@@ -1,12 +1,14 @@
-import { TimeMs } from "@zudojs/constants";
 /**
- * Supported cryptographic algorithms used by Zudojs.
+ * Cryptographic algorithms implemented by Zudojs.
+ *
+ * Every member listed here is implemented by the Node provider. Algorithms
+ * that are not implemented (AES-CBC, ChaCha20-Poly1305, Argon2id, X25519,
+ * bcrypt) are deliberately absent so that the type system and the runtime
+ * agree on what is supported.
  */
 export var CryptoAlgorithm;
 (function (CryptoAlgorithm) {
     CryptoAlgorithm["AES_256_GCM"] = "aes-256-gcm";
-    CryptoAlgorithm["AES_256_CBC"] = "aes-256-cbc";
-    CryptoAlgorithm["CHACHA20_POLY1305"] = "chacha20-poly1305";
     CryptoAlgorithm["SHA_256"] = "sha256";
     CryptoAlgorithm["SHA_384"] = "sha384";
     CryptoAlgorithm["SHA_512"] = "sha512";
@@ -17,18 +19,16 @@ export var CryptoAlgorithm;
     CryptoAlgorithm["HMAC_SHA384"] = "hmac-sha384";
     CryptoAlgorithm["HMAC_SHA512"] = "hmac-sha512";
     CryptoAlgorithm["PBKDF2_SHA256"] = "pbkdf2-sha256";
+    CryptoAlgorithm["PBKDF2_SHA384"] = "pbkdf2-sha384";
     CryptoAlgorithm["PBKDF2_SHA512"] = "pbkdf2-sha512";
     CryptoAlgorithm["SCRYPT"] = "scrypt";
-    CryptoAlgorithm["ARGON2ID"] = "argon2id";
     CryptoAlgorithm["ED25519"] = "ed25519";
-    CryptoAlgorithm["X25519"] = "x25519";
 })(CryptoAlgorithm || (CryptoAlgorithm = {}));
 /**
  * Algorithms that provide authenticated encryption.
  */
 export const AEAD_ALGORITHMS = Object.freeze([
     CryptoAlgorithm.AES_256_GCM,
-    CryptoAlgorithm.CHACHA20_POLY1305,
 ]);
 /**
  * Algorithms intended for hashing.
@@ -46,9 +46,9 @@ export const HASH_ALGORITHMS = Object.freeze([
  */
 export const KEY_DERIVATION_ALGORITHMS = Object.freeze([
     CryptoAlgorithm.PBKDF2_SHA256,
+    CryptoAlgorithm.PBKDF2_SHA384,
     CryptoAlgorithm.PBKDF2_SHA512,
     CryptoAlgorithm.SCRYPT,
-    CryptoAlgorithm.ARGON2ID,
 ]);
 /**
  * Algorithms intended for message authentication.
@@ -58,8 +58,22 @@ export const MAC_ALGORITHMS = Object.freeze([
     CryptoAlgorithm.HMAC_SHA384,
     CryptoAlgorithm.HMAC_SHA512,
 ]);
+/**
+ * Key algorithms intended for digital signatures.
+ *
+ * Only Ed25519 keys are representable as a `CryptoKey`. RSA and ECDSA
+ * signing is supported through `SignatureAlgorithm` with PEM/DER key
+ * material rather than through this enum.
+ */
+export const SIGNATURE_ALGORITHMS = Object.freeze([
+    CryptoAlgorithm.ED25519,
+]);
 /**
  * AES-GCM constants.
+ *
+ * The 96-bit IV and 128-bit authentication tag are the only sizes accepted
+ * by this package: shorter tags weaken forgery resistance and non-96-bit
+ * IVs are GHASH-derived, which shrinks the effective nonce space.
  */
 export const AES_GCM = Object.freeze({
     KEY_BYTES: 32,
@@ -87,6 +101,7 @@ export const KEY_SIZE = Object.freeze({
     AES_256_BITS: 256,
     ED25519_BITS: 256,
     MIN_SYMMETRIC_KEY_BITS: 128,
+    MIN_HMAC_KEY_BYTES: 16,
 });
 /**
  * Encoding constants.
@@ -98,19 +113,26 @@ export const ENCODING = Object.freeze({
     UTF8: "utf8",
 });
 /**
- * Cryptographic algorithm identifiers.
+ * Cryptographic algorithm identifiers as a plain constant object.
+ *
+ * Mirrors `CryptoAlgorithm` exactly (same names and values) for callers
+ * that prefer `as const` objects over enums.
  */
 export const CRYPTO_ALGORITHM = Object.freeze({
-    SHA256: "sha256",
-    SHA384: "sha384",
-    SHA512: "sha512",
+    AES_256_GCM: "aes-256-gcm",
+    SHA_256: "sha256",
+    SHA_384: "sha384",
+    SHA_512: "sha512",
     SHA3_256: "sha3-256",
     SHA3_384: "sha3-384",
     SHA3_512: "sha3-512",
-    AES_256_GCM: "aes-256-gcm",
-    ED25519: "ed25519",
+    HMAC_SHA256: "hmac-sha256",
+    HMAC_SHA384: "hmac-sha384",
+    HMAC_SHA512: "hmac-sha512",
     PBKDF2_SHA256: "pbkdf2-sha256",
+    PBKDF2_SHA384: "pbkdf2-sha384",
     PBKDF2_SHA512: "pbkdf2-sha512",
     SCRYPT: "scrypt",
+    ED25519: "ed25519",
 });
 //# sourceMappingURL=cryptoConstants.type.js.map

package/dist/cryptoEncoding/cryptoEncoding.compare.d.ts

@@ -2,7 +2,10 @@ import type { CryptoEncoding } from "./cryptoEncoding.core.js";
 /**
  * Compares two encoded values using constant-time comparison.
  *
- * Both values must use the same encoding.
+ * Both values must use the same encoding. Returns false (rather than
+ * throwing) when either value is not a valid, canonical encoding, so
+ * malleable encodings of the same bytes never compare equal to each other
+ * through a non-canonical form.
  */
 export declare function timingSafeEqualEncoded(left: string, right: string, encoding?: CryptoEncoding): boolean;
 //# sourceMappingURL=cryptoEncoding.compare.d.ts.map

package/dist/cryptoEncoding/cryptoEncoding.compare.js

@@ -3,12 +3,19 @@ import { decode } from "./cryptoEncoding.core.js";
 /**
  * Compares two encoded values using constant-time comparison.
  *
- * Both values must use the same encoding.
+ * Both values must use the same encoding. Returns false (rather than
+ * throwing) when either value is not a valid, canonical encoding, so
+ * malleable encodings of the same bytes never compare equal to each other
+ * through a non-canonical form.
  */
 export function timingSafeEqualEncoded(left, right, encoding = "base64url") {
-    const leftBytes = decode(left, encoding);
-    const rightBytes = decode(right, encoding);
-    if (leftBytes.byteLength !== rightBytes.byteLength) {
+    let leftBytes;
+    let rightBytes;
+    try {
+        leftBytes = decode(left, encoding);
+        rightBytes = decode(right, encoding);
+    }
+    catch {
         return false;
     }
     return timingSafeEqual(leftBytes, rightBytes);

package/dist/cryptoEncoding/cryptoEncoding.core.d.ts

@@ -1,7 +1,27 @@
 /**
  * Supported binary encodings.
+ *
+ * `utf8` is a text encoding, not a binary one: `encode(bytes, "utf8")`
+ * throws when the bytes are not valid UTF-8 rather than producing
+ * replacement characters.
  */
 export type CryptoEncoding = "hex" | "base64" | "base64url" | "utf8";
+/**
+ * Binary-safe encodings (every byte sequence round-trips).
+ */
+export type BinaryEncoding = Exclude<CryptoEncoding, "utf8">;
+/**
+ * Returns whether a value names a supported encoding.
+ */
+export declare function isCryptoEncoding(value: unknown): value is CryptoEncoding;
+/**
+ * Returns whether a value names a binary-safe encoding.
+ */
+export declare function isBinaryEncoding(value: unknown): value is BinaryEncoding;
+/**
+ * Asserts that a value names a binary-safe encoding.
+ */
+export declare function assertBinaryEncoding(value: unknown): asserts value is BinaryEncoding;
 /**
  * Encodes bytes into a string.
  */
@@ -16,6 +36,8 @@ export declare function decode(value: string, encoding?: CryptoEncoding): Uint8A
 export declare function utf8Encode(value: string): Uint8Array;
 /**
  * Decodes UTF-8 bytes into a string.
+ *
+ * Throws when the bytes are not well-formed UTF-8.
  */
 export declare function utf8Decode(value: Uint8Array): string;
 //# sourceMappingURL=cryptoEncoding.core.d.ts.map

package/dist/cryptoEncoding/cryptoEncoding.core.js

@@ -1,6 +1,37 @@
 import { toHex, fromHex } from "./encoding/cryptoEncoding.hex.js";
 import { toBase64, fromBase64 } from "./encoding/cryptoEncoding.base64.js";
 import { toBase64Url, fromBase64Url, } from "./encoding/cryptoEncoding.base64url.js";
+const CRYPTO_ENCODINGS = new Set([
+    "hex",
+    "base64",
+    "base64url",
+    "utf8",
+]);
+const BINARY_ENCODINGS = new Set([
+    "hex",
+    "base64",
+    "base64url",
+]);
+/**
+ * Returns whether a value names a supported encoding.
+ */
+export function isCryptoEncoding(value) {
+    return typeof value === "string" && CRYPTO_ENCODINGS.has(value);
+}
+/**
+ * Returns whether a value names a binary-safe encoding.
+ */
+export function isBinaryEncoding(value) {
+    return typeof value === "string" && BINARY_ENCODINGS.has(value);
+}
+/**
+ * Asserts that a value names a binary-safe encoding.
+ */
+export function assertBinaryEncoding(value) {
+    if (!isBinaryEncoding(value)) {
+        throw new TypeError(`Unsupported binary encoding: ${String(value)}. Use hex, base64 or base64url.`);
+    }
+}
 /**
  * Encodes bytes into a string.
  */
@@ -14,7 +45,7 @@ export function encode(value, encoding = "base64url") {
         case "base64url":
             return toBase64Url(value);
         case "utf8":
-            return new TextDecoder().decode(value);
+            return utf8Decode(value);
         default:
             throw new TypeError(`Unsupported crypto encoding: ${String(encoding)}.`);
     }
@@ -34,7 +65,7 @@ export function decode(value, encoding = "base64url") {
         case "base64url":
             return fromBase64Url(value);
         case "utf8":
-            return new TextEncoder().encode(value);
+            return utf8Encode(value);
         default:
             throw new TypeError(`Unsupported crypto encoding: ${String(encoding)}.`);
     }
@@ -50,10 +81,17 @@ export function utf8Encode(value) {
 }
 /**
  * Decodes UTF-8 bytes into a string.
+ *
+ * Throws when the bytes are not well-formed UTF-8.
  */
 export function utf8Decode(value) {
     assertBytes(value);
-    return new TextDecoder().decode(value);
+    try {
+        return new TextDecoder("utf-8", { fatal: true }).decode(value);
+    }
+    catch (error) {
+        throw new TypeError("Value is not valid UTF-8.", { cause: error });
+    }
 }
 function assertBytes(value) {
     if (!(value instanceof Uint8Array)) {

package/dist/cryptoEncoding/encoding/cryptoEncoding.base64.d.ts

@@ -1,13 +1,21 @@
 /**
- * Encodes bytes as standard Base64.
+ * Encodes bytes as standard, padded Base64.
+ *
+ * An empty byte array encodes to the empty string.
  */
 export declare function toBase64(value: Uint8Array): string;
 /**
  * Decodes standard Base64 into bytes.
+ *
+ * Input must be canonical: padded to a multiple of four characters, using
+ * only the standard alphabet, with zero-valued trailing bits. The empty
+ * string decodes to an empty byte array.
  */
 export declare function fromBase64(value: string): Uint8Array;
 /**
- * Returns whether a string is valid standard Base64.
+ * Returns whether a string is valid, canonical standard Base64.
+ *
+ * The empty string is valid (it encodes zero bytes).
  */
 export declare function isBase64(value: string): boolean;
 //# sourceMappingURL=cryptoEncoding.base64.d.ts.map

package/dist/cryptoEncoding/encoding/cryptoEncoding.base64.js

@@ -1,35 +1,43 @@
 /**
- * Encodes bytes as standard Base64.
+ * Encodes bytes as standard, padded Base64.
+ *
+ * An empty byte array encodes to the empty string.
  */
 export function toBase64(value) {
-    const binary = Array.from(value)
-        .map((b) => String.fromCharCode(b))
-        .join("");
-    return btoa(binary);
+    assertBytes(value);
+    return Buffer.from(value.buffer, value.byteOffset, value.byteLength).toString("base64");
 }
 /**
  * Decodes standard Base64 into bytes.
+ *
+ * Input must be canonical: padded to a multiple of four characters, using
+ * only the standard alphabet, with zero-valued trailing bits. The empty
+ * string decodes to an empty byte array.
  */
 export function fromBase64(value) {
     if (!isBase64(value)) {
         throw new TypeError("Invalid Base64 value.");
     }
-    const binary = atob(value);
-    const result = new Uint8Array(binary.length);
-    for (let i = 0; i < binary.length; i += 1) {
-        result[i] = binary.charCodeAt(i);
-    }
-    return result;
+    return new Uint8Array(Buffer.from(value, "base64"));
 }
 /**
- * Returns whether a string is valid standard Base64.
+ * Returns whether a string is valid, canonical standard Base64.
+ *
+ * The empty string is valid (it encodes zero bytes).
  */
 export function isBase64(value) {
-    if (typeof value !== "string" ||
-        value.length === 0 ||
-        value.length % 4 !== 0) {
+    if (typeof value !== "string" || value.length % 4 !== 0) {
+        return false;
+    }
+    if (!/^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$/.test(value)) {
         return false;
     }
-    return /^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$/.test(value);
+    // Reject non-canonical encodings (non-zero trailing bits).
+    return Buffer.from(value, "base64").toString("base64") === value;
+}
+function assertBytes(value) {
+    if (!(value instanceof Uint8Array)) {
+        throw new TypeError("Value must be a Uint8Array.");
+    }
 }
 //# sourceMappingURL=cryptoEncoding.base64.js.map

package/dist/cryptoEncoding/encoding/cryptoEncoding.base64url.d.ts

@@ -1,13 +1,21 @@
 /**
  * Encodes bytes as URL-safe Base64 without padding.
+ *
+ * An empty byte array encodes to the empty string.
  */
 export declare function toBase64Url(value: Uint8Array): string;
 /**
  * Decodes URL-safe Base64 into bytes.
+ *
+ * Input must be canonical: unpadded, using only the URL-safe alphabet,
+ * never of length ≡ 1 (mod 4), and with zero-valued trailing bits. The
+ * empty string decodes to an empty byte array.
  */
 export declare function fromBase64Url(value: string): Uint8Array;
 /**
- * Returns whether a string is valid URL-safe Base64.
+ * Returns whether a string is valid, canonical URL-safe Base64.
+ *
+ * The empty string is valid (it encodes zero bytes).
  */
 export declare function isBase64Url(value: string): boolean;
 //# sourceMappingURL=cryptoEncoding.base64url.d.ts.map

package/dist/cryptoEncoding/encoding/cryptoEncoding.base64url.js

@@ -1,40 +1,43 @@
-import { toBase64 } from "./cryptoEncoding.base64.js";
-import { fromBase64 } from "./cryptoEncoding.base64.js";
 /**
  * Encodes bytes as URL-safe Base64 without padding.
+ *
+ * An empty byte array encodes to the empty string.
  */
 export function toBase64Url(value) {
-    return toBase64(value)
-        .replace(/\+/g, "-")
-        .replace(/\//g, "_")
-        .replace(/=+$/, "");
+    assertBytes(value);
+    return Buffer.from(value.buffer, value.byteOffset, value.byteLength).toString("base64url");
 }
 /**
  * Decodes URL-safe Base64 into bytes.
+ *
+ * Input must be canonical: unpadded, using only the URL-safe alphabet,
+ * never of length ≡ 1 (mod 4), and with zero-valued trailing bits. The
+ * empty string decodes to an empty byte array.
  */
 export function fromBase64Url(value) {
-    if (value.length === 0) {
-        return new Uint8Array();
-    }
     if (!isBase64Url(value)) {
         throw new TypeError("Invalid Base64URL value.");
     }
-    if (value.length % 4 === 1) {
-        throw new TypeError("Invalid Base64URL length.");
-    }
-    let base64 = value.replace(/-/g, "+").replace(/_/g, "/");
-    while (base64.length % 4) {
-        base64 += "=";
-    }
-    return fromBase64(base64);
+    return new Uint8Array(Buffer.from(value, "base64url"));
 }
 /**
- * Returns whether a string is valid URL-safe Base64.
+ * Returns whether a string is valid, canonical URL-safe Base64.
+ *
+ * The empty string is valid (it encodes zero bytes).
  */
 export function isBase64Url(value) {
-    if (typeof value !== "string" || value.length === 0) {
+    if (typeof value !== "string" || value.length % 4 === 1) {
         return false;
     }
-    return /^(?:[A-Za-z0-9_-]{2,4})*(?:[A-Za-z0-9_-]{2,3})?$/.test(value);
+    if (!/^[A-Za-z0-9_-]*$/.test(value)) {
+        return false;
+    }
+    // Reject non-canonical encodings (non-zero trailing bits).
+    return Buffer.from(value, "base64url").toString("base64url") === value;
+}
+function assertBytes(value) {
+    if (!(value instanceof Uint8Array)) {
+        throw new TypeError("Value must be a Uint8Array.");
+    }
 }
 //# sourceMappingURL=cryptoEncoding.base64url.js.map

package/dist/cryptoEncoding/encoding/cryptoEncoding.hex.d.ts

@@ -1,13 +1,20 @@
 /**
- * Encodes bytes as hexadecimal.
+ * Encodes bytes as lowercase hexadecimal.
+ *
+ * An empty byte array encodes to the empty string.
  */
 export declare function toHex(value: Uint8Array): string;
 /**
  * Decodes hexadecimal into bytes.
+ *
+ * Both upper- and lowercase digits are accepted. The empty string decodes
+ * to an empty byte array. Throws for odd lengths or non-hex characters.
  */
 export declare function fromHex(value: string): Uint8Array;
 /**
- * Returns whether a string is valid hexadecimal.
+ * Returns whether a string is valid hexadecimal (even length, hex digits only).
+ *
+ * The empty string is valid (it encodes zero bytes).
  */
 export declare function isHex(value: string): boolean;
 //# sourceMappingURL=cryptoEncoding.hex.d.ts.map

package/dist/cryptoEncoding/encoding/cryptoEncoding.hex.js

@@ -1,31 +1,37 @@
 /**
- * Encodes bytes as hexadecimal.
+ * Encodes bytes as lowercase hexadecimal.
+ *
+ * An empty byte array encodes to the empty string.
  */
 export function toHex(value) {
-    return Array.from(value)
-        .map((b) => b.toString(16).padStart(2, "0"))
-        .join("");
+    assertBytes(value);
+    return Buffer.from(value.buffer, value.byteOffset, value.byteLength).toString("hex");
 }
 /**
  * Decodes hexadecimal into bytes.
+ *
+ * Both upper- and lowercase digits are accepted. The empty string decodes
+ * to an empty byte array. Throws for odd lengths or non-hex characters.
  */
 export function fromHex(value) {
     if (!isHex(value)) {
         throw new TypeError("Invalid hexadecimal value.");
     }
-    const result = new Uint8Array(value.length / 2);
-    for (let i = 0; i < value.length; i += 2) {
-        result[i / 2] = parseInt(value.slice(i, i + 2), 16);
-    }
-    return result;
+    return new Uint8Array(Buffer.from(value, "hex"));
 }
 /**
- * Returns whether a string is valid hexadecimal.
+ * Returns whether a string is valid hexadecimal (even length, hex digits only).
+ *
+ * The empty string is valid (it encodes zero bytes).
  */
 export function isHex(value) {
     return (typeof value === "string" &&
-        value.length > 0 &&
         value.length % 2 === 0 &&
         /^[0-9a-fA-F]*$/.test(value));
 }
+function assertBytes(value) {
+    if (!(value instanceof Uint8Array)) {
+        throw new TypeError("Value must be a Uint8Array.");
+    }
+}
 //# sourceMappingURL=cryptoEncoding.hex.js.map

package/dist/cryptoErrors/cryptoErrors.helper.d.ts

@@ -0,0 +1,30 @@
+import { CryptoError, CryptoOperation } from "@zudojs/errors";
+/**
+ * Builds a cipher error that preserves the underlying failure as `cause`.
+ */
+export declare function cipherError(message: string, operation: CryptoOperation.ENCRYPT | CryptoOperation.DECRYPT, algorithm: string | undefined, cause?: unknown): CryptoError;
+/**
+ * Builds a hashing error that preserves the underlying failure as `cause`.
+ */
+export declare function hashError(message: string, algorithm: string | undefined, cause?: unknown): CryptoError;
+/**
+ * Builds a signature error that preserves the underlying failure as `cause`.
+ */
+export declare function signatureError(message: string, operation: CryptoOperation.SIGN | CryptoOperation.VERIFY_SIGNATURE, algorithm: string | undefined, cause?: unknown): CryptoError;
+/**
+ * Builds a key derivation error that preserves the underlying failure as `cause`.
+ */
+export declare function keyDerivationError(message: string, algorithm: string | undefined, cause?: unknown): CryptoError;
+/**
+ * Builds a key error that preserves the underlying failure as `cause`.
+ */
+export declare function keyError(message: string, operation: CryptoOperation.KEY_GENERATION | CryptoOperation.KEY_IMPORT | CryptoOperation.KEY_EXPORT, algorithm: string | undefined, cause?: unknown): CryptoError;
+/**
+ * Builds a generic crypto error for an operation, preserving `cause`.
+ */
+export declare function operationError(message: string, operation: CryptoOperation, cause?: unknown): CryptoError;
+/**
+ * Re-throws CryptoErrors unchanged and wraps anything else.
+ */
+export declare function rethrowAsCryptoError(error: unknown, wrap: (cause: unknown) => CryptoError): never;
+//# sourceMappingURL=cryptoErrors.helper.d.ts.map

package/dist/cryptoErrors/cryptoErrors.helper.js

@@ -0,0 +1,72 @@
+import { CryptoError, CryptoOperation, ErrorCode, isCryptoError, } from "@zudojs/errors";
+/**
+ * Builds a cipher error that preserves the underlying failure as `cause`.
+ */
+export function cipherError(message, operation, algorithm, cause) {
+    return new CryptoError(message, {
+        code: ErrorCode.CRYPTO_CIPHER,
+        operation,
+        algorithm,
+        cause,
+    });
+}
+/**
+ * Builds a hashing error that preserves the underlying failure as `cause`.
+ */
+export function hashError(message, algorithm, cause) {
+    return new CryptoError(message, {
+        code: ErrorCode.CRYPTO_HASH,
+        operation: CryptoOperation.HASH,
+        algorithm,
+        cause,
+    });
+}
+/**
+ * Builds a signature error that preserves the underlying failure as `cause`.
+ */
+export function signatureError(message, operation, algorithm, cause) {
+    return new CryptoError(message, {
+        code: ErrorCode.CRYPTO_SIGNATURE,
+        operation,
+        algorithm,
+        cause,
+    });
+}
+/**
+ * Builds a key derivation error that preserves the underlying failure as `cause`.
+ */
+export function keyDerivationError(message, algorithm, cause) {
+    return new CryptoError(message, {
+        code: ErrorCode.CRYPTO_DERIVATION,
+        operation: CryptoOperation.KEY_DERIVATION,
+        algorithm,
+        cause,
+    });
+}
+/**
+ * Builds a key error that preserves the underlying failure as `cause`.
+ */
+export function keyError(message, operation, algorithm, cause) {
+    return new CryptoError(message, {
+        code: ErrorCode.CRYPTO_KEY,
+        operation,
+        algorithm,
+        cause,
+    });
+}
+/**
+ * Builds a generic crypto error for an operation, preserving `cause`.
+ */
+export function operationError(message, operation, cause) {
+    return new CryptoError(message, { operation, cause });
+}
+/**
+ * Re-throws CryptoErrors unchanged and wraps anything else.
+ */
+export function rethrowAsCryptoError(error, wrap) {
+    if (isCryptoError(error)) {
+        throw error;
+    }
+    throw wrap(error);
+}
+//# sourceMappingURL=cryptoErrors.helper.js.map