@ht-sdks/events-sdk-js-browser 1.0.4

package/src/core/user/vendor/crypto-es/lib/enc-base64.ts

@@ -0,0 +1,110 @@
+//@ts-nocheck
+import { WordArray } from './core'
+
+export const parseLoop = (base64Str, base64StrLength, reverseMap) => {
+  const words = []
+  let nBytes = 0
+  for (let i = 0; i < base64StrLength; i += 1) {
+    if (i % 4) {
+      const bits1 = reverseMap[base64Str.charCodeAt(i - 1)] << ((i % 4) * 2)
+      const bits2 = reverseMap[base64Str.charCodeAt(i)] >>> (6 - (i % 4) * 2)
+      const bitsCombined = bits1 | bits2
+      words[nBytes >>> 2] |= bitsCombined << (24 - (nBytes % 4) * 8)
+      nBytes += 1
+    }
+  }
+  return WordArray.create(words, nBytes)
+}
+
+/**
+ * Base64 encoding strategy.
+ */
+export const Base64 = {
+  /**
+   * Converts a word array to a Base64 string.
+   *
+   * @param {WordArray} wordArray The word array.
+   *
+   * @return {string} The Base64 string.
+   *
+   * @static
+   *
+   * @example
+   *
+   *     const base64String = CryptoJS.enc.Base64.stringify(wordArray);
+   */
+  stringify(wordArray) {
+    // Shortcuts
+    const { words, sigBytes } = wordArray
+    const map = this._map
+
+    // Clamp excess bits
+    wordArray.clamp()
+
+    // Convert
+    const base64Chars = []
+    for (let i = 0; i < sigBytes; i += 3) {
+      const byte1 = (words[i >>> 2] >>> (24 - (i % 4) * 8)) & 0xff
+      const byte2 = (words[(i + 1) >>> 2] >>> (24 - ((i + 1) % 4) * 8)) & 0xff
+      const byte3 = (words[(i + 2) >>> 2] >>> (24 - ((i + 2) % 4) * 8)) & 0xff
+
+      const triplet = (byte1 << 16) | (byte2 << 8) | byte3
+
+      for (let j = 0; j < 4 && i + j * 0.75 < sigBytes; j += 1) {
+        base64Chars.push(map.charAt((triplet >>> (6 * (3 - j))) & 0x3f))
+      }
+    }
+
+    // Add padding
+    const paddingChar = map.charAt(64)
+    if (paddingChar) {
+      while (base64Chars.length % 4) {
+        base64Chars.push(paddingChar)
+      }
+    }
+
+    return base64Chars.join('')
+  },
+
+  /**
+   * Converts a Base64 string to a word array.
+   *
+   * @param {string} base64Str The Base64 string.
+   *
+   * @return {WordArray} The word array.
+   *
+   * @static
+   *
+   * @example
+   *
+   *     const wordArray = CryptoJS.enc.Base64.parse(base64String);
+   */
+  parse(base64Str) {
+    // Shortcuts
+    let base64StrLength = base64Str.length
+    const map = this._map
+    let reverseMap = this._reverseMap
+
+    if (!reverseMap) {
+      this._reverseMap = []
+      reverseMap = this._reverseMap
+      for (let j = 0; j < map.length; j += 1) {
+        reverseMap[map.charCodeAt(j)] = j
+      }
+    }
+
+    // Ignore padding
+    const paddingChar = map.charAt(64)
+    if (paddingChar) {
+      const paddingIndex = base64Str.indexOf(paddingChar)
+      if (paddingIndex !== -1) {
+        base64StrLength = paddingIndex
+      }
+    }
+
+    // Convert
+    return parseLoop(base64Str, base64StrLength, reverseMap)
+  },
+
+  _map: 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=',
+}

package/src/core/user/vendor/crypto-es/lib/evpkdf.ts

