@wular/coder 0.4.2 → 0.4.4

package/dist/dash/standalone/node_modules/@wular/pnext/src/request/cache.ts

@@ -0,0 +1,64 @@
+import { AsyncLocalStorage } from 'node:async_hooks'
+
+export interface CacheNode {
+  children: Map<unknown, CacheNode>
+  record?: CacheRecord
+}
+
+export type CacheRecord =
+  | { status: 'pending'; value: Promise<unknown> }
+  | { status: 'resolved'; value: unknown; async: boolean }
+  | { status: 'rejected'; error: unknown; async: boolean }
+
+export interface CacheScope {
+  functions: WeakMap<object, CacheNode>
+  fetches?: Map<string, Promise<unknown>>
+  /**
+   * Lazily-created controller backing React.cacheSignal() in a request render. The signal stays live
+   * for the whole render - including deferred/streamed Suspense boundaries that resolve after the
+   * shell has flushed - so a slow cache component's bounded polling is never cut short. A build
+   * prerender uses the prerender scope's signal instead, which aborts at completePrerender().
+   */
+  controller?: AbortController
+}
+
+// globalThis-anchored: the prebundled server entry inlines its own copy of this module.
+const CACHE_SCOPE_STORAGE = Symbol.for('pnext.cacheScopeStorage')
+const storage = ((globalThis as Record<PropertyKey, unknown>)[CACHE_SCOPE_STORAGE] ??=
+  new AsyncLocalStorage<CacheScope>()) as AsyncLocalStorage<CacheScope>
+
+export function currentCacheScope() {
+  return storage.getStore()
+}
+
+/**
+ * The AbortSignal for the current cache/render scope (React.cacheSignal()), or null outside any
+ * render. A request render's shell can flush while deferred boundaries are still resolving, so this
+ * signal is intentionally NOT aborted at shell-flush time - doing so would abort a still-pending slow
+ * boundary's polling. Build prerenders get a deterministically-aborting signal from the prerender scope.
+ */
+export function currentCacheSignal(): AbortSignal | null {
+  const scope = storage.getStore()
+  if (!scope) return null
+  if (!scope.controller) scope.controller = new AbortController()
+  return scope.controller.signal
+}
+
+export function runWithCacheScope<T>(callback: () => T): T {
+  const existing = storage.getStore()
+  if (existing) return callback()
+  return storage.run({ functions: new WeakMap() }, callback)
+}
+
+/**
+ * Capture the current cache scope (if any) and return a wrapper that re-runs a
+ * function inside it. after() uses this so a callback registered during a page
+ * render still shares the render's React cache() memo cache when it runs later
+ * in the detached work-unit flush (which otherwise carries no cache scope).
+ * Returns an identity wrapper when no scope is active.
+ */
+export function captureCacheScope(): <T>(fn: () => T) => T {
+  const scope = storage.getStore()
+  if (!scope) return fn => fn()
+  return fn => storage.run(scope, fn)
+}

package/dist/dash/standalone/node_modules/@wular/pnext/src/routing/href.ts

