@hazeljs/resilience 0.2.0-beta.41

package/dist/rate-limiter/rate-limiter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rate-limiter.d.ts","sourceRoot":"","sources":["../../src/rate-limiter/rate-limiter.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EAAE,iBAAiB,EAAkB,mBAAmB,EAAE,MAAM,UAAU,CAAC;AAElF;;;GAGG;AACH,qBAAa,kBAAkB;IAC7B,OAAO,CAAC,MAAM,CAAS;IACvB,OAAO,CAAC,UAAU,CAAS;IAC3B,OAAO,CAAC,QAAQ,CAAS;IACzB,OAAO,CAAC,UAAU,CAAS;gBAEf,QAAQ,EAAE,MAAM,EAAE,mBAAmB,EAAE,MAAM;IAOzD;;OAEG;IACH,UAAU,IAAI,OAAO;IASrB;;OAEG;IACH,eAAe,IAAI,MAAM;IAOzB,OAAO,CAAC,MAAM;CAMf;AAED;;;GAGG;AACH,qBAAa,oBAAoB;IAC/B,OAAO,CAAC,OAAO,CAA6B;IAC5C,OAAO,CAAC,GAAG,CAAS;IACpB,OAAO,CAAC,QAAQ,CAAS;IACzB,OAAO,CAAC,WAAW,CAAS;gBAEhB,GAAG,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM;IAOzC;;OAEG;IACH,UAAU,IAAI,OAAO;IAYrB;;OAEG;IACH,eAAe,IAAI,MAAM;IAOzB,OAAO,CAAC,eAAe;IAQvB,OAAO,CAAC,gBAAgB;IAIxB,OAAO,CAAC,KAAK;CAQd;AAED;;GAEG;AACH,qBAAa,WAAW;IACtB,OAAO,CAAC,OAAO,CAA4C;IAC3D,OAAO,CAAC,QAAQ,CAAsB;gBAE1B,MAAM,EAAE,iBAAiB;IAWrC;;OAEG;IACG,OAAO,CAAC,CAAC,EAAE,EAAE,EAAE,MAAM,OAAO,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC;IAQlD;;OAEG;IACH,UAAU,IAAI,OAAO;IAIrB;;OAEG;IACH,eAAe,IAAI,MAAM;IAIzB;;OAEG;IACH,WAAW,IAAI,mBAAmB;CAGnC"}

package/dist/rate-limiter/rate-limiter.js