@@ -0,0 +1,110 @@
+//@ts-nocheck
+import { Base, WordArray } from './core'
+import { MD5Algo } from './md5'
+
+/**
+ * This key derivation function is meant to conform with EVP_BytesToKey.
+ * www.openssl.org/docs/crypto/EVP_BytesToKey.html
+ */
+export class EvpKDFAlgo extends Base {
+  /**
+   * Initializes a newly created key derivation function.
+   *
+   * @param {Object} cfg (Optional) The configuration options to use for the derivation.
+   *
+   * @example
+   *
+   *     const kdf = CryptoJS.algo.EvpKDF.create();
+   *     const kdf = CryptoJS.algo.EvpKDF.create({ keySize: 8 });
+   *     const kdf = CryptoJS.algo.EvpKDF.create({ keySize: 8, iterations: 1000 });
+   */
+  constructor(cfg) {
+    super()
+
+    /**
+     * Configuration options.
+     *
+     * @property {number} keySize The key size in words to generate. Default: 4 (128 bits)
+     * @property {Hasher} hasher The hash algorithm to use. Default: MD5
+     * @property {number} iterations The number of iterations to perform. Default: 1
+     */
+    this.cfg = Object.assign(
+      new Base(),
+      {
+        keySize: 128 / 32,
+        hasher: MD5Algo,
+        iterations: 1,
+      },
+      cfg
+    )
+  }
+
+  /**
+   * Derives a key from a password.
+   *
+   * @param {WordArray|string} password The password.
+   * @param {WordArray|string} salt A salt.
+   *
+   * @return {WordArray} The derived key.
+   *
+   * @example
+   *
+   *     const key = kdf.compute(password, salt);
+   */
+  compute(password, salt) {
+    let block
+
+    // Shortcut
+    const { cfg } = this
+
+    // Init hasher
+    const hasher = cfg.hasher.create()
+
+    // Initial values
+    const derivedKey = WordArray.create()
+
+    // Shortcuts
+    const derivedKeyWords = derivedKey.words
+    const { keySize, iterations } = cfg
+
+    // Generate key
+    while (derivedKeyWords.length < keySize) {
+      if (block) {
+        hasher.update(block)
+      }
+      block = hasher.update(password).finalize(salt)
+      hasher.reset()
+
+      // Iterations
+      for (let i = 1; i < iterations; i += 1) {
+        block = hasher.finalize(block)
+        hasher.reset()
+      }
+
+      derivedKey.concat(block)
+    }
+    derivedKey.sigBytes = keySize * 4
+
+    return derivedKey
+  }
+}
+
+/**
+ * Derives a key from a password.
+ *
+ * @param {WordArray|string} password The password.
+ * @param {WordArray|string} salt A salt.
+ * @param {Object} cfg (Optional) The configuration options to use for this computation.
+ *
+ * @return {WordArray} The derived key.
+ *
+ * @static
+ *
+ * @example
+ *
+ *     var key = CryptoJS.EvpKDF(password, salt);
+ *     var key = CryptoJS.EvpKDF(password, salt, { keySize: 8 });
+ *     var key = CryptoJS.EvpKDF(password, salt, { keySize: 8, iterations: 1000 });
+ */
+export const EvpKDF = (password, salt, cfg) =>
+  EvpKDFAlgo.create(cfg).compute(password, salt)

package/src/core/user/vendor/crypto-es/lib/md5.ts

