@digitaldefiance/node-ecies-lib 1.1.21 → 1.1.22

package/src/services/ecies/utilities.ts

@@ -0,0 +1,111 @@
+import {
+  EciesEncryptionType,
+  ECIESError,
+  ECIESErrorTypeEnum,
+  IECIESConfig,
+} from '@digitaldefiance/ecies-lib';
+import { createEciesTranslationEngine } from '../../i18n/ecies-i18n-factory';
+import { ECIESService } from './service';
+import { getNodeRuntimeConfiguration } from '../../constants';
+
+/**
+ * Utility functions for ECIES operations
+ */
+export class EciesUtilities {
+  /**
+   * Computes the encrypted length from the data length.
+   * @param dataLength - The length of the data.
+   * @param encryptionMode - The encryption mode (simple, single, multiple).
+   * @param recipientCount - The number of recipients for multiple encryption mode.
+   * @returns The encrypted length details.
+   */
+  public computeEncryptedLengthFromDataLength(
+    dataLength: number,
+    encryptionMode: EciesEncryptionType,
+    recipientCount?: number,
+  ): number {
+    if (dataLength < 0) {
+      throw new ECIESError(
+        ECIESErrorTypeEnum.InvalidDataLength,
+        createEciesTranslationEngine(),
+      );
+    }
+    const runtimeDefaults = getNodeRuntimeConfiguration();
+    const eciesDefaults = runtimeDefaults.ECIES;
+    const config: IECIESConfig = {
+      curveName: eciesDefaults.CURVE_NAME,
+      primaryKeyDerivationPath: eciesDefaults.PRIMARY_KEY_DERIVATION_PATH,
+      mnemonicStrength: eciesDefaults.MNEMONIC_STRENGTH,
+      symmetricAlgorithm: eciesDefaults.SYMMETRIC_ALGORITHM_CONFIGURATION,
+      symmetricKeyBits: eciesDefaults.SYMMETRIC.KEY_BITS,
+      symmetricKeyMode: eciesDefaults.SYMMETRIC.MODE,
+    };
+    const engine = createEciesTranslationEngine();
+    const eciesService: ECIESService = new ECIESService(
+      engine,
+      config,
+      eciesDefaults,
+    );
+    switch (encryptionMode) {
+      case 'simple':
+        // type (1) + public key (65) + IV (16) + auth tag (16) = 98
+        return dataLength + eciesDefaults.SIMPLE.FIXED_OVERHEAD_SIZE;
+      case 'single':
+        // type (1) + public key (65) + IV (16) + auth tag (16) + data length (4) + crc16 (2) = 104
+        return dataLength + eciesDefaults.SINGLE.FIXED_OVERHEAD_SIZE;
+      case 'multiple':
+        return (
+          dataLength +
+          eciesService.calculateECIESMultipleRecipientOverhead(
+            recipientCount ?? 1,
+            true,
+          )
+        );
+      default:
+        throw new ECIESError(
+          ECIESErrorTypeEnum.InvalidEncryptionType,
+          createEciesTranslationEngine(),
+        );
+    }
+  }
+
+  /**
+   * Computes the decrypted length from the encrypted data length.
+   * @param encryptedDataLength - The length of the encrypted data.
+   * @param padding - Optional padding value.
+   * @returns The decrypted length.
+   */
+  public computeDecryptedLengthFromEncryptedDataLength(
+    encryptedDataLength: number,
+    padding?: number,
+  ): number {
+    if (encryptedDataLength < 0) {
+      throw new ECIESError(
+        ECIESErrorTypeEnum.InvalidEncryptedDataLength,
+        createEciesTranslationEngine(),
+      );
+    }
+
+    const { ECIES: eciesDefaults } = getNodeRuntimeConfiguration();
+    const overhead = eciesDefaults.SINGLE.FIXED_OVERHEAD_SIZE;
+    const actualPadding = padding !== undefined ? padding : 0;
+
+    const decryptedLength = encryptedDataLength - overhead - actualPadding;
+    if (decryptedLength < 0) {
+      throw new ECIESError(
+        ECIESErrorTypeEnum.InvalidEncryptedDataLength,
+        createEciesTranslationEngine(),
+        undefined,
+        undefined,
+        {
+          encryptedDataLength: String(encryptedDataLength),
+          overhead: String(overhead),
+          padding: String(actualPadding),
+          computedLength: String(decryptedLength),
+        },
+      );
+    }
+
+    return decryptedLength;
+  }
+}

