@kabyeon/nexusjs 0.6.5

package/dist/crypto/hash.d.ts

@@ -0,0 +1,52 @@
+/**
+ * `HashService` — secure password hashing.
+ *
+ * Algorithms:
+ * - `scrypt` (default) — built into Node, no extra deps. Memory-
+ *   hard and CPU-hard. Recommended for new apps.
+ * - `argon2` (optional) — the @node-rs/argon2 package is the
+ *   reference implementation. Install it as a peer dep:
+ *
+ *     bun add @node-rs/argon2
+ *
+ *   When installed, the service auto-detects it.
+ *
+ * Output format (scrypt): a base64 string with the cost parameters
+ * encoded: `$scrypt$N=16384,r=8,p=1$<saltB64>$<hashB64>`.
+ * This is similar to the well-known `passlib` / PHC format and
+ * lets us verify hashes that were generated with different
+ * parameters.
+ */
+import type { HashConfig, HashOptions, HashedPassword } from "./types.js";
+export declare class HashService {
+    readonly algorithm: "scrypt" | "argon2";
+    private readonly scryptCost;
+    private readonly scryptBlockSize;
+    private readonly scryptParallelization;
+    private readonly scryptKeyLength;
+    private readonly argon2MemoryCost;
+    private readonly argon2TimeCost;
+    private readonly argon2Parallelism;
+    constructor(config?: HashConfig);
+    /**
+     * Hash a password. Returns a self-describing string that
+     * includes the algorithm and cost parameters.
+     */
+    hash(password: string, options?: HashOptions): Promise<HashedPassword>;
+    /**
+     * Verify a password against a previously generated hash.
+     * Returns `true` on match, `false` otherwise.
+     */
+    verify(hashed: HashedPassword, password: string): Promise<boolean>;
+    /**
+     * True if a hash was generated with parameters that are below
+     * the current security floor. The caller should re-hash and
+     * update the stored value.
+     */
+    needsRehash(hashed: HashedPassword): boolean;
+    private hashScrypt;
+    private verifyScrypt;
+    private hashArgon2;
+    private verifyArgon2;
+}
+//# sourceMappingURL=hash.d.ts.map

package/dist/crypto/hash.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hash.d.ts","sourceRoot":"","sources":["../../src/crypto/hash.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAoBH,OAAO,KAAK,EAAE,UAAU,EAAE,WAAW,EAAE,cAAc,EAAE,MAAM,YAAY,CAAC;AAK1E,qBAAa,WAAW;IACvB,QAAQ,CAAC,SAAS,EAAE,QAAQ,GAAG,QAAQ,CAAC;IACxC,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAS;IACpC,OAAO,CAAC,QAAQ,CAAC,eAAe,CAAS;IACzC,OAAO,CAAC,QAAQ,CAAC,qBAAqB,CAAS;IAC/C,OAAO,CAAC,QAAQ,CAAC,eAAe,CAAS;IACzC,OAAO,CAAC,QAAQ,CAAC,gBAAgB,CAAS;IAC1C,OAAO,CAAC,QAAQ,CAAC,cAAc,CAAS;IACxC,OAAO,CAAC,QAAQ,CAAC,iBAAiB,CAAS;gBAE/B,MAAM,GAAE,UAAe;IAWnC;;;OAGG;IACG,IAAI,CAAC,QAAQ,EAAE,MAAM,EAAE,OAAO,GAAE,WAAgB,GAAG,OAAO,CAAC,cAAc,CAAC;IAOhF;;;OAGG;IACG,MAAM,CAAC,MAAM,EAAE,cAAc,EAAE,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC;IASxE;;;;OAIG;IACH,WAAW,CAAC,MAAM,EAAE,cAAc,GAAG,OAAO;YAiB9B,UAAU;YAgBV,YAAY;YAoBZ,UAAU;YAUV,YAAY;CAQ1B"}

package/dist/crypto/index.d.ts

