@aziontech/jwt 1.0.0

package/README.md

@@ -0,0 +1,218 @@
+# Azion JWT Library
+
+The Azion JWT Library provides utility functions for signing, verifying, and decoding JSON Web Tokens (JWTs). This library ensures ease of use and security when handling JWTs in web applications.
+
+## Table of Contents
+
+- [Installation](#installation)
+- [Usage](#usage)
+  - [Sign JWT](#sign-jwt)
+  - [Verify JWT](#verify-jwt)
+  - [Decode JWT](#decode-jwt)
+- [API Reference](#api-reference)
+  - [`sign`](#sign)
+  - [`verify`](#verify)
+  - [`decode`](#decode)
+- [Types](#types)
+  - [`JWTPayload`](#jwtpayload)
+  - [`TokenHeader`](#tokenheader)
+- [Errors](#errors)
+  - [`JwtAlgorithmNotImplemented`](#jwtalgorithmnotimplemented)
+  - [`JwtTokenInvalid`](#jwttokeninvalid)
+  - [`JwtTokenNotBefore`](#jwttokennotbefore)
+  - [`JwtTokenExpired`](#jwttokenexpired)
+  - [`JwtTokenIssuedAt`](#jwttokenissuedat)
+  - [`JwtHeaderInvalid`](#jwtheaderinvalid)
+  - [`JwtTokenSignatureMismatched`](#jwttokensignaturemismatched)
+- [Contributing](#contributing)
+
+## Installation
+
+Install the package using npm or yarn:
+
+```sh
+npm install azion
+```
+
+or
+
+```sh
+yarn add azion
+```
+
+## Usage
+
+### Sign JWT
+
+**JavaScript:**
+
+```javascript
+import { sign } from '@aziontech/jwt';
+
+const privateKey = 'your-private-key';
+const payload = { userId: 123, exp: Math.floor(Date.now() / 1000) + 3600 }; // 1 hour expiration
+sign(payload, privateKey).then((token) => console.log(token)); // Outputs the signed JWT
+```
+
+**TypeScript:**
+
+```typescript
+import { sign } from '@aziontech/jwt';
+import type { JWTPayload } from '@aziontech/jwt';
+
+const privateKey: string = 'your-private-key';
+const payload: JWTPayload = { userId: 123, exp: Math.floor(Date.now() / 1000) + 3600 }; // 1 hour expiration
+sign(payload, privateKey).then((token: string) => console.log(token)); // Outputs the signed JWT
+```
+
+### Verify JWT
+
+**JavaScript:**
+
+```javascript
+import { verify } from '@aziontech/jwt';
+
+const publicKey = 'your-public-key';
+const token = 'your-jwt-token';
+verify(token, publicKey)
+  .then((payload) => console.log(payload))
+  .catch((err) => console.error(err)); // Outputs the payload if verification is successful
+```
+
+**TypeScript:**
+
+```typescript
+import { verify } from '@aziontech/jwt';
+import type { JWTPayload } from '@aziontech/jwt';
+
+const publicKey: string = 'your-public-key';
+const token: string = 'your-jwt-token';
+verify(token, publicKey)
+  .then((payload: JWTPayload) => console.log(payload))
+  .catch((err) => console.error(err)); // Outputs the payload if verification is successful
+```
+
+### Decode JWT
+
+**JavaScript:**
+
+```javascript
+import { decode } from '@aziontech/jwt';
+
+const token = 'your-jwt-token';
+const { header, payload } = decode(token);
+console.log(header, payload); // Outputs the decoded header and payload
+```
+
+**TypeScript:**
+
+```typescript
+import { decode } from '@aziontech/jwt';
+import type { JWTPayload, TokenHeader } from '@aziontech/jwt';
+
+const token: string = 'your-jwt-token';
+const { header, payload }: { header: TokenHeader; payload: JWTPayload } = decode(token);
+console.log(header, payload); // Outputs the decoded header and payload
+```
+
+## API Reference
+
+### `sign`
+
+Signs a JWT payload with the specified algorithm and private key.
+
+**Parameters:**
+
+- `payload: JWTPayload` - The payload to be signed.
+- `privateKey: SignatureKey` - The private key used for signing.
+- `alg?: SignatureAlgorithm` - The algorithm to use for signing (default is `'HS256'`).
+
+**Returns:**
+
+- `Promise<string>` - The signed JWT.
+
+### `verify`
+
+Verifies a JWT using the specified public key and algorithm.
+
+**Parameters:**
+
+- `token: string` - The JWT to verify.
+- `publicKey: SignatureKey` - The public key used for verification.
+- `alg?: SignatureAlgorithm` - The algorithm to use for verification (default is `'HS256'`).
+
+**Returns:**
+
+- `Promise<JWTPayload>` - The decoded payload if the token is valid.
+
+### `decode`
+
+Decodes a JWT without verifying its signature.
+
+**Parameters:**
+
+- `token: string` - The JWT to decode.
+
+**Returns:**
+
+- `{ header: TokenHeader; payload: JWTPayload }` - The decoded header and payload.
+
+## Types
+
+### `JWTPayload`
+
+Defines the structure of the JWT payload.
+
+```typescript
+type JWTPayload = {
+  [key: string]: unknown;
+  exp?: number;
+  nbf?: number;
+  iat?: number;
+};
+```
+
+### `TokenHeader`
+
+Defines the structure of the JWT header.
+
+```typescript
+interface TokenHeader {
+  alg: SignatureAlgorithm;
+  typ?: 'JWT';
+}
+```
+
+## Errors
+
+### `JwtAlgorithmNotImplemented`
+
+Thrown when an algorithm is not implemented.
+
+### `JwtTokenInvalid`
+
+Thrown when a JWT is invalid.
+
+### `JwtTokenNotBefore`
+
+Thrown when a JWT is used before its `nbf` claim.
+
+### `JwtTokenExpired`
+
+Thrown when a JWT has expired.
+
+### `JwtTokenIssuedAt`
+
+Thrown when a JWT `iat` claim is in the future.
+
+### `JwtHeaderInvalid`
+
+Thrown when a JWT header is invalid.
+
+### `JwtTokenSignatureMismatched`
+
+Thrown when a JWT signature does not match.
+
+## Contributing
+
+Feel free to submit issues or pull requests to improve the functionality or documentation.

package/dist/index.cjs

@@ -0,0 +1,2 @@
+"use strict";Object.defineProperties(exports,{__esModule:{value:!0},[Symbol.toStringTag]:{value:"Module"}});class g extends Error{constructor(t){super(`${t} is not an implemented algorithm`),this.name="JwtAlgorithmNotImplemented"}}class h extends Error{constructor(t){super(`invalid JWT token: ${t}`),this.name="JwtTokenInvalid"}}class J extends Error{constructor(t){super(`token (${t}) is being used before it's valid`),this.name="JwtTokenNotBefore"}}class x extends Error{constructor(t){super(`token (${t}) expired`),this.name="JwtTokenExpired"}}class K extends Error{constructor(t,r){super(`Incorrect "iat" claim must be a older than "${t}" (iat: "${r}")`),this.name="JwtTokenIssuedAt"}}class R extends Error{constructor(t){super(`jwt header is invalid: ${JSON.stringify(t)}`),this.name="JwtHeaderInvalid"}}class C extends Error{constructor(t){super(`token(${t}) signature mismatched`),this.name="JwtTokenSignatureMismatched"}}var i=(e=>(e.Encrypt="encrypt",e.Decrypt="decrypt",e.Sign="sign",e.Verify="verify",e.DeriveKey="deriveKey",e.DeriveBits="deriveBits",e.WrapKey="wrapKey",e.UnwrapKey="unwrapKey",e))(i||{}),m=(e=>(e.HS256="HS256",e.HS384="HS384",e.HS512="HS512",e.RS256="RS256",e.RS384="RS384",e.RS512="RS512",e.PS256="PS256",e.PS384="PS384",e.PS512="PS512",e.ES256="ES256",e.ES384="ES384",e.ES512="ES512",e.EdDSA="EdDSA",e))(m||{});const y=e=>E(e.replace(/_|-/g,t=>({_:"/","-":"+"})[t]??t)),b=e=>I(e).replace(/\/|\+/g,t=>({"/":"_","+":"-"})[t]??t),I=e=>{let t="";const r=new Uint8Array(e);for(let n=0,a=r.length;n<a;n++)t+=String.fromCharCode(r[n]);return btoa(t)},E=e=>{const t=atob(e),r=new Uint8Array(new ArrayBuffer(t.length)),n=t.length/2;for(let a=0,s=t.length-1;a<=n;a++,s--)r[a]=t.charCodeAt(a),r[s]=t.charCodeAt(s);return r},u=new TextEncoder,$=new TextDecoder;async function D(e,t,r){const n=v(t),a=await B(e,n);return await crypto.subtle.sign(n,a,r)}async function j(e,t,r,n){const a=v(t),s=await T(e,a);return await crypto.subtle.verify(a,s,r,n)}function d(e){return E(e.split(`
+`).filter(t=>!t.includes("BEGIN")&&!t.includes("END")).join("").replace(/\s/g,""))}async function B(e,t){if(!crypto.subtle||!crypto.subtle.importKey)throw new Error("`crypto.subtle.importKey` is undefined. JWT auth middleware requires it.");if(P(e)){if(e.type!=="private")throw new Error(`unexpected non private key: CryptoKey.type is ${e.type}`);return e}const r=[i.Sign];return typeof e=="object"?await crypto.subtle.importKey("jwk",e,t,!1,r):e.includes("PRIVATE")?await crypto.subtle.importKey("pkcs8",d(e),t,!1,r):await crypto.subtle.importKey("raw",u.encode(e),t,!1,r)}async function T(e,t){if(!crypto.subtle||!crypto.subtle.importKey)throw new Error("`crypto.subtle.importKey` is undefined. JWT auth middleware requires it.");if(P(e)){if(e.type==="public"||e.type==="secret")return e;e=await p(e)}if(typeof e=="string"&&e.includes("PRIVATE")){const n=await crypto.subtle.importKey("pkcs8",d(e),t,!0,[i.Sign]);e=await p(n)}const r=[i.Verify];return typeof e=="object"?await crypto.subtle.importKey("jwk",e,t,!1,r):e.includes("PUBLIC")?await crypto.subtle.importKey("spki",d(e),t,!1,r):await crypto.subtle.importKey("raw",u.encode(e),t,!1,r)}async function p(e){if(e.type!=="private")throw new Error(`unexpected key type: ${e.type}`);if(!e.extractable)throw new Error("unexpected private key is unextractable");const t=await crypto.subtle.exportKey("jwk",e),{kty:r}=t,{alg:n,e:a,n:s}=t,{crv:o,x:c,y:l}=t;return{kty:r,alg:n,e:a,n:s,crv:o,x:c,y:l,key_ops:[i.Verify]}}function v(e){switch(e){case"HS256":return{name:"HMAC",hash:{name:"SHA-256"}};case"HS384":return{name:"HMAC",hash:{name:"SHA-384"}};case"HS512":return{name:"HMAC",hash:{name:"SHA-512"}};case"RS256":return{name:"RSASSA-PKCS1-v1_5",hash:{name:"SHA-256"}};case"RS384":return{name:"RSASSA-PKCS1-v1_5",hash:{name:"SHA-384"}};case"RS512":return{name:"RSASSA-PKCS1-v1_5",hash:{name:"SHA-512"}};case"PS256":return{name:"RSA-PSS",hash:{name:"SHA-256"},saltLength:32};case"PS384":return{name:"RSA-PSS",hash:{name:"SHA-384"},saltLength:48};case"PS512":return{name:"RSA-PSS",hash:{name:"SHA-512"},saltLength:64};case"ES256":return{name:"ECDSA",hash:{name:"SHA-256"},namedCurve:"P-256"};case"ES384":return{name:"ECDSA",hash:{name:"SHA-384"},namedCurve:"P-384"};case"ES512":return{name:"ECDSA",hash:{name:"SHA-512"},namedCurve:"P-521"};case"EdDSA":return{name:"Ed25519",namedCurve:"Ed25519"};default:throw new g(e)}}function P(e){return e instanceof CryptoKey}const w=e=>b(u.encode(JSON.stringify(e))).replace(/=/g,""),N=e=>b(e).replace(/=/g,""),f=e=>JSON.parse($.decode(y(e)));function _(e){if(typeof e=="object"&&e!==null){const t=e;return"alg"in t&&Object.values(m).includes(t.alg)&&(!("typ"in t)||t.typ==="JWT")}return!1}const A=async(e,t,r="HS256")=>{const n=w(e),s=`${w({alg:r,typ:"JWT"})}.${n}`,o=await D(t,r,u.encode(s)),c=N(o);return`${s}.${c}`},H=async(e,t,r="HS256")=>{const n=e.split(".");if(n.length!==3)throw new h(e);const{header:a,payload:s}=S(e);if(!_(a))throw new R(a);const o=Math.floor(Date.now()/1e3);if(s.nbf&&s.nbf>o)throw new J(e);if(s.exp&&s.exp<=o)throw new x(e);if(s.iat&&o<s.iat)throw new K(o,s.iat);const c=e.substring(0,e.lastIndexOf("."));if(!await j(t,r,y(n[2]),u.encode(c)))throw new C(e);return s},S=e=>{try{const[t,r]=e.split("."),n=f(t),a=f(r);return{header:n,payload:a}}catch{throw new h(e)}},M={decode:S,sign:A,verify:H};exports.decode=S;exports.default=M;exports.sign=A;exports.verify=H;

package/dist/index.d.ts

@@ -0,0 +1,150 @@
+/**
+ * @module
+ * JSON Web Algorithms (JWA)
+ * https://datatracker.ietf.org/doc/html/rfc7518
+ */
+declare enum AlgorithmTypes {
+    HS256 = "HS256",
+    HS384 = "HS384",
+    HS512 = "HS512",
+    RS256 = "RS256",
+    RS384 = "RS384",
+    RS512 = "RS512",
+    PS256 = "PS256",
+    PS384 = "PS384",
+    PS512 = "PS512",
+    ES256 = "ES256",
+    ES384 = "ES384",
+    ES512 = "ES512",
+    EdDSA = "EdDSA"
+}
+
+export declare enum CryptoKeyUsage {
+    Encrypt = "encrypt",
+    Decrypt = "decrypt",
+    Sign = "sign",
+    Verify = "verify",
+    DeriveKey = "deriveKey",
+    DeriveBits = "deriveBits",
+    WrapKey = "wrapKey",
+    UnwrapKey = "unwrapKey"
+}
+
+/**
+ * Decodes a JWT into its header and payload.
+ * @param token - The JWT to decode.
+ * @returns An object containing the decoded header and payload.
+ * @throws {JwtTokenInvalid} If the token is invalid.
+ * @example
+ * const { header, payload } = decode(token);
+ * console.log(header, payload);
+ */
+export declare const decode: (token: string) => {
+    header: TokenHeader;
+    payload: JWTPayload;
+};
+
+declare const jwt: {
+    decode: (token: string) => {
+        header: TokenHeader;
+        payload: JWTPayload;
+    };
+    sign: (payload: JWTPayload, privateKey: SignatureKey, alg?: SignatureAlgorithm) => Promise<string>;
+    verify: (token: string, publicKey: SignatureKey, alg?: SignatureAlgorithm) => Promise<JWTPayload>;
+};
+export default jwt;
+
+/**
+ * @module
+ * Type definitions for JWT utilities.
+ */
+export declare class JwtAlgorithmNotImplemented extends Error {
+    constructor(alg: string);
+}
+
+export declare class JwtHeaderInvalid extends Error {
+    constructor(header: object);
+}
+
+/**
+ * JWT Payload
+ */
+export declare type JWTPayload = {
+    [key: string]: unknown;
+    /**
+     * The token is checked to ensure it has not expired.
+     */
+    exp?: number;
+    /**
+     * The token is checked to ensure it is not being used before a specified time.
+     */
+    nbf?: number;
+    /**
+     * The token is checked to ensure it is not issued in the future.
+     */
+    iat?: number;
+};
+
+export declare class JwtTokenExpired extends Error {
+    constructor(token: string);
+}
+
+export declare class JwtTokenInvalid extends Error {
+    constructor(token: string);
+}
+
+export declare class JwtTokenIssuedAt extends Error {
+    constructor(currentTimestamp: number, iat: number);
+}
+
+export declare class JwtTokenNotBefore extends Error {
+    constructor(token: string);
+}
+
+export declare class JwtTokenSignatureMismatched extends Error {
+    constructor(token: string);
+}
+
+/**
+ * Signs a JWT payload with a given private key and algorithm.
+ * @param payload - The JWT payload to sign.
+ * @param privateKey - The private key to sign the payload with.
+ * @param alg - The signature algorithm to use (default is 'HS256').
+ * @returns The signed JWT as a string.
+ * @example
+ * const token = await sign({ sub: '1234567890', name: 'John Doe', iat: 1516239022 }, privateKey);
+ * console.log(token);
+ */
+export declare const sign: (payload: JWTPayload, privateKey: SignatureKey, alg?: SignatureAlgorithm) => Promise<string>;
+
+declare type SignatureAlgorithm = keyof typeof AlgorithmTypes;
+
+declare type SignatureKey = string | JsonWebKey | CryptoKey;
+
+/**
+ * Interface representing the JWT header.
+ */
+declare interface TokenHeader {
+    alg: SignatureAlgorithm;
+    typ?: 'JWT';
+}
+
+/**
+ * Verifies a JWT with a given public key and algorithm.
+ * @param token - The JWT to verify.
+ * @param publicKey - The public key to verify the JWT with.
+ * @param alg - The signature algorithm to use (default is 'HS256').
+ * @returns The decoded JWT payload if verification is successful.
+ * @throws {JwtTokenInvalid} If the token is invalid.
+ * @throws {JwtHeaderInvalid} If the token header is invalid.
+ * @throws {JwtTokenNotBefore} If the token is not yet valid.
+ * @throws {JwtTokenExpired} If the token has expired.
+ * @throws {JwtTokenIssuedAt} If the token was issued in the future.
+ * @throws {JwtTokenSignatureMismatched} If the token signature does not match.
+ * @example
+ * const payload = await verify(token, publicKey);
+ * console.log(payload);
+ */
+export declare const verify: (token: string, publicKey: SignatureKey, alg?: SignatureAlgorithm) => Promise<JWTPayload>;
+
+export { }

package/dist/index.mjs

@@ -0,0 +1,253 @@
+class H extends Error {
+  constructor(t) {
+    super(`${t} is not an implemented algorithm`), this.name = "JwtAlgorithmNotImplemented";
+  }
+}
+class f extends Error {
+  constructor(t) {
+    super(`invalid JWT token: ${t}`), this.name = "JwtTokenInvalid";
+  }
+}
+class P extends Error {
+  constructor(t) {
+    super(`token (${t}) is being used before it's valid`), this.name = "JwtTokenNotBefore";
+  }
+}
+class J extends Error {
+  constructor(t) {
+    super(`token (${t}) expired`), this.name = "JwtTokenExpired";
+  }
+}
+class x extends Error {
+  constructor(t, r) {
+    super(`Incorrect "iat" claim must be a older than "${t}" (iat: "${r}")`), this.name = "JwtTokenIssuedAt";
+  }
+}
+class g extends Error {
+  constructor(t) {
+    super(`jwt header is invalid: ${JSON.stringify(t)}`), this.name = "JwtHeaderInvalid";
+  }
+}
+class K extends Error {
+  constructor(t) {
+    super(`token(${t}) signature mismatched`), this.name = "JwtTokenSignatureMismatched";
+  }
+}
+var i = /* @__PURE__ */ ((e) => (e.Encrypt = "encrypt", e.Decrypt = "decrypt", e.Sign = "sign", e.Verify = "verify", e.DeriveKey = "deriveKey", e.DeriveBits = "deriveBits", e.WrapKey = "wrapKey", e.UnwrapKey = "unwrapKey", e))(i || {}), h = /* @__PURE__ */ ((e) => (e.HS256 = "HS256", e.HS384 = "HS384", e.HS512 = "HS512", e.RS256 = "RS256", e.RS384 = "RS384", e.RS512 = "RS512", e.PS256 = "PS256", e.PS384 = "PS384", e.PS512 = "PS512", e.ES256 = "ES256", e.ES384 = "ES384", e.ES512 = "ES512", e.EdDSA = "EdDSA", e))(h || {});
+const m = (e) => E(e.replace(/_|-/g, (t) => ({ _: "/", "-": "+" })[t] ?? t)), y = (e) => R(e).replace(/\/|\+/g, (t) => ({ "/": "_", "+": "-" })[t] ?? t), R = (e) => {
+  let t = "";
+  const r = new Uint8Array(e);
+  for (let n = 0, a = r.length; n < a; n++)
+    t += String.fromCharCode(r[n]);
+  return btoa(t);
+}, E = (e) => {
+  const t = atob(e), r = new Uint8Array(new ArrayBuffer(t.length)), n = t.length / 2;
+  for (let a = 0, s = t.length - 1; a <= n; a++, s--)
+    r[a] = t.charCodeAt(a), r[s] = t.charCodeAt(s);
+  return r;
+}, u = new TextEncoder(), C = new TextDecoder();
+async function I(e, t, r) {
+  const n = b(t), a = await D(e, n);
+  return await crypto.subtle.sign(n, a, r);
+}
+async function $(e, t, r, n) {
+  const a = b(t), s = await B(e, a);
+  return await crypto.subtle.verify(a, s, r, n);
+}
+function d(e) {
+  return E(
+    e.split(`
+`).filter((t) => !t.includes("BEGIN") && !t.includes("END")).join("").replace(/\s/g, "")
+  );
+}
+async function D(e, t) {
+  if (!crypto.subtle || !crypto.subtle.importKey)
+    throw new Error("`crypto.subtle.importKey` is undefined. JWT auth middleware requires it.");
+  if (v(e)) {
+    if (e.type !== "private")
+      throw new Error(`unexpected non private key: CryptoKey.type is ${e.type}`);
+    return e;
+  }
+  const r = [i.Sign];
+  return typeof e == "object" ? await crypto.subtle.importKey("jwk", e, t, !1, r) : e.includes("PRIVATE") ? await crypto.subtle.importKey("pkcs8", d(e), t, !1, r) : await crypto.subtle.importKey("raw", u.encode(e), t, !1, r);
+}
+async function B(e, t) {
+  if (!crypto.subtle || !crypto.subtle.importKey)
+    throw new Error("`crypto.subtle.importKey` is undefined. JWT auth middleware requires it.");
+  if (v(e)) {
+    if (e.type === "public" || e.type === "secret")
+      return e;
+    e = await l(e);
+  }
+  if (typeof e == "string" && e.includes("PRIVATE")) {
+    const n = await crypto.subtle.importKey("pkcs8", d(e), t, !0, [i.Sign]);
+    e = await l(n);
+  }
+  const r = [i.Verify];
+  return typeof e == "object" ? await crypto.subtle.importKey("jwk", e, t, !1, r) : e.includes("PUBLIC") ? await crypto.subtle.importKey("spki", d(e), t, !1, r) : await crypto.subtle.importKey("raw", u.encode(e), t, !1, r);
+}
+async function l(e) {
+  if (e.type !== "private")
+    throw new Error(`unexpected key type: ${e.type}`);
+  if (!e.extractable)
+    throw new Error("unexpected private key is unextractable");
+  const t = await crypto.subtle.exportKey("jwk", e), { kty: r } = t, { alg: n, e: a, n: s } = t, { crv: o, x: c, y: S } = t;
+  return { kty: r, alg: n, e: a, n: s, crv: o, x: c, y: S, key_ops: [i.Verify] };
+}
+function b(e) {
+  switch (e) {
+    case "HS256":
+      return {
+        name: "HMAC",
+        hash: {
+          name: "SHA-256"
+        }
+      };
+    case "HS384":
+      return {
+        name: "HMAC",
+        hash: {
+          name: "SHA-384"
+        }
+      };
+    case "HS512":
+      return {
+        name: "HMAC",
+        hash: {
+          name: "SHA-512"
+        }
+      };
+    case "RS256":
+      return {
+        name: "RSASSA-PKCS1-v1_5",
+        hash: {
+          name: "SHA-256"
+        }
+      };
+    case "RS384":
+      return {
+        name: "RSASSA-PKCS1-v1_5",
+        hash: {
+          name: "SHA-384"
+        }
+      };
+    case "RS512":
+      return {
+        name: "RSASSA-PKCS1-v1_5",
+        hash: {
+          name: "SHA-512"
+        }
+      };
+    case "PS256":
+      return {
+        name: "RSA-PSS",
+        hash: {
+          name: "SHA-256"
+        },
+        saltLength: 32
+        // 256 >> 3
+      };
+    case "PS384":
+      return {
+        name: "RSA-PSS",
+        hash: {
+          name: "SHA-384"
+        },
+        saltLength: 48
+        // 384 >> 3
+      };
+    case "PS512":
+      return {
+        name: "RSA-PSS",
+        hash: {
+          name: "SHA-512"
+        },
+        saltLength: 64
+        // 512 >> 3,
+      };
+    case "ES256":
+      return {
+        name: "ECDSA",
+        hash: {
+          name: "SHA-256"
+        },
+        namedCurve: "P-256"
+      };
+    case "ES384":
+      return {
+        name: "ECDSA",
+        hash: {
+          name: "SHA-384"
+        },
+        namedCurve: "P-384"
+      };
+    case "ES512":
+      return {
+        name: "ECDSA",
+        hash: {
+          name: "SHA-512"
+        },
+        namedCurve: "P-521"
+      };
+    case "EdDSA":
+      return {
+        name: "Ed25519",
+        namedCurve: "Ed25519"
+      };
+    default:
+      throw new H(e);
+  }
+}
+function v(e) {
+  return e instanceof CryptoKey;
+}
+const p = (e) => (
+  // eslint-disable-next-line
+  // @ts-ignore
+  y(u.encode(JSON.stringify(e))).replace(/=/g, "")
+), j = (e) => y(e).replace(/=/g, ""), w = (e) => JSON.parse(C.decode(m(e)));
+function T(e) {
+  if (typeof e == "object" && e !== null) {
+    const t = e;
+    return "alg" in t && Object.values(h).includes(t.alg) && (!("typ" in t) || t.typ === "JWT");
+  }
+  return !1;
+}
+const N = async (e, t, r = "HS256") => {
+  const n = p(e), s = `${p({ alg: r, typ: "JWT" })}.${n}`, o = await I(t, r, u.encode(s)), c = j(o);
+  return `${s}.${c}`;
+}, W = async (e, t, r = "HS256") => {
+  const n = e.split(".");
+  if (n.length !== 3)
+    throw new f(e);
+  const { header: a, payload: s } = A(e);
+  if (!T(a))
+    throw new g(a);
+  const o = Math.floor(Date.now() / 1e3);
+  if (s.nbf && s.nbf > o)
+    throw new P(e);
+  if (s.exp && s.exp <= o)
+    throw new J(e);
+  if (s.iat && o < s.iat)
+    throw new x(o, s.iat);
+  const c = e.substring(0, e.lastIndexOf("."));
+  if (!await $(t, r, m(n[2]), u.encode(c)))
+    throw new K(e);
+  return s;
+}, A = (e) => {
+  try {
+    const [t, r] = e.split("."), n = w(t), a = w(r);
+    return {
+      header: n,
+      payload: a
+    };
+  } catch {
+    throw new f(e);
+  }
+}, _ = { decode: A, sign: N, verify: W };
+export {
+  A as decode,
+  _ as default,
+  N as sign,
+  W as verify
+};

package/package.json

@@ -0,0 +1,44 @@
+{
+  "name": "@aziontech/jwt",
+  "version": "1.0.0",
+  "description": "The Azion JWT Library provides utility functions for signing, verifying, and decoding JSON Web Tokens (JWTs).",
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.mjs",
+  "types": "./dist/index.d.ts",
+  "scripts": {
+    "compile": "vite build",
+    "lint": "eslint .",
+    "lint:fix": "eslint --fix .",
+    "prettier": "prettier --write .",
+    "prettier:check": "prettier --check .",
+    "test": "jest --clearCache && jest"
+  },
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "require": "./dist/index.cjs",
+      "import": "./dist/index.mjs"
+    }
+  },
+  "author": "aziontech",
+  "license": "MIT",
+  "files": [
+    "dist",
+    "package.json"
+  ],
+  "devDependencies": {
+    "@aziontech/vite-config": "workspace:*",
+    "@jest/globals": "^29.7.0",
+    "@peculiar/webcrypto": "^1.5.0",
+    "@types/jest": "^29.5.12",
+    "jest": "^29.7.0",
+    "ts-jest": "^29.2.2",
+    "ts-node": "^10.9.2",
+    "typescript": "^5.5.3"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/aziontech/lib.git",
+    "directory": "packages/jwt"
+  }
+}