package/src/services/index.ts

@@ -0,0 +1,3 @@
+export * from './aes-gcm';
+export * from './ecies';
+export * from './pbkdf2';

package/src/services/pbkdf2.ts

@@ -0,0 +1,307 @@
+import { PluginI18nEngine, CoreLanguageCode } from '@digitaldefiance/i18n-lib';
+import { EciesStringKey, EciesComponentId } from '@digitaldefiance/ecies-lib';
+import {
+  IPbkdf2Config,
+  IPBkdf2Consts,
+  Pbkdf2ErrorType,
+} from '@digitaldefiance/ecies-lib';
+import { pbkdf2 as pbkdf2Async, pbkdf2Sync, randomBytes } from 'crypto';
+import { promisify } from 'util';
+import { IConstants } from '../interfaces/constants';
+import { Pbkdf2ProfileEnum } from '../enumerations/pbkdf2-profile';
+import { getEciesPluginI18nEngine, getNodeEciesTranslation, NodeEciesStringKey, NodeEciesComponentId } from '../i18n/ecies-i18n-factory';
+import { IPbkdf2Result } from '../interfaces/pbkdf2-result';
+import { IECIESConsts } from '../interfaces/ecies-consts';
+import { Constants, getNodeRuntimeConfiguration } from '../constants';
+
+/**
+ * Custom PBKDF2 error class that works with the plugin i18n system
+ */
+export class NodePbkdf2Error extends Error {
+  constructor(message: string, public readonly type: Pbkdf2ErrorType) {
+    super(message);
+    this.name = 'NodePbkdf2Error';
+  }
+}
+
+/**
+ * Service for handling PBKDF2 (Password-Based Key Derivation Function 2) operations.
+ * This service provides functionality for:
+ * - Generating secure key derivation configurations
+ * - Deriving cryptographic keys from passwords
+ * - Managing salt and iteration parameters
+ * - Both synchronous and asynchronous key derivation
+ */
+export class Pbkdf2Service<TLanguage extends CoreLanguageCode = CoreLanguageCode> {
+  protected readonly engine: PluginI18nEngine<TLanguage>;
+  protected readonly profiles: Record<string, IPbkdf2Config>;
+  protected readonly eciesConsts: IECIESConsts;
+  protected readonly pbkdf2Consts: IPBkdf2Consts;
+  
+  constructor(
+    engine: PluginI18nEngine<TLanguage>,
+    profiles?: Record<string, IPbkdf2Config>,
+    eciesParams: IECIESConsts = Constants.ECIES,
+    pbkdf2Params: IPBkdf2Consts = Constants.PBKDF2,
+  ) {
+    this.engine = engine;
+    this.profiles = profiles ? { ...profiles } : {};
+    const runtimeDefaults = getNodeRuntimeConfiguration();
+    this.eciesConsts = eciesParams ?? runtimeDefaults.ECIES;
+    this.pbkdf2Consts =
+      pbkdf2Params ?? runtimeDefaults.PBKDF2;
+  }
+
+  /**
+   * Register a new PBKDF2 profile
+   * @param profileName The name of the profile
+   * @param config The configuration for the profile
+   */
+  public registerProfile(profileName: string, config: IPbkdf2Config): void {
+    this.profiles[profileName] = { ...config };
+  }
+
+  /**
+   * Get all registered profile names
+   * @returns Array of profile names
+   */
+  public getRegisteredProfiles(): string[] {
+    return Object.keys(this.profiles);
+  }
+
+  /**
+   * Check if a profile is registered
+   * @param profileName The name of the profile to check
+   * @returns True if the profile exists
+   */
+  public hasProfile(profileName: string): boolean {
+    return profileName in this.profiles;
+  }
+
+  /**
+   * Create a Pbkdf2Service instance from IConstants (for backward compatibility)
+   * @param constants The constants object
+   * @returns A new Pbkdf2Service instance
+   */
+  public static fromConstants(constants: IConstants): Pbkdf2Service {
+    const engine = getEciesPluginI18nEngine();
+    const runtimeDefaults = getNodeRuntimeConfiguration();
+    return new Pbkdf2Service(
+      engine,
+      constants.PBKDF2_PROFILES,
+      runtimeDefaults.ECIES,
+      constants.PBKDF2,
+    );
+  }
+  /**
+   * Get a predefined configuration profile for common use cases
+   * @param profile The name of the profile to use
+   * @returns Configuration object for the specified profile
+   */
+  public getProfileConfig(
+    profile: string,
+  ): IPbkdf2Config {
+    const profileConfig = this.profiles[profile];
+    if (!profileConfig) {
+      throw new NodePbkdf2Error(
+        getNodeEciesTranslation(NodeEciesStringKey.Error_Pbkdf2_InvalidSaltLength),
+        Pbkdf2ErrorType.InvalidProfile,
+      );
+    }
+    return {
+      hashBytes: profileConfig.hashBytes,
+      saltBytes: profileConfig.saltBytes,
+      iterations: profileConfig.iterations,
+      algorithm: profileConfig.algorithm,
+    };
+  }
+
+  /**
+   * Generate an options object for pbkdf2
+   * @param iterations Optional number of iterations (defaults to Pbkdf2IterationsPerSecond)
+   * @param saltBytes Optional salt size in bytes (defaults to PBKDF2.SALT_BYTES)
+   * @param hashBytes Optional hash size in bytes (defaults to ECIES.SYMMETRIC.KEY_SIZE)
+   * @param algorithm Optional hash algorithm (defaults to PBKDF2.ALGORITHM)
+   * @returns Configuration object for PBKDF2
+   */
+  public getConfig(
+    iterations?: number,
+    saltBytes?: number,
+    hashBytes?: number,
+    algorithm?: string,
+  ): IPbkdf2Config {
+    // larger numbers mean better security, less
+    return {
+      // size of the generated hash
+      hashBytes: hashBytes ?? this.eciesConsts.SYMMETRIC.KEY_SIZE,
+      // larger salt means hashed passwords are more resistant to rainbow table, but
+      // you get diminishing returns pretty fast
+      saltBytes: saltBytes ?? this.pbkdf2Consts.SALT_BYTES,
+      // more iterations means an attacker has to take longer to brute force an
+      // individual password, so larger is better. however, larger also means longer
+      // to hash the password. tune so that hashing the password takes about a
+      // second
+      iterations: iterations ?? this.pbkdf2Consts.ITERATIONS_PER_SECOND,
+      // hash algorithm
+      algorithm: algorithm ?? this.pbkdf2Consts.ALGORITHM,
+    };
+  }
+
+  /**
+   * Given a password, use pbkdf2 to generate an appropriately sized key for AES encryption
+   * @param password The password to derive a key from
+   * @param salt Optional salt (will be randomly generated if not provided)
+   * @param iterations Optional number of iterations
+   * @param saltBytes Optional salt size in bytes
+   * @param keySize Optional key size in bytes
+   * @param algorithm Optional hash algorithm
+   * @returns Object containing the derived key, salt, and iteration count
+   */
+  public deriveKeyFromPassword(
+    password: Buffer,
+    salt?: Buffer,
+    iterations?: number,
+    saltBytes?: number,
+    keySize?: number,
+    algorithm?: string,
+  ): IPbkdf2Result {
+    const config = this.getConfig(
+      iterations,
+      saltBytes,
+      keySize,
+      algorithm,
+    );
+    const saltBytes_ = salt ?? randomBytes(config.saltBytes);
+
+    if (saltBytes_.length !== config.saltBytes) {
+      throw new NodePbkdf2Error(
+        getNodeEciesTranslation(NodeEciesStringKey.Error_Pbkdf2_InvalidSaltLength),
+        Pbkdf2ErrorType.InvalidSaltLength,
+      );
+    }
+
+    const hashBytes = pbkdf2Sync(
+      password,
+      saltBytes_,
+      config.iterations,
+      config.hashBytes,
+      config.algorithm,
+    );
+
+    if (hashBytes.length !== config.hashBytes) {
+      throw new NodePbkdf2Error(
+        getNodeEciesTranslation(NodeEciesStringKey.Error_Pbkdf2_InvalidHashLength),
+        Pbkdf2ErrorType.InvalidHashLength,
+      );
+    }
+
+    return {
+      salt: saltBytes_,
+      hash: hashBytes,
+      iterations: config.iterations,
+    };
+  }
+
+  /**
+   * Async version of deriveKeyFromPassword that uses libuv threadpool via crypto.pbkdf2
+   * to avoid blocking the event loop during password verification.
+   * @param password The password to derive a key from
+   * @param salt Optional salt (will be randomly generated if not provided)
+   * @param iterations Optional number of iterations
+   * @param saltBytes Optional salt size in bytes
+   * @param keySize Optional key size in bytes
+   * @param algorithm Optional hash algorithm
+   * @returns Promise resolving to object containing the derived key, salt, and iteration count
+   */
+  public async deriveKeyFromPasswordAsync(
+    password: Buffer,
+    salt?: Buffer,
+    iterations?: number,
+    saltBytes?: number,
+    keySize?: number,
+    algorithm?: string,
+  ): Promise<IPbkdf2Result> {
+    const config = this.getConfig(
+      iterations,
+      saltBytes,
+      keySize,
+      algorithm,
+    );
+    const saltBytes_ = salt ?? randomBytes(config.saltBytes);
+
+    if (saltBytes_.length !== config.saltBytes) {
+      throw new NodePbkdf2Error(
+        getNodeEciesTranslation(NodeEciesStringKey.Error_Pbkdf2_InvalidSaltLength),
+        Pbkdf2ErrorType.InvalidSaltLength,
+      );
+    }
+
+    const pbkdf2 = promisify(pbkdf2Async);
+    const hashBytes = (await pbkdf2(
+      password,
+      saltBytes_,
+      config.iterations,
+      config.hashBytes,
+      config.algorithm,
+    )) as Buffer;
+
+    if (hashBytes.length !== config.hashBytes) {
+      throw new NodePbkdf2Error(
+        getNodeEciesTranslation(NodeEciesStringKey.Error_Pbkdf2_InvalidHashLength),
+        Pbkdf2ErrorType.InvalidHashLength,
+      );
+    }
+
+    return {
+      salt: saltBytes_,
+      hash: hashBytes,
+      iterations: config.iterations,
+    };
+  }
+
+  /**
+   * Derive a key using a predefined configuration profile
+   * @param password The password to derive a key from
+   * @param profile The configuration profile to use
+   * @param salt Optional salt (will be randomly generated if not provided)
+   * @returns Object containing the derived key, salt, and iteration count
+   */
+  public deriveKeyFromPasswordWithProfile(
+    password: Buffer,
+    profile: Pbkdf2ProfileEnum,
+    salt?: Buffer,
+  ): IPbkdf2Result {
+    const config = this.getProfileConfig(profile);
+    return this.deriveKeyFromPassword(
+      password,
+      salt,
+      config.iterations,
+      config.saltBytes,
+      config.hashBytes,
+      config.algorithm,
+    );
+  }
+
+  /**
+   * Async version of deriveKeyFromPasswordWithProfile
+   * @param password The password to derive a key from
+   * @param profile The configuration profile to use
+   * @param salt Optional salt (will be randomly generated if not provided)
+   * @returns Promise resolving to object containing the derived key, salt, and iteration count
+   */
+  public async deriveKeyFromPasswordWithProfileAsync(
+    password: Buffer,
+    profile: Pbkdf2ProfileEnum,
+    salt?: Buffer,
+  ): Promise<IPbkdf2Result> {
+    const config = this.getProfileConfig(profile);
+    return this.deriveKeyFromPasswordAsync(
+      password,
+      salt,
+      config.iterations,
+      config.saltBytes,
+      config.hashBytes,
+      config.algorithm,
+    );
+  }
+}