@@ -0,0 +1,238 @@
+//@ts-nocheck
+import { WordArray, Hasher } from './core'
+
+// Constants table
+const T = []
+
+// Compute constants
+for (let i = 0; i < 64; i += 1) {
+  T[i] = (Math.abs(Math.sin(i + 1)) * 0x100000000) | 0
+}
+
+const FF = (a, b, c, d, x, s, t) => {
+  const n = a + ((b & c) | (~b & d)) + x + t
+  return ((n << s) | (n >>> (32 - s))) + b
+}
+
+const GG = (a, b, c, d, x, s, t) => {
+  const n = a + ((b & d) | (c & ~d)) + x + t
+  return ((n << s) | (n >>> (32 - s))) + b
+}
+
+const HH = (a, b, c, d, x, s, t) => {
+  const n = a + (b ^ c ^ d) + x + t
+  return ((n << s) | (n >>> (32 - s))) + b
+}
+
+const II = (a, b, c, d, x, s, t) => {
+  const n = a + (c ^ (b | ~d)) + x + t
+  return ((n << s) | (n >>> (32 - s))) + b
+}
+
+/**
+ * MD5 hash algorithm.
+ */
+export class MD5Algo extends Hasher {
+  _doReset() {
+    this._hash = new WordArray([0x67452301, 0xefcdab89, 0x98badcfe, 0x10325476])
+  }
+
+  _doProcessBlock(M, offset) {
+    const _M = M
+
+    // Swap endian
+    for (let i = 0; i < 16; i += 1) {
+      // Shortcuts
+      const offset_i = offset + i
+      const M_offset_i = M[offset_i]
+
+      _M[offset_i] =
+        (((M_offset_i << 8) | (M_offset_i >>> 24)) & 0x00ff00ff) |
+        (((M_offset_i << 24) | (M_offset_i >>> 8)) & 0xff00ff00)
+    }
+
+    // Shortcuts
+    const H = this._hash.words
+
+    const M_offset_0 = _M[offset + 0]
+    const M_offset_1 = _M[offset + 1]
+    const M_offset_2 = _M[offset + 2]
+    const M_offset_3 = _M[offset + 3]
+    const M_offset_4 = _M[offset + 4]
+    const M_offset_5 = _M[offset + 5]
+    const M_offset_6 = _M[offset + 6]
+    const M_offset_7 = _M[offset + 7]
+    const M_offset_8 = _M[offset + 8]
+    const M_offset_9 = _M[offset + 9]
+    const M_offset_10 = _M[offset + 10]
+    const M_offset_11 = _M[offset + 11]
+    const M_offset_12 = _M[offset + 12]
+    const M_offset_13 = _M[offset + 13]
+    const M_offset_14 = _M[offset + 14]
+    const M_offset_15 = _M[offset + 15]
+
+    // Working varialbes
+    let a = H[0]
+    let b = H[1]
+    let c = H[2]
+    let d = H[3]
+
+    // Computation
+    a = FF(a, b, c, d, M_offset_0, 7, T[0])
+    d = FF(d, a, b, c, M_offset_1, 12, T[1])
+    c = FF(c, d, a, b, M_offset_2, 17, T[2])
+    b = FF(b, c, d, a, M_offset_3, 22, T[3])
+    a = FF(a, b, c, d, M_offset_4, 7, T[4])
+    d = FF(d, a, b, c, M_offset_5, 12, T[5])
+    c = FF(c, d, a, b, M_offset_6, 17, T[6])
+    b = FF(b, c, d, a, M_offset_7, 22, T[7])
+    a = FF(a, b, c, d, M_offset_8, 7, T[8])
+    d = FF(d, a, b, c, M_offset_9, 12, T[9])
+    c = FF(c, d, a, b, M_offset_10, 17, T[10])
+    b = FF(b, c, d, a, M_offset_11, 22, T[11])
+    a = FF(a, b, c, d, M_offset_12, 7, T[12])
+    d = FF(d, a, b, c, M_offset_13, 12, T[13])
+    c = FF(c, d, a, b, M_offset_14, 17, T[14])
+    b = FF(b, c, d, a, M_offset_15, 22, T[15])
+
+    a = GG(a, b, c, d, M_offset_1, 5, T[16])
+    d = GG(d, a, b, c, M_offset_6, 9, T[17])
+    c = GG(c, d, a, b, M_offset_11, 14, T[18])
+    b = GG(b, c, d, a, M_offset_0, 20, T[19])
+    a = GG(a, b, c, d, M_offset_5, 5, T[20])
+    d = GG(d, a, b, c, M_offset_10, 9, T[21])
+    c = GG(c, d, a, b, M_offset_15, 14, T[22])
+    b = GG(b, c, d, a, M_offset_4, 20, T[23])
+    a = GG(a, b, c, d, M_offset_9, 5, T[24])
+    d = GG(d, a, b, c, M_offset_14, 9, T[25])
+    c = GG(c, d, a, b, M_offset_3, 14, T[26])
+    b = GG(b, c, d, a, M_offset_8, 20, T[27])
+    a = GG(a, b, c, d, M_offset_13, 5, T[28])
+    d = GG(d, a, b, c, M_offset_2, 9, T[29])
+    c = GG(c, d, a, b, M_offset_7, 14, T[30])
+    b = GG(b, c, d, a, M_offset_12, 20, T[31])
+
+    a = HH(a, b, c, d, M_offset_5, 4, T[32])
+    d = HH(d, a, b, c, M_offset_8, 11, T[33])
+    c = HH(c, d, a, b, M_offset_11, 16, T[34])
+    b = HH(b, c, d, a, M_offset_14, 23, T[35])
+    a = HH(a, b, c, d, M_offset_1, 4, T[36])
+    d = HH(d, a, b, c, M_offset_4, 11, T[37])
+    c = HH(c, d, a, b, M_offset_7, 16, T[38])
+    b = HH(b, c, d, a, M_offset_10, 23, T[39])
+    a = HH(a, b, c, d, M_offset_13, 4, T[40])
+    d = HH(d, a, b, c, M_offset_0, 11, T[41])
+    c = HH(c, d, a, b, M_offset_3, 16, T[42])
+    b = HH(b, c, d, a, M_offset_6, 23, T[43])
+    a = HH(a, b, c, d, M_offset_9, 4, T[44])
+    d = HH(d, a, b, c, M_offset_12, 11, T[45])
+    c = HH(c, d, a, b, M_offset_15, 16, T[46])
+    b = HH(b, c, d, a, M_offset_2, 23, T[47])
+
+    a = II(a, b, c, d, M_offset_0, 6, T[48])
+    d = II(d, a, b, c, M_offset_7, 10, T[49])
+    c = II(c, d, a, b, M_offset_14, 15, T[50])
+    b = II(b, c, d, a, M_offset_5, 21, T[51])
+    a = II(a, b, c, d, M_offset_12, 6, T[52])
+    d = II(d, a, b, c, M_offset_3, 10, T[53])
+    c = II(c, d, a, b, M_offset_10, 15, T[54])
+    b = II(b, c, d, a, M_offset_1, 21, T[55])
+    a = II(a, b, c, d, M_offset_8, 6, T[56])
+    d = II(d, a, b, c, M_offset_15, 10, T[57])
+    c = II(c, d, a, b, M_offset_6, 15, T[58])
+    b = II(b, c, d, a, M_offset_13, 21, T[59])
+    a = II(a, b, c, d, M_offset_4, 6, T[60])
+    d = II(d, a, b, c, M_offset_11, 10, T[61])
+    c = II(c, d, a, b, M_offset_2, 15, T[62])
+    b = II(b, c, d, a, M_offset_9, 21, T[63])
+
+    // Intermediate hash value
+    H[0] = (H[0] + a) | 0
+    H[1] = (H[1] + b) | 0
+    H[2] = (H[2] + c) | 0
+    H[3] = (H[3] + d) | 0
+  }
+  /* eslint-ensable no-param-reassign */
+
+  _doFinalize() {
+    // Shortcuts
+    const data = this._data
+    const dataWords = data.words
+
+    const nBitsTotal = this._nDataBytes * 8
+    const nBitsLeft = data.sigBytes * 8
+
+    // Add padding
+    dataWords[nBitsLeft >>> 5] |= 0x80 << (24 - (nBitsLeft % 32))
+
+    const nBitsTotalH = Math.floor(nBitsTotal / 0x100000000)
+    const nBitsTotalL = nBitsTotal
+    dataWords[(((nBitsLeft + 64) >>> 9) << 4) + 15] =
+      (((nBitsTotalH << 8) | (nBitsTotalH >>> 24)) & 0x00ff00ff) |
+      (((nBitsTotalH << 24) | (nBitsTotalH >>> 8)) & 0xff00ff00)
+    dataWords[(((nBitsLeft + 64) >>> 9) << 4) + 14] =
+      (((nBitsTotalL << 8) | (nBitsTotalL >>> 24)) & 0x00ff00ff) |
+      (((nBitsTotalL << 24) | (nBitsTotalL >>> 8)) & 0xff00ff00)
+
+    data.sigBytes = (dataWords.length + 1) * 4
+
+    // Hash final blocks
+    this._process()
+
+    // Shortcuts
+    const hash = this._hash
+    const H = hash.words
+
+    // Swap endian
+    for (let i = 0; i < 4; i += 1) {
+      // Shortcut
+      const H_i = H[i]
+
+      H[i] =
+        (((H_i << 8) | (H_i >>> 24)) & 0x00ff00ff) |
+        (((H_i << 24) | (H_i >>> 8)) & 0xff00ff00)
+    }
+
+    // Return final computed hash
+    return hash
+  }
+
+  clone() {
+    const clone = super.clone.call(this)
+    clone._hash = this._hash.clone()
+
+    return clone
+  }
+}
+
+/**
+ * Shortcut function to the hasher's object interface.
+ *
+ * @param {WordArray|string} message The message to hash.
+ *
+ * @return {WordArray} The hash.
+ *
+ * @static
+ *
+ * @example
+ *
+ *     var hash = CryptoJS.MD5('message');
+ *     var hash = CryptoJS.MD5(wordArray);
+ */
+export const MD5 = Hasher._createHelper(MD5Algo)
+
+/**
+ * Shortcut function to the HMAC's object interface.
+ *
+ * @param {WordArray|string} message The message to hash.
+ * @param {WordArray|string} key The secret key.
+ *
+ * @return {WordArray} The HMAC.
+ *
+ * @static
+ *
+ * @example
+ *
+ *     var hmac = CryptoJS.HmacMD5(message, key);
+ */
+export const HmacMD5 = Hasher._createHmacHelper(MD5Algo)

