key-rotation-manager 1.0.10 → 1.1.1

package/README.md

@@ -521,13 +521,13 @@ const cloned = original.clone({
 
 ## 📖 API Reference
 
-### `create(options?, only?)`
+### `create(options?, singleton?)`
 
 Creates a new KeyManager instance.
 
 **Parameters:**
 - `options` (optional): Partial `TModuleOptions`
-- `only` (optional): `boolean` - If `false`, returns a singleton instance
+- `singleton` (optional): `boolean` - If `true`, returns a shared singleton instance (default: `false`)
 
 **Returns:** `KM` instance
 
@@ -535,7 +535,7 @@ Creates a new KeyManager instance.
 ```typescript
 const km = create({ versionGenerator: () => 'v1' });
 // or
-const km = create({}, false); // Singleton instance
+const km = create({}, true); // Singleton instance
 ```
 
 ### `newKey(options, variables?)`
@@ -615,7 +615,8 @@ Sets a single hook.
 
 See the full changelog for each version:
 
-- **[v1.0.10](./changelogs/1.0.10.md)** - Hooks system, enhanced gitIgnore configuration
+- **[v1.1.1](https://github.com/DucAnh2611/key-rotation-manager/tree/master/changelogs/1.1.1.md)** - Native crypto, zero dependencies, bug fixes
+- **[v1.0.10](https://github.com/DucAnh2611/key-rotation-manager/tree/master/changelogs/1.0.10.md)** - Hooks system, enhanced gitIgnore configuration
 
 ---
 
@@ -648,7 +649,7 @@ Contributions are welcome! Please feel free to submit a Pull Request.
 
 ## 📄 License
 
-This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.
+This project is licensed under the MIT License - see the [LICENSE](https://github.com/DucAnh2611/key-rotation-manager/blob/master/LICENSE) file for details.
 
 ---
 

package/dist/index.cjs

@@ -1,14 +1,13 @@
 'use strict';
 
-var EventEmitter = require('events');
 var promises = require('fs/promises');
 var path = require('path');
-var CryptoJS = require('crypto-js');
+var crypto = require('crypto');
+var EventEmitter = require('events');
 
 function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
 
 var EventEmitter__default = /*#__PURE__*/_interopDefault(EventEmitter);
-var CryptoJS__default = /*#__PURE__*/_interopDefault(CryptoJS);
 
 // src/constants/default.constant.ts
 var DEFAULT_CRYPTO_OPTIONS = {
@@ -59,99 +58,6 @@ var EEvent = /* @__PURE__ */ ((EEvent2) => {
   return EEvent2;
 })(EEvent || {});
 
-// src/types/module.types.ts
-var EError = /* @__PURE__ */ ((EError2) => {
-  return EError2;
-})(EError || {});
-
-// src/core/base.core.ts
-var Base = class {
-  logger;
-  bOptions;
-  hooks = /* @__PURE__ */ new Map();
-  constructor(options) {
-    this.bOptions = { ...DEFAULT_BASE_OPTIONS, ...options };
-    this.logger = DEFAULT_BASE_LOGGER;
-  }
-  getLogger() {
-    return this.logger;
-  }
-  setLogger(logger) {
-    this.logger = logger;
-    return this;
-  }
-  async sysLog(...args) {
-    if (!this.bOptions.quiet) await this.logger(...args);
-    return this;
-  }
-  async customLog(logger, ...args) {
-    await logger(...args);
-    return this;
-  }
-  setHooks(hooks) {
-    Object.entries(hooks).forEach(([name, handler]) => {
-      if (this.hooks.has(name)) {
-        this.hooks.get("onHookOverriding")?.call(this, name);
-      }
-      this.hooks.set(name, handler);
-    });
-    return this;
-  }
-  runHook(name, ...args) {
-    if (!this.hooks.has(name)) {
-      this.hooks.get("onHookNotFound")?.call(this, name);
-      return void 0;
-    }
-    return this.hooks.get(name).call(this, ...args);
-  }
-  getHooks() {
-    return Object.fromEntries(this.hooks.entries());
-  }
-};
-
-// src/core/events.core.ts
-var Events = class extends Base {
-  events;
-  eOptions;
-  constructor(options) {
-    super(options);
-    this.eOptions = {
-      ...DEFAULT_EVENTS_OPTIONS,
-      ...options
-    };
-    if (this.eOptions.useEvent) {
-      this.events = new EventEmitter__default.default();
-    }
-  }
-  emit(event, args) {
-    if (!this.events) return this;
-    this.events.emit(event, args);
-    return this;
-  }
-  on(event, listener) {
-    if (!this.events) return this;
-    this.events.on(event, listener);
-    return this;
-  }
-  once(event, listener) {
-    if (!this.events) return this;
-    this.events.once(event, listener);
-    return this;
-  }
-  off(event, listener) {
-    if (!this.events) return this;
-    this.events.off(event, listener);
-    return this;
-  }
-};
-
-// src/core/config-events.core.ts
-var ConfigEvents = class extends Events {
-  constructor(options) {
-    super(options);
-  }
-};
-
 // src/utils/promise.util.ts
 var executePromisably = (promiseOrFn) => {
   try {
@@ -161,35 +67,45 @@ var executePromisably = (promiseOrFn) => {
     return Promise.reject(error);
   }
 };
+var FileUtilError = class extends Error {
+  constructor(message, path, operation, cause) {
+    super(message);
+    this.path = path;
+    this.operation = operation;
+    this.cause = cause;
+    this.name = "FileUtilError";
+  }
+};
 var FileUtil = class {
   async getFolder(path) {
     try {
+      await promises.access(path);
+      return path;
+    } catch {
       try {
-        await promises.access(path);
-      } catch {
         await promises.mkdir(path, { recursive: true });
+        return path;
+      } catch (error) {
+        throw new FileUtilError(`Failed to create folder: ${path}`, path, "mkdir", error);
       }
-      return path;
-    } catch {
-      throw new Error(`Failed to get folder: ${path}`);
     }
   }
-  async read(path, fallback = "") {
+  async read(path, fallback) {
     try {
       const data = await promises.readFile(path, { encoding: "utf8" });
       return data;
     } catch (error) {
-      if (fallback) return fallback;
-      throw error;
+      if (fallback !== void 0) return fallback;
+      throw new FileUtilError(`Failed to read file: ${path}`, path, "read", error);
     }
   }
   async write(path$1, data, flag = "w") {
+    const dir = path.dirname(path$1);
+    await this.getFolder(dir);
     try {
-      const dir = path.dirname(path$1);
-      await this.getFolder(dir);
       await promises.writeFile(path$1, data, { encoding: "utf8", flag });
     } catch (error) {
-      throw new Error(`Failed to write file: ${path$1}`);
+      throw new FileUtilError(`Failed to write file: ${path$1}`, path$1, "write", error);
     }
   }
   async checkExists(path) {
@@ -197,14 +113,14 @@ var FileUtil = class {
       await promises.access(path);
       return true;
     } catch {
-      throw new Error(`Failed to check existence of file: ${path}`);
+      return false;
     }
   }
   async delete(path) {
     try {
       await promises.unlink(path);
-    } catch {
-      throw new Error(`Failed to delete file: ${path}`);
+    } catch (error) {
+      throw new FileUtilError(`Failed to delete file: ${path}`, path, "delete", error);
     }
   }
 };
@@ -268,7 +184,7 @@ var isType = (data) => {
   return {
     number: typeof data === "number" && !Number.isNaN(Number(data)),
     string: typeof data === "string",
-    stringNumber: typeof data === "string" && !Number.isNaN(Number(data)) || typeof data === "number",
+    stringNumber: typeof data === "string" || typeof data === "number",
     boolean: typeof data === "boolean",
     null: data === null,
     undefined: data === void 0
@@ -279,97 +195,77 @@ var CryptoService = class {
   constructor(options = {}) {
     this.options = { ...DEFAULT_CRYPTO_OPTIONS, ...options };
   }
-  generateRandomWordArray(length) {
-    return CryptoJS__default.default.lib.WordArray.random(length);
-  }
+  /**
+   * Generate random bytes and encode them
+   */
   generateRandom(length = 32) {
-    const wordArray = this.generateRandomWordArray(length);
-    return this.encode(wordArray);
+    const buffer = crypto.randomBytes(length);
+    return this.encodeBuffer(buffer);
   }
-  /*
+  /**
    * Generate a random key
-   * @param length Length of the key
+   * @param length Length of the key in bytes
    * @default cryptoOptions.keyLength
-   * @returns { key: string, length: number }
    */
   generateKey(length = this.options.keyLength) {
     return { key: this.generateRandom(length), length };
   }
-  /*
+  /**
    * Generate a random salt
-   * @param length Length of the salt
+   * @param length Length of the salt in bytes
    * @default cryptoOptions.saltLength
-   * @returns { salt: string, length: number }
    */
   generateSalt(length = this.options.saltLength) {
     return { salt: this.generateRandom(length), length };
   }
-  /*
+  /**
    * Generate a random IV
-   * @param length Length of the IV
+   * @param length Length of the IV in bytes
    * @default cryptoOptions.ivLength
-   * @returns { iv: string, length: number }
    */
   generateIV(length = this.options.ivLength) {
     return { iv: this.generateRandom(length), length };
   }
-  encode(wordArray) {
+  encodeBuffer(buffer) {
     switch (this.options.encoding) {
       case "hex":
-        return wordArray.toString(CryptoJS__default.default.enc.Hex);
+        return buffer.toString("hex");
       case "base64url":
-        return wordArray.toString(CryptoJS__default.default.enc.Base64).replace(/\+/g, "-").replace(/\//g, "_").replace(/=/g, "");
+        return buffer.toString("base64url");
       case "base64":
       default:
-        return wordArray.toString(CryptoJS__default.default.enc.Base64);
+        return buffer.toString("base64");
     }
   }
-  decode(encoded) {
+  decodeToBuffer(encoded) {
     switch (this.options.encoding) {
       case "hex":
-        return CryptoJS__default.default.enc.Hex.parse(encoded);
+        return Buffer.from(encoded, "hex");
       case "base64url":
-        const base64 = encoded.replace(/-/g, "+").replace(/_/g, "/");
-        const padding = "=".repeat((4 - base64.length % 4) % 4);
-        return CryptoJS__default.default.enc.Base64.parse(base64 + padding);
+        return Buffer.from(encoded, "base64url");
       case "base64":
       default:
-        return CryptoJS__default.default.enc.Base64.parse(encoded);
+        return Buffer.from(encoded, "base64");
     }
   }
   deriveKey(password, salt, keyLength) {
     if (this.options.kdf === "none") {
-      return CryptoJS__default.default.enc.Hex.parse(password);
+      return Buffer.from(password, "hex");
     }
     const actualKeyLength = keyLength ?? this.options.keyLength;
-    const keySize = actualKeyLength / 4;
-    return CryptoJS__default.default.PBKDF2(password, salt, {
-      keySize,
-      iterations: this.options.iterations,
-      hasher: this.getHasher()
-    });
-  }
-  getHasher() {
-    switch (this.options.hashAlgorithm) {
-      case "sha512":
-        return CryptoJS__default.default.algo.SHA512;
-      case "sha384":
-        return CryptoJS__default.default.algo.SHA384;
-      case "sha256":
-      default:
-        return CryptoJS__default.default.algo.SHA256;
-    }
-  }
-  getAESMode() {
-    return CryptoJS__default.default.mode.CBC;
-  }
-  getPadding() {
-    return CryptoJS__default.default.pad.Pkcs7;
+    return crypto.pbkdf2Sync(
+      password,
+      salt,
+      this.options.iterations,
+      actualKeyLength,
+      this.options.hashAlgorithm
+    );
   }
   /**
-   * Encrypt data
+   * Encrypt data using AES-CBC
    * @param plainText Text to encrypt
-   * @param secret Secret key for encryption Key length, salt, and IV will be randomly generated within configured range
+   * @param secret Secret key for encryption
+   * @param options Optional lengths for key, salt, and IV
    */
   encrypt(plainText, secret, {
     keyLength,
@@ -379,61 +275,48 @@ var CryptoService = class {
     keyLength = keyLength ?? this.options.keyLength;
     saltLength = saltLength ?? this.options.saltLength;
     ivLength = ivLength ?? this.options.ivLength;
-    const salt = this.options.kdf !== "none" ? this.generateRandomWordArray(saltLength) : CryptoJS__default.default.lib.WordArray.create();
-    const iv = this.generateRandomWordArray(ivLength);
+    const salt = this.options.kdf !== "none" ? crypto.randomBytes(saltLength) : Buffer.alloc(0);
+    const iv = crypto.randomBytes(ivLength);
     const key = this.deriveKey(secret, salt, keyLength);
-    const encrypted = CryptoJS__default.default.AES.encrypt(plainText, key, {
-      iv,
-      mode: this.getAESMode(),
-      padding: this.getPadding()
-    });
-    const actualSaltLength = salt.sigBytes;
-    const keyLengthHex = keyLength.toString(16).padStart(4, "0");
-    const saltLengthHex = actualSaltLength.toString(16).padStart(4, "0");
-    const ivLengthHex = ivLength.toString(16).padStart(4, "0");
-    const saltHex = salt.toString(CryptoJS__default.default.enc.Hex);
-    const ivHex = iv.toString(CryptoJS__default.default.enc.Hex);
-    const encryptedHex = encrypted.ciphertext.toString(CryptoJS__default.default.enc.Hex);
-    const combined = keyLengthHex + saltLengthHex + ivLengthHex + saltHex + ivHex + encryptedHex;
-    return this.encode(CryptoJS__default.default.enc.Hex.parse(combined));
+    const cipher = crypto.createCipheriv(this.options.algorithm, key, iv);
+    const encrypted = Buffer.concat([cipher.update(plainText, "utf8"), cipher.final()]);
+    const keyLengthBuf = Buffer.alloc(2);
+    keyLengthBuf.writeUInt16BE(keyLength);
+    const saltLengthBuf = Buffer.alloc(2);
+    saltLengthBuf.writeUInt16BE(salt.length);
+    const ivLengthBuf = Buffer.alloc(2);
+    ivLengthBuf.writeUInt16BE(ivLength);
+    const combined = Buffer.concat([keyLengthBuf, saltLengthBuf, ivLengthBuf, salt, iv, encrypted]);
+    return this.encodeBuffer(combined);
   }
   /**
    * Decrypt data
    * @param encryptedData Encrypted data to decrypt
    * @param secret Secret key for decryption
+   * @returns Decrypted string, or empty string if decryption fails (wrong password/corrupted data)
    */
   decrypt(encryptedData, secret) {
-    const combined = this.decode(encryptedData);
-    const combinedHex = combined.toString(CryptoJS__default.default.enc.Hex);
-    let offset = 0;
-    const keyLengthHex = combinedHex.substring(offset, offset + 4);
-    offset += 4;
-    const saltLengthHex = combinedHex.substring(offset, offset + 4);
-    offset += 4;
-    const ivLengthHex = combinedHex.substring(offset, offset + 4);
-    offset += 4;
-    const keyLength = parseInt(keyLengthHex, 16);
-    const saltLength = parseInt(saltLengthHex, 16);
-    const ivLength = parseInt(ivLengthHex, 16);
-    const saltHexLength = saltLength * 2;
-    const ivHexLength = ivLength * 2;
-    const saltHex = saltHexLength > 0 ? combinedHex.substring(offset, offset + saltHexLength) : "";
-    offset += saltHexLength;
-    const ivHex = combinedHex.substring(offset, offset + ivHexLength);
-    offset += ivHexLength;
-    const encryptedHex = combinedHex.substring(offset);
-    const salt = saltHex ? CryptoJS__default.default.enc.Hex.parse(saltHex) : CryptoJS__default.default.lib.WordArray.create();
-    const iv = CryptoJS__default.default.enc.Hex.parse(ivHex);
-    const encrypted = CryptoJS__default.default.lib.CipherParams.create({
-      ciphertext: CryptoJS__default.default.enc.Hex.parse(encryptedHex)
-    });
-    const key = this.deriveKey(secret, salt, keyLength);
-    const decrypted = CryptoJS__default.default.AES.decrypt(encrypted, key, {
-      iv,
-      mode: this.getAESMode(),
-      padding: this.getPadding()
-    });
-    return decrypted.toString(CryptoJS__default.default.enc.Utf8);
+    try {
+      const combined = this.decodeToBuffer(encryptedData);
+      let offset = 0;
+      const keyLength = combined.readUInt16BE(offset);
+      offset += 2;
+      const saltLength = combined.readUInt16BE(offset);
+      offset += 2;
+      const ivLength = combined.readUInt16BE(offset);
+      offset += 2;
+      const salt = combined.subarray(offset, offset + saltLength);
+      offset += saltLength;
+      const iv = combined.subarray(offset, offset + ivLength);
+      offset += ivLength;
+      const encrypted = combined.subarray(offset);
+      const key = this.deriveKey(secret, salt, keyLength);
+      const decipher = crypto.createDecipheriv(this.options.algorithm, key, iv);
+      const decrypted = Buffer.concat([decipher.update(encrypted), decipher.final()]);
+      return decrypted.toString("utf8");
+    } catch {
+      return "";
+    }
   }
   /**
    * Hash data (one-way)
@@ -442,19 +325,17 @@ var CryptoService = class {
    * @param salt Optional encoded salt string for deterministic hashing
    */
   hash(data, secret, salt) {
-    const secretWordArray = CryptoJS__default.default.enc.Utf8.parse(secret);
-    const hasher = this.getHasher();
-    let saltWordArray;
+    let saltBuffer;
     let saltStr;
     if (salt) {
-      saltWordArray = this.decode(salt);
+      saltBuffer = this.decodeToBuffer(salt);
       saltStr = salt;
     } else {
-      saltWordArray = this.generateRandomWordArray(this.options.saltLength);
-      saltStr = this.encode(saltWordArray);
+      saltBuffer = crypto.randomBytes(this.options.saltLength);
+      saltStr = this.encodeBuffer(saltBuffer);
     }
-    const hash = hasher.create().update(data).update(secretWordArray).update(saltWordArray).finalize();
-    const hashStr = this.encode(hash);
+    const hash = crypto.createHash(this.options.hashAlgorithm).update(data).update(secret).update(saltBuffer).digest();
+    const hashStr = this.encodeBuffer(hash);
     return `${saltStr}:${hashStr}`;
   }
   /**
@@ -468,15 +349,102 @@ var CryptoService = class {
     if (!saltStr || !expectedHashStr) {
       return false;
     }
-    const salt = this.decode(saltStr);
-    const secretWordArray = CryptoJS__default.default.enc.Utf8.parse(secret);
-    const hasher = this.getHasher();
-    const hash = hasher.create().update(data).update(secretWordArray).update(salt).finalize();
-    const hashStr = this.encode(hash);
+    const saltBuffer = this.decodeToBuffer(saltStr);
+    const hash = crypto.createHash(this.options.hashAlgorithm).update(data).update(secret).update(saltBuffer).digest();
+    const hashStr = this.encodeBuffer(hash);
     return hashStr === expectedHashStr;
   }
 };
-var Store = class extends ConfigEvents {
+
+// src/core/base.core.ts
+var Base = class {
+  logger;
+  bOptions;
+  hooks = /* @__PURE__ */ new Map();
+  constructor(options) {
+    this.bOptions = { ...DEFAULT_BASE_OPTIONS, ...options };
+    this.logger = DEFAULT_BASE_LOGGER;
+  }
+  getLogger() {
+    return this.logger;
+  }
+  setLogger(logger) {
+    this.logger = logger;
+    return this;
+  }
+  sysLog(...args) {
+    if (!this.bOptions.quiet) {
+      const result = this.logger(...args);
+      if (result && typeof result === "object" && "catch" in result) {
+        result.catch(() => {
+        });
+      }
+    }
+    return this;
+  }
+  async customLog(logger, ...args) {
+    await logger(...args);
+    return this;
+  }
+  setHooks(hooks) {
+    Object.entries(hooks).forEach(([name, handler]) => {
+      if (this.hooks.has(name)) {
+        this.hooks.get("onHookOverriding")?.call(this, name);
+      }
+      this.hooks.set(name, handler);
+    });
+    return this;
+  }
+  runHook(name, ...args) {
+    if (!this.hooks.has(name)) {
+      this.hooks.get("onHookNotFound")?.call(this, name);
+      return void 0;
+    }
+    return this.hooks.get(name).call(this, ...args);
+  }
+  getHooks() {
+    return Object.fromEntries(this.hooks.entries());
+  }
+};
+
+// src/core/events.core.ts
+var Events = class extends Base {
+  events;
+  eOptions;
+  constructor(options) {
+    super(options);
+    this.eOptions = {
+      ...DEFAULT_EVENTS_OPTIONS,
+      ...options
+    };
+    if (this.eOptions.useEvent) {
+      this.events = new EventEmitter__default.default();
+    }
+  }
+  emit(event, args) {
+    if (!this.events) return this;
+    this.events.emit(event, args);
+    return this;
+  }
+  on(event, listener) {
+    if (!this.events) return this;
+    this.events.on(event, listener);
+    return this;
+  }
+  once(event, listener) {
+    if (!this.events) return this;
+    this.events.once(event, listener);
+    return this;
+  }
+  off(event, listener) {
+    if (!this.events) return this;
+    this.events.off(event, listener);
+    return this;
+  }
+};
+
+// src/core/store.core.ts
+var Store = class extends Events {
   sOptions;
   fileUtil;
   storePath;
@@ -663,21 +631,21 @@ var KeyManager = class extends Store {
    *   console.log('Key was rotated from version:', expired.version);
    * }
    *
-   * // Use expired.originKey ?? ready.originKey safely
+   * // Use expired?.key ?? ready?.key safely
    * ```
    */
   async getKey(options) {
     const { path, version } = options;
     const key = await this.getKeyByStore(path, String(version));
     if (!key) {
-      await this.runKeyHook("onKeyNotFound", path, version);
+      this.runKeyHook("onKeyNotFound", path, version);
       this.sysLog(`Key not found!`, { path, version });
       return { expired: null, ready: null };
     }
     const { ok, message, isExpired, isRenewable, errorOn } = this.validateKey(key);
     if (!ok && isExpired && isRenewable && key) {
       if (!options.onRotate) {
-        await this.runKeyHook("onKeyMissingRotateOption", key, options);
+        this.runKeyHook("onKeyMissingRotateOption", key, options);
         this.sysLog(`Key missing rotate option!`, { path, version });
         return { expired: null, ready: null };
       }
@@ -686,17 +654,17 @@ var KeyManager = class extends Store {
         ...options.onRotate
       });
       const resGetKey = { expired: key, ready: renew.key };
-      await this.runKeyHook("onKeyRenewed", resGetKey, options);
+      this.runKeyHook("onKeyRenewed", resGetKey, options);
       this.sysLog(`Key renewed!`, { path, version });
       return resGetKey;
     }
     if (!ok && isExpired && !isRenewable && key) {
-      await this.runKeyHook("onKeyExpired", path, key);
+      this.runKeyHook("onKeyExpired", path, key);
       this.sysLog(`Key expired!`, { path, version });
       return { expired: key, ready: null };
     }
     if (!ok) {
-      await this.runKeyHook("onKeyInvalid", key, message, errorOn);
+      this.runKeyHook("onKeyInvalid", key, message, errorOn);
       this.sysLog(`Key invalid!`, { path, version });
       return { expired: null, ready: null };
     }
@@ -743,7 +711,7 @@ var KeyManager = class extends Store {
     const { rotate, duration, type, unit, merge, keyLength } = options;
     const { key, length: kLength } = this.cryptoService.generateKey(keyLength);
     const { salt } = this.cryptoService.generateSalt();
-    await this.sysLog(`Key generated
+    this.sysLog(`Key generated
 Options:`, options);
     const hashedKey = this.cryptoService.hash(key, salt);
     const now = /* @__PURE__ */ new Date();
@@ -758,7 +726,7 @@ Options:`, options);
       rotate: !!rotate
     };
     const path = await this.saveKeyToStore(keyGenerated, !!merge, variables);
-    await this.sysLog(`Key saved!`, {
+    this.sysLog(`Key saved!`, {
       path,
       version: keyGenerated.version,
       type: keyGenerated.type
@@ -788,7 +756,7 @@ Options:`, options);
       hashed: "string",
       rotate: "boolean",
       type: "string",
-      version: "string",
+      version: "stringNumber",
       hashedBytes: "number"
     };
     for (const [field, type] of Object.entries(typeChecks)) {
@@ -883,8 +851,8 @@ var KM = class _KM extends KeyManager {
 
 // src/index.ts
 var instance = null;
-var create = (options = {}, only = true) => {
-  if (only) return new KM(options);
+var create = (options = {}, singleton = false) => {
+  if (!singleton) return new KM(options);
   if (!instance) {
     instance = new KM(options);
   }
@@ -892,7 +860,6 @@ var create = (options = {}, only = true) => {
 };
 var km = create;
 
-exports.EError = EError;
 exports.EEvent = EEvent;
 exports.create = create;
 exports.km = km;