package/{dist/types.d.ts → src/types.ts}

@@ -5,21 +5,38 @@ import { ISigningKeyPrivateKeyInfo } from './interfaces/signing-key-private-key-
 import { ISimpleKeyPairBuffer } from './interfaces/simple-keypair-buffer';
 import { ISimplePublicKeyOnly } from './interfaces/simple-public-key-only';
 import { ISimplePublicKeyOnlyBuffer } from './interfaces/simple-public-key-only-buffer';
-export type KeyPairBufferWithUnEncryptedPrivateKey = Brand<IKeyPairBufferWithUnEncryptedPrivateKey, 'KeyPairBufferWithUnEncryptedPrivateKey'>;
-export type SigningKeyPrivateKeyInfo = Brand<ISigningKeyPrivateKeyInfo, 'SigningKeyPrivateKeyInfo'>;
+
+export type KeyPairBufferWithUnEncryptedPrivateKey = Brand<
+  IKeyPairBufferWithUnEncryptedPrivateKey,
+  'KeyPairBufferWithUnEncryptedPrivateKey'
+>;
+export type SigningKeyPrivateKeyInfo = Brand<
+  ISigningKeyPrivateKeyInfo,
+  'SigningKeyPrivateKeyInfo'
+>;
 export type SimpleKeyPair = Brand<SimplePublicKeyOnly, 'SimpleKeyPair'>;
