@posthog/core 1.3.1 → 1.5.0

package/dist/utils/bot-detection.d.ts

@@ -0,0 +1,6 @@
+export declare const DEFAULT_BLOCKED_UA_STRS: string[];
+/**
+ * Block various web spiders from executing our JS and sending false capturing data
+ */
+export declare const isBlockedUA: (ua: string | undefined, customBlockedUserAgents?: string[]) => boolean;
+//# sourceMappingURL=bot-detection.d.ts.map

package/dist/utils/bot-detection.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bot-detection.d.ts","sourceRoot":"","sources":["../../src/utils/bot-detection.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,uBAAuB,UA+FnC,CAAA;AAED;;GAEG;AACH,eAAO,MAAM,WAAW,GAAa,IAAI,MAAM,GAAG,SAAS,EAAE,0BAAyB,MAAM,EAAO,KAAG,OAWrG,CAAA"}

package/dist/utils/bot-detection.js

@@ -0,0 +1,125 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ('undefined' != typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    DEFAULT_BLOCKED_UA_STRS: ()=>DEFAULT_BLOCKED_UA_STRS,
+    isBlockedUA: ()=>isBlockedUA
+});
+const DEFAULT_BLOCKED_UA_STRS = [
+    'amazonbot',
+    'amazonproductbot',
+    'app.hypefactors.com',
+    'applebot',
+    'archive.org_bot',
+    'awariobot',
+    'backlinksextendedbot',
+    'baiduspider',
+    'bingbot',
+    'bingpreview',
+    'chrome-lighthouse',
+    'dataforseobot',
+    'deepscan',
+    'duckduckbot',
+    'facebookexternal',
+    'facebookcatalog',
+    'http://yandex.com/bots',
+    'hubspot',
+    'ia_archiver',
+    'leikibot',
+    'linkedinbot',
+    'meta-externalagent',
+    'mj12bot',
+    'msnbot',
+    'nessus',
+    'petalbot',
+    'pinterest',
+    'prerender',
+    'rogerbot',
+    'screaming frog',
+    'sebot-wa',
+    'sitebulb',
+    'slackbot',
+    'slurp',
+    'trendictionbot',
+    'turnitin',
+    'twitterbot',
+    'vercel-screenshot',
+    'vercelbot',
+    'yahoo! slurp',
+    'yandexbot',
+    'zoombot',
+    'bot.htm',
+    'bot.php',
+    '(bot;',
+    'bot/',
+    'crawler',
+    'ahrefsbot',
+    'ahrefssiteaudit',
+    'semrushbot',
+    'siteauditbot',
+    'splitsignalbot',
+    'gptbot',
+    'oai-searchbot',
+    'chatgpt-user',
+    'perplexitybot',
+    'better uptime bot',
+    'sentryuptimebot',
+    'uptimerobot',
+    'headlesschrome',
+    'cypress',
+    'google-hoteladsverifier',
+    'adsbot-google',
+    'apis-google',
+    'duplexweb-google',
+    'feedfetcher-google',
+    'google favicon',
+    'google web preview',
+    'google-read-aloud',
+    'googlebot',
+    'googleother',
+    'google-cloudvertexbot',
+    'googleweblight',
+    'mediapartners-google',
+    'storebot-google',
+    'google-inspectiontool',
+    'bytespider'
+];
+const isBlockedUA = function(ua, customBlockedUserAgents = []) {
+    if (!ua) return false;
+    const uaLower = ua.toLowerCase();
+    return DEFAULT_BLOCKED_UA_STRS.concat(customBlockedUserAgents).some((blockedUA)=>{
+        const blockedUaLower = blockedUA.toLowerCase();
+        return -1 !== uaLower.indexOf(blockedUaLower);
+    });
+};
+exports.DEFAULT_BLOCKED_UA_STRS = __webpack_exports__.DEFAULT_BLOCKED_UA_STRS;
+exports.isBlockedUA = __webpack_exports__.isBlockedUA;
+for(var __webpack_i__ in __webpack_exports__)if (-1 === [
+    "DEFAULT_BLOCKED_UA_STRS",
+    "isBlockedUA"
+].indexOf(__webpack_i__)) exports[__webpack_i__] = __webpack_exports__[__webpack_i__];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/utils/bot-detection.mjs

@@ -0,0 +1,88 @@
+const DEFAULT_BLOCKED_UA_STRS = [
+    'amazonbot',
+    'amazonproductbot',
+    'app.hypefactors.com',
+    'applebot',
+    'archive.org_bot',
+    'awariobot',
+    'backlinksextendedbot',
+    'baiduspider',
+    'bingbot',
+    'bingpreview',
+    'chrome-lighthouse',
+    'dataforseobot',
+    'deepscan',
+    'duckduckbot',
+    'facebookexternal',
+    'facebookcatalog',
+    'http://yandex.com/bots',
+    'hubspot',
+    'ia_archiver',
+    'leikibot',
+    'linkedinbot',
+    'meta-externalagent',
+    'mj12bot',
+    'msnbot',
+    'nessus',
+    'petalbot',
+    'pinterest',
+    'prerender',
+    'rogerbot',
+    'screaming frog',
+    'sebot-wa',
+    'sitebulb',
+    'slackbot',
+    'slurp',
+    'trendictionbot',
+    'turnitin',
+    'twitterbot',
+    'vercel-screenshot',
+    'vercelbot',
+    'yahoo! slurp',
+    'yandexbot',
+    'zoombot',
+    'bot.htm',
+    'bot.php',
+    '(bot;',
+    'bot/',
+    'crawler',
+    'ahrefsbot',
+    'ahrefssiteaudit',
+    'semrushbot',
+    'siteauditbot',
+    'splitsignalbot',
+    'gptbot',
+    'oai-searchbot',
+    'chatgpt-user',
+    'perplexitybot',
+    'better uptime bot',
+    'sentryuptimebot',
+    'uptimerobot',
+    'headlesschrome',
+    'cypress',
+    'google-hoteladsverifier',
+    'adsbot-google',
+    'apis-google',
+    'duplexweb-google',
+    'feedfetcher-google',
+    'google favicon',
+    'google web preview',
+    'google-read-aloud',
+    'googlebot',
+    'googleother',
+    'google-cloudvertexbot',
+    'googleweblight',
+    'mediapartners-google',
+    'storebot-google',
+    'google-inspectiontool',
+    'bytespider'
+];
+const isBlockedUA = function(ua, customBlockedUserAgents = []) {
+    if (!ua) return false;
+    const uaLower = ua.toLowerCase();
+    return DEFAULT_BLOCKED_UA_STRS.concat(customBlockedUserAgents).some((blockedUA)=>{
+        const blockedUaLower = blockedUA.toLowerCase();
+        return -1 !== uaLower.indexOf(blockedUaLower);
+    });
+};
+export { DEFAULT_BLOCKED_UA_STRS, isBlockedUA };