@@ -0,0 +1,147 @@
+"use strict";
+/**
+ * Rate Limiter
+ * Token bucket and sliding window implementations for rate limiting.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RateLimiter = exports.SlidingWindowLimiter = exports.TokenBucketLimiter = void 0;
+const types_1 = require("../types");
+/**
+ * Token Bucket Rate Limiter
+ * Allows bursts up to the bucket capacity and refills at a steady rate.
+ */
+class TokenBucketLimiter {
+    constructor(capacity, refillRatePerSecond) {
+        this.capacity = capacity;
+        this.tokens = capacity;
+        this.refillRate = refillRatePerSecond / 1000;
+        this.lastRefill = Date.now();
+    }
+    /**
+     * Try to consume a token. Returns true if allowed.
+     */
+    tryAcquire() {
+        this.refill();
+        if (this.tokens >= 1) {
+            this.tokens -= 1;
+            return true;
+        }
+        return false;
+    }
+    /**
+     * Get time in ms until the next token is available
+     */
+    getRetryAfterMs() {
+        this.refill();
+        if (this.tokens >= 1)
+            return 0;
+        const needed = 1 - this.tokens;
+        return Math.ceil(needed / this.refillRate);
+    }
+    refill() {
+        const now = Date.now();
+        const elapsed = now - this.lastRefill;
+        this.tokens = Math.min(this.capacity, this.tokens + elapsed * this.refillRate);
+        this.lastRefill = now;
+    }
+}
+exports.TokenBucketLimiter = TokenBucketLimiter;
+/**
+ * Sliding Window Counter Rate Limiter
+ * Tracks request counts in small sub-windows for more accurate rate limiting.
+ */
+class SlidingWindowLimiter {
+    constructor(max, windowMs) {
+        this.windows = new Map();
+        this.max = max;
+        this.windowMs = windowMs;
+        // Use 10 sub-windows for granularity
+        this.subWindowMs = Math.max(1, Math.floor(windowMs / 10));
+    }
+    /**
+     * Try to record a request. Returns true if within limit.
+     */
+    tryAcquire() {
+        this.evict();
+        const count = this.getCurrentCount();
+        if (count >= this.max) {
+            return false;
+        }
+        const subKey = this.getCurrentSubKey();
+        this.windows.set(subKey, (this.windows.get(subKey) || 0) + 1);
+        return true;
+    }
+    /**
+     * Get time in ms until a slot opens up
+     */
+    getRetryAfterMs() {
+        this.evict();
+        if (this.getCurrentCount() < this.max)
+            return 0;
+        // Earliest sub-window will expire after subWindowMs
+        return this.subWindowMs;
+    }
+    getCurrentCount() {
+        let total = 0;
+        for (const count of this.windows.values()) {
+            total += count;
+        }
+        return total;
+    }
+    getCurrentSubKey() {
+        return Math.floor(Date.now() / this.subWindowMs);
+    }
+    evict() {
+        const cutoffKey = Math.floor((Date.now() - this.windowMs) / this.subWindowMs);
+        for (const key of this.windows.keys()) {
+            if (key <= cutoffKey) {
+                this.windows.delete(key);
+            }
+        }
+    }
+}
+exports.SlidingWindowLimiter = SlidingWindowLimiter;
+/**
+ * Unified RateLimiter that wraps the configured strategy
+ */
+class RateLimiter {
+    constructor(config) {
+        this.strategy = config.strategy;
+        if (config.strategy === 'token-bucket') {
+            const refillRate = config.refillRate ?? config.max / (config.window / 1000);
+            this.limiter = new TokenBucketLimiter(config.max, refillRate);
+        }
+        else {
+            this.limiter = new SlidingWindowLimiter(config.max, config.window);
+        }
+    }
+    /**
+     * Execute a function within rate limit constraints
+     */
+    async execute(fn) {
+        if (!this.limiter.tryAcquire()) {
+            const retryAfter = this.limiter.getRetryAfterMs();
+            throw new types_1.RateLimitError(`Rate limit exceeded. Retry after ${retryAfter}ms`, retryAfter);
+        }
+        return fn();
+    }
+    /**
+     * Try to acquire permission (consumes a token/slot)
+     */
+    tryAcquire() {
+        return this.limiter.tryAcquire();
+    }
+    /**
+     * Get time in ms until the next request is allowed
+     */
+    getRetryAfterMs() {
+        return this.limiter.getRetryAfterMs();
+    }
+    /**
+     * Get the strategy in use
+     */
+    getStrategy() {
+        return this.strategy;
+    }
+}
+exports.RateLimiter = RateLimiter;

package/dist/retry/retry-policy.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Retry Policy
+ * Configurable retry with exponential backoff, jitter, and retryable-error predicates.
+ */
+import { RetryConfig } from '../types';
+export declare class RetryPolicy {
+    private config;
+    constructor(config?: Partial<RetryConfig>);
+    /**
+     * Execute a function with retry logic
+     */
+    execute<T>(fn: () => Promise<T>): Promise<T>;
+    /**
+     * Get the configured max attempts
+     */
+    getMaxAttempts(): number;
+    private sleep;
+}
+//# sourceMappingURL=retry-policy.d.ts.map

package/dist/retry/retry-policy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"retry-policy.d.ts","sourceRoot":"","sources":["../../src/retry/retry-policy.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EAAE,WAAW,EAAwC,MAAM,UAAU,CAAC;AAoD7E,qBAAa,WAAW;IACtB,OAAO,CAAC,MAAM,CAAwB;gBAE1B,MAAM,GAAE,OAAO,CAAC,WAAW,CAAM;IAI7C;;OAEG;IACG,OAAO,CAAC,CAAC,EAAE,EAAE,EAAE,MAAM,OAAO,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC;IA2ClD;;OAEG;IACH,cAAc,IAAI,MAAM;IAIxB,OAAO,CAAC,KAAK;CAGd"}