-export type SimplePublicKeyOnly = Brand<ISimplePublicKeyOnly, 'SimplePublicKeyOnly'>;
-export type SimpleKeyPairBuffer = Brand<ISimpleKeyPairBuffer, 'SimpleKeyPairBuffer'>;
-export type SimplePublicKeyOnlyBuffer = Brand<ISimplePublicKeyOnlyBuffer, 'SimplePublicKeyOnlyBuffer'>;
+export type SimplePublicKeyOnly = Brand<
+  ISimplePublicKeyOnly,
+  'SimplePublicKeyOnly'
+>;
+export type SimpleKeyPairBuffer = Brand<
+  ISimpleKeyPairBuffer,
+  'SimpleKeyPairBuffer'
+>;
+export type SimplePublicKeyOnlyBuffer = Brand<
+  ISimplePublicKeyOnlyBuffer,
+  'SimplePublicKeyOnlyBuffer'
+>;
 export type SignatureString = Brand<HexString, 'SignatureString'>;
 export type SignatureBuffer = Buffer & Brand<Buffer, 'SignatureBuffer'>;
-export type ChecksumBuffer = Buffer & Brand<Buffer, 'Sha3Checksum', 'ChecksumBuffer'>;
+export type ChecksumBuffer = Buffer &
+  Brand<Buffer, 'Sha3Checksum', 'ChecksumBuffer'>;
 export type ChecksumString = Brand<HexString, 'Sha3Checksum', 'ChecksumString'>;