@@ -0,0 +1,49 @@
+/**
+ * `nexusjs/crypto` — encryption + password hashing.
+ *
+ * Public API:
+ * - `EncryptionService` — AES-256-GCM + HMAC sign/unsign.
+ * - `HashService`       — scrypt (default) or argon2 (optional).
+ * - `CryptoModule.forRoot({ key })` — wires both into the DI
+ *   container.
+ *
+ * Zero external dependencies. All primitives come from Node's
+ * built-in `crypto` module.
+ *
+ *   bun add nexus
+ *   # Optional (only if you use argon2):
+ *   bun add @node-rs/argon2
+ *
+ * Quick start:
+ *
+ *   import { Module } from "nexusjs";
+ *   import { CryptoModule, EncryptionService, HashService } from "nexusjs/crypto";
+ *
+ *   @Module({
+ *     imports: [CryptoModule.forRoot({ key: process.env.APP_KEY! })],
+ *   })
+ *   class AppModule {}
+ *
+ *   @Injectable()
+ *   class UserService {
+ *     constructor(
+ *       @Inject(EncryptionService.TOKEN) private enc: EncryptionService,
+ *       @Inject(HashService.TOKEN) private hash: HashService,
+ *     ) {}
+ *
+ *     async createUser(email: string, password: string) {
+ *       const passwordHash = await this.hash.hash(password);
+ *       const apiToken = this.enc.sign(email);
+ *       // ... store
+ *     }
+ *
+ *     async verifyPassword(plain: string, stored: string) {
+ *       return this.hash.verify(stored, plain);
+ *     }
+ *   }
+ */
+export { EncryptionService } from "./encryption.js";
+export { HashService } from "./hash.js";
+export { CryptoModule, ENCRYPTION_SERVICE_TOKEN, HASH_SERVICE_TOKEN } from "./module.js";
+export type { EncryptionConfig, EncryptOptions, HashConfig, HashOptions, HashAlgorithm, HmacConfig, EncryptedValue, SignedValue, HashedPassword, } from "./types.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/crypto/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/crypto/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2CG;AAEH,OAAO,EAAE,iBAAiB,EAAE,MAAM,iBAAiB,CAAC;AACpD,OAAO,EAAE,WAAW,EAAE,MAAM,WAAW,CAAC;AACxC,OAAO,EAAE,YAAY,EAAE,wBAAwB,EAAE,kBAAkB,EAAE,MAAM,aAAa,CAAC;AACzF,YAAY,EACX,gBAAgB,EAChB,cAAc,EACd,UAAU,EACV,WAAW,EACX,aAAa,EACb,UAAU,EACV,cAAc,EACd,WAAW,EACX,cAAc,GACd,MAAM,YAAY,CAAC"}

package/dist/crypto/index.js

