@leanbase.com/js 0.1.1 → 0.1.3

package/src/utils/user-agent-utils.ts

@@ -0,0 +1,357 @@
+import { isFunction, isUndefined, includes } from '@posthog/core'
+
+/**
+ * this device detection code is (at time of writing) about 3% of the size of the entire library
+ * this is mostly because the identifiers user in regexes and results can't be minified away since
+ * they have meaning
+ *
+ * so, there are some pre-uglifying choices in the code to help reduce the size
+ * e.g. many repeated strings are stored as variables and then old-fashioned concatenated together
+ *
+ * TL;DR here be dragons
+ */
+const FACEBOOK = 'Facebook'
+const MOBILE = 'Mobile'
+const IOS = 'iOS'
+const ANDROID = 'Android'
+const TABLET = 'Tablet'
+const ANDROID_TABLET = ANDROID + ' ' + TABLET
+const IPAD = 'iPad'
+const APPLE = 'Apple'
+const APPLE_WATCH = APPLE + ' Watch'
+const SAFARI = 'Safari'
+const BLACKBERRY = 'BlackBerry'
+const SAMSUNG = 'Samsung'
+const SAMSUNG_BROWSER = SAMSUNG + 'Browser'
+const SAMSUNG_INTERNET = SAMSUNG + ' Internet'
+const CHROME = 'Chrome'
+const CHROME_OS = CHROME + ' OS'
+const CHROME_IOS = CHROME + ' ' + IOS
+const INTERNET_EXPLORER = 'Internet Explorer'
+const INTERNET_EXPLORER_MOBILE = INTERNET_EXPLORER + ' ' + MOBILE
+const OPERA = 'Opera'
+const OPERA_MINI = OPERA + ' Mini'
+const EDGE = 'Edge'
+const MICROSOFT_EDGE = 'Microsoft ' + EDGE
+const FIREFOX = 'Firefox'
+const FIREFOX_IOS = FIREFOX + ' ' + IOS
+const NINTENDO = 'Nintendo'
+const PLAYSTATION = 'PlayStation'
+const XBOX = 'Xbox'
+const ANDROID_MOBILE = ANDROID + ' ' + MOBILE
+const MOBILE_SAFARI = MOBILE + ' ' + SAFARI
+const WINDOWS = 'Windows'
+const WINDOWS_PHONE = WINDOWS + ' Phone'
+const NOKIA = 'Nokia'
+const OUYA = 'Ouya'
+const GENERIC = 'Generic'
+const GENERIC_MOBILE = GENERIC + ' ' + MOBILE.toLowerCase()
+const GENERIC_TABLET = GENERIC + ' ' + TABLET.toLowerCase()
+const KONQUEROR = 'Konqueror'
+
+const BROWSER_VERSION_REGEX_SUFFIX = '(\\d+(\\.\\d+)?)'
+const DEFAULT_BROWSER_VERSION_REGEX = new RegExp('Version/' + BROWSER_VERSION_REGEX_SUFFIX)
+
+const XBOX_REGEX = new RegExp(XBOX, 'i')
+const PLAYSTATION_REGEX = new RegExp(PLAYSTATION + ' \\w+', 'i')
+const NINTENDO_REGEX = new RegExp(NINTENDO + ' \\w+', 'i')
+const BLACKBERRY_REGEX = new RegExp(BLACKBERRY + '|PlayBook|BB10', 'i')
+
+const windowsVersionMap: Record<string, string> = {
+    'NT3.51': 'NT 3.11',
+    'NT4.0': 'NT 4.0',
+    '5.0': '2000',
+    '5.1': 'XP',
+    '5.2': 'XP',
+    '6.0': 'Vista',
+    '6.1': '7',
+    '6.2': '8',
+    '6.3': '8.1',
+    '6.4': '10',
+    '10.0': '10',
+}
+
+/**
+ * Safari detection turns out to be complicated. For e.g. https://stackoverflow.com/a/29696509
+ * We can be slightly loose because some options have been ruled out (e.g. firefox on iOS)
+ * before this check is made
+ */
+function isSafari(userAgent: string): boolean {
+    return includes(userAgent, SAFARI) && !includes(userAgent, CHROME) && !includes(userAgent, ANDROID)
+}
+
+const safariCheck = (ua: string, vendor?: string) => (vendor && includes(vendor, APPLE)) || isSafari(ua)
+
+/**
+ * This function detects which browser is running this script.
+ * The order of the checks are important since many user agents
+ * include keywords used in later checks.
+ */
+export const detectBrowser = function (user_agent: string, vendor: string | undefined): string {
+    vendor = vendor || '' // vendor is undefined for at least IE9
+
+    if (includes(user_agent, ' OPR/') && includes(user_agent, 'Mini')) {
+        return OPERA_MINI
+    } else if (includes(user_agent, ' OPR/')) {
+        return OPERA
+    } else if (BLACKBERRY_REGEX.test(user_agent)) {
+        return BLACKBERRY
+    } else if (includes(user_agent, 'IE' + MOBILE) || includes(user_agent, 'WPDesktop')) {
+        return INTERNET_EXPLORER_MOBILE
+    }
+    // https://developer.samsung.com/internet/user-agent-string-format
+    else if (includes(user_agent, SAMSUNG_BROWSER)) {
+        return SAMSUNG_INTERNET
+    } else if (includes(user_agent, EDGE) || includes(user_agent, 'Edg/')) {
+        return MICROSOFT_EDGE
+    } else if (includes(user_agent, 'FBIOS')) {
+        return FACEBOOK + ' ' + MOBILE
+    } else if (includes(user_agent, 'UCWEB') || includes(user_agent, 'UCBrowser')) {
+        return 'UC Browser'
+    } else if (includes(user_agent, 'CriOS')) {
+        return CHROME_IOS // why not just Chrome?
+    } else if (includes(user_agent, 'CrMo')) {
+        return CHROME
+    } else if (includes(user_agent, CHROME)) {
+        return CHROME
+    } else if (includes(user_agent, ANDROID) && includes(user_agent, SAFARI)) {
+        return ANDROID_MOBILE
+    } else if (includes(user_agent, 'FxiOS')) {
+        return FIREFOX_IOS
+    } else if (includes(user_agent.toLowerCase(), KONQUEROR.toLowerCase())) {
+        return KONQUEROR
+    } else if (safariCheck(user_agent, vendor)) {
+        return includes(user_agent, MOBILE) ? MOBILE_SAFARI : SAFARI
+    } else if (includes(user_agent, FIREFOX)) {
+        return FIREFOX
+    } else if (includes(user_agent, 'MSIE') || includes(user_agent, 'Trident/')) {
+        return INTERNET_EXPLORER
+    } else if (includes(user_agent, 'Gecko')) {
+        return FIREFOX
+    }
+
+    return ''
+}
+
+const versionRegexes: Record<string, RegExp[]> = {
+    [INTERNET_EXPLORER_MOBILE]: [new RegExp('rv:' + BROWSER_VERSION_REGEX_SUFFIX)],
+    [MICROSOFT_EDGE]: [new RegExp(EDGE + '?\\/' + BROWSER_VERSION_REGEX_SUFFIX)],
+    [CHROME]: [new RegExp('(' + CHROME + '|CrMo)\\/' + BROWSER_VERSION_REGEX_SUFFIX)],
+    [CHROME_IOS]: [new RegExp('CriOS\\/' + BROWSER_VERSION_REGEX_SUFFIX)],
+    'UC Browser': [new RegExp('(UCBrowser|UCWEB)\\/' + BROWSER_VERSION_REGEX_SUFFIX)],
+    [SAFARI]: [DEFAULT_BROWSER_VERSION_REGEX],
+    [MOBILE_SAFARI]: [DEFAULT_BROWSER_VERSION_REGEX],
+    [OPERA]: [new RegExp('(' + OPERA + '|OPR)\\/' + BROWSER_VERSION_REGEX_SUFFIX)],
+    [FIREFOX]: [new RegExp(FIREFOX + '\\/' + BROWSER_VERSION_REGEX_SUFFIX)],
+    [FIREFOX_IOS]: [new RegExp('FxiOS\\/' + BROWSER_VERSION_REGEX_SUFFIX)],
+    [KONQUEROR]: [new RegExp('Konqueror[:/]?' + BROWSER_VERSION_REGEX_SUFFIX, 'i')],
+    // not every blackberry user agent has the version after the name
+    [BLACKBERRY]: [new RegExp(BLACKBERRY + ' ' + BROWSER_VERSION_REGEX_SUFFIX), DEFAULT_BROWSER_VERSION_REGEX],
+    [ANDROID_MOBILE]: [new RegExp('android\\s' + BROWSER_VERSION_REGEX_SUFFIX, 'i')],
+    [SAMSUNG_INTERNET]: [new RegExp(SAMSUNG_BROWSER + '\\/' + BROWSER_VERSION_REGEX_SUFFIX)],
+    [INTERNET_EXPLORER]: [new RegExp('(rv:|MSIE )' + BROWSER_VERSION_REGEX_SUFFIX)],
+    Mozilla: [new RegExp('rv:' + BROWSER_VERSION_REGEX_SUFFIX)],
+}
+
+/**
+ * This function detects which browser version is running this script,
+ * parsing major and minor version (e.g., 42.1). User agent strings from:
+ * http://www.useragentstring.com/pages/useragentstring.php
+ *
+ * `navigator.vendor` is passed in and used to help with detecting certain browsers
+ * NB `navigator.vendor` is deprecated and not present in every browser
+ */
+export const detectBrowserVersion = function (userAgent: string, vendor: string | undefined): number | null {
+    const browser = detectBrowser(userAgent, vendor)
+    const regexes: RegExp[] | undefined = versionRegexes[browser as keyof typeof versionRegexes]
+    if (isUndefined(regexes)) {
+        return null
+    }
+
+    for (let i = 0; i < regexes.length; i++) {
+        const regex = regexes[i]
+        const matches = userAgent.match(regex)
+        if (matches) {
+            return parseFloat(matches[matches.length - 2])
+        }
+    }
+    return null
+}
+
+// to avoid repeating regexes or calling them twice, we have an array of matches
+// the first regex that matches uses its matcher function to return the result
+const osMatchers: [
+    RegExp,
+    [string, string] | ((match: RegExpMatchArray | null, user_agent: string) => [string, string]),
+][] = [
+    [
+        new RegExp(XBOX + '; ' + XBOX + ' (.*?)[);]', 'i'),
+        (match) => {
+            return [XBOX, (match && match[1]) || '']
+        },
+    ],
+    [new RegExp(NINTENDO, 'i'), [NINTENDO, '']],
+    [new RegExp(PLAYSTATION, 'i'), [PLAYSTATION, '']],
+    [BLACKBERRY_REGEX, [BLACKBERRY, '']],
+    [
+        new RegExp(WINDOWS, 'i'),
+        (_, user_agent) => {
+            if (/Phone/.test(user_agent) || /WPDesktop/.test(user_agent)) {
+                return [WINDOWS_PHONE, '']
+            }
+            // not all JS versions support negative lookbehind, so we need two checks here
+            if (new RegExp(MOBILE).test(user_agent) && !/IEMobile\b/.test(user_agent)) {
+                return [WINDOWS + ' ' + MOBILE, '']
+            }
+            const match = /Windows NT ([0-9.]+)/i.exec(user_agent)
+            if (match && match[1]) {
+                const version = match[1]
+                let osVersion = windowsVersionMap[version] || ''
+                if (/arm/i.test(user_agent)) {
+                    osVersion = 'RT'
+                }
+                return [WINDOWS, osVersion]
+            }
+            return [WINDOWS, '']
+        },
+    ],
+    [
+        /((iPhone|iPad|iPod).*?OS (\d+)_(\d+)_?(\d+)?|iPhone)/,
+        (match) => {
+            if (match && match[3]) {
+                const versionParts = [match[3], match[4], match[5] || '0']
+                return [IOS, versionParts.join('.')]
+            }
+            return [IOS, '']
+        },
+    ],
+    [
+        /(watch.*\/(\d+\.\d+\.\d+)|watch os,(\d+\.\d+),)/i,
+        (match) => {
+            // e.g. Watch4,3/5.3.8 (16U680)
+            let version = ''
+            if (match && match.length >= 3) {
+                version = isUndefined(match[2]) ? match[3] : match[2]
+            }
+            return ['watchOS', version]
+        },
+    ],
+    [
+        new RegExp('(' + ANDROID + ' (\\d+)\\.(\\d+)\\.?(\\d+)?|' + ANDROID + ')', 'i'),
+        (match) => {
+            if (match && match[2]) {
+                const versionParts = [match[2], match[3], match[4] || '0']
+                return [ANDROID, versionParts.join('.')]
+            }
+            return [ANDROID, '']
+        },
+    ],
+    [
+        /Mac OS X (\d+)[_.](\d+)[_.]?(\d+)?/i,
+        (match) => {
+            const result: [string, string] = ['Mac OS X', '']
+            if (match && match[1]) {
+                const versionParts = [match[1], match[2], match[3] || '0']
+                result[1] = versionParts.join('.')
+            }
+            return result
+        },
+    ],
+    [
+        /Mac/i,
+        // mop up a few non-standard UAs that should match mac
+        ['Mac OS X', ''],
+    ],
+    [/CrOS/, [CHROME_OS, '']],
+    [/Linux|debian/i, ['Linux', '']],
+]
+
+export const detectOS = function (user_agent: string): [string, string] {
+    for (let i = 0; i < osMatchers.length; i++) {
+        const [rgex, resultOrFn] = osMatchers[i]
+        const match = rgex.exec(user_agent)
+        const result = match && (isFunction(resultOrFn) ? resultOrFn(match, user_agent) : resultOrFn)
+        if (result) {
+            return result
+        }
+    }
+    return ['', '']
+}
+
+export const detectDevice = function (user_agent: string): string {
+    if (NINTENDO_REGEX.test(user_agent)) {
+        return NINTENDO
+    } else if (PLAYSTATION_REGEX.test(user_agent)) {
+        return PLAYSTATION
+    } else if (XBOX_REGEX.test(user_agent)) {
+        return XBOX
+    } else if (new RegExp(OUYA, 'i').test(user_agent)) {
+        return OUYA
+    } else if (new RegExp('(' + WINDOWS_PHONE + '|WPDesktop)', 'i').test(user_agent)) {
+        return WINDOWS_PHONE
+    } else if (/iPad/.test(user_agent)) {
+        return IPAD
+    } else if (/iPod/.test(user_agent)) {
+        return 'iPod Touch'
+    } else if (/iPhone/.test(user_agent)) {
+        return 'iPhone'
+    } else if (/(watch)(?: ?os[,/]|\d,\d\/)[\d.]+/i.test(user_agent)) {
+        return APPLE_WATCH
+    } else if (BLACKBERRY_REGEX.test(user_agent)) {
+        return BLACKBERRY
+    } else if (/(kobo)\s(ereader|touch)/i.test(user_agent)) {
+        return 'Kobo'
+    } else if (new RegExp(NOKIA, 'i').test(user_agent)) {
+        return NOKIA
+    } else if (
+        // Kindle Fire without Silk / Echo Show
+        /(kf[a-z]{2}wi|aeo[c-r]{2})( bui|\))/i.test(user_agent) ||
+        // Kindle Fire HD
+        /(kf[a-z]+)( bui|\)).+silk\//i.test(user_agent)
+    ) {
+        return 'Kindle Fire'
+    } else if (/(Android|ZTE)/i.test(user_agent)) {
+        if (
+            !new RegExp(MOBILE).test(user_agent) ||
+            /(9138B|TB782B|Nexus [97]|pixel c|HUAWEISHT|BTV|noble nook|smart ultra 6)/i.test(user_agent)
+        ) {
+            if (
+                (/pixel[\daxl ]{1,6}/i.test(user_agent) && !/pixel c/i.test(user_agent)) ||
+                /(huaweimed-al00|tah-|APA|SM-G92|i980|zte|U304AA)/i.test(user_agent) ||
+                (/lmy47v/i.test(user_agent) && !/QTAQZ3/i.test(user_agent))
+            ) {
+                return ANDROID
+            }
+            return ANDROID_TABLET
+        } else {
+            return ANDROID
+        }
+    } else if (new RegExp('(pda|' + MOBILE + ')', 'i').test(user_agent)) {
+        return GENERIC_MOBILE
+    } else if (new RegExp(TABLET, 'i').test(user_agent) && !new RegExp(TABLET + ' pc', 'i').test(user_agent)) {
+        return GENERIC_TABLET
+    } else {
+        return ''
+    }
+}
+
+export const detectDeviceType = function (user_agent: string): string {
+    const device = detectDevice(user_agent)
+    if (
+        device === IPAD ||
+        device === ANDROID_TABLET ||
+        device === 'Kobo' ||
+        device === 'Kindle Fire' ||
+        device === GENERIC_TABLET
+    ) {
+        return TABLET
+    } else if (device === NINTENDO || device === XBOX || device === PLAYSTATION || device === OUYA) {
+        return 'Console'
+    } else if (device === APPLE_WATCH) {
+        return 'Wearable'
+    } else if (device) {
+        return MOBILE
+    } else {
+        return 'Desktop'
+    }
+}