package/dist/retry/retry-policy.js

@@ -0,0 +1,87 @@
+"use strict";
+/**
+ * Retry Policy
+ * Configurable retry with exponential backoff, jitter, and retryable-error predicates.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RetryPolicy = void 0;
+const types_1 = require("../types");
+const DEFAULT_CONFIG = {
+    maxAttempts: 3,
+    backoff: 'exponential',
+    baseDelay: 1000,
+    maxDelay: 30000,
+    jitter: true,
+    retryPredicate: undefined,
+    onRetry: undefined,
+};
+/**
+ * Calculate delay based on backoff strategy
+ */
+function calculateDelay(strategy, attempt, baseDelay, maxDelay, jitter) {
+    let delay;
+    switch (strategy) {
+        case 'fixed':
+            delay = baseDelay;
+            break;
+        case 'linear':
+            delay = baseDelay * attempt;
+            break;
+        case 'exponential':
+            delay = baseDelay * Math.pow(2, attempt - 1);
+            break;
+        default:
+            delay = baseDelay;
+    }
+    // Cap at max delay
+    delay = Math.min(delay, maxDelay);
+    // Add jitter (random value between 0 and delay)
+    if (jitter) {
+        delay = delay * (0.5 + Math.random() * 0.5);
+    }
+    return Math.floor(delay);
+}
+class RetryPolicy {
+    constructor(config = {}) {
+        this.config = { ...DEFAULT_CONFIG, ...config };
+    }
+    /**
+     * Execute a function with retry logic
+     */
+    async execute(fn) {
+        let lastError;
+        // Attempt 0 is the initial call, attempts 1..maxAttempts are retries
+        for (let attempt = 0; attempt <= this.config.maxAttempts; attempt++) {
+            try {
+                return await fn();
+            }
+            catch (error) {
+                lastError = error;
+                // Check if this error is retryable
+                if (this.config.retryPredicate && !this.config.retryPredicate(error)) {
+                    throw error;
+                }
+                // If we've exhausted all retries, throw
+                if (attempt >= this.config.maxAttempts) {
+                    break;
+                }
+                // Notify retry listener
+                this.config.onRetry?.(error, attempt + 1);
+                // Wait before next attempt
+                const delay = calculateDelay(this.config.backoff, attempt + 1, this.config.baseDelay, this.config.maxDelay, this.config.jitter);
+                await this.sleep(delay);
+            }
+        }
+        throw new types_1.RetryExhaustedError(`Retry exhausted after ${this.config.maxAttempts} attempts`, this.config.maxAttempts, lastError);
+    }
+    /**
+     * Get the configured max attempts
+     */
+    getMaxAttempts() {
+        return this.config.maxAttempts;
+    }
+    sleep(ms) {
+        return new Promise((resolve) => setTimeout(resolve, ms));
+    }
+}
+exports.RetryPolicy = RetryPolicy;

package/dist/timeout/timeout.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Timeout
+ * Promise-based timeout wrapper with cancellation support.
+ */
+import { TimeoutConfig } from '../types';
+export declare class Timeout {
+    private durationMs;
+    private message;
+    constructor(config: TimeoutConfig | number);
+    /**
+     * Execute a function with a timeout
+     */
+    execute<T>(fn: () => Promise<T>): Promise<T>;
+    /**
+     * Get the configured duration
+     */
+    getDuration(): number;
+}
+/**
+ * Convenience function to wrap a promise with a timeout
+ */
+export declare function withTimeout<T>(fn: () => Promise<T>, durationMs: number, message?: string): Promise<T>;
+//# sourceMappingURL=timeout.d.ts.map