+
 /**
  * Extended Buffer type for data
  */
 export type DataBuffer = Buffer & {
-    toBuffer(): Buffer;
-    toHex(): string;
+  toBuffer(): Buffer;
+  toHex(): string;
 };
-//# sourceMappingURL=types.d.ts.map

package/src/utils.ts

@@ -0,0 +1,104 @@
+import {
+  getLengthEncodingTypeForLength,
+  getLengthEncodingTypeFromValue,
+  getLengthForLengthType,
+  LengthEncodingType,
+} from '@digitaldefiance/ecies-lib';
+import {
+  getEciesPluginI18nEngine,
+  getNodeEciesTranslation,
+  NodeEciesComponentId,
+  NodeEciesStringKey,
+} from './i18n/ecies-i18n-factory';
+
+/**
+ * Custom error class for length encoding errors
+ */
+class LengthEncodingError extends Error {
+  constructor(message: string) {
+    super(message);
+    this.name = 'LengthEncodingError';
+  }
+}
+
+/**
+ * Encodes the length of the data in the buffer
+ * @param buffer The buffer to encode
+ * @returns The encoded buffer
+ */
+export function lengthEncodeData(buffer: Buffer): Buffer {
+  const lengthType: LengthEncodingType = getLengthEncodingTypeForLength(
+    buffer.length,
+  );
+  const lengthTypeSize: number = getLengthForLengthType(lengthType);
+  const result: Buffer = Buffer.alloc(1 + lengthTypeSize + buffer.length);
+  result.writeUInt8(lengthType, 0);
+  switch (lengthType) {
+    case LengthEncodingType.UInt8:
+      result.writeUInt8(buffer.length, 1);
+      break;
+    case LengthEncodingType.UInt16:
+      result.writeUInt16BE(buffer.length, 1);
+      break;
+    case LengthEncodingType.UInt32:
+      result.writeUInt32BE(buffer.length, 1);
+      break;
+    case LengthEncodingType.UInt64:
+      result.writeBigUInt64BE(BigInt(buffer.length), 1);
+      break;
+  }
+  buffer.copy(result, 1 + lengthTypeSize);
+  return result;
+}
+
+export function decodeLengthEncodedData(buffer: Buffer): {
+  data: Buffer;
+  totalLength: number;
+} {
+  const pluginEngine = getEciesPluginI18nEngine();
+  if (buffer.length < 1) {
+    throw new RangeError(pluginEngine.translate(NodeEciesComponentId, NodeEciesStringKey.Error_BufferIsTooShort));
+  }
+  const lengthType: LengthEncodingType = getLengthEncodingTypeFromValue(
+    buffer.readUint8(0),
+  );
+  const lengthTypeSize: number = getLengthForLengthType(lengthType);
+
+  if (buffer.length < 1 + lengthTypeSize) {
+    throw new RangeError(pluginEngine.translate(NodeEciesComponentId, NodeEciesStringKey.Error_BufferIsTooShortToReadFullLengthValue));
+  }
+
+  let length: number | BigInt;
+  switch (lengthType) {
+    case LengthEncodingType.UInt8:
+      length = buffer.readUint8(1);
+      break;
+    case LengthEncodingType.UInt16:
+      length = buffer.readUint16BE(1);
+      break;
+    case LengthEncodingType.UInt32:
+      length = buffer.readUint32BE(1);
+      break;
+    case LengthEncodingType.UInt64:
+      length = buffer.readBigUInt64BE(1);
+      if (Number(length) > Number.MAX_SAFE_INTEGER) {
+        throw new RangeError(pluginEngine.translate(NodeEciesComponentId, NodeEciesStringKey.Error_LengthExceedsMaximumSafeInteger));
+      }
+      break;
+    default:
+      throw new LengthEncodingError(
+        getNodeEciesTranslation(
+          NodeEciesStringKey.Error_LengthError_LengthIsInvalidType,
+        ),
+      );
+  }
+
+  const totalLength = 1 + lengthTypeSize + Number(length);
+  if (totalLength > buffer.length) {
+    throw new RangeError(pluginEngine.translate(NodeEciesComponentId, NodeEciesStringKey.Error_BufferIsTooShortForDeclaredDataLength));
+  }
+  return {
+    data: buffer.subarray(1 + lengthTypeSize, totalLength),
+    totalLength,
+  };
+}