package/src/uuidv7.ts

@@ -0,0 +1,268 @@
+/**
+ * uuidv7: An experimental implementation of the proposed UUID Version 7
+ *
+ * @license Apache-2.0
+ * @copyright 2021-2023 LiosK
+ * @packageDocumentation
+ *
+ * from https://github.com/LiosK/uuidv7/blob/e501462ea3d23241de13192ceae726956f9b3b7d/src/index.ts
+ */
+
+// polyfill for IE11
+import { window } from './utils'
+
+import { isNumber, isUndefined } from '@posthog/core'
+
+if (!Math.trunc) {
+    Math.trunc = function (v) {
+        return v < 0 ? Math.ceil(v) : Math.floor(v)
+    }
+}
+
+// polyfill for IE11
+if (!Number.isInteger) {
+    Number.isInteger = function (value) {
+        return isNumber(value) && isFinite(value) && Math.floor(value) === value
+    }
+}
+
+const DIGITS = '0123456789abcdef'
+
+/** Represents a UUID as a 16-byte byte array. */
+export class UUID {
+    /** @param bytes - The 16-byte byte array representation. */
+    constructor(readonly bytes: Readonly<Uint8Array>) {
+        if (bytes.length !== 16) {
+            throw new TypeError('not 128-bit length')
+        }
+    }
+
+    /**
+     * Builds a byte array from UUIDv7 field values.
+     *
+     * @param unixTsMs - A 48-bit `unix_ts_ms` field value.
+     * @param randA - A 12-bit `rand_a` field value.
+     * @param randBHi - The higher 30 bits of 62-bit `rand_b` field value.
+     * @param randBLo - The lower 32 bits of 62-bit `rand_b` field value.
+     */
+    static fromFieldsV7(unixTsMs: number, randA: number, randBHi: number, randBLo: number): UUID {
+        if (
+            !Number.isInteger(unixTsMs) ||
+            !Number.isInteger(randA) ||
+            !Number.isInteger(randBHi) ||
+            !Number.isInteger(randBLo) ||
+            unixTsMs < 0 ||
+            randA < 0 ||
+            randBHi < 0 ||
+            randBLo < 0 ||
+            unixTsMs > 0xffff_ffff_ffff ||
+            randA > 0xfff ||
+            randBHi > 0x3fff_ffff ||
+            randBLo > 0xffff_ffff
+        ) {
+            throw new RangeError('invalid field value')
+        }
+
+        const bytes = new Uint8Array(16)
+        bytes[0] = unixTsMs / 2 ** 40
+        bytes[1] = unixTsMs / 2 ** 32
+        bytes[2] = unixTsMs / 2 ** 24
+        bytes[3] = unixTsMs / 2 ** 16
+        bytes[4] = unixTsMs / 2 ** 8
+        bytes[5] = unixTsMs
+        bytes[6] = 0x70 | (randA >>> 8)
+        bytes[7] = randA
+        bytes[8] = 0x80 | (randBHi >>> 24)
+        bytes[9] = randBHi >>> 16
+        bytes[10] = randBHi >>> 8
+        bytes[11] = randBHi
+        bytes[12] = randBLo >>> 24
+        bytes[13] = randBLo >>> 16
+        bytes[14] = randBLo >>> 8
+        bytes[15] = randBLo
+        return new UUID(bytes)
+    }
+
+    /** @returns The 8-4-4-4-12 canonical hexadecimal string representation. */
+    toString(): string {
+        let text = ''
+        for (let i = 0; i < this.bytes.length; i++) {
+            text = text + DIGITS.charAt(this.bytes[i] >>> 4) + DIGITS.charAt(this.bytes[i] & 0xf)
+            if (i === 3 || i === 5 || i === 7 || i === 9) {
+                text += '-'
+            }
+        }
+
+        if (text.length !== 36) {
+            // We saw one customer whose bundling code was mangling the UUID generation
+            // rather than accept a bad UUID, we throw an error here.
+            throw new Error('Invalid UUIDv7 was generated')
+        }
+        return text
+    }
+
+    /** Creates an object from `this`. */
+    clone(): UUID {
+        return new UUID(this.bytes.slice(0))
+    }
+
+    /** Returns true if `this` is equivalent to `other`. */
+    equals(other: UUID): boolean {
+        return this.compareTo(other) === 0
+    }
+
+    /**
+     * Returns a negative integer, zero, or positive integer if `this` is less
+     * than, equal to, or greater than `other`, respectively.
+     */
+    compareTo(other: UUID): number {
+        for (let i = 0; i < 16; i++) {
+            const diff = this.bytes[i] - other.bytes[i]
+            if (diff !== 0) {
+                return Math.sign(diff)
+            }
+        }
+        return 0
+    }
+}
+
+/** Encapsulates the monotonic counter state. */
+class V7Generator {
+    private _timestamp = 0
+    private _counter = 0
+    private readonly _random = new DefaultRandom()
+
+    /**
+     * Generates a new UUIDv7 object from the current timestamp, or resets the
+     * generator upon significant timestamp rollback.
+     *
+     * This method returns monotonically increasing UUIDs unless the up-to-date
+     * timestamp is significantly (by ten seconds or more) smaller than the one
+     * embedded in the immediately preceding UUID. If such a significant clock
+     * rollback is detected, this method resets the generator and returns a new
+     * UUID based on the current timestamp.
+     */
+    generate(): UUID {
+        const value = this.generateOrAbort()
+        if (!isUndefined(value)) {
+            return value
+        } else {
+            // reset state and resume
+            this._timestamp = 0
+            const valueAfterReset = this.generateOrAbort()
+            if (isUndefined(valueAfterReset)) {
+                throw new Error('Could not generate UUID after timestamp reset')
+            }
+            return valueAfterReset
+        }
+    }
+
+    /**
+     * Generates a new UUIDv7 object from the current timestamp, or returns
+     * `undefined` upon significant timestamp rollback.
+     *
+     * This method returns monotonically increasing UUIDs unless the up-to-date
+     * timestamp is significantly (by ten seconds or more) smaller than the one
+     * embedded in the immediately preceding UUID. If such a significant clock
+     * rollback is detected, this method aborts and returns `undefined`.
+     */
+    generateOrAbort(): UUID | undefined {
+        const MAX_COUNTER = 0x3ff_ffff_ffff
+        const ROLLBACK_ALLOWANCE = 10_000 // 10 seconds
+
+        const ts = Date.now()
+        if (ts > this._timestamp) {
+            this._timestamp = ts
+            this._resetCounter()
+        } else if (ts + ROLLBACK_ALLOWANCE > this._timestamp) {
+            // go on with previous timestamp if new one is not much smaller
+            this._counter++
+            if (this._counter > MAX_COUNTER) {
+                // increment timestamp at counter overflow
+                this._timestamp++
+                this._resetCounter()
+            }
+        } else {
+            // abort if clock went backwards to unbearable extent
+            return undefined
+        }
+
+        return UUID.fromFieldsV7(
+            this._timestamp,
+            Math.trunc(this._counter / 2 ** 30),
+            this._counter & (2 ** 30 - 1),
+            this._random.nextUint32()
+        )
+    }
+
+    /** Initializes the counter at a 42-bit random integer. */
+    private _resetCounter(): void {
+        this._counter = this._random.nextUint32() * 0x400 + (this._random.nextUint32() & 0x3ff)
+    }
+}
+
+/** A global flag to force use of cryptographically strong RNG. */
+declare const UUIDV7_DENY_WEAK_RNG: boolean
+
+/** Stores `crypto.getRandomValues()` available in the environment. */
+let getRandomValues: <T extends Uint8Array | Uint32Array>(buffer: T) => T = (buffer) => {
+    // fall back on Math.random() unless the flag is set to true
+    // TRICKY: don't use the isUndefined method here as can't pass the reference
+    if (typeof UUIDV7_DENY_WEAK_RNG !== 'undefined' && UUIDV7_DENY_WEAK_RNG) {
+        throw new Error('no cryptographically strong RNG available')
+    }
+
+    for (let i = 0; i < buffer.length; i++) {
+        buffer[i] = Math.trunc(Math.random() * 0x1_0000) * 0x1_0000 + Math.trunc(Math.random() * 0x1_0000)
+    }
+    return buffer
+}
+
+// detect Web Crypto API
+if (window && !isUndefined(window.crypto) && crypto.getRandomValues) {
+    getRandomValues = (buffer) => crypto.getRandomValues(buffer)
+}
+
+/**
+ * Wraps `crypto.getRandomValues()` and compatibles to enable buffering; this
+ * uses a small buffer by default to avoid unbearable throughput decline in some
+ * environments as well as the waste of time and space for unused values.
+ */
+class DefaultRandom {
+    private readonly _buffer = new Uint32Array(8)
+    private _cursor = Infinity
+    nextUint32(): number {
+        if (this._cursor >= this._buffer.length) {
+            getRandomValues(this._buffer)
+            this._cursor = 0
+        }
+        return this._buffer[this._cursor++]
+    }
+}
+
+let defaultGenerator: V7Generator | undefined
+
+/**
+ * Generates a UUIDv7 string.
+ *
+ * @returns The 8-4-4-4-12 canonical hexadecimal string representation
+ * ("xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx").
+ */
+export const uuidv7 = (): string => uuidv7obj().toString()
+
+/** Generates a UUIDv7 object. */
+const uuidv7obj = (): UUID => (defaultGenerator || (defaultGenerator = new V7Generator())).generate()
+
+export const uuid7ToTimestampMs = (uuid: string): number => {
+    // remove hyphens
+    const hex = uuid.replace(/-/g, '')
+    // ensure that it's a version 7 UUID
+    if (hex.length !== 32) {
+        throw new Error('Not a valid UUID')
+    }
+    if (hex[12] !== '7') {
+        throw new Error('Not a UUIDv7')
+    }
+    // the first 6 bytes are the timestamp, which means that we can read only the first 12 hex characters
+    return parseInt(hex.substring(0, 12), 16)
+}

package/src/version.ts

@@ -1 +1 @@
-export const version = '0.1.1'
+export const version = '0.1.3'

package/LICENSE

@@ -1,37 +0,0 @@
-Copyright 2025 Leanflag Limited
-This project is a fork of PostHog/posthog-js.
-
-All rights reserved. This software is proprietary to Leanflag Limited and may only be used for Leanflag Limited products and internal purposes. Redistribution, modification, or commercial use outside of Leanflag Limited is strictly prohibited without explicit written permission from Leanflag Limited.
-
-
----
-
-Copyright 2020 Posthog / Hiberly, Inc.
-
-Copyright 2015 Mixpanel, Inc.
-
-
-Some files in this codebase contain code from getsentry/sentry-javascript by Software, Inc. dba Sentry.
-In such cases it is explicitly stated in the file header. This license only applies to the relevant code in such cases. 
-
-MIT License
-
-Copyright (c) 2012 Functional Software, Inc. dba Sentry
-
-Permission is hereby granted, free of charge, to any person obtaining a copy of
-this software and associated documentation files (the "Software"), to deal in
-the Software without restriction, including without limitation the rights to
-use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
-of the Software, and to permit persons to whom the Software is furnished to do
-so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.