package/src/core/user/vendor/readme.md

@@ -0,0 +1,7 @@
+# Why are we vendoring crypto-es?
+
+> jest syntaxerror: cannot use import statement outside a module
+
+Crypto-es decided to write their package in "esm" style modules, with a ".js" extension, with no babel or other build step. It doesn't work with jest + typescript. https://github.com/jestjs/jest/issues/9430 https://github.com/jestjs/jest/issues/12990
+
+We need crypto-es to "decrypt" Rudder's anonymousId. We've vendored crypto-es (along with its MIT license https://github.com/entronad/crypto-es/blob/master/LICENSE) instead of continuing on the esm + jest issue.

package/src/generated/version.ts

@@ -0,0 +1,2 @@
+// This file is generated.
+export const version = '1.0.4'

package/src/index.ts

@@ -0,0 +1,13 @@
+export * from './core/analytics'
+export * from './browser'
+export * from './node'
+
+export * from './core/context'
+export * from './core/events'
+export * from './core/plugin'
+export * from './core/user'
+
+export type { AnalyticsSnippet } from './browser/standalone-interface'
+export type { MiddlewareFunction } from './plugins/middleware'
+export { getGlobalAnalytics } from './lib/global-analytics-helper'
+export { UniversalStorage, Store, StorageObject } from './core/storage'

package/src/lib/bind-all.ts

@@ -0,0 +1,19 @@
+export default function bindAll<
+  ObjType extends { [key: string]: any },
+  KeyType extends keyof ObjType
+>(obj: ObjType): ObjType {
+  const proto = obj.constructor.prototype
+  for (const key of Object.getOwnPropertyNames(proto)) {
+    if (key !== 'constructor') {
+      const desc = Object.getOwnPropertyDescriptor(
+        obj.constructor.prototype,
+        key
+      )
+      if (!!desc && typeof desc.value === 'function') {
+        obj[key as KeyType] = obj[key].bind(obj)
+      }
+    }
+  }
+
+  return obj
+}

package/src/lib/browser-polyfill.ts

@@ -0,0 +1,23 @@
+export function shouldPolyfill(): boolean {
+  const browserVersionCompatList: { [browser: string]: number } = {
+    Firefox: 46,
+    Edge: 13,
+  }
+
+  // Unfortunately IE doesn't follow the same pattern as other browsers, so we
+  // need to check `isIE11` differently.
+  // @ts-expect-error
+  const isIE11 = !!window.MSInputMethodContext && !!document.documentMode
+
+  const userAgent = navigator.userAgent.split(' ')
+  const [browser, version] = userAgent[userAgent.length - 1].split('/')
+
+  return (
+    isIE11 ||
+    (browserVersionCompatList[browser] !== undefined &&
+      browserVersionCompatList[browser] >= parseInt(version))
+  )
+}
+
+// appName = Netscape IE / Edge
+// edge 13 Edge/13... same as FF

package/src/lib/client-hints/index.ts

@@ -0,0 +1,16 @@
+import { HighEntropyHint, NavigatorUAData, UADataValues } from './interfaces'
+
+export async function clientHints(
+  hints?: HighEntropyHint[]
+): Promise<UADataValues | undefined> {
+  const userAgentData = (navigator as any).userAgentData as
+    | NavigatorUAData
+    | undefined
+
+  if (!userAgentData) return undefined
+
+  if (!hints) return userAgentData.toJSON()
+  return userAgentData
+    .getHighEntropyValues(hints)
+    .catch(() => userAgentData.toJSON())
+}

package/src/lib/client-hints/interfaces.ts

@@ -0,0 +1,42 @@
+// https://wicg.github.io/ua-client-hints/#dictdef-navigatoruabrandversion
+export interface NavigatorUABrandVersion {
+  readonly brand: string
+  readonly version: string
+}
+
+// https://wicg.github.io/ua-client-hints/#dictdef-uadatavalues
+export interface UADataValues {
+  readonly brands?: NavigatorUABrandVersion[]
+  readonly mobile?: boolean
+  readonly platform?: string
+  readonly architecture?: string
+  readonly bitness?: string
+  readonly model?: string
+  readonly platformVersion?: string
+  /** @deprecated in favour of fullVersionList */
+  readonly uaFullVersion?: string
+  readonly fullVersionList?: NavigatorUABrandVersion[]
+  readonly wow64?: boolean
+}
+
+// https://wicg.github.io/ua-client-hints/#dictdef-ualowentropyjson
+export interface UALowEntropyJSON {
+  readonly brands: NavigatorUABrandVersion[]
+  readonly mobile: boolean
+  readonly platform: string
+}
+
+// https://wicg.github.io/ua-client-hints/#navigatoruadata
+export interface NavigatorUAData extends UALowEntropyJSON {
+  getHighEntropyValues(hints: HighEntropyHint[]): Promise<UADataValues>
+  toJSON(): UALowEntropyJSON
+}
+
+export type HighEntropyHint =
+  | 'architecture'
+  | 'bitness'
+  | 'model'
+  | 'platformVersion'
+  | 'uaFullVersion'
+  | 'fullVersionList'
+  | 'wow64'

package/src/lib/create-deferred.ts

@@ -0,0 +1,16 @@
+/**
+ * Return a promise that can be externally resolved
+ */
+export const createDeferred = <T>() => {
+  let resolve!: (value: T | PromiseLike<T>) => void
+  let reject!: (reason: any) => void
+  const promise = new Promise<T>((_resolve, _reject) => {
+    resolve = _resolve
+    reject = _reject
+  })
+  return {
+    resolve,
+    reject,
+    promise,
+  }
+}

package/src/lib/csp-detection.ts

@@ -0,0 +1,8 @@
+type CSPErrorEvent = SecurityPolicyViolationEvent & {
+  disposition?: 'enforce' | 'report'
+}
+export const isAnalyticsCSPError = (e: CSPErrorEvent) => {
+  return (
+    e.disposition !== 'report' && e.blockedURI.includes('cdn.hightouch-events')
+  )
+}

package/src/lib/embedded-write-key.ts

@@ -0,0 +1,24 @@
+declare global {
+  interface Window {
+    analyticsWriteKey?: string
+  }
+}
+
+// This variable is used as an optional fallback for when customers
+// host or proxy their own analytics.js.
+try {
+  window.analyticsWriteKey = '__WRITE_KEY__'
+} catch (_) {
+  // @ eslint-disable-next-line
+}
+
+export function embeddedWriteKey(): string | undefined {
+  if (window.analyticsWriteKey === undefined) {
+    return undefined
+  }
+
+  // this is done so that we don't accidentally override every reference to __write_key__
+  return window.analyticsWriteKey !== ['__', 'WRITE', '_', 'KEY', '__'].join('')
+    ? window.analyticsWriteKey
+    : undefined
+}

package/src/lib/fetch.ts

@@ -0,0 +1,10 @@
+import unfetch from 'unfetch'
+import { getGlobal } from './get-global'
+
+/**
+ * Wrapper around native `fetch` containing `unfetch` fallback.
+ */
+export const fetch: typeof global.fetch = (...args) => {
+  const global = getGlobal()
+  return ((global && global.fetch) || unfetch)(...args)
+}

package/src/lib/get-global.ts

@@ -0,0 +1,16 @@
+// This an imperfect polyfill for globalThis
+export const getGlobal = () => {
+  if (typeof globalThis !== 'undefined') {
+    return globalThis
+  }
+  if (typeof self !== 'undefined') {
+    return self
+  }
+  if (typeof window !== 'undefined') {
+    return window
+  }
+  if (typeof global !== 'undefined') {
+    return global
+  }
+  return null
+}

package/src/lib/get-process-env.ts

@@ -0,0 +1,11 @@
+/**
+ * Returns `process.env` if it is available in the environment.
+ * Always returns an object make it similarly easy to use as `process.env`.
+ */
+export function getProcessEnv(): { [key: string]: string | undefined } {
+  if (typeof process === 'undefined' || !process.env) {
+    return {}
+  }
+
+  return process.env
+}