package/dist/constants.d.ts

@@ -1,32 +0,0 @@
-import { IPBkdf2Consts, getRuntimeConfiguration, registerRuntimeConfiguration } from '@digitaldefiance/ecies-lib';
-import { CipherGCMTypes } from 'crypto';
-import { IChecksumConsts } from './interfaces/checksum-consts';
-import { IConstants } from './interfaces/constants';
-import { IEncryptionConsts } from './interfaces/encryption-consts';
-import { IKeyringConsts } from './interfaces/keyring-consts';
-import { PbkdfProfiles } from './interfaces/pbkdf-profiles';
-import { IWrappedKeyConsts } from './interfaces/wrapped-key-consts';
-/**
- * Constants for checksum operations
- * These values are critical for data integrity and MUST NOT be changed
- * in an already established system as it will break all existing checksums.
- */
-export declare const NODE_RUNTIME_CONFIGURATION_KEY: unique symbol;
-type NodeRuntimeConfiguration = ReturnType<typeof getRuntimeConfiguration>;
-type NodeRuntimeOverrides = Parameters<typeof registerRuntimeConfiguration>[1];
-export declare const NODE_DEFAULTS_OVERRIDES: NodeRuntimeOverrides;
-export declare function getNodeRuntimeConfiguration(): NodeRuntimeConfiguration;
-export declare function registerNodeRuntimeConfiguration(configOrOverrides?: NodeRuntimeOverrides | NodeRuntimeConfiguration, options?: Parameters<typeof registerRuntimeConfiguration>[2]): NodeRuntimeConfiguration;
-export declare const CHECKSUM: IChecksumConsts;
-export declare const KEYRING: IKeyringConsts;
-export declare const PBKDF2: IPBkdf2Consts;
-export declare const PBKDF2_PROFILES: PbkdfProfiles;
-export declare const WRAPPED_KEY: IWrappedKeyConsts;
-export declare const KEYRING_ALGORITHM_CONFIGURATION: CipherGCMTypes;
-/**
- * Constants for encrypted data
- */
-export declare const ENCRYPTION: IEncryptionConsts;
-export declare const Constants: IConstants;
-export {};
-//# sourceMappingURL=constants.d.ts.map