package/dist/utils/bucketed-rate-limiter.d.ts

@@ -1,23 +1,19 @@
 import { Logger } from '../types';
 export declare class BucketedRateLimiter<T extends string | number> {
-    private readonly _options;
     private _bucketSize;
     private _refillRate;
     private _refillInterval;
     private _onBucketRateLimited?;
     private _buckets;
-    private _removeInterval;
-    constructor(_options: {
+    constructor(options: {
         bucketSize: number;
         refillRate: number;
         refillInterval: number;
         _logger: Logger;
         _onBucketRateLimited?: (key: T) => void;
     });
-    private _refillBuckets;
-    private _getBucket;
-    private _setBucket;
-    consumeRateLimit: (key: T) => boolean;
+    private _applyRefill;
+    consumeRateLimit(key: T): boolean;
     stop(): void;
 }
 //# sourceMappingURL=bucketed-rate-limiter.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"bucketed-rate-limiter.d.ts","sourceRoot":"","sources":["../../src/utils/bucketed-rate-limiter.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,UAAU,CAAA;AAGjC,qBAAa,mBAAmB,CAAC,CAAC,SAAS,MAAM,GAAG,MAAM;IAUtD,OAAO,CAAC,QAAQ,CAAC,QAAQ;IAT3B,OAAO,CAAC,WAAW,CAAA;IACnB,OAAO,CAAC,WAAW,CAAA;IACnB,OAAO,CAAC,eAAe,CAAA;IACvB,OAAO,CAAC,oBAAoB,CAAC,CAAkB;IAE/C,OAAO,CAAC,QAAQ,CAA6B;IAC7C,OAAO,CAAC,eAAe,CAA4B;gBAGhC,QAAQ,EAAE;QACzB,UAAU,EAAE,MAAM,CAAA;QAClB,UAAU,EAAE,MAAM,CAAA;QAClB,cAAc,EAAE,MAAM,CAAA;QACtB,OAAO,EAAE,MAAM,CAAA;QACf,oBAAoB,CAAC,EAAE,CAAC,GAAG,EAAE,CAAC,KAAK,IAAI,CAAA;KACxC;IAqBH,OAAO,CAAC,cAAc,CAUrB;IAED,OAAO,CAAC,UAAU,CAEjB;IACD,OAAO,CAAC,UAAU,CAEjB;IAEM,gBAAgB,GAAI,KAAK,CAAC,aAiBhC;IAEM,IAAI;CAMZ"}
+{"version":3,"file":"bucketed-rate-limiter.d.ts","sourceRoot":"","sources":["../../src/utils/bucketed-rate-limiter.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,UAAU,CAAA;AAMjC,qBAAa,mBAAmB,CAAC,CAAC,SAAS,MAAM,GAAG,MAAM;IACxD,OAAO,CAAC,WAAW,CAAQ;IAC3B,OAAO,CAAC,WAAW,CAAQ;IAC3B,OAAO,CAAC,eAAe,CAAQ;IAC/B,OAAO,CAAC,oBAAoB,CAAC,CAAkB;IAC/C,OAAO,CAAC,QAAQ,CAA6B;gBAEjC,OAAO,EAAE;QACnB,UAAU,EAAE,MAAM,CAAA;QAClB,UAAU,EAAE,MAAM,CAAA;QAClB,cAAc,EAAE,MAAM,CAAA;QACtB,OAAO,EAAE,MAAM,CAAA;QACf,oBAAoB,CAAC,EAAE,CAAC,GAAG,EAAE,CAAC,KAAK,IAAI,CAAA;KACxC;IAOD,OAAO,CAAC,YAAY;IAWb,gBAAgB,CAAC,GAAG,EAAE,CAAC,GAAG,OAAO;IA0BjC,IAAI,IAAI,IAAI;CAGpB"}

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

@@ -27,43 +27,43 @@ __webpack_require__.d(__webpack_exports__, {
     BucketedRateLimiter: ()=>BucketedRateLimiter
 });
 const external_number_utils_js_namespaceObject = require("./number-utils.js");
+const ONE_DAY_IN_MS = 86400000;
 class BucketedRateLimiter {
-    constructor(_options){
-        this._options = _options;
+    constructor(options){
         this._buckets = {};
-        this._refillBuckets = ()=>{
-            Object.keys(this._buckets).forEach((key)=>{
-                const newTokens = this._getBucket(key) + this._refillRate;
-                if (newTokens >= this._bucketSize) delete this._buckets[key];
-                else this._setBucket(key, newTokens);
-            });
-        };
-        this._getBucket = (key)=>this._buckets[String(key)];
-        this._setBucket = (key, value)=>{
-            this._buckets[String(key)] = value;
-        };
-        this.consumeRateLimit = (key)=>{
-            let tokens = this._getBucket(key) ?? this._bucketSize;
-            tokens = Math.max(tokens - 1, 0);
-            if (0 === tokens) return true;
-            this._setBucket(key, tokens);
-            const hasReachedZero = 0 === tokens;
-            if (hasReachedZero) this._onBucketRateLimited?.(key);
-            return hasReachedZero;
-        };
-        this._onBucketRateLimited = this._options._onBucketRateLimited;
-        this._bucketSize = (0, external_number_utils_js_namespaceObject.clampToRange)(this._options.bucketSize, 0, 100, this._options._logger);
-        this._refillRate = (0, external_number_utils_js_namespaceObject.clampToRange)(this._options.refillRate, 0, this._bucketSize, this._options._logger);
-        this._refillInterval = (0, external_number_utils_js_namespaceObject.clampToRange)(this._options.refillInterval, 0, 86400000, this._options._logger);
-        this._removeInterval = setInterval(()=>{
-            this._refillBuckets();
-        }, this._refillInterval);
+        this._onBucketRateLimited = options._onBucketRateLimited;
+        this._bucketSize = (0, external_number_utils_js_namespaceObject.clampToRange)(options.bucketSize, 0, 100, options._logger);
+        this._refillRate = (0, external_number_utils_js_namespaceObject.clampToRange)(options.refillRate, 0, this._bucketSize, options._logger);
+        this._refillInterval = (0, external_number_utils_js_namespaceObject.clampToRange)(options.refillInterval, 0, ONE_DAY_IN_MS, options._logger);
     }
-    stop() {
-        if (this._removeInterval) {
-            clearInterval(this._removeInterval);
-            this._removeInterval = void 0;
+    _applyRefill(bucket, now) {
+        const elapsedMs = now - bucket.lastAccess;
+        const refillIntervals = Math.floor(elapsedMs / this._refillInterval);
+        if (refillIntervals > 0) {
+            const tokensToAdd = refillIntervals * this._refillRate;
+            bucket.tokens = Math.min(bucket.tokens + tokensToAdd, this._bucketSize);
+            bucket.lastAccess = bucket.lastAccess + refillIntervals * this._refillInterval;
+        }
+    }
+    consumeRateLimit(key) {
+        const now = Date.now();
+        const keyStr = String(key);
+        let bucket = this._buckets[keyStr];
+        if (bucket) this._applyRefill(bucket, now);
+        else {
+            bucket = {
+                tokens: this._bucketSize,
+                lastAccess: now
+            };
+            this._buckets[keyStr] = bucket;
         }
+        if (0 === bucket.tokens) return true;
+        bucket.tokens--;
+        if (0 === bucket.tokens) this._onBucketRateLimited?.(key);
+        return 0 === bucket.tokens;
+    }
+    stop() {
+        this._buckets = {};
     }
 }
 exports.BucketedRateLimiter = __webpack_exports__.BucketedRateLimiter;

package/dist/utils/bucketed-rate-limiter.mjs

@@ -1,41 +1,41 @@
 import { clampToRange } from "./number-utils.mjs";
+const ONE_DAY_IN_MS = 86400000;
 class BucketedRateLimiter {
-    constructor(_options){
-        this._options = _options;
+    constructor(options){
         this._buckets = {};
-        this._refillBuckets = ()=>{
-            Object.keys(this._buckets).forEach((key)=>{
-                const newTokens = this._getBucket(key) + this._refillRate;
-                if (newTokens >= this._bucketSize) delete this._buckets[key];
-                else this._setBucket(key, newTokens);
-            });
-        };
-        this._getBucket = (key)=>this._buckets[String(key)];
-        this._setBucket = (key, value)=>{
-            this._buckets[String(key)] = value;
-        };
-        this.consumeRateLimit = (key)=>{
-            let tokens = this._getBucket(key) ?? this._bucketSize;
-            tokens = Math.max(tokens - 1, 0);
-            if (0 === tokens) return true;
-            this._setBucket(key, tokens);
-            const hasReachedZero = 0 === tokens;
-            if (hasReachedZero) this._onBucketRateLimited?.(key);
-            return hasReachedZero;
-        };
-        this._onBucketRateLimited = this._options._onBucketRateLimited;
-        this._bucketSize = clampToRange(this._options.bucketSize, 0, 100, this._options._logger);
-        this._refillRate = clampToRange(this._options.refillRate, 0, this._bucketSize, this._options._logger);
-        this._refillInterval = clampToRange(this._options.refillInterval, 0, 86400000, this._options._logger);
-        this._removeInterval = setInterval(()=>{
-            this._refillBuckets();
-        }, this._refillInterval);
+        this._onBucketRateLimited = options._onBucketRateLimited;
+        this._bucketSize = clampToRange(options.bucketSize, 0, 100, options._logger);
+        this._refillRate = clampToRange(options.refillRate, 0, this._bucketSize, options._logger);
+        this._refillInterval = clampToRange(options.refillInterval, 0, ONE_DAY_IN_MS, options._logger);
     }
-    stop() {
-        if (this._removeInterval) {
-            clearInterval(this._removeInterval);
-            this._removeInterval = void 0;
+    _applyRefill(bucket, now) {
+        const elapsedMs = now - bucket.lastAccess;
+        const refillIntervals = Math.floor(elapsedMs / this._refillInterval);
+        if (refillIntervals > 0) {
+            const tokensToAdd = refillIntervals * this._refillRate;
+            bucket.tokens = Math.min(bucket.tokens + tokensToAdd, this._bucketSize);
+            bucket.lastAccess = bucket.lastAccess + refillIntervals * this._refillInterval;
+        }
+    }
+    consumeRateLimit(key) {
+        const now = Date.now();
+        const keyStr = String(key);
+        let bucket = this._buckets[keyStr];
+        if (bucket) this._applyRefill(bucket, now);
+        else {
+            bucket = {
+                tokens: this._bucketSize,
+                lastAccess: now
+            };
+            this._buckets[keyStr] = bucket;
         }
+        if (0 === bucket.tokens) return true;
+        bucket.tokens--;
+        if (0 === bucket.tokens) this._onBucketRateLimited?.(key);
+        return 0 === bucket.tokens;
+    }
+    stop() {
+        this._buckets = {};
     }
 }
 export { BucketedRateLimiter };

package/dist/utils/index.d.ts

@@ -1,4 +1,5 @@
 import { FetchLike } from '../types';
+export * from './bot-detection';
 export * from './bucketed-rate-limiter';
 export * from './number-utils';
 export * from './string-utils';

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/utils/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,UAAU,CAAA;AAEpC,cAAc,yBAAyB,CAAA;AACvC,cAAc,gBAAgB,CAAA;AAC9B,cAAc,gBAAgB,CAAA;AAC9B,cAAc,cAAc,CAAA;AAC5B,cAAc,iBAAiB,CAAA;AAE/B,eAAO,MAAM,aAAa,SAAS,CAAA;AAEnC,wBAAgB,MAAM,CAAC,WAAW,EAAE,GAAG,EAAE,OAAO,EAAE,MAAM,GAAG,IAAI,CAI9D;AASD,wBAAgB,mBAAmB,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAEvD;AAED,MAAM,WAAW,gBAAgB;IAC/B,UAAU,EAAE,MAAM,CAAA;IAClB,UAAU,EAAE,MAAM,CAAA;IAClB,UAAU,EAAE,CAAC,GAAG,EAAE,OAAO,KAAK,OAAO,CAAA;CACtC;AAED,wBAAsB,SAAS,CAAC,CAAC,EAAE,EAAE,EAAE,MAAM,OAAO,CAAC,CAAC,CAAC,EAAE,KAAK,EAAE,gBAAgB,GAAG,OAAO,CAAC,CAAC,CAAC,CAqB5F;AAED,wBAAgB,gBAAgB,IAAI,MAAM,CAEzC;AAED,wBAAgB,cAAc,IAAI,MAAM,CAEvC;AAED,wBAAgB,cAAc,CAAC,EAAE,EAAE,MAAM,IAAI,EAAE,OAAO,EAAE,MAAM,GAAG,GAAG,CAOnE;AAGD,eAAO,MAAM,SAAS,GAAI,KAAK,GAAG,KAAG,GAAG,IAAI,OAAO,CAAC,GAAG,CAEtD,CAAA;AAED,eAAO,MAAM,OAAO,GAAI,GAAG,OAAO,KAAG,CAAC,IAAI,KAEzC,CAAA;AAED,wBAAgB,QAAQ,IAAI,SAAS,GAAG,SAAS,CAEhD;AAED,wBAAgB,UAAU,CAAC,CAAC,EAC1B,QAAQ,EAAE,CAAC,OAAO,CAAC,CAAC,CAAC,GAAG,IAAI,GAAG,SAAS,CAAC,EAAE,GAC1C,OAAO,CAAC,CAAC;IAAE,MAAM,EAAE,WAAW,CAAC;IAAC,KAAK,EAAE,CAAC,CAAA;CAAE,GAAG;IAAE,MAAM,EAAE,UAAU,CAAC;IAAC,MAAM,EAAE,GAAG,CAAA;CAAE,CAAC,EAAE,CAAC,CAStF"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/utils/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,UAAU,CAAA;AAEpC,cAAc,iBAAiB,CAAA;AAC/B,cAAc,yBAAyB,CAAA;AACvC,cAAc,gBAAgB,CAAA;AAC9B,cAAc,gBAAgB,CAAA;AAC9B,cAAc,cAAc,CAAA;AAC5B,cAAc,iBAAiB,CAAA;AAE/B,eAAO,MAAM,aAAa,SAAS,CAAA;AAEnC,wBAAgB,MAAM,CAAC,WAAW,EAAE,GAAG,EAAE,OAAO,EAAE,MAAM,GAAG,IAAI,CAI9D;AASD,wBAAgB,mBAAmB,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAEvD;AAED,MAAM,WAAW,gBAAgB;IAC/B,UAAU,EAAE,MAAM,CAAA;IAClB,UAAU,EAAE,MAAM,CAAA;IAClB,UAAU,EAAE,CAAC,GAAG,EAAE,OAAO,KAAK,OAAO,CAAA;CACtC;AAED,wBAAsB,SAAS,CAAC,CAAC,EAAE,EAAE,EAAE,MAAM,OAAO,CAAC,CAAC,CAAC,EAAE,KAAK,EAAE,gBAAgB,GAAG,OAAO,CAAC,CAAC,CAAC,CAqB5F;AAED,wBAAgB,gBAAgB,IAAI,MAAM,CAEzC;AAED,wBAAgB,cAAc,IAAI,MAAM,CAEvC;AAED,wBAAgB,cAAc,CAAC,EAAE,EAAE,MAAM,IAAI,EAAE,OAAO,EAAE,MAAM,GAAG,GAAG,CAOnE;AAGD,eAAO,MAAM,SAAS,GAAI,KAAK,GAAG,KAAG,GAAG,IAAI,OAAO,CAAC,GAAG,CAEtD,CAAA;AAED,eAAO,MAAM,OAAO,GAAI,GAAG,OAAO,KAAG,CAAC,IAAI,KAEzC,CAAA;AAED,wBAAgB,QAAQ,IAAI,SAAS,GAAG,SAAS,CAEhD;AAED,wBAAgB,UAAU,CAAC,CAAC,EAC1B,QAAQ,EAAE,CAAC,OAAO,CAAC,CAAC,CAAC,GAAG,IAAI,GAAG,SAAS,CAAC,EAAE,GAC1C,OAAO,CAAC,CAAC;IAAE,MAAM,EAAE,WAAW,CAAC;IAAC,KAAK,EAAE,CAAC,CAAA;CAAE,GAAG;IAAE,MAAM,EAAE,UAAU,CAAC;IAAC,MAAM,EAAE,GAAG,CAAA;CAAE,CAAC,EAAE,CAAC,CAStF"}

package/dist/utils/index.js

@@ -1,5 +1,8 @@
 "use strict";
 var __webpack_modules__ = {
+    "./bot-detection": function(module) {
+        module.exports = require("./bot-detection.js");
+    },
     "./bucketed-rate-limiter": function(module) {
         module.exports = require("./bucketed-rate-limiter.js");
     },
@@ -72,9 +75,28 @@ var __webpack_exports__ = {};
         retriable: ()=>retriable,
         safeSetTimeout: ()=>safeSetTimeout
     });
-    var _bucketed_rate_limiter__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__("./bucketed-rate-limiter");
+    var _bot_detection__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__("./bot-detection");
+    var __WEBPACK_REEXPORT_OBJECT__ = {};
+    for(var __WEBPACK_IMPORT_KEY__ in _bot_detection__WEBPACK_IMPORTED_MODULE_0__)if ([
+        "removeTrailingSlash",
+        "retriable",
+        "default",
+        "currentISOTime",
+        "currentTimestamp",
+        "STRING_FORMAT",
+        "isError",
+        "safeSetTimeout",
+        "getFetch",
+        "isPromise",
+        "assert",
+        "allSettled"
+    ].indexOf(__WEBPACK_IMPORT_KEY__) < 0) __WEBPACK_REEXPORT_OBJECT__[__WEBPACK_IMPORT_KEY__] = (function(key) {
+        return _bot_detection__WEBPACK_IMPORTED_MODULE_0__[key];
+    }).bind(0, __WEBPACK_IMPORT_KEY__);
+    __webpack_require__.d(__webpack_exports__, __WEBPACK_REEXPORT_OBJECT__);
+    var _bucketed_rate_limiter__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__("./bucketed-rate-limiter");
     var __WEBPACK_REEXPORT_OBJECT__ = {};
-    for(var __WEBPACK_IMPORT_KEY__ in _bucketed_rate_limiter__WEBPACK_IMPORTED_MODULE_0__)if ([
+    for(var __WEBPACK_IMPORT_KEY__ in _bucketed_rate_limiter__WEBPACK_IMPORTED_MODULE_1__)if ([
         "removeTrailingSlash",
         "retriable",
         "default",
@@ -88,12 +110,12 @@ var __webpack_exports__ = {};
         "assert",
         "allSettled"
     ].indexOf(__WEBPACK_IMPORT_KEY__) < 0) __WEBPACK_REEXPORT_OBJECT__[__WEBPACK_IMPORT_KEY__] = (function(key) {
-        return _bucketed_rate_limiter__WEBPACK_IMPORTED_MODULE_0__[key];
+        return _bucketed_rate_limiter__WEBPACK_IMPORTED_MODULE_1__[key];
     }).bind(0, __WEBPACK_IMPORT_KEY__);
     __webpack_require__.d(__webpack_exports__, __WEBPACK_REEXPORT_OBJECT__);
-    var _number_utils__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__("./number-utils");
+    var _number_utils__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__("./number-utils");
     var __WEBPACK_REEXPORT_OBJECT__ = {};
-    for(var __WEBPACK_IMPORT_KEY__ in _number_utils__WEBPACK_IMPORTED_MODULE_1__)if ([
+    for(var __WEBPACK_IMPORT_KEY__ in _number_utils__WEBPACK_IMPORTED_MODULE_2__)if ([
         "removeTrailingSlash",
         "retriable",
         "default",
@@ -107,12 +129,12 @@ var __webpack_exports__ = {};
         "assert",
         "allSettled"
     ].indexOf(__WEBPACK_IMPORT_KEY__) < 0) __WEBPACK_REEXPORT_OBJECT__[__WEBPACK_IMPORT_KEY__] = (function(key) {
-        return _number_utils__WEBPACK_IMPORTED_MODULE_1__[key];
+        return _number_utils__WEBPACK_IMPORTED_MODULE_2__[key];
     }).bind(0, __WEBPACK_IMPORT_KEY__);
     __webpack_require__.d(__webpack_exports__, __WEBPACK_REEXPORT_OBJECT__);
-    var _string_utils__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__("./string-utils");
+    var _string_utils__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__("./string-utils");
     var __WEBPACK_REEXPORT_OBJECT__ = {};
-    for(var __WEBPACK_IMPORT_KEY__ in _string_utils__WEBPACK_IMPORTED_MODULE_2__)if ([
+    for(var __WEBPACK_IMPORT_KEY__ in _string_utils__WEBPACK_IMPORTED_MODULE_3__)if ([
         "removeTrailingSlash",
         "retriable",
         "default",
@@ -126,12 +148,12 @@ var __webpack_exports__ = {};
         "assert",
         "allSettled"
     ].indexOf(__WEBPACK_IMPORT_KEY__) < 0) __WEBPACK_REEXPORT_OBJECT__[__WEBPACK_IMPORT_KEY__] = (function(key) {
-        return _string_utils__WEBPACK_IMPORTED_MODULE_2__[key];
+        return _string_utils__WEBPACK_IMPORTED_MODULE_3__[key];
     }).bind(0, __WEBPACK_IMPORT_KEY__);
     __webpack_require__.d(__webpack_exports__, __WEBPACK_REEXPORT_OBJECT__);
-    var _type_utils__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__("./type-utils");
+    var _type_utils__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__("./type-utils");
     var __WEBPACK_REEXPORT_OBJECT__ = {};
-    for(var __WEBPACK_IMPORT_KEY__ in _type_utils__WEBPACK_IMPORTED_MODULE_3__)if ([
+    for(var __WEBPACK_IMPORT_KEY__ in _type_utils__WEBPACK_IMPORTED_MODULE_4__)if ([
         "removeTrailingSlash",
         "retriable",
         "default",
@@ -145,12 +167,12 @@ var __webpack_exports__ = {};
         "assert",
         "allSettled"
     ].indexOf(__WEBPACK_IMPORT_KEY__) < 0) __WEBPACK_REEXPORT_OBJECT__[__WEBPACK_IMPORT_KEY__] = (function(key) {
-        return _type_utils__WEBPACK_IMPORTED_MODULE_3__[key];
+        return _type_utils__WEBPACK_IMPORTED_MODULE_4__[key];
     }).bind(0, __WEBPACK_IMPORT_KEY__);
     __webpack_require__.d(__webpack_exports__, __WEBPACK_REEXPORT_OBJECT__);
-    var _promise_queue__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__("./promise-queue");
+    var _promise_queue__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__("./promise-queue");
     var __WEBPACK_REEXPORT_OBJECT__ = {};
-    for(var __WEBPACK_IMPORT_KEY__ in _promise_queue__WEBPACK_IMPORTED_MODULE_4__)if ([
+    for(var __WEBPACK_IMPORT_KEY__ in _promise_queue__WEBPACK_IMPORTED_MODULE_5__)if ([
         "removeTrailingSlash",
         "retriable",
         "default",
@@ -164,7 +186,7 @@ var __webpack_exports__ = {};
         "assert",
         "allSettled"
     ].indexOf(__WEBPACK_IMPORT_KEY__) < 0) __WEBPACK_REEXPORT_OBJECT__[__WEBPACK_IMPORT_KEY__] = (function(key) {
-        return _promise_queue__WEBPACK_IMPORTED_MODULE_4__[key];
+        return _promise_queue__WEBPACK_IMPORTED_MODULE_5__[key];
     }).bind(0, __WEBPACK_IMPORT_KEY__);
     __webpack_require__.d(__webpack_exports__, __WEBPACK_REEXPORT_OBJECT__);
     const STRING_FORMAT = 'utf8';

package/dist/utils/index.mjs

@@ -1,3 +1,4 @@
+export * from "./bot-detection.mjs";
 export * from "./bucketed-rate-limiter.mjs";
 export * from "./number-utils.mjs";
 export * from "./string-utils.mjs";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@posthog/core",
-  "version": "1.3.1",
+  "version": "1.5.0",
   "license": "MIT",
   "main": "dist/index.js",
   "module": "dist/index.mjs",

package/src/utils/bot-detection.ts

@@ -0,0 +1,114 @@
+// List of blocked user agent strings that identify bots
+// This is shared between browser and node SDKs to ensure consistent bot detection
+export const DEFAULT_BLOCKED_UA_STRS = [
+  // Random assortment of bots
+  'amazonbot',
+  'amazonproductbot',
+  'app.hypefactors.com', // Buck, but "buck" is too short to be safe to block (https://app.hypefactors.com/media-monitoring/about.htm)
+  'applebot',
+  'archive.org_bot',
+  'awariobot',
+  'backlinksextendedbot',
+  'baiduspider',
+  'bingbot',
+  'bingpreview',
+  'chrome-lighthouse',
+  'dataforseobot',
+  'deepscan',
+  'duckduckbot',
+  'facebookexternal',
+  'facebookcatalog',
+  'http://yandex.com/bots',
+  'hubspot',
+  'ia_archiver',
+  'leikibot',
+  'linkedinbot',
+  'meta-externalagent',
+  'mj12bot',
+  'msnbot',
+  'nessus',
+  'petalbot',
+  'pinterest',
+  'prerender',
+  'rogerbot',
+  'screaming frog',
+  'sebot-wa',
+  'sitebulb',
+  'slackbot',
+  'slurp',
+  'trendictionbot',
+  'turnitin',
+  'twitterbot',
+  'vercel-screenshot',
+  'vercelbot',
+  'yahoo! slurp',
+  'yandexbot',
+  'zoombot',
+
+  // Bot-like words, maybe we should block `bot` entirely?
+  'bot.htm',
+  'bot.php',
+  '(bot;',
+  'bot/',
+  'crawler',
+
+  // Ahrefs: https://ahrefs.com/seo/glossary/ahrefsbot
+  'ahrefsbot',
+  'ahrefssiteaudit',
+
+  // Semrush bots: https://www.semrush.com/bot/
+  'semrushbot',
+  'siteauditbot',
+  'splitsignalbot',
+
+  // AI Crawlers
+  'gptbot',
+  'oai-searchbot',
+  'chatgpt-user',
+  'perplexitybot',
+
+  // Uptime-like stuff
+  'better uptime bot',
+  'sentryuptimebot',
+  'uptimerobot',
+
+  // headless browsers
+  'headlesschrome',
+  'cypress',
+  // we don't block electron here, as many customers use posthog-js in electron apps
+
+  // a whole bunch of goog-specific crawlers
+  // https://developers.google.com/search/docs/advanced/crawling/overview-google-crawlers
+  'google-hoteladsverifier',
+  'adsbot-google',
+  'apis-google',
+  'duplexweb-google',
+  'feedfetcher-google',
+  'google favicon',
+  'google web preview',
+  'google-read-aloud',
+  'googlebot',
+  'googleother',
+  'google-cloudvertexbot',
+  'googleweblight',
+  'mediapartners-google',
+  'storebot-google',
+  'google-inspectiontool',
+  'bytespider',
+]
+
+/**
+ * Block various web spiders from executing our JS and sending false capturing data
+ */
+export const isBlockedUA = function (ua: string | undefined, customBlockedUserAgents: string[] = []): boolean {
+  if (!ua) {
+    return false
+  }
+
+  const uaLower = ua.toLowerCase()
+  return DEFAULT_BLOCKED_UA_STRS.concat(customBlockedUserAgents).some((blockedUA) => {
+    const blockedUaLower = blockedUA.toLowerCase()
+    // can't use includes because IE 11 :/
+    return uaLower.indexOf(blockedUaLower) !== -1
+  })
+}

package/src/utils/bucketed-rate-limiter.spec.ts

@@ -19,15 +19,272 @@ describe('BucketedRateLimiter', () => {
     jest.clearAllMocks()
   })
 
-  test('it is not rate limited by default', () => {
-    const result = rateLimiter.consumeRateLimit('ResizeObserver')
-    expect(result).toBe(false)
+  describe('basic consumption', () => {
+    test('it is not rate limited by default', () => {
+      const result = rateLimiter.consumeRateLimit('ResizeObserver')
+      expect(result).toBe(false)
+    })
+
+    test('returns bucket is rate limited if no mutations are left', () => {
+      rateLimiter['_buckets']['ResizeObserver'] = { tokens: 0, lastAccess: Date.now() }
+
+      const result = rateLimiter.consumeRateLimit('ResizeObserver')
+      expect(result).toBe(true)
+    })
+
+    test.each([
+      { bucketSize: 1, consumptions: 1 },
+      { bucketSize: 5, consumptions: 5 },
+      { bucketSize: 10, consumptions: 10 },
+      { bucketSize: 50, consumptions: 50 },
+    ])('exhausts bucket of size $bucketSize after $consumptions consumptions', ({ bucketSize, consumptions }) => {
+      const limiter = new BucketedRateLimiter({
+        bucketSize,
+        refillRate: 1,
+        refillInterval: 1000,
+        _logger: {} as unknown as Logger,
+      })
+
+      for (let i = 0; i < consumptions - 1; i++) {
+        expect(limiter.consumeRateLimit('test')).toBe(false)
+      }
+
+      expect(limiter.consumeRateLimit('test')).toBe(true)
+      // can check the same bucket more than once
+      expect(limiter.consumeRateLimit('test')).toBe(true)
+    })
+  })
+
+  describe('refill behavior', () => {
+    test('refills tokens based on elapsed time', () => {
+      const key = 'ResizeObserver'
+
+      for (let i = 0; i < 9; i++) {
+        expect(rateLimiter.consumeRateLimit(key)).toBe(false)
+      }
+
+      expect(rateLimiter.consumeRateLimit(key)).toBe(true)
+
+      jest.advanceTimersByTime(2000)
+
+      const result = rateLimiter.consumeRateLimit(key)
+      expect(result).toBe(false)
+
+      const bucket = rateLimiter['_buckets'][key]
+      expect(bucket.tokens).toBe(1)
+    })
+
+    test('refills to bucket size maximum', () => {
+      const key = 'ResizeObserver'
+      rateLimiter.consumeRateLimit(key)
+
+      jest.advanceTimersByTime(20000)
+
+      rateLimiter.consumeRateLimit(key)
+
+      const bucket = rateLimiter['_buckets'][key]
+      expect(bucket.tokens).toBe(9)
+    })
+
+    test('partial refill intervals do not refill tokens', () => {
+      const key = 'test'
+
+      for (let i = 0; i < 9; i++) {
+        rateLimiter.consumeRateLimit(key)
+      }
+
+      jest.advanceTimersByTime(999)
+
+      rateLimiter.consumeRateLimit(key)
+      expect(rateLimiter['_buckets'][key].tokens).toBe(0)
+    })
+
+    test.each([
+      { refillRate: 1, intervals: 1, expected: 9 },
+      { refillRate: 2, intervals: 1, expected: 9 },
+      { refillRate: 1, intervals: 2, expected: 9 },
+      { refillRate: 3, intervals: 1, tokensLeft: 5, expected: 7 },
+      { refillRate: 2, intervals: 2, tokensLeft: 5, expected: 8 },
+    ])(
+      'with rate $refillRate, $intervals intervals, starting at $tokensLeft tokens, ends at $expected',
+      ({ refillRate, intervals, tokensLeft = 9, expected }) => {
+        const limiter = new BucketedRateLimiter({
+          bucketSize: 10,
+          refillRate,
+          refillInterval: 1000,
+          _logger: {} as unknown as Logger,
+        })
+
+        const consumptions = 10 - tokensLeft
+        for (let i = 0; i < consumptions; i++) {
+          limiter.consumeRateLimit('test')
+        }
+
+        jest.advanceTimersByTime(intervals * 1000)
+
+        limiter.consumeRateLimit('test')
+        expect(limiter['_buckets']['test'].tokens).toBe(expected)
+      }
+    )
+  })
+
+  describe('bucket isolation', () => {
+    test('different keys maintain separate buckets', () => {
+      const key1 = 'bucket1'
+      const key2 = 'bucket2'
+
+      for (let i = 0; i < 9; i++) {
+        rateLimiter.consumeRateLimit(key1)
+      }
+
+      expect(rateLimiter.consumeRateLimit(key1)).toBe(true)
+      expect(rateLimiter.consumeRateLimit(key2)).toBe(false)
+
+      expect(rateLimiter['_buckets'][key1].tokens).toBe(0)
+      expect(rateLimiter['_buckets'][key2].tokens).toBe(9)
+    })
+
+    test('supports both string and number keys', () => {
+      const limiter = new BucketedRateLimiter<string | number>({
+        bucketSize: 5,
+        refillRate: 1,
+        refillInterval: 1000,
+        _logger: {} as unknown as Logger,
+      })
+
+      for (let i = 0; i < 4; i++) {
+        limiter.consumeRateLimit('string-key')
+        limiter.consumeRateLimit(123)
+      }
+
+      expect(limiter['_buckets']['string-key'].tokens).toBe(1)
+      expect(limiter['_buckets']['123'].tokens).toBe(1)
+    })
+  })
+
+  describe('callback behavior', () => {
+    test('invokes callback when bucket reaches zero', () => {
+      const callback = jest.fn()
+      const limiter = new BucketedRateLimiter({
+        bucketSize: 3,
+        refillRate: 1,
+        refillInterval: 1000,
+        _logger: {} as unknown as Logger,
+        _onBucketRateLimited: callback,
+      })
+
+      limiter.consumeRateLimit('test')
+      limiter.consumeRateLimit('test')
+      expect(callback).not.toHaveBeenCalled()
+
+      limiter.consumeRateLimit('test')
+      expect(callback).toHaveBeenCalledWith('test')
+      expect(callback).toHaveBeenCalledTimes(1)
+    })
+
+    test('does not invoke callback for subsequent calls when already at zero', () => {
+      const callback = jest.fn()
+      const limiter = new BucketedRateLimiter({
+        bucketSize: 2,
+        refillRate: 1,
+        refillInterval: 1000,
+        _logger: {} as unknown as Logger,
+        _onBucketRateLimited: callback,
+      })
+
+      limiter.consumeRateLimit('test')
+      limiter.consumeRateLimit('test')
+      expect(callback).toHaveBeenCalledTimes(1)
+
+      limiter.consumeRateLimit('test')
+      limiter.consumeRateLimit('test')
+      expect(callback).toHaveBeenCalledTimes(1)
+    })
+
+    test('invokes callback again after refill and re-exhaustion', () => {
+      const callback = jest.fn()
+      const limiter = new BucketedRateLimiter({
+        bucketSize: 2,
+        refillRate: 1,
+        refillInterval: 1000,
+        _logger: {} as unknown as Logger,
+        _onBucketRateLimited: callback,
+      })
+
+      limiter.consumeRateLimit('test')
+      limiter.consumeRateLimit('test')
+      expect(callback).toHaveBeenCalledTimes(1)
+
+      jest.advanceTimersByTime(2000)
+
+      limiter.consumeRateLimit('test')
+      limiter.consumeRateLimit('test')
+      expect(callback).toHaveBeenCalledTimes(2)
+    })
+  })
+
+  describe('stop method', () => {
+    test('clears all buckets', () => {
+      rateLimiter.consumeRateLimit('key1')
+      rateLimiter.consumeRateLimit('key2')
+
+      expect(Object.keys(rateLimiter['_buckets']).length).toBe(2)
+
+      rateLimiter.stop()
+
+      expect(Object.keys(rateLimiter['_buckets']).length).toBe(0)
+    })
+
+    test('resets state after stop', () => {
+      for (let i = 0; i < 9; i++) {
+        rateLimiter.consumeRateLimit('test')
+      }
+
+      rateLimiter.stop()
+
+      expect(rateLimiter.consumeRateLimit('test')).toBe(false)
+      expect(rateLimiter['_buckets']['test'].tokens).toBe(9)
+    })
   })
 
-  test('returns true if no mutations are left', () => {
-    rateLimiter['_buckets']['ResizeObserver'] = 0
+  describe('timestamp tracking', () => {
+    test('preserves fractional intervals', () => {
+      const key = 'test'
+      const startTime = Date.now()
+
+      rateLimiter.consumeRateLimit(key)
+      expect(rateLimiter['_buckets'][key].lastAccess).toBe(startTime)
+      expect(rateLimiter['_buckets'][key].tokens).toBe(9)
+
+      jest.advanceTimersByTime(500)
+
+      rateLimiter.consumeRateLimit(key)
+      expect(rateLimiter['_buckets'][key].lastAccess).toBe(startTime)
+      expect(rateLimiter['_buckets'][key].tokens).toBe(8)
 
-    const result = rateLimiter.consumeRateLimit('ResizeObserver')
-    expect(result).toBe(true)
+      jest.advanceTimersByTime(600)
+
+      rateLimiter.consumeRateLimit(key)
+      expect(rateLimiter['_buckets'][key].lastAccess).toBe(startTime + 1000)
+      expect(rateLimiter['_buckets'][key].tokens).toBe(8)
+    })
+
+    test('advances lastAccess by complete intervals on refill', () => {
+      const key = 'test'
+      const startTime = Date.now()
+
+      for (let i = 0; i < 9; i++) {
+        rateLimiter.consumeRateLimit(key)
+      }
+
+      expect(rateLimiter['_buckets'][key].lastAccess).toBe(startTime)
+
+      jest.advanceTimersByTime(2500)
+
+      rateLimiter.consumeRateLimit(key)
+
+      expect(rateLimiter['_buckets'][key].lastAccess).toBe(startTime + 2000)
+      expect(rateLimiter['_buckets'][key].tokens).toBe(2)
+    })
   })
 })

package/src/utils/bucketed-rate-limiter.ts

@@ -1,85 +1,67 @@
 import { Logger } from '../types'
 import { clampToRange } from './number-utils'
 
+type Bucket = { tokens: number; lastAccess: number }
+const ONE_DAY_IN_MS = 86400000
+
 export class BucketedRateLimiter<T extends string | number> {
-  private _bucketSize
-  private _refillRate
-  private _refillInterval
+  private _bucketSize: number
+  private _refillRate: number
+  private _refillInterval: number
   private _onBucketRateLimited?: (key: T) => void
+  private _buckets: Record<string, Bucket> = {}
 
-  private _buckets: Record<string, number> = {}
-  private _removeInterval: NodeJS.Timeout | undefined
-
-  constructor(
-    private readonly _options: {
-      bucketSize: number
-      refillRate: number
-      refillInterval: number
-      _logger: Logger
-      _onBucketRateLimited?: (key: T) => void
-    }
-  ) {
-    this._onBucketRateLimited = this._options._onBucketRateLimited
-    this._bucketSize = clampToRange(this._options.bucketSize, 0, 100, this._options._logger)
-    this._refillRate = clampToRange(
-      this._options.refillRate,
-      0,
-      this._bucketSize, // never refill more than bucket size
-      this._options._logger
-    )
-    this._refillInterval = clampToRange(
-      this._options.refillInterval,
-      0,
-      86400000, // one day in milliseconds
-      this._options._logger
-    )
-    this._removeInterval = setInterval(() => {
-      this._refillBuckets()
-    }, this._refillInterval)
+  constructor(options: {
+    bucketSize: number
+    refillRate: number
+    refillInterval: number
+    _logger: Logger
+    _onBucketRateLimited?: (key: T) => void
+  }) {
+    this._onBucketRateLimited = options._onBucketRateLimited
+    this._bucketSize = clampToRange(options.bucketSize, 0, 100, options._logger)
+    this._refillRate = clampToRange(options.refillRate, 0, this._bucketSize, options._logger)
+    this._refillInterval = clampToRange(options.refillInterval, 0, ONE_DAY_IN_MS, options._logger)
   }
 
-  private _refillBuckets = () => {
-    Object.keys(this._buckets).forEach((key) => {
-      const newTokens = this._getBucket(key) + this._refillRate
+  private _applyRefill(bucket: Bucket, now: number): void {
+    const elapsedMs = now - bucket.lastAccess
+    const refillIntervals = Math.floor(elapsedMs / this._refillInterval)
 
-      if (newTokens >= this._bucketSize) {
-        delete this._buckets[key]
-      } else {
-        this._setBucket(key, newTokens)
-      }
-    })
+    if (refillIntervals > 0) {
+      const tokensToAdd = refillIntervals * this._refillRate
+      bucket.tokens = Math.min(bucket.tokens + tokensToAdd, this._bucketSize)
+      bucket.lastAccess = bucket.lastAccess + refillIntervals * this._refillInterval
+    }
   }
 
-  private _getBucket = (key: T | string) => {
-    return this._buckets[String(key)]
-  }
-  private _setBucket = (key: T | string, value: number) => {
-    this._buckets[String(key)] = value
-  }
+  public consumeRateLimit(key: T): boolean {
+    const now = Date.now()
+    const keyStr = String(key)
 
-  public consumeRateLimit = (key: T) => {
-    let tokens = this._getBucket(key) ?? this._bucketSize
-    tokens = Math.max(tokens - 1, 0)
+    let bucket = this._buckets[keyStr]
 
-    if (tokens === 0) {
-      return true
+    if (!bucket) {
+      bucket = { tokens: this._bucketSize, lastAccess: now }
+      this._buckets[keyStr] = bucket
+    } else {
+      this._applyRefill(bucket, now)
     }
 
-    this._setBucket(key, tokens)
+    if (bucket.tokens === 0) {
+      return true
+    }
 
-    const hasReachedZero = tokens === 0
+    bucket.tokens--
 
-    if (hasReachedZero) {
+    if (bucket.tokens === 0) {
       this._onBucketRateLimited?.(key)
     }
 
-    return hasReachedZero
+    return bucket.tokens === 0
   }
 
-  public stop() {
-    if (this._removeInterval) {
-      clearInterval(this._removeInterval)
-      this._removeInterval = undefined
-    }
+  public stop(): void {
+    this._buckets = {}
   }
 }

package/src/utils/index.ts

@@ -1,5 +1,6 @@
 import { FetchLike } from '../types'
 
+export * from './bot-detection'
 export * from './bucketed-rate-limiter'
 export * from './number-utils'
 export * from './string-utils'