package/dist/timeout/timeout.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"timeout.d.ts","sourceRoot":"","sources":["../../src/timeout/timeout.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EAAE,aAAa,EAAgB,MAAM,UAAU,CAAC;AAEvD,qBAAa,OAAO;IAClB,OAAO,CAAC,UAAU,CAAS;IAC3B,OAAO,CAAC,OAAO,CAAS;gBAEZ,MAAM,EAAE,aAAa,GAAG,MAAM;IAU1C;;OAEG;IACG,OAAO,CAAC,CAAC,EAAE,EAAE,EAAE,MAAM,OAAO,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC;IAmBlD;;OAEG;IACH,WAAW,IAAI,MAAM;CAGtB;AAED;;GAEG;AACH,wBAAsB,WAAW,CAAC,CAAC,EACjC,EAAE,EAAE,MAAM,OAAO,CAAC,CAAC,CAAC,EACpB,UAAU,EAAE,MAAM,EAClB,OAAO,CAAC,EAAE,MAAM,GACf,OAAO,CAAC,CAAC,CAAC,CAGZ"}

package/dist/timeout/timeout.js

@@ -0,0 +1,55 @@
+"use strict";
+/**
+ * Timeout
+ * Promise-based timeout wrapper with cancellation support.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Timeout = void 0;
+exports.withTimeout = withTimeout;
+const types_1 = require("../types");
+class Timeout {
+    constructor(config) {
+        if (typeof config === 'number') {
+            this.durationMs = config;
+            this.message = 'Operation timed out';
+        }
+        else {
+            this.durationMs = config.duration;
+            this.message = config.message || 'Operation timed out';
+        }
+    }
+    /**
+     * Execute a function with a timeout
+     */
+    async execute(fn) {
+        let timeoutId;
+        const timeoutPromise = new Promise((_, reject) => {
+            timeoutId = setTimeout(() => {
+                reject(new types_1.TimeoutError(`${this.message} (after ${this.durationMs}ms)`));
+            }, this.durationMs);
+        });
+        try {
+            const result = await Promise.race([fn(), timeoutPromise]);
+            return result;
+        }
+        finally {
+            if (timeoutId) {
+                clearTimeout(timeoutId);
+            }
+        }
+    }
+    /**
+     * Get the configured duration
+     */
+    getDuration() {
+        return this.durationMs;
+    }
+}
+exports.Timeout = Timeout;
+/**
+ * Convenience function to wrap a promise with a timeout
+ */
+async function withTimeout(fn, durationMs, message) {
+    const timeout = new Timeout({ duration: durationMs, message });
+    return timeout.execute(fn);
+}

package/dist/types/index.d.ts