@@ -0,0 +1,236 @@
+import type { PrefetchMode, RouteParamValue } from '../types'
+
+export type SearchValue = string | number | boolean | null | undefined
+export type SearchInput = URLSearchParams | Record<string, SearchValue | SearchValue[]>
+
+export interface HrefParts {
+  params?: Record<string, RouteParamValue>
+  search?: SearchInput
+  hash?: string
+}
+
+/**
+ * A request for pnext's own build output: `/assets/*`, and next-compat's `/_next/static/*` - the
+ * same output under the path Next serves it from (see assetPathname). Every bypass that must not
+ * treat build output as a page (proxy, trailing-slash canonicalization) asks HERE, so moving the
+ * emitted prefix can never leave a bypass knowing only the old one.
+ */
+export function isBuildAssetPathname(pathname: string) {
+  return pathname.startsWith('/assets/') || pathname.startsWith('/_next/static/')
+}
+
+export function routeHref(route: string, options: HrefParts = {}) {
+  const path = applyTrailingSlash(fillParams(route, options.params ?? {}))
+  const search = searchString(options.search)
+  const hash = hashString(options.hash)
+  return `${path}${search}${hash}`
+}
+
+declare global {
+  interface Window {
+    __PNEXT_TRAILING_SLASH__?: boolean
+    __PNEXT_PREFETCH__?: PrefetchMode
+  }
+  var __PNEXT_TRAILING_SLASH__: boolean | undefined
+  var __PNEXT_PREFETCH__: PrefetchMode | undefined
+}
+
+// With `trailingSlash: true` the server 308s bare page URLs to their slashed
+// form; Links render the canonical (slashed) href directly, like Next. Set
+// once per process by the server runtime from the resolved config. On the
+// client the value is read from the injected window global (register-render's
+// trailingSlashScript), mirroring basePath / skipTrailingSlash.
+// Anchored on globalThis, not a module local: this module is dual-copied into
+// the client/prebundled bundles, where setTrailingSlashUrls never runs.
+export function setTrailingSlashUrls(enabled: boolean) {
+  globalThis.__PNEXT_TRAILING_SLASH__ = enabled
+}
+
+function isTrailingSlashEnabled(): boolean {
+  if (process.browser || typeof window !== 'undefined')
+    return window.__PNEXT_TRAILING_SLASH__ === true
+  return globalThis.__PNEXT_TRAILING_SLASH__ === true
+}
+
+export function getTrailingSlashUrls() {
+  return isTrailingSlashEnabled()
+}
+
+// The app-wide default prefetch mode (config `prefetch`), for links that set
+// none of their own. Isomorphic like the trailing-slash seam: the server sets it
+// from the resolved config, the client reads the injected window global
+// (renderer's prefetchModeScript).
+export function setDefaultPrefetchMode(mode: PrefetchMode | undefined) {
+  globalThis.__PNEXT_PREFETCH__ = mode
+}
+
+export function getDefaultPrefetchMode(): PrefetchMode {
+  const mode =
+    process.browser || typeof window !== 'undefined'
+      ? window.__PNEXT_PREFETCH__
+      : globalThis.__PNEXT_PREFETCH__
+  return mode === undefined ? 'visible' : mode
+}
+
+// The configured basePath ('' when unset). Set once per process by the server
+// runtime from the resolved config (registerServerRuntime), mirroring the
+// trailing-slash seam. Core render code (metadata) reads it through
+// withBasePath so file-convention asset hrefs (og-image, manifest) carry the
+// prefix without a compat/next.config import in core.
+let basePathPrefix = ''
+
+export function setBasePathPrefix(value: string) {
+  basePathPrefix = value
+}
+
+export function getBasePathPrefix() {
+  return basePathPrefix
+}
+
+/**
+ * Prefix a root-relative in-app path with the configured basePath (Next's
+ * addBasePath). Absolute/protocol-relative URLs, non-root-relative strings, and
+ * paths already under the basePath are returned unchanged. A no-basePath app is
+ * always a no-op. Any query/hash on the path rides along untouched.
+ */
+export function withBasePath(path: string) {
+  const base = basePathPrefix
+  if (!base) return path
+  if (!path.startsWith('/') || path.startsWith('//')) return path
+  if (path === base || path.startsWith(`${base}/`)) return path
+  return `${base}${path}`
+}
+
+export function applyTrailingSlash(pathname: string) {
+  const [, path = '', rest = ''] = /^([^?#]*)([\s\S]*)$/.exec(pathname) ?? []
+  if (!path.startsWith('/')) return pathname
+  if (isTrailingSlashEnabled()) {
+    // Add the canonical trailing slash (skip root, already-slashed, and files).
+    if (path === '/' || path.endsWith('/') || /\.[^/]+$/.test(path)) return pathname
+    return `${path}/${rest}`
+  }
+  // trailingSlash:false — Next strips a trailing slash from hrefs so the anchor
+  // matches the canonical (unslashed) form and avoids a 308 on click. Root and
+  // file paths (`/a.txt/` is not a thing) are left alone.
+  if (path === '/' || !path.endsWith('/') || /\.[^/]+\/$/.test(path)) return pathname
+  return `${path.replace(/\/+$/, '')}${rest}`
+}
+
+function fillParams(route: string, params: Record<string, RouteParamValue>) {
+  const filled = route
+    // Optional catch-all `[[...slug]]` must be matched before the plain
+    // catch-all form so its doubled brackets aren't mis-parsed.
+    .replace(/\[\[\.\.\.([^\]]+)\]\]/g, (_match, key: string) => encodeParam(params[key], true))
+    .replace(/\[\.\.\.([^\]]+)\]/g, (_match, key: string) => encodeParam(params[key], true))
+    .replace(/\[([^\]]+)\]/g, (_match, key: string) => encodeParam(params[key], false))
+  // An absent optional catch-all (`[[...slug]]`) leaves a dangling `/`; drop it
+  // so /docs/:slug* with no params yields /docs, not /docs/.
+  return collapseTrailingSlash(filled)
+}
+
+function collapseTrailingSlash(pathname: string) {
+  if (pathname.length <= 1) return pathname
+  return pathname.replace(/\/+$/, '') || '/'
+}
+
+function encodeParam(value: RouteParamValue | undefined, catchAll: boolean) {
+  if (Array.isArray(value)) {
+    const encoded = value.map(segment => encodeURIComponent(segment))
+    return catchAll ? encoded.join('/') : (encoded[0] ?? '')
+  }
+  return encodeURIComponent(value ?? '')
+}
+
+function searchString(search: SearchInput | undefined) {
+  if (!search) return ''
+  const params = search instanceof URLSearchParams ? search : objectSearchParams(search)
+  const value = params.toString()
+  return value ? `?${value}` : ''
+}
+
+function objectSearchParams(search: Record<string, SearchValue | SearchValue[]>) {
+  const params = new URLSearchParams()
+  for (const [key, value] of Object.entries(search)) {
+    const values = Array.isArray(value) ? value : [value]
+    for (const item of values) {
+      if (item == null) continue
+      params.append(key, String(item))
+    }
+  }
+  return params
+}
+
+function hashString(hash: string | undefined) {
+  if (!hash) return ''
+  return hash.startsWith('#') ? hash : `#${hash}`
+}
+
+/**
+ * Malformed percent-encoding in the request path (e.g. `/%2`, a lone `%` or an
+ * out-of-range escape) is a 400 "Bad Request" before any routing, matching
+ * Next. Returns the response when the path cannot be decoded, else null.
+ */
+export function malformedUrlResponse(request: Request): Response | null {
+  let pathname: string
+  try {
+    pathname = new URL(request.url).pathname
+  } catch {
+    return new Response('Bad Request', { status: 400 })
+  }
+  if (!pathname.includes('%')) return null
+  try {
+    decodeURIComponent(pathname)
+    return null
+  } catch {
+    return new Response('Bad Request', { status: 400 })
+  }
+}
+
+/**
+ * The canonical form of `pathname` under the given `trailingSlash` setting:
+ * with it on, a bare page path gains a trailing slash; with it off, a slashed
+ * path loses it. Root (`/`) and file-ish paths (an extension in the last
+ * segment) are always left untouched. Returns the pathname unchanged when it is
+ * already canonical.
+ */
+export function canonicalTrailingSlashPath(pathname: string, trailingSlash: boolean): string {
+  if (pathname === '/' || pathname === '') return pathname
+  if (/\.[^/]+$/.test(pathname)) return pathname
+  const slashed = pathname.endsWith('/')
+  if (trailingSlash ? slashed : !slashed) return pathname
+  // Collapsed, so a rewritten path can never read as protocol-relative (`//host`).
+  const bare = pathname.replace(/\/{2,}/g, '/').replace(/\/+$/, '')
+  return trailingSlash ? `${bare}/` : bare || '/'
+}
+
+/** Next 308s a path with repeated slashes to its collapsed form, for every method, before anything else. */
+export function repeatedSlashRedirect(url: URL): Response | null {
+  if (!url.pathname.includes('//')) return null
+  const target = `${url.pathname.replace(/\/{2,}/g, '/')}${url.search}`
+  return new Response(target, { status: 308, headers: { location: target } })
+}
+
+/**
+ * Next-style trailing-slash normalization: with `trailingSlash: true` page
+ * URLs 308-redirect to their slashed form; with it off (the default) slashed
+ * URLs redirect to the bare form. File-ish paths (extensions) and internal
+ * paths are untouched. Returns null when the URL is already canonical.
+ */
+export function trailingSlashRedirect(
+  config: { trailingSlash?: boolean; skipTrailingSlashRedirect?: boolean },
+  url: URL,
+): Response | null {
+  // skipTrailingSlashRedirect: the app serves both slashed and unslashed URLs
+  // as-is, so no canonical redirect is ever emitted (route matching already
+  // tolerates a trailing slash via normalizePathname).
+  if (config.skipTrailingSlashRedirect) return null
+  const pathname = url.pathname
+  if (pathname === '/' || pathname === '') return null
+  if (pathname.startsWith('/__pnext') || isBuildAssetPathname(pathname)) return null
+  const target = canonicalTrailingSlashPath(pathname, Boolean(config.trailingSlash))
+  if (target === pathname) return null
+  return new Response(null, {
+    status: 308,
+    headers: { location: `${target}${url.search}` },
+  })
+}