package/dist/constants.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../src/constants.ts"],"names":[],"mappings":"AAAA,OAAO,EAGL,aAAa,EACb,uBAAuB,EACvB,4BAA4B,EAC7B,MAAM,4BAA4B,CAAC;AACpC,OAAO,EAAE,cAAc,EAAE,MAAM,QAAQ,CAAC;AAExC,OAAO,EAAE,eAAe,EAAE,MAAM,8BAA8B,CAAC;AAC/D,OAAO,EAAE,UAAU,EAAE,MAAM,wBAAwB,CAAC;AACpD,OAAO,EAAE,iBAAiB,EAAE,MAAM,gCAAgC,CAAC;AACnE,OAAO,EAAE,cAAc,EAAE,MAAM,6BAA6B,CAAC;AAC7D,OAAO,EAAE,aAAa,EAAE,MAAM,6BAA6B,CAAC;AAC5D,OAAO,EAAE,iBAAiB,EAAE,MAAM,iCAAiC,CAAC;AAIpE;;;;GAIG;AACH,eAAO,MAAM,8BAA8B,eAE1C,CAAC;AAEF,KAAK,wBAAwB,GAAG,UAAU,CAAC,OAAO,uBAAuB,CAAC,CAAC;AAC3E,KAAK,oBAAoB,GAAG,UAAU,CACpC,OAAO,4BAA4B,CACpC,CAAC,CAAC,CAAC,CAAC;AAEL,eAAO,MAAM,uBAAuB,EAAE,oBAIpC,CAAC;AAOH,wBAAgB,2BAA2B,IAAI,wBAAwB,CAEtE;AAED,wBAAgB,gCAAgC,CAC9C,iBAAiB,CAAC,EAAE,oBAAoB,GAAG,wBAAwB,EACnE,OAAO,CAAC,EAAE,UAAU,CAAC,OAAO,4BAA4B,CAAC,CAAC,CAAC,CAAC,GAC3D,wBAAwB,CAO1B;AAED,eAAO,MAAM,QAAQ,EAAE,eAA0C,CAAC;AAElE,eAAO,MAAM,OAAO,EAAE,cAIX,CAAC;AAEZ,eAAO,MAAM,MAAM,EAAE,aAAsC,CAAC;AAE5D,eAAO,MAAM,eAAe,EAAE,aAwCnB,CAAC;AAEZ,eAAO,MAAM,WAAW,EAAE,iBAKf,CAAC;AAEZ,eAAO,MAAM,+BAA+B,EACoB,cAAc,CAAC;AAE/E;;GAEG;AACH,eAAO,MAAM,UAAU,EAAE,iBAGd,CAAC;AAGZ,eAAO,MAAM,SAAS,EAAE,UAoCb,CAAC"}