@@ -0,0 +1,533 @@
+// @bun
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+function __accessProp(key) {
+  return this[key];
+}
+var __toCommonJS = (from) => {
+  var entry = (__moduleCache ??= new WeakMap).get(from), desc;
+  if (entry)
+    return entry;
+  entry = __defProp({}, "__esModule", { value: true });
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (var key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(entry, key))
+        __defProp(entry, key, {
+          get: __accessProp.bind(from, key),
+          enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+        });
+  }
+  __moduleCache.set(from, entry);
+  return entry;
+};
+var __moduleCache;
+var __returnValue = (v) => v;
+function __exportSetter(name, newValue) {
+  this[name] = __returnValue.bind(null, newValue);
+}
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: __exportSetter.bind(all, name)
+    });
+};
+var __legacyDecorateClassTS = function(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function")
+    r = Reflect.decorate(decorators, target, key, desc);
+  else
+    for (var i = decorators.length - 1;i >= 0; i--)
+      if (d = decorators[i])
+        r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __legacyDecorateParamTS = (index, decorator) => (target, key) => decorator(target, key, index);
+var __legacyMetadataTS = (k, v) => {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function")
+    return Reflect.metadata(k, v);
+};
+var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
+var __require = import.meta.require;
+
+// src/core/constants.ts
+var METADATA_KEY, PARAM_TYPES, HTTP_METHODS;
+var init_constants = __esm(() => {
+  METADATA_KEY = {
+    CONTROLLER: "nexus:controller",
+    INJECTABLE: "nexus:injectable",
+    REPOSITORY: "nexus:repository",
+    MODULE: "nexus:module",
+    ROUTES: "nexus:routes",
+    PARAMS: "nexus:params",
+    VALIDATE: "nexus:validate",
+    PARAMTYPES: "design:paramtypes",
+    TYPE: "design:type",
+    RETURNTYPE: "design:returntype",
+    INJECT: "nexus:inject"
+  };
+  PARAM_TYPES = {
+    REQUEST: 0,
+    RESPONSE: 1,
+    NEXT: 2,
+    BODY: 3,
+    QUERY: 4,
+    PARAM: 5,
+    HEADERS: 6,
+    CTX: 7,
+    USER: 8
+  };
+  HTTP_METHODS = [
+    "GET",
+    "POST",
+    "PUT",
+    "DELETE",
+    "PATCH",
+    "OPTIONS",
+    "HEAD"
+  ];
+});
+
+// src/crypto/encryption.ts
+import {
+  createCipheriv,
+  createDecipheriv,
+  createHmac,
+  hkdfSync,
+  randomBytes,
+  timingSafeEqual
+} from "crypto";
+var VERSION = "v1";
+var IV_BYTES = 12;
+var TAG_BYTES = 16;
+
+class EncryptionService {
+  aesKey;
+  hmacKey;
+  constructor(masterKey) {
+    const derived = deriveKeys(masterKey);
+    this.aesKey = derived.aes;
+    this.hmacKey = derived.hmac;
+  }
+  encrypt(value, options = {}) {
+    const iv = randomBytes(IV_BYTES);
+    const cipher = createCipheriv("aes-256-gcm", this.aesKey, iv);
+    const plaintext = Buffer.from(value, "utf8");
+    const ciphertext = Buffer.concat([cipher.update(plaintext), cipher.final()]);
+    const tag = cipher.getAuthTag();
+    const expiry = encodeExpiry(options.expiresAt);
+    const purposeBuf = Buffer.from(options.purpose ?? "", "utf8");
+    const mac = this.macOver([VERSION, iv, tag, ciphertext, expiry, purposeBuf]);
+    return [
+      VERSION,
+      b64(iv),
+      b64(tag),
+      b64(ciphertext),
+      b64(expiry),
+      b64(purposeBuf),
+      b64(mac)
+    ].join(".");
+  }
+  decrypt(payload) {
+    const parsed = parseV1(payload);
+    if (!parsed)
+      throw new Error("Encrypted payload is malformed");
+    const expectedMac = this.macOver([
+      VERSION,
+      parsed.iv,
+      parsed.tag,
+      parsed.ciphertext,
+      parsed.expiry,
+      parsed.purpose
+    ]);
+    if (!constantTimeEqual(expectedMac, parsed.mac)) {
+      throw new Error("Encrypted payload failed integrity check");
+    }
+    if (parsed.expiry.length > 0) {
+      const expiryMs = parseExpiry(parsed.expiry.toString("utf8"));
+      if (expiryMs > 0 && Date.now() > expiryMs) {
+        throw new Error("Encrypted payload has expired");
+      }
+    }
+    const decipher = createDecipheriv("aes-256-gcm", this.aesKey, parsed.iv);
+    decipher.setAuthTag(parsed.tag);
+    const plaintext = Buffer.concat([
+      decipher.update(parsed.ciphertext),
+      decipher.final()
+    ]);
+    return plaintext.toString("utf8");
+  }
+  isEncrypted(value) {
+    if (typeof value !== "string")
+      return false;
+    return value.startsWith(VERSION + ".");
+  }
+  sign(value, purpose = "") {
+    const mac = createHmac("sha256", this.hmacKey).update(purpose).update("|").update(value).digest();
+    return `${b64(Buffer.from(value, "utf8"))}.${b64(mac)}`;
+  }
+  signRaw(value, purpose = "") {
+    const mac = createHmac("sha256", this.hmacKey).update(purpose).update("|").update(value).digest();
+    return b64(mac);
+  }
+  verifyRaw(value, signature, purpose = "") {
+    const expected = createHmac("sha256", this.hmacKey).update(purpose).update("|").update(value).digest();
+    const given = fromB64(signature);
+    if (!given)
+      return false;
+    return constantTimeEqual(given, expected);
+  }
+  unsign(signed, purpose = "") {
+    const dot = signed.lastIndexOf(".");
+    if (dot < 1 || dot === signed.length - 1)
+      return null;
+    const valueB64 = signed.slice(0, dot);
+    const macB64 = signed.slice(dot + 1);
+    const value = fromB64(valueB64);
+    const mac = fromB64(macB64);
+    if (!value || !mac)
+      return null;
+    const expected = createHmac("sha256", this.hmacKey).update(purpose).update("|").update(value).digest();
+    if (!constantTimeEqual(mac, expected))
+      return null;
+    return value.toString("utf8");
+  }
+  macOver(parts) {
+    const h = createHmac("sha256", this.hmacKey);
+    for (const p of parts) {
+      h.update("|");
+      h.update(p);
+    }
+    return h.digest();
+  }
+}
+function b64(buf) {
+  return buf.toString("base64url");
+}
+function fromB64(s) {
+  try {
+    return Buffer.from(s, "base64url");
+  } catch {
+    return null;
+  }
+}
+function constantTimeEqual(a, b) {
+  if (a.length !== b.length)
+    return false;
+  return timingSafeEqual(a, b);
+}
+function encodeExpiry(expiresAt) {
+  if (expiresAt === undefined)
+    return Buffer.alloc(0);
+  let ms;
+  if (typeof expiresAt === "number") {
+    ms = expiresAt > 1000000000000 ? expiresAt : Date.now() + expiresAt * 1000;
+  } else if (typeof expiresAt === "string") {
+    const asNum = Number(expiresAt);
+    if (!isNaN(asNum) && asNum > 0) {
+      ms = asNum > 1000000000000 ? asNum : Date.now() + asNum * 1000;
+    } else {
+      ms = Date.parse(expiresAt);
+    }
+  } else {
+    ms = expiresAt.getTime();
+  }
+  if (!isFinite(ms))
+    return Buffer.alloc(0);
+  return Buffer.from(String(ms), "utf8");
+}
+function parseExpiry(s) {
+  const n = Number(s);
+  return isFinite(n) ? n : 0;
+}
+function parseV1(s) {
+  if (typeof s !== "string" || !s.startsWith(VERSION + "."))
+    return null;
+  const parts = s.split(".");
+  if (parts.length !== 7)
+    return null;
+  const [, ivB64, tagB64, ctB64, expB64, purposeB64, macB64] = parts;
+  const iv = fromB64(ivB64);
+  const tag = fromB64(tagB64);
+  const ct = fromB64(ctB64);
+  const exp = fromB64(expB64);
+  const purpose = fromB64(purposeB64);
+  const mac = fromB64(macB64);
+  if (!iv || !tag || !ct || !exp || !purpose || !mac)
+    return null;
+  if (iv.length !== IV_BYTES)
+    return null;
+  if (tag.length !== TAG_BYTES)
+    return null;
+  return { iv, tag, ciphertext: ct, expiry: exp, purpose, mac };
+}
+function deriveKeys(masterKey) {
+  let input;
+  try {
+    const decoded = Buffer.from(masterKey, "base64");
+    if (decoded.length >= 32 && masterKey.length % 4 === 0) {
+      input = decoded;
+    } else {
+      input = Buffer.from(masterKey, "utf8");
+    }
+  } catch {
+    input = Buffer.from(masterKey, "utf8");
+  }
+  const ikm = input.length < 32 ? padKey(input) : input;
+  const out = hkdfSync("sha256", ikm, Buffer.alloc(0), "nexus:crypto:v1", 64);
+  const outBuf = Buffer.from(out);
+  return {
+    aes: Buffer.from(outBuf.subarray(0, 32)),
+    hmac: Buffer.from(outBuf.subarray(32, 64))
+  };
+}
+function padKey(input) {
+  const hash = createHmac("sha256", "nexus:crypto:pad").update(input).digest();
+  const out = Buffer.alloc(32);
+  input.copy(out, 0, 0, Math.min(input.length, 32));
+  hash.copy(out, input.length < 32 ? input.length : 0, 0, 32 - Math.min(input.length, 32));
+  return out;
+}
+// src/crypto/hash.ts
+import { scrypt as scryptCb, randomBytes as randomBytes2, timingSafeEqual as timingSafeEqual2 } from "crypto";
+function scrypt(password, salt, keylen, options) {
+  return new Promise((resolve, reject) => {
+    scryptCb(password, salt, keylen, options, (err, derived) => {
+      if (err)
+        reject(err);
+      else
+        resolve(derived);
+    });
+  });
+}
+var PREFIX_SCRYPT = "$scrypt$";
+var PREFIX_ARGON2 = "$argon2";
+
+class HashService {
+  algorithm;
+  scryptCost;
+  scryptBlockSize;
+  scryptParallelization;
+  scryptKeyLength;
+  argon2MemoryCost;
+  argon2TimeCost;
+  argon2Parallelism;
+  constructor(config = {}) {
+    this.algorithm = config.algorithm ?? "scrypt";
+    this.scryptCost = config.scryptCost ?? 16384;
+    this.scryptBlockSize = config.scryptBlockSize ?? 8;
+    this.scryptParallelization = config.scryptParallelization ?? 1;
+    this.scryptKeyLength = config.scryptKeyLength ?? 64;
+    this.argon2MemoryCost = config.argon2MemoryCost ?? 65536;
+    this.argon2TimeCost = config.argon2TimeCost ?? 3;
+    this.argon2Parallelism = config.argon2Parallelism ?? 4;
+  }
+  async hash(password, options = {}) {
+    const algo = options.algorithm ?? this.algorithm;
+    if (algo === "scrypt")
+      return this.hashScrypt(password);
+    if (algo === "argon2")
+      return this.hashArgon2(password);
+    throw new Error(`Unknown hash algorithm: ${algo}`);
+  }
+  async verify(hashed, password) {
+    if (typeof hashed !== "string" || hashed.length === 0)
+      return false;
+    if (hashed.startsWith(PREFIX_SCRYPT))
+      return this.verifyScrypt(hashed, password);
+    if (hashed.startsWith(PREFIX_ARGON2))
+      return this.verifyArgon2(hashed, password);
+    return false;
+  }
+  needsRehash(hashed) {
+    if (typeof hashed !== "string" || !hashed.startsWith(PREFIX_SCRYPT)) {
+      return true;
+    }
+    const params = parseScryptParams(hashed);
+    if (!params)
+      return true;
+    if (params.N < this.scryptCost)
+      return true;
+    if (params.r < this.scryptBlockSize)
+      return true;
+    if (params.p < this.scryptParallelization)
+      return true;
+    if (params.keyLen < this.scryptKeyLength)
+      return true;
+    return false;
+  }
+  async hashScrypt(password) {
+    const salt = randomBytes2(16);
+    const derived = await scrypt(password, salt, this.scryptKeyLength, {
+      N: this.scryptCost,
+      r: this.scryptBlockSize,
+      p: this.scryptParallelization,
+      maxmem: 256 * 1024 * 1024
+    });
+    return [
+      PREFIX_SCRYPT,
+      `N=${this.scryptCost},r=${this.scryptBlockSize},p=${this.scryptParallelization},keyLen=${this.scryptKeyLength}`,
+      `$${salt.toString("base64url")}`,
+      `$${derived.toString("base64url")}`
+    ].join("");
+  }
+  async verifyScrypt(hashed, password) {
+    const params = parseScryptParams(hashed);
+    if (!params)
+      return false;
+    const [, , , saltB64, hashB64] = hashed.split("$");
+    if (!saltB64 || !hashB64)
+      return false;
+    const salt = Buffer.from(saltB64, "base64url");
+    const expected = Buffer.from(hashB64, "base64url");
+    const derived = await scrypt(password, salt, expected.length, {
+      N: params.N,
+      r: params.r,
+      p: params.p,
+      maxmem: 256 * 1024 * 1024
+    });
+    if (derived.length !== expected.length)
+      return false;
+    return timingSafeEqual2(derived, expected);
+  }
+  async hashArgon2(password) {
+    const mod = await loadArgon2();
+    const hash = await mod.hash(password, {
+      memoryCost: this.argon2MemoryCost,
+      timeCost: this.argon2TimeCost,
+      parallelism: this.argon2Parallelism
+    });
+    return hash;
+  }
+  async verifyArgon2(hashed, password) {
+    const mod = await loadArgon2();
+    try {
+      return await mod.verify(hashed, password);
+    } catch {
+      return false;
+    }
+  }
+}
+function parseScryptParams(hashed) {
+  const parts = hashed.split("$");
+  if (parts.length !== 5)
+    return null;
+  const paramsPart = parts[2];
+  if (!paramsPart)
+    return null;
+  const m = {};
+  for (const kv of paramsPart.split(",")) {
+    const [k, v] = kv.split("=");
+    if (k && v)
+      m[k] = Number(v);
+  }
+  if (!m.N || !m.r || !m.p || !m.keyLen)
+    return null;
+  return { N: m.N, r: m.r, p: m.p, keyLen: m.keyLen };
+}
+var _argon2;
+async function loadArgon2() {
+  if (_argon2 !== undefined) {
+    if (_argon2 === null) {
+      throw new Error("argon2 is not installed. Install with: bun add @node-rs/argon2");
+    }
+    return _argon2;
+  }
+  try {
+    const mod = await import("@node-rs/argon2");
+    _argon2 = mod.default ?? mod;
+    if (!_argon2)
+      throw new Error("invalid argon2 module");
+    return _argon2;
+  } catch {
+    _argon2 = null;
+    throw new Error("argon2 is not installed. Install with: bun add @node-rs/argon2");
+  }
+}
+// src/core/decorators/module.ts
+init_constants();
+import"reflect-metadata";
+function Module(options = {}) {
+  return (target) => {
+    Reflect.defineMetadata(METADATA_KEY.MODULE, options, target);
+  };
+}
+function getModuleOptions(target) {
+  return Reflect.getMetadata(METADATA_KEY.MODULE, target) ?? {};
+}
+
+// src/crypto/module.ts
+var ENCRYPTION_SERVICE_TOKEN = Symbol.for("nexus:EncryptionService");
+var HASH_SERVICE_TOKEN = Symbol.for("nexus:HashService");
+
+class CryptoModule {
+  static forRoot(config = { key: "" }) {
+    const fullEncryptionConfig = {
+      key: config.key,
+      algorithm: config.algorithm ?? "aes-256-gcm",
+      defaultExpiresIn: config.defaultExpiresIn
+    };
+    const fullHashConfig = config.hash ?? {};
+
+    class ConfiguredCryptoModule {
+    }
+    ConfiguredCryptoModule = __legacyDecorateClassTS([
+      Module({
+        providers: [
+          { provide: "ENCRYPTION_CONFIG", useValue: fullEncryptionConfig },
+          { provide: "HASH_CONFIG", useValue: fullHashConfig },
+          {
+            provide: EncryptionService,
+            useFactory: () => new EncryptionService(fullEncryptionConfig.key)
+          },
+          {
+            provide: HashService,
+            useFactory: () => new HashService(fullHashConfig)
+          },
+          { provide: ENCRYPTION_SERVICE_TOKEN, useExisting: EncryptionService },
+          { provide: HASH_SERVICE_TOKEN, useExisting: HashService }
+        ],
+        exports: [
+          EncryptionService,
+          HashService,
+          ENCRYPTION_SERVICE_TOKEN,
+          HASH_SERVICE_TOKEN
+        ]
+      })
+    ], ConfiguredCryptoModule);
+    Object.defineProperty(ConfiguredCryptoModule, "name", {
+      value: "ConfiguredCryptoModule"
+    });
+    return ConfiguredCryptoModule;
+  }
+}
+CryptoModule = __legacyDecorateClassTS([
+  Module({
+    providers: [
+      EncryptionService,
+      HashService,
+      { provide: ENCRYPTION_SERVICE_TOKEN, useExisting: EncryptionService },
+      { provide: HASH_SERVICE_TOKEN, useExisting: HashService }
+    ],
+    exports: [
+      EncryptionService,
+      HashService,
+      ENCRYPTION_SERVICE_TOKEN,
+      HASH_SERVICE_TOKEN
+    ]
+  })
+], CryptoModule);
+export {
+  HashService,
+  HASH_SERVICE_TOKEN,
+  EncryptionService,
+  ENCRYPTION_SERVICE_TOKEN,
+  CryptoModule
+};
+
+//# debugId=8C681A43289D389864756E2164756E21
+//# sourceMappingURL=index.js.map