package/dist/dash/standalone/node_modules/@wular/pnext/src/utils/decode.ts

@@ -0,0 +1,7 @@
+export function safeDecode(value: string) {
+  try {
+    return decodeURIComponent(value)
+  } catch {
+    return value
+  }
+}

package/dist/dash/standalone/node_modules/@wular/pnext/tsconfig.json

@@ -0,0 +1,10 @@
+{
+  "extends": "./config/ts/react.json",
+  "compilerOptions": {
+    "jsxImportSource": "preact",
+    "types": ["bun-types"],
+    "allowImportingTsExtensions": true
+  },
+  "include": ["."],
+  "exclude": ["node_modules", ".pnext", "bench/fixtures", "src/cli/template"]
+}

package/dist/dash/standalone/node_modules/dotenv/lib/main.js

@@ -0,0 +1,386 @@
+const fs = require('fs')
+const path = require('path')
+const os = require('os')
+const crypto = require('crypto')
+const packageJson = require('../package.json')
+
+const version = packageJson.version
+
+const LINE = /(?:^|^)\s*(?:export\s+)?([\w.-]+)(?:\s*=\s*?|:\s+?)(\s*'(?:\\'|[^'])*'|\s*"(?:\\"|[^"])*"|\s*`(?:\\`|[^`])*`|[^#\r\n]+)?\s*(?:#.*)?(?:$|$)/mg
+
+// Parse src into an Object
+function parse (src) {
+  const obj = {}
+
+  // Convert buffer to string
+  let lines = src.toString()
+
+  // Convert line breaks to same format
+  lines = lines.replace(/\r\n?/mg, '\n')
+
+  let match
+  while ((match = LINE.exec(lines)) != null) {
+    const key = match[1]
+
+    // Default undefined or null to empty string
+    let value = (match[2] || '')
+
+    // Remove whitespace
+    value = value.trim()
+
+    // Check if double quoted
+    const maybeQuote = value[0]
+
+    // Remove surrounding quotes
+    value = value.replace(/^(['"`])([\s\S]*)\1$/mg, '$2')
+
+    // Expand newlines if double quoted
+    if (maybeQuote === '"') {
+      value = value.replace(/\\n/g, '\n')
+      value = value.replace(/\\r/g, '\r')
+    }
+
+    // Add to object
+    obj[key] = value
+  }
+
+  return obj
+}
+
+function _parseVault (options) {
+  options = options || {}
+
+  const vaultPath = _vaultPath(options)
+  options.path = vaultPath // parse .env.vault
+  const result = DotenvModule.configDotenv(options)
+  if (!result.parsed) {
+    const err = new Error(`MISSING_DATA: Cannot parse ${vaultPath} for an unknown reason`)
+    err.code = 'MISSING_DATA'
+    throw err
+  }
+
+  // handle scenario for comma separated keys - for use with key rotation
+  // example: DOTENV_KEY="dotenv://:key_1234@dotenvx.com/vault/.env.vault?environment=prod,dotenv://:key_7890@dotenvx.com/vault/.env.vault?environment=prod"
+  const keys = _dotenvKey(options).split(',')
+  const length = keys.length
+
+  let decrypted
+  for (let i = 0; i < length; i++) {
+    try {
+      // Get full key
+      const key = keys[i].trim()
+
+      // Get instructions for decrypt
+      const attrs = _instructions(result, key)
+
+      // Decrypt
+      decrypted = DotenvModule.decrypt(attrs.ciphertext, attrs.key)
+
+      break
+    } catch (error) {
+      // last key
+      if (i + 1 >= length) {
+        throw error
+      }
+      // try next key
+    }
+  }
+
+  // Parse decrypted .env string
+  return DotenvModule.parse(decrypted)
+}
+
+function _warn (message) {
+  console.log(`[dotenv@${version}][WARN] ${message}`)
+}
+
+function _debug (message) {
+  console.log(`[dotenv@${version}][DEBUG] ${message}`)
+}
+
+function _log (message) {
+  console.log(`[dotenv@${version}] ${message}`)
+}
+
+function _dotenvKey (options) {
+  // prioritize developer directly setting options.DOTENV_KEY
+  if (options && options.DOTENV_KEY && options.DOTENV_KEY.length > 0) {
+    return options.DOTENV_KEY
+  }
+
+  // secondary infra already contains a DOTENV_KEY environment variable
+  if (process.env.DOTENV_KEY && process.env.DOTENV_KEY.length > 0) {
+    return process.env.DOTENV_KEY
+  }
+
+  // fallback to empty string
+  return ''
+}
+
+function _instructions (result, dotenvKey) {
+  // Parse DOTENV_KEY. Format is a URI
+  let uri
+  try {
+    uri = new URL(dotenvKey)
+  } catch (error) {
+    if (error.code === 'ERR_INVALID_URL') {
+      const err = new Error('INVALID_DOTENV_KEY: Wrong format. Must be in valid uri format like dotenv://:key_1234@dotenvx.com/vault/.env.vault?environment=development')
+      err.code = 'INVALID_DOTENV_KEY'
+      throw err
+    }
+
+    throw error
+  }
+
+  // Get decrypt key
+  const key = uri.password
+  if (!key) {
+    const err = new Error('INVALID_DOTENV_KEY: Missing key part')
+    err.code = 'INVALID_DOTENV_KEY'
+    throw err
+  }
+
+  // Get environment
+  const environment = uri.searchParams.get('environment')
+  if (!environment) {
+    const err = new Error('INVALID_DOTENV_KEY: Missing environment part')
+    err.code = 'INVALID_DOTENV_KEY'
+    throw err
+  }
+
+  // Get ciphertext payload
+  const environmentKey = `DOTENV_VAULT_${environment.toUpperCase()}`
+  const ciphertext = result.parsed[environmentKey] // DOTENV_VAULT_PRODUCTION
+  if (!ciphertext) {
+    const err = new Error(`NOT_FOUND_DOTENV_ENVIRONMENT: Cannot locate environment ${environmentKey} in your .env.vault file.`)
+    err.code = 'NOT_FOUND_DOTENV_ENVIRONMENT'
+    throw err
+  }
+
+  return { ciphertext, key }
+}
+
+function _vaultPath (options) {
+  let possibleVaultPath = null
+
+  if (options && options.path && options.path.length > 0) {
+    if (Array.isArray(options.path)) {
+      for (const filepath of options.path) {
+        if (fs.existsSync(filepath)) {
+          possibleVaultPath = filepath.endsWith('.vault') ? filepath : `${filepath}.vault`
+        }
+      }
+    } else {
+      possibleVaultPath = options.path.endsWith('.vault') ? options.path : `${options.path}.vault`
+    }
+  } else {
+    possibleVaultPath = path.resolve(process.cwd(), '.env.vault')
+  }
+
+  if (fs.existsSync(possibleVaultPath)) {
+    return possibleVaultPath
+  }
+
+  return null
+}
+
+function _resolveHome (envPath) {
+  return envPath[0] === '~' ? path.join(os.homedir(), envPath.slice(1)) : envPath
+}
+
+function _configVault (options) {
+  const debug = Boolean(options && options.debug)
+  const quiet = options && 'quiet' in options ? options.quiet : true
+
+  if (debug || !quiet) {
+    _log('Loading env from encrypted .env.vault')
+  }
+
+  const parsed = DotenvModule._parseVault(options)
+
+  let processEnv = process.env
+  if (options && options.processEnv != null) {
+    processEnv = options.processEnv
+  }
+
+  DotenvModule.populate(processEnv, parsed, options)
+
+  return { parsed }
+}
+
+function configDotenv (options) {
+  const dotenvPath = path.resolve(process.cwd(), '.env')
+  let encoding = 'utf8'
+  const debug = Boolean(options && options.debug)
+  const quiet = options && 'quiet' in options ? options.quiet : true
+
+  if (options && options.encoding) {
+    encoding = options.encoding
+  } else {
+    if (debug) {
+      _debug('No encoding is specified. UTF-8 is used by default')
+    }
+  }
+
+  let optionPaths = [dotenvPath] // default, look for .env
+  if (options && options.path) {
+    if (!Array.isArray(options.path)) {
+      optionPaths = [_resolveHome(options.path)]
+    } else {
+      optionPaths = [] // reset default
+      for (const filepath of options.path) {
+        optionPaths.push(_resolveHome(filepath))
+      }
+    }
+  }
+
+  // Build the parsed data in a temporary object (because we need to return it).  Once we have the final
+  // parsed data, we will combine it with process.env (or options.processEnv if provided).
+  let lastError
+  const parsedAll = {}
+  for (const path of optionPaths) {
+    try {
+      // Specifying an encoding returns a string instead of a buffer
+      const parsed = DotenvModule.parse(fs.readFileSync(path, { encoding }))
+
+      DotenvModule.populate(parsedAll, parsed, options)
+    } catch (e) {
+      if (debug) {
+        _debug(`Failed to load ${path} ${e.message}`)
+      }
+      lastError = e
+    }
+  }
+
+  let processEnv = process.env
+  if (options && options.processEnv != null) {
+    processEnv = options.processEnv
+  }
+
+  DotenvModule.populate(processEnv, parsedAll, options)
+
+  if (debug || !quiet) {
+    const keysCount = Object.keys(parsedAll).length
+    const shortPaths = []
+    for (const filePath of optionPaths) {
+      try {
+        const relative = path.relative(process.cwd(), filePath)
+        shortPaths.push(relative)
+      } catch (e) {
+        if (debug) {
+          _debug(`Failed to load ${filePath} ${e.message}`)
+        }
+        lastError = e
+      }
+    }
+
+    _log(`injecting env (${keysCount}) from ${shortPaths.join(',')}`)
+  }
+
+  if (lastError) {
+    return { parsed: parsedAll, error: lastError }
+  } else {
+    return { parsed: parsedAll }
+  }
+}
+
+// Populates process.env from .env file
+function config (options) {
+  // fallback to original dotenv if DOTENV_KEY is not set
+  if (_dotenvKey(options).length === 0) {
+    return DotenvModule.configDotenv(options)
+  }
+
+  const vaultPath = _vaultPath(options)
+
+  // dotenvKey exists but .env.vault file does not exist
+  if (!vaultPath) {
+    _warn(`You set DOTENV_KEY but you are missing a .env.vault file at ${vaultPath}. Did you forget to build it?`)
+
+    return DotenvModule.configDotenv(options)
+  }
+
+  return DotenvModule._configVault(options)
+}
+
+function decrypt (encrypted, keyStr) {
+  const key = Buffer.from(keyStr.slice(-64), 'hex')
+  let ciphertext = Buffer.from(encrypted, 'base64')
+
+  const nonce = ciphertext.subarray(0, 12)
+  const authTag = ciphertext.subarray(-16)
+  ciphertext = ciphertext.subarray(12, -16)
+
+  try {
+    const aesgcm = crypto.createDecipheriv('aes-256-gcm', key, nonce)
+    aesgcm.setAuthTag(authTag)
+    return `${aesgcm.update(ciphertext)}${aesgcm.final()}`
+  } catch (error) {
+    const isRange = error instanceof RangeError
+    const invalidKeyLength = error.message === 'Invalid key length'
+    const decryptionFailed = error.message === 'Unsupported state or unable to authenticate data'
+
+    if (isRange || invalidKeyLength) {
+      const err = new Error('INVALID_DOTENV_KEY: It must be 64 characters long (or more)')
+      err.code = 'INVALID_DOTENV_KEY'
+      throw err
+    } else if (decryptionFailed) {
+      const err = new Error('DECRYPTION_FAILED: Please check your DOTENV_KEY')
+      err.code = 'DECRYPTION_FAILED'
+      throw err
+    } else {
+      throw error
+    }
+  }
+}
+
+// Populate process.env with parsed values
+function populate (processEnv, parsed, options = {}) {
+  const debug = Boolean(options && options.debug)
+  const override = Boolean(options && options.override)
+
+  if (typeof parsed !== 'object') {
+    const err = new Error('OBJECT_REQUIRED: Please check the processEnv argument being passed to populate')
+    err.code = 'OBJECT_REQUIRED'
+    throw err
+  }
+
+  // Set process.env
+  for (const key of Object.keys(parsed)) {
+    if (Object.prototype.hasOwnProperty.call(processEnv, key)) {
+      if (override === true) {
+        processEnv[key] = parsed[key]
+      }
+
+      if (debug) {
+        if (override === true) {
+          _debug(`"${key}" is already defined and WAS overwritten`)
+        } else {
+          _debug(`"${key}" is already defined and was NOT overwritten`)
+        }
+      }
+    } else {
+      processEnv[key] = parsed[key]
+    }
+  }
+}
+
+const DotenvModule = {
+  configDotenv,
+  _configVault,
+  _parseVault,
+  config,
+  decrypt,
+  parse,
+  populate
+}
+
+module.exports.configDotenv = DotenvModule.configDotenv
+module.exports._configVault = DotenvModule._configVault
+module.exports._parseVault = DotenvModule._parseVault
+module.exports.config = DotenvModule.config
+module.exports.decrypt = DotenvModule.decrypt
+module.exports.parse = DotenvModule.parse
+module.exports.populate = DotenvModule.populate
+
+module.exports = DotenvModule