@@ -0,0 +1,135 @@
+/**
+ * @hazeljs/resilience - Type Definitions
+ */
+export declare enum CircuitState {
+    CLOSED = "CLOSED",
+    OPEN = "OPEN",
+    HALF_OPEN = "HALF_OPEN"
+}
+export interface SlidingWindowConfig {
+    /** 'count' uses last N calls; 'time' uses a rolling time window */
+    type: 'count' | 'time';
+    /** For 'count': number of calls. For 'time': window duration in ms */
+    size: number;
+}
+export interface CircuitBreakerConfig {
+    /** Number of failures before opening the circuit */
+    failureThreshold: number;
+    /** Number of successes in HALF_OPEN before closing */
+    successThreshold: number;
+    /** Max time a single call may take before being considered failed (ms) */
+    timeout: number;
+    /** Time to wait in OPEN before transitioning to HALF_OPEN (ms) */
+    resetTimeout: number;
+    /** Sliding window configuration for failure rate calculation */
+    slidingWindow?: SlidingWindowConfig;
+    /** Custom predicate to determine if an error should count as a failure */
+    failurePredicate?: (error: unknown) => boolean;
+    /** Name of the fallback method on the same class */
+    fallback?: string;
+    /** Callback when state changes */
+    onStateChange?: (from: CircuitState, to: CircuitState) => void;
+}
+export interface CircuitBreakerMetrics {
+    totalRequests: number;
+    successCount: number;
+    failureCount: number;
+    failureRate: number;
+    state: CircuitState;
+    lastFailureTime?: number;
+    lastSuccessTime?: number;
+    averageResponseTime: number;
+    p99ResponseTime: number;
+}
+export type BackoffStrategy = 'fixed' | 'exponential' | 'linear';
+export interface RetryConfig {
+    /** Maximum number of retry attempts (not counting the initial call) */
+    maxAttempts: number;
+    /** Backoff strategy between retries */
+    backoff: BackoffStrategy;
+    /** Base delay in ms */
+    baseDelay: number;
+    /** Maximum delay between retries in ms */
+    maxDelay?: number;
+    /** Whether to add jitter to delay to avoid thundering herd */
+    jitter?: boolean;
+    /** Custom predicate to decide if an error is retryable */
+    retryPredicate?: (error: unknown) => boolean;
+    /** Called before each retry attempt */
+    onRetry?: (error: unknown, attempt: number) => void;
+}
+export interface TimeoutConfig {
+    /** Timeout duration in ms */
+    duration: number;
+    /** Custom error message */
+    message?: string;
+}
+export interface BulkheadConfig {
+    /** Maximum concurrent executions */
+    maxConcurrent: number;
+    /** Maximum number of calls waiting in queue */
+    maxQueue: number;
+    /** Time a call can wait in the queue before being rejected (ms) */
+    queueTimeout?: number;
+}
+export interface BulkheadMetrics {
+    activeCalls: number;
+    queueLength: number;
+    maxConcurrent: number;
+    maxQueue: number;
+    rejectedCount: number;
+}
+export type RateLimiterStrategy = 'token-bucket' | 'sliding-window';
+export interface RateLimiterConfig {
+    /** Strategy to use */
+    strategy: RateLimiterStrategy;
+    /** Maximum number of requests allowed in the window */
+    max: number;
+    /** Time window in ms (e.g. 60000 for 1 minute) */
+    window: number;
+    /** For token-bucket: refill rate (tokens per second). Defaults to max/window. */
+    refillRate?: number;
+}
+export interface MetricsSnapshot {
+    totalCalls: number;
+    successCalls: number;
+    failureCalls: number;
+    failureRate: number;
+    averageResponseTime: number;
+    p50ResponseTime: number;
+    p95ResponseTime: number;
+    p99ResponseTime: number;
+    minResponseTime: number;
+    maxResponseTime: number;
+    lastCallTime?: number;
+}
+export interface MetricsEntry {
+    timestamp: number;
+    duration: number;
+    success: boolean;
+    error?: string;
+}
+export declare class ResilienceError extends Error {
+    readonly code: string;
+    constructor(message: string, code: string);
+}
+export declare class CircuitBreakerError extends ResilienceError {
+    readonly state: CircuitState;
+    constructor(message: string, state: CircuitState);
+}
+export declare class TimeoutError extends ResilienceError {
+    constructor(message?: string);
+}
+export declare class BulkheadError extends ResilienceError {
+    constructor(message?: string);
+}
+export declare class RateLimitError extends ResilienceError {
+    readonly retryAfterMs?: number | undefined;
+    constructor(message?: string, retryAfterMs?: number | undefined);
+}
+export declare class RetryExhaustedError extends ResilienceError {
+    readonly attempts: number;
+    readonly lastError: unknown;
+    constructor(message: string, attempts: number, lastError: unknown);
+}
+//# sourceMappingURL=index.d.ts.map

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

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

package/dist/types/index.js

@@ -0,0 +1,61 @@
+"use strict";
+/**
+ * @hazeljs/resilience - Type Definitions
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RetryExhaustedError = exports.RateLimitError = exports.BulkheadError = exports.TimeoutError = exports.CircuitBreakerError = exports.ResilienceError = exports.CircuitState = void 0;
+// ─── Circuit Breaker ───
+var CircuitState;
+(function (CircuitState) {
+    CircuitState["CLOSED"] = "CLOSED";
+    CircuitState["OPEN"] = "OPEN";
+    CircuitState["HALF_OPEN"] = "HALF_OPEN";
+})(CircuitState || (exports.CircuitState = CircuitState = {}));
+// ─── Common ───
+class ResilienceError extends Error {
+    constructor(message, code) {
+        super(message);
+        this.code = code;
+        this.name = 'ResilienceError';
+    }
+}
+exports.ResilienceError = ResilienceError;
+class CircuitBreakerError extends ResilienceError {
+    constructor(message, state) {
+        super(message, 'CIRCUIT_OPEN');
+        this.state = state;
+        this.name = 'CircuitBreakerError';
+    }
+}
+exports.CircuitBreakerError = CircuitBreakerError;
+class TimeoutError extends ResilienceError {
+    constructor(message = 'Operation timed out') {
+        super(message, 'TIMEOUT');
+        this.name = 'TimeoutError';
+    }
+}
+exports.TimeoutError = TimeoutError;
+class BulkheadError extends ResilienceError {
+    constructor(message = 'Bulkhead capacity exceeded') {
+        super(message, 'BULKHEAD_FULL');
+        this.name = 'BulkheadError';
+    }
+}
+exports.BulkheadError = BulkheadError;
+class RateLimitError extends ResilienceError {
+    constructor(message = 'Rate limit exceeded', retryAfterMs) {
+        super(message, 'RATE_LIMITED');
+        this.retryAfterMs = retryAfterMs;
+        this.name = 'RateLimitError';
+    }
+}
+exports.RateLimitError = RateLimitError;
+class RetryExhaustedError extends ResilienceError {
+    constructor(message, attempts, lastError) {
+        super(message, 'RETRY_EXHAUSTED');
+        this.attempts = attempts;
+        this.lastError = lastError;
+        this.name = 'RetryExhaustedError';
+    }
+}
+exports.RetryExhaustedError = RetryExhaustedError;

package/package.json

@@ -0,0 +1,63 @@
+{
+  "name": "@hazeljs/resilience",
+  "version": "0.2.0-beta.41",
+  "description": "Fault-tolerance and resilience patterns for HazelJS - Circuit Breaker, Retry, Bulkhead, Timeout, Rate Limiter",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "test": "jest --coverage --passWithNoTests",
+    "test:ci": "jest --coverage --coverageReporters=text --coverageReporters=lcov --coverageReporters=clover --no-coverage-threshold",
+    "test:watch": "jest --watch",
+    "lint": "eslint \"src/**/*.ts\"",
+    "lint:fix": "eslint \"src/**/*.ts\" --fix",
+    "format": "prettier --write \"src/**/*.ts\"",
+    "clean": "rm -rf dist"
+  },
+  "dependencies": {
+    "@hazeljs/core": "^0.2.0-beta.41",
+    "reflect-metadata": "^0.2.2"
+  },
+  "devDependencies": {
+    "@types/jest": "^29.5.14",
+    "@types/node": "^20.17.50",
+    "@typescript-eslint/eslint-plugin": "^8.18.2",
+    "@typescript-eslint/parser": "^8.18.2",
+    "eslint": "^8.56.0",
+    "eslint-config-prettier": "^9.1.0",
+    "eslint-plugin-prettier": "^5.1.3",
+    "jest": "^29.7.0",
+    "prettier": "^3.2.5",
+    "ts-jest": "^29.1.2",
+    "typescript": "^5.3.3"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/hazel-js/hazeljs.git",
+    "directory": "packages/resilience"
+  },
+  "keywords": [
+    "hazeljs",
+    "resilience",
+    "circuit-breaker",
+    "retry",
+    "bulkhead",
+    "timeout",
+    "rate-limiter",
+    "fault-tolerance",
+    "microservices"
+  ],
+  "author": "Muhammad Arslan <marslan@hazeljs.com>",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/hazeljs/hazel-js/issues"
+  },
+  "homepage": "https://hazeljs.com",
+  "gitHead": "b50699eaa4847a8cfe9c346d7e4464b4af7f3120"
+}