@digitaldefiance/secrets 2.0.3

package/dist/umd/browser-types.js

@@ -0,0 +1,252 @@
+// Browser-specific type definitions and error handling
+// Provides enhanced typing for browser Web Crypto API and environment-specific behavior
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+(function (factory) {
+    if (typeof module === "object" && typeof module.exports === "object") {
+        var v = factory(require, exports);
+        if (v !== undefined) module.exports = v;
+    }
+    else if (typeof define === "function" && define.amd) {
+        define(["require", "exports", "./errors"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.WebCryptoNotSupportedError = exports.BrowserEnvironmentError = exports.BrowserCryptoError = void 0;
+    exports.isUint32Array = isUint32Array;
+    exports.isTypedArray = isTypedArray;
+    exports.isBrowserEnvironment = isBrowserEnvironment;
+    exports.getBrowserCrypto = getBrowserCrypto;
+    exports.hasBrowserCryptoGetRandomValues = hasBrowserCryptoGetRandomValues;
+    exports.createBrowserRNG = createBrowserRNG;
+    exports.createBrowserCryptoEnvironment = createBrowserCryptoEnvironment;
+    exports.validateUint32Array = validateUint32Array;
+    exports.validateTypedArray = validateTypedArray;
+    exports.requireBrowserCrypto = requireBrowserCrypto;
+    exports.isWebCryptoSupported = isWebCryptoSupported;
+    var errors_1 = require("./errors");
+    /**
+     * Type guard for Uint32Array
+     */
+    function isUint32Array(value) {
+        var _a;
+        return value !== null &&
+            typeof value === 'object' &&
+            ((_a = value.constructor) === null || _a === void 0 ? void 0 : _a.name) === 'Uint32Array';
+    }
+    /**
+     * Type guard for any typed array
+     */
+    function isTypedArray(value) {
+        return value !== null &&
+            typeof value === 'object' &&
+            ArrayBuffer.isView(value);
+    }
+    // ============================================================================
+    // Browser Environment Detection
+    // ============================================================================
+    /**
+     * Detects if the current environment is a browser
+     * @returns true if running in a browser, false otherwise
+     */
+    function isBrowserEnvironment() {
+        return typeof window !== 'undefined' &&
+            typeof window.document !== 'undefined';
+    }
+    /**
+     * Attempts to access the browser Web Crypto API
+     * @returns BrowserCryptoAPI if available, null otherwise
+     */
+    function getBrowserCrypto() {
+        // Check for window.crypto
+        if (typeof window !== 'undefined' && window.crypto) {
+            var crypto_1 = window.crypto;
+            if (typeof crypto_1.getRandomValues === 'function' ||
+                typeof crypto_1.getRandomValues === 'object') {
+                return crypto_1;
+            }
+        }
+        // Check for global crypto (some environments)
+        if (typeof global !== 'undefined' && global.crypto) {
+            var crypto_2 = global.crypto;
+            if (typeof crypto_2.getRandomValues === 'function' ||
+                typeof crypto_2.getRandomValues === 'object') {
+                return crypto_2;
+            }
+        }
+        return null;
+    }
+    /**
+     * Checks if browser crypto.getRandomValues is available
+     * @returns true if crypto.getRandomValues is available
+     */
+    function hasBrowserCryptoGetRandomValues() {
+        var crypto = getBrowserCrypto();
+        if (!crypto) {
+            return false;
+        }
+        // Check if Uint32Array is available
+        if (typeof Uint32Array !== 'function' && typeof Uint32Array !== 'object') {
+            return false;
+        }
+        return typeof crypto.getRandomValues === 'function' ||
+            typeof crypto.getRandomValues === 'object';
+    }
+    // ============================================================================
+    // Browser-Specific Error Types
+    // ============================================================================
+    /**
+     * Error thrown when browser crypto operations fail
+     */
+    var BrowserCryptoError = /** @class */ (function (_super) {
+        __extends(BrowserCryptoError, _super);
+        function BrowserCryptoError(operation, reason, originalError) {
+            var _this = _super.call(this, operation, "Browser crypto error: ".concat(reason)) || this;
+            _this.originalError = originalError;
+            _this.name = 'BrowserCryptoError';
+            if (originalError && Error.captureStackTrace) {
+                Error.captureStackTrace(_this, BrowserCryptoError);
+            }
+            return _this;
+        }
+        return BrowserCryptoError;
+    }(errors_1.CryptoError));
+    exports.BrowserCryptoError = BrowserCryptoError;
+    /**
+     * Error thrown when browser environment is required but not available
+     */
+    var BrowserEnvironmentError = /** @class */ (function (_super) {
+        __extends(BrowserEnvironmentError, _super);
+        function BrowserEnvironmentError(feature) {
+            var _this = _super.call(this, 'environment_check', "Feature '".concat(feature, "' requires browser environment but is not available")) || this;
+            _this.name = 'BrowserEnvironmentError';
+            return _this;
+        }
+        return BrowserEnvironmentError;
+    }(errors_1.CryptoError));
+    exports.BrowserEnvironmentError = BrowserEnvironmentError;
+    /**
+     * Error thrown when Web Crypto API is not supported
+     */
+    var WebCryptoNotSupportedError = /** @class */ (function (_super) {
+        __extends(WebCryptoNotSupportedError, _super);
+        function WebCryptoNotSupportedError() {
+            var _this = _super.call(this, 'getRandomValues', 'Web Crypto API is not supported in this browser') || this;
+            _this.name = 'WebCryptoNotSupportedError';
+            return _this;
+        }
+        return WebCryptoNotSupportedError;
+    }(BrowserCryptoError));
+    exports.WebCryptoNotSupportedError = WebCryptoNotSupportedError;
+    // ============================================================================
+    // Browser RNG Implementation
+    // ============================================================================
+    /**
+     * Creates a browser-specific RNG function using crypto.getRandomValues
+     * @param crypto - Browser Web Crypto API
+     * @returns RNG function that generates random binary strings
+     * @throws {BrowserCryptoError} If random value generation fails
+     */
+    function createBrowserRNG(crypto) {
+        return function browserCryptoGetRandomValues(bits) {
+            if (typeof bits !== 'number' || bits <= 0 || bits % 1 !== 0) {
+                throw new BrowserCryptoError('getRandomValues', "Invalid bits parameter: ".concat(bits, ". Must be a positive integer."));
+            }
+            // Calculate number of 32-bit integers needed
+            var elems = Math.ceil(bits / 32);
+            try {
+                // Generate random values
+                var array = new Uint32Array(elems);
+                crypto.getRandomValues(array);
+                // Convert to binary string
+                var binary = '';
+                for (var i = 0; i < array.length; i++) {
+                    var value = array[i];
+                    var bin = value.toString(2);
+                    // Pad to 32 bits
+                    binary += '00000000000000000000000000000000'.substring(bin.length) + bin;
+                }
+                // Return exactly the requested number of bits
+                return binary.substring(0, bits);
+            }
+            catch (error) {
+                throw new BrowserCryptoError('getRandomValues', 'Failed to generate random values', error);
+            }
+        };
+    }
+    /**
+     * Creates a browser crypto environment descriptor
+     * @returns BrowserCryptoEnvironment if browser crypto is available, null otherwise
+     */
+    function createBrowserCryptoEnvironment() {
+        var crypto = getBrowserCrypto();
+        if (!crypto) {
+            return null;
+        }
+        return {
+            type: 'browser',
+            crypto: crypto,
+            rngType: 'browserCryptoGetRandomValues',
+            rng: createBrowserRNG(crypto)
+        };
+    }
+    // ============================================================================
+    // Type Validation for Browser
+    // ============================================================================
+    /**
+     * Validates that a value is a valid Uint32Array
+     * @param value - Value to validate
+     * @param paramName - Parameter name for error messages
+     * @throws {BrowserCryptoError} If value is not a valid Uint32Array
+     */
+    function validateUint32Array(value, paramName) {
+        if (!isUint32Array(value)) {
+            throw new BrowserCryptoError('validation', "Parameter '".concat(paramName, "' must be a Uint32Array"));
+        }
+    }
+    /**
+     * Validates that a value is a valid typed array
+     * @param value - Value to validate
+     * @param paramName - Parameter name for error messages
+     * @throws {BrowserCryptoError} If value is not a valid typed array
+     */
+    function validateTypedArray(value, paramName) {
+        if (!isTypedArray(value)) {
+            throw new BrowserCryptoError('validation', "Parameter '".concat(paramName, "' must be a typed array"));
+        }
+    }
+    /**
+     * Validates that browser crypto is available
+     * @throws {WebCryptoNotSupportedError} If browser crypto is not available
+     */
+    function requireBrowserCrypto() {
+        var crypto = getBrowserCrypto();
+        if (!crypto) {
+            throw new WebCryptoNotSupportedError();
+        }
+        return crypto;
+    }
+    /**
+     * Checks if the browser supports the Web Crypto API
+     * @returns true if Web Crypto API is fully supported
+     */
+    function isWebCryptoSupported() {
+        return hasBrowserCryptoGetRandomValues() &&
+            (typeof Uint32Array === 'function' || typeof Uint32Array === 'object');
+    }
+});
+//# sourceMappingURL=browser-types.js.map

package/dist/umd/browser-types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"browser-types.js","sourceRoot":"","sources":["../../src/browser-types.ts"],"names":[],"mappings":"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"}

package/dist/umd/errors.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Base error class for all secrets library errors
+ */
+export declare class SecretsError extends Error {
+    readonly code: string;
+    readonly context?: Record<string, unknown> | undefined;
+    constructor(message: string, code: string, context?: Record<string, unknown> | undefined);
+}
+/**
+ * Error thrown when invalid parameters are provided to a function
+ */
+export declare class InvalidParameterError extends SecretsError {
+    constructor(parameter: string, value: unknown, expected: string);
+}
+/**
+ * Error thrown when initialization fails
+ */
+export declare class InitializationError extends SecretsError {
+    constructor(reason: string);
+}
+/**
+ * Error thrown when share data is invalid or corrupted
+ */
+export declare class InvalidShareError extends SecretsError {
+    constructor(share: string, reason: string);
+}
+/**
+ * Error thrown when cryptographic operations fail
+ */
+export declare class CryptoError extends SecretsError {
+    constructor(operation: string, reason: string);
+}
+//# sourceMappingURL=errors.d.ts.map

package/dist/umd/errors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../../src/errors.ts"],"names":[],"mappings":"AAGA;;GAEG;AACH,qBAAa,YAAa,SAAQ,KAAK;aAGnB,IAAI,EAAE,MAAM;aACZ,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;gBAFjD,OAAO,EAAE,MAAM,EACC,IAAI,EAAE,MAAM,EACZ,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,YAAA;CAUpD;AAED;;GAEG;AACH,qBAAa,qBAAsB,SAAQ,YAAY;gBACzC,SAAS,EAAE,MAAM,EAAE,KAAK,EAAE,OAAO,EAAE,QAAQ,EAAE,MAAM;CAQhE;AAED;;GAEG;AACH,qBAAa,mBAAoB,SAAQ,YAAY;gBACvC,MAAM,EAAE,MAAM;CAQ3B;AAED;;GAEG;AACH,qBAAa,iBAAkB,SAAQ,YAAY;gBACrC,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM;CAQ1C;AAED;;GAEG;AACH,qBAAa,WAAY,SAAQ,YAAY;gBAC/B,SAAS,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM;CAQ9C"}

package/dist/umd/errors.js

@@ -0,0 +1,102 @@
+// Type-safe error handling for @digitaldefiance/secrets
+// Provides structured error classes with context information
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+(function (factory) {
+    if (typeof module === "object" && typeof module.exports === "object") {
+        var v = factory(require, exports);
+        if (v !== undefined) module.exports = v;
+    }
+    else if (typeof define === "function" && define.amd) {
+        define(["require", "exports"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.CryptoError = exports.InvalidShareError = exports.InitializationError = exports.InvalidParameterError = exports.SecretsError = void 0;
+    /**
+     * Base error class for all secrets library errors
+     */
+    var SecretsError = /** @class */ (function (_super) {
+        __extends(SecretsError, _super);
+        function SecretsError(message, code, context) {
+            var _this = _super.call(this, message) || this;
+            _this.code = code;
+            _this.context = context;
+            _this.name = 'SecretsError';
+            // Maintains proper stack trace for where our error was thrown (only available on V8)
+            if (Error.captureStackTrace) {
+                Error.captureStackTrace(_this, SecretsError);
+            }
+            return _this;
+        }
+        return SecretsError;
+    }(Error));
+    exports.SecretsError = SecretsError;
+    /**
+     * Error thrown when invalid parameters are provided to a function
+     */
+    var InvalidParameterError = /** @class */ (function (_super) {
+        __extends(InvalidParameterError, _super);
+        function InvalidParameterError(parameter, value, expected) {
+            var _this = _super.call(this, "Invalid parameter '".concat(parameter, "': expected ").concat(expected, ", got ").concat(typeof value), 'INVALID_PARAMETER', { parameter: parameter, value: value, expected: expected }) || this;
+            _this.name = 'InvalidParameterError';
+            return _this;
+        }
+        return InvalidParameterError;
+    }(SecretsError));
+    exports.InvalidParameterError = InvalidParameterError;
+    /**
+     * Error thrown when initialization fails
+     */
+    var InitializationError = /** @class */ (function (_super) {
+        __extends(InitializationError, _super);
+        function InitializationError(reason) {
+            var _this = _super.call(this, "Initialization failed: ".concat(reason), 'INITIALIZATION_FAILED', { reason: reason }) || this;
+            _this.name = 'InitializationError';
+            return _this;
+        }
+        return InitializationError;
+    }(SecretsError));
+    exports.InitializationError = InitializationError;
+    /**
+     * Error thrown when share data is invalid or corrupted
+     */
+    var InvalidShareError = /** @class */ (function (_super) {
+        __extends(InvalidShareError, _super);
+        function InvalidShareError(share, reason) {
+            var _this = _super.call(this, "Invalid share data: ".concat(reason), 'INVALID_SHARE', { share: share, reason: reason }) || this;
+            _this.name = 'InvalidShareError';
+            return _this;
+        }
+        return InvalidShareError;
+    }(SecretsError));
+    exports.InvalidShareError = InvalidShareError;
+    /**
+     * Error thrown when cryptographic operations fail
+     */
+    var CryptoError = /** @class */ (function (_super) {
+        __extends(CryptoError, _super);
+        function CryptoError(operation, reason) {
+            var _this = _super.call(this, "Cryptographic operation '".concat(operation, "' failed: ").concat(reason), 'CRYPTO_ERROR', { operation: operation, reason: reason }) || this;
+            _this.name = 'CryptoError';
+            return _this;
+        }
+        return CryptoError;
+    }(SecretsError));
+    exports.CryptoError = CryptoError;
+});
+//# sourceMappingURL=errors.js.map

package/dist/umd/errors.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.js","sourceRoot":"","sources":["../../src/errors.ts"],"names":[],"mappings":"AAAA,wDAAwD;AACxD,6DAA6D;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAE7D;;OAEG;IACH;QAAkC,gCAAK;QACrC,sBACE,OAAe,EACC,IAAY,EACZ,OAAiC;YAEjD,YAAA,MAAK,YAAC,OAAO,CAAC,SAAC;YAHC,UAAI,GAAJ,IAAI,CAAQ;YACZ,aAAO,GAAP,OAAO,CAA0B;YAGjD,KAAI,CAAC,IAAI,GAAG,cAAc,CAAC;YAE3B,qFAAqF;YACrF,IAAI,KAAK,CAAC,iBAAiB,EAAE,CAAC;gBAC5B,KAAK,CAAC,iBAAiB,CAAC,KAAI,EAAE,YAAY,CAAC,CAAC;YAC9C,CAAC;;QACH,CAAC;QACH,mBAAC;IAAD,CAAC,AAdD,CAAkC,KAAK,GActC;IAdY,oCAAY;IAgBzB;;OAEG;IACH;QAA2C,yCAAY;QACrD,+BAAY,SAAiB,EAAE,KAAc,EAAE,QAAgB;YAC7D,YAAA,MAAK,YACH,6BAAsB,SAAS,yBAAe,QAAQ,mBAAS,OAAO,KAAK,CAAE,EAC7E,mBAAmB,EACnB,EAAE,SAAS,WAAA,EAAE,KAAK,OAAA,EAAE,QAAQ,UAAA,EAAE,CAC/B,SAAC;YACF,KAAI,CAAC,IAAI,GAAG,uBAAuB,CAAC;;QACtC,CAAC;QACH,4BAAC;IAAD,CAAC,AATD,CAA2C,YAAY,GAStD;IATY,sDAAqB;IAWlC;;OAEG;IACH;QAAyC,uCAAY;QACnD,6BAAY,MAAc;YACxB,YAAA,MAAK,YACH,iCAA0B,MAAM,CAAE,EAClC,uBAAuB,EACvB,EAAE,MAAM,QAAA,EAAE,CACX,SAAC;YACF,KAAI,CAAC,IAAI,GAAG,qBAAqB,CAAC;;QACpC,CAAC;QACH,0BAAC;IAAD,CAAC,AATD,CAAyC,YAAY,GASpD;IATY,kDAAmB;IAWhC;;OAEG;IACH;QAAuC,qCAAY;QACjD,2BAAY,KAAa,EAAE,MAAc;YACvC,YAAA,MAAK,YACH,8BAAuB,MAAM,CAAE,EAC/B,eAAe,EACf,EAAE,KAAK,OAAA,EAAE,MAAM,QAAA,EAAE,CAClB,SAAC;YACF,KAAI,CAAC,IAAI,GAAG,mBAAmB,CAAC;;QAClC,CAAC;QACH,wBAAC;IAAD,CAAC,AATD,CAAuC,YAAY,GASlD;IATY,8CAAiB;IAW9B;;OAEG;IACH;QAAiC,+BAAY;QAC3C,qBAAY,SAAiB,EAAE,MAAc;YAC3C,YAAA,MAAK,YACH,mCAA4B,SAAS,uBAAa,MAAM,CAAE,EAC1D,cAAc,EACd,EAAE,SAAS,WAAA,EAAE,MAAM,QAAA,EAAE,CACtB,SAAC;YACF,KAAI,CAAC,IAAI,GAAG,aAAa,CAAC;;QAC5B,CAAC;QACH,kBAAC;IAAD,CAAC,AATD,CAAiC,YAAY,GAS5C;IATY,kCAAW"}

package/dist/umd/node-types.d.ts

@@ -0,0 +1,87 @@
+import type { RNGFunction, CSPRNGType } from './types';
+import { CryptoError } from './errors';
+/**
+ * Enhanced Node.js crypto module interface with comprehensive typing
+ */
+export interface NodeCryptoModule {
+    /**
+     * Generates cryptographically strong pseudo-random data
+     * @param size - Number of bytes to generate
+     * @returns Buffer containing random bytes
+     * @throws {Error} If random data generation fails
+     */
+    randomBytes(size: number): Buffer;
+    /**
+     * Synchronous version of randomBytes
+     * @param size - Number of bytes to generate
+     * @returns Buffer containing random bytes
+     * @throws {Error} If random data generation fails
+     */
+    randomBytesSync?(size: number): Buffer;
+}
+/**
+ * Node.js Buffer type guard
+ */
+export declare function isNodeBuffer(value: unknown): value is Buffer;
+/**
+ * Detects if the current environment is Node.js
+ * @returns true if running in Node.js, false otherwise
+ */
+export declare function isNodeEnvironment(): boolean;
+/**
+ * Attempts to load the Node.js crypto module
+ * @returns NodeCryptoModule if available, null otherwise
+ */
+export declare function getNodeCrypto(): NodeCryptoModule | null;
+/**
+ * Checks if Node.js crypto.randomBytes is available
+ * @returns true if crypto.randomBytes is available
+ */
+export declare function hasNodeCryptoRandomBytes(): boolean;
+/**
+ * Error thrown when Node.js crypto operations fail
+ */
+export declare class NodeCryptoError extends CryptoError {
+    readonly originalError?: Error | undefined;
+    constructor(operation: string, reason: string, originalError?: Error | undefined);
+}
+/**
+ * Error thrown when Node.js environment is required but not available
+ */
+export declare class NodeEnvironmentError extends CryptoError {
+    constructor(feature: string);
+}
+/**
+ * Creates a Node.js-specific RNG function using crypto.randomBytes
+ * @param crypto - Node.js crypto module
+ * @returns RNG function that generates random binary strings
+ * @throws {NodeCryptoError} If random byte generation fails
+ */
+export declare function createNodeRNG(crypto: NodeCryptoModule): RNGFunction;
+/**
+ * Node.js-specific crypto environment descriptor
+ */
+export interface NodeCryptoEnvironment {
+    readonly type: 'node';
+    readonly crypto: NodeCryptoModule;
+    readonly rngType: CSPRNGType;
+    readonly rng: RNGFunction;
+}
+/**
+ * Creates a Node.js crypto environment descriptor
+ * @returns NodeCryptoEnvironment if Node.js crypto is available, null otherwise
+ */
+export declare function createNodeCryptoEnvironment(): NodeCryptoEnvironment | null;
+/**
+ * Validates that a value is a valid Node.js Buffer
+ * @param value - Value to validate
+ * @param paramName - Parameter name for error messages
+ * @throws {NodeCryptoError} If value is not a valid Buffer
+ */
+export declare function validateNodeBuffer(value: unknown, paramName: string): asserts value is Buffer;
+/**
+ * Validates that Node.js crypto is available
+ * @throws {NodeEnvironmentError} If Node.js crypto is not available
+ */
+export declare function requireNodeCrypto(): NodeCryptoModule;
+//# sourceMappingURL=node-types.d.ts.map

package/dist/umd/node-types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"node-types.d.ts","sourceRoot":"","sources":["../../src/node-types.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,WAAW,EAAE,UAAU,EAAE,MAAM,SAAS,CAAC;AACvD,OAAO,EAAE,WAAW,EAAE,MAAM,UAAU,CAAC;AAMvC;;GAEG;AACH,MAAM,WAAW,gBAAgB;IAC/B;;;;;OAKG;IACH,WAAW,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAAC;IAElC;;;;;OAKG;IACH,eAAe,CAAC,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAAC;CACxC;AAED;;GAEG;AACH,wBAAgB,YAAY,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,MAAM,CAK5D;AAMD;;;GAGG;AACH,wBAAgB,iBAAiB,IAAI,OAAO,CAI3C;AAED;;;GAGG;AACH,wBAAgB,aAAa,IAAI,gBAAgB,GAAG,IAAI,CAiBvD;AAED;;;GAGG;AACH,wBAAgB,wBAAwB,IAAI,OAAO,CAGlD;AAMD;;GAEG;AACH,qBAAa,eAAgB,SAAQ,WAAW;aACiB,aAAa,CAAC,EAAE,KAAK;gBAAxE,SAAS,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAkB,aAAa,CAAC,EAAE,KAAK,YAAA;CAQrF;AAED;;GAEG;AACH,qBAAa,oBAAqB,SAAQ,WAAW;gBACvC,OAAO,EAAE,MAAM;CAO5B;AAMD;;;;;GAKG;AACH,wBAAgB,aAAa,CAAC,MAAM,EAAE,gBAAgB,GAAG,WAAW,CAwCnE;AAED;;GAEG;AACH,MAAM,WAAW,qBAAqB;IACpC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,MAAM,EAAE,gBAAgB,CAAC;IAClC,QAAQ,CAAC,OAAO,EAAE,UAAU,CAAC;IAC7B,QAAQ,CAAC,GAAG,EAAE,WAAW,CAAC;CAC3B;AAED;;;GAGG;AACH,wBAAgB,2BAA2B,IAAI,qBAAqB,GAAG,IAAI,CAa1E;AAMD;;;;;GAKG;AACH,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,OAAO,EAAE,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,KAAK,IAAI,MAAM,CAO7F;AAED;;;GAGG;AACH,wBAAgB,iBAAiB,IAAI,gBAAgB,CAQpD"}