@discomedia/utils 1.0.37 → 1.0.38

package/dist/index-frontend.mjs

@@ -8159,335 +8159,1311 @@ const makeDeepseekCall = async (content, responseFormat = 'json', options = {})
     }
 };
 
-function getDefaultExportFromCjs (x) {
-	return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, 'default') ? x['default'] : x;
+/**
+ * Logs a message to the console.
+ * @param message The message to log.
+ * @param options Optional options.
+ * @param options.source The source of the message.
+ * @param options.type The type of message to log.
+ * @param options.symbol The trading symbol associated with this log.
+ * @param options.account The account associated with this log.
+ */
+function log$1(message, options = { source: 'App', type: 'info' }) {
+    // Format the timestamp
+    const date = new Date();
+    const timestamp = date.toLocaleString('en-US', { timeZone: 'America/New_York' });
+    const account = options?.account;
+    const symbol = options?.symbol;
+    // Build the log message
+    const logMessage = `[${timestamp}]${options?.source ? ` [${options.source}] ` : ''}${account ? ` [${account}] ` : ''}${symbol ? ` [${symbol}] ` : ''}${message}`;
+    // Use appropriate console method based on type
+    if (options?.type === 'error') {
+        console.error(logMessage);
+    }
+    else if (options?.type === 'warn') {
+        console.warn(logMessage);
+    }
+    else {
+        console.log(logMessage);
+    }
 }
 
-var bufferUtil = {exports: {}};
-
-var constants;
-var hasRequiredConstants;
-
-function requireConstants () {
-	if (hasRequiredConstants) return constants;
-	hasRequiredConstants = 1;
-
-	const BINARY_TYPES = ['nodebuffer', 'arraybuffer', 'fragments'];
-	const hasBlob = typeof Blob !== 'undefined';
-
-	if (hasBlob) BINARY_TYPES.push('blob');
+// market-hours.ts
+const marketHolidays = {
+    2024: {
+        "New Year's Day": { date: '2024-01-01' },
+        'Martin Luther King, Jr. Day': { date: '2024-01-15' },
+        "Washington's Birthday": { date: '2024-02-19' },
+        'Good Friday': { date: '2024-03-29' },
+        'Memorial Day': { date: '2024-05-27' },
+        'Juneteenth National Independence Day': { date: '2024-06-19' },
+        'Independence Day': { date: '2024-07-04' },
+        'Labor Day': { date: '2024-09-02' },
+        'Thanksgiving Day': { date: '2024-11-28' },
+        'Christmas Day': { date: '2024-12-25' },
+    },
+    2025: {
+        "New Year's Day": { date: '2025-01-01' },
+        'Jimmy Carter Memorial Day': { date: '2025-01-09' },
+        'Martin Luther King, Jr. Day': { date: '2025-01-20' },
+        "Washington's Birthday": { date: '2025-02-17' },
+        'Good Friday': { date: '2025-04-18' },
+        'Memorial Day': { date: '2025-05-26' },
+        'Juneteenth National Independence Day': { date: '2025-06-19' },
+        'Independence Day': { date: '2025-07-04' },
+        'Labor Day': { date: '2025-09-01' },
+        'Thanksgiving Day': { date: '2025-11-27' },
+        'Christmas Day': { date: '2025-12-25' },
+    },
+    2026: {
+        "New Year's Day": { date: '2026-01-01' },
+        'Martin Luther King, Jr. Day': { date: '2026-01-19' },
+        "Washington's Birthday": { date: '2026-02-16' },
+        'Good Friday': { date: '2026-04-03' },
+        'Memorial Day': { date: '2026-05-25' },
+        'Juneteenth National Independence Day': { date: '2026-06-19' },
+        'Independence Day': { date: '2026-07-03' },
+        'Labor Day': { date: '2026-09-07' },
+        'Thanksgiving Day': { date: '2026-11-26' },
+        'Christmas Day': { date: '2026-12-25' },
+    },
+};
+const marketEarlyCloses = {
+    2024: {
+        '2024-07-03': {
+            date: '2024-07-03',
+            time: '13:00',
+            optionsTime: '13:15',
+            notes: 'Market closes early on Wednesday, July 3, 2024 at 1:00 p.m. (1:15 p.m. for eligible options). NYSE American Equities, NYSE Arca Equities, NYSE Chicago, and NYSE National late trading sessions will close at 5:00 p.m. Eastern Time.',
+        },
+        '2024-11-29': {
+            date: '2024-11-29',
+            time: '13:00',
+            optionsTime: '13:15',
+            notes: 'Market closes early on Friday, November 29, 2024 at 1:00 p.m. (1:15 p.m. for eligible options). NYSE American Equities, NYSE Arca Equities, NYSE Chicago, and NYSE National late trading sessions will close at 5:00 p.m. Eastern Time.',
+        },
+        '2024-12-24': {
+            date: '2024-12-24',
+            time: '13:00',
+            optionsTime: '13:15',
+            notes: 'Market closes early on Tuesday, December 24, 2024 at 1:00 p.m. (1:15 p.m. for eligible options). NYSE American Equities, NYSE Arca Equities, NYSE Chicago, and NYSE National late trading sessions will close at 5:00 p.m. Eastern Time.',
+        },
+    },
+    2025: {
+        '2025-07-03': {
+            date: '2025-07-03',
+            time: '13:00',
+            optionsTime: '13:15',
+            notes: 'Market closes early on Thursday, July 3, 2025 at 1:00 p.m. (1:15 p.m. for eligible options). NYSE American Equities, NYSE Arca Equities, NYSE Chicago, and NYSE National late trading sessions will close at 5:00 p.m. Eastern Time.',
+        },
+        '2025-11-28': {
+            date: '2025-11-28',
+            time: '13:00',
+            optionsTime: '13:15',
+            notes: 'Market closes early on Friday, November 28, 2025 at 1:00 p.m. (1:15 p.m. for eligible options). NYSE American Equities, NYSE Arca Equities, NYSE Chicago, and NYSE National late trading sessions will close at 5:00 p.m. Eastern Time.',
+        },
+        '2025-12-24': {
+            date: '2025-12-24',
+            time: '13:00',
+            optionsTime: '13:15',
+            notes: 'Market closes early on Wednesday, December 24, 2025 at 1:00 p.m. (1:15 p.m. for eligible options). NYSE American Equities, NYSE Arca Equities, NYSE Chicago, and NYSE National late trading sessions will close at 5:00 p.m. Eastern Time.',
+        },
+    },
+    2026: {
+        '2026-07-02': {
+            date: '2026-07-02',
+            time: '13:00',
+            optionsTime: '13:15',
+            notes: 'Independence Day observed, market closes early at 1:00 p.m. (1:15 p.m. for eligible options). NYSE American Equities, NYSE Arca Equities, NYSE Chicago, and NYSE National late trading sessions will close at 5:00 p.m. Eastern Time.',
+        },
+        '2026-11-27': {
+            date: '2026-11-27',
+            time: '13:00',
+            optionsTime: '13:15',
+            notes: 'Market closes early on Friday, November 27, 2026 at 1:00 p.m. (1:15 p.m. for eligible options). NYSE American Equities, NYSE Arca Equities, NYSE Chicago, and NYSE National late trading sessions will close at 5:00 p.m. Eastern Time.',
+        },
+        '2026-12-24': {
+            date: '2026-12-24',
+            time: '13:00',
+            optionsTime: '13:15',
+            notes: 'Market closes early on Thursday, December 24, 2026 at 1:00 p.m. (1:15 p.m. for eligible options). NYSE American Equities, NYSE Arca Equities, NYSE Chicago, and NYSE National late trading sessions will close at 5:00 p.m. Eastern Time.',
+        },
+    },
+};
 
-	constants = {
-	  BINARY_TYPES,
-	  EMPTY_BUFFER: Buffer.alloc(0),
-	  GUID: '258EAFA5-E914-47DA-95CA-C5AB0DC85B11',
-	  hasBlob,
-	  kForOnEventAttribute: Symbol('kIsForOnEventAttribute'),
-	  kListener: Symbol('kListener'),
-	  kStatusCode: Symbol('status-code'),
-	  kWebSocket: Symbol('websocket'),
-	  NOOP: () => {}
-	};
-	return constants;
+// Constants for NY market times (Eastern Time)
+const MARKET_CONFIG = {
+    TIMEZONE: 'America/New_York',
+    UTC_OFFSET_STANDARD: -5, // EST
+    UTC_OFFSET_DST: -4, // EDT
+    TIMES: {
+        EXTENDED_START: { hour: 4, minute: 0 },
+        MARKET_OPEN: { hour: 9, minute: 30 },
+        EARLY_MARKET_END: { hour: 10, minute: 0 },
+        MARKET_CLOSE: { hour: 16, minute: 0 },
+        EARLY_CLOSE: { hour: 13, minute: 0 },
+        EXTENDED_END: { hour: 20, minute: 0 },
+        EARLY_EXTENDED_END: { hour: 17, minute: 0 },
+    },
+};
+// Helper: Get NY offset for a given UTC date (DST rules for US)
+/**
+ * Returns the NY timezone offset (in hours) for a given UTC date, accounting for US DST rules.
+ * @param date - UTC date
+ * @returns offset in hours (-5 for EST, -4 for EDT)
+ */
+function getNYOffset(date) {
+    // US DST starts 2nd Sunday in March, ends 1st Sunday in November
+    const year = date.getUTCFullYear();
+    const dstStart = getNthWeekdayOfMonth(year, 3, 0, 2); // March, Sunday, 2nd
+    const dstEnd = getNthWeekdayOfMonth(year, 11, 0, 1); // November, Sunday, 1st
+    const utcTime = date.getTime();
+    if (utcTime >= dstStart.getTime() && utcTime < dstEnd.getTime()) {
+        return MARKET_CONFIG.UTC_OFFSET_DST;
+    }
+    return MARKET_CONFIG.UTC_OFFSET_STANDARD;
 }
-
-var hasRequiredBufferUtil;
-
-function requireBufferUtil () {
-	if (hasRequiredBufferUtil) return bufferUtil.exports;
-	hasRequiredBufferUtil = 1;
-
-	const { EMPTY_BUFFER } = requireConstants();
-
-	const FastBuffer = Buffer[Symbol.species];
-
-	/**
-	 * Merges an array of buffers into a new buffer.
-	 *
-	 * @param {Buffer[]} list The array of buffers to concat
-	 * @param {Number} totalLength The total length of buffers in the list
-	 * @return {Buffer} The resulting buffer
-	 * @public
-	 */
-	function concat(list, totalLength) {
-	  if (list.length === 0) return EMPTY_BUFFER;
-	  if (list.length === 1) return list[0];
-
-	  const target = Buffer.allocUnsafe(totalLength);
-	  let offset = 0;
-
-	  for (let i = 0; i < list.length; i++) {
-	    const buf = list[i];
-	    target.set(buf, offset);
-	    offset += buf.length;
-	  }
-
-	  if (offset < totalLength) {
-	    return new FastBuffer(target.buffer, target.byteOffset, offset);
-	  }
-
-	  return target;
-	}
-
-	/**
-	 * Masks a buffer using the given mask.
-	 *
-	 * @param {Buffer} source The buffer to mask
-	 * @param {Buffer} mask The mask to use
-	 * @param {Buffer} output The buffer where to store the result
-	 * @param {Number} offset The offset at which to start writing
-	 * @param {Number} length The number of bytes to mask.
-	 * @public
-	 */
-	function _mask(source, mask, output, offset, length) {
-	  for (let i = 0; i < length; i++) {
-	    output[offset + i] = source[i] ^ mask[i & 3];
-	  }
-	}
-
-	/**
-	 * Unmasks a buffer using the given mask.
-	 *
-	 * @param {Buffer} buffer The buffer to unmask
-	 * @param {Buffer} mask The mask to use
-	 * @public
-	 */
-	function _unmask(buffer, mask) {
-	  for (let i = 0; i < buffer.length; i++) {
-	    buffer[i] ^= mask[i & 3];
-	  }
-	}
-
-	/**
-	 * Converts a buffer to an `ArrayBuffer`.
-	 *
-	 * @param {Buffer} buf The buffer to convert
-	 * @return {ArrayBuffer} Converted buffer
-	 * @public
-	 */
-	function toArrayBuffer(buf) {
-	  if (buf.length === buf.buffer.byteLength) {
-	    return buf.buffer;
-	  }
-
-	  return buf.buffer.slice(buf.byteOffset, buf.byteOffset + buf.length);
-	}
-
-	/**
-	 * Converts `data` to a `Buffer`.
-	 *
-	 * @param {*} data The data to convert
-	 * @return {Buffer} The buffer
-	 * @throws {TypeError}
-	 * @public
-	 */
-	function toBuffer(data) {
-	  toBuffer.readOnly = true;
-
-	  if (Buffer.isBuffer(data)) return data;
-
-	  let buf;
-
-	  if (data instanceof ArrayBuffer) {
-	    buf = new FastBuffer(data);
-	  } else if (ArrayBuffer.isView(data)) {
-	    buf = new FastBuffer(data.buffer, data.byteOffset, data.byteLength);
-	  } else {
-	    buf = Buffer.from(data);
-	    toBuffer.readOnly = false;
-	  }
-
-	  return buf;
-	}
-
-	bufferUtil.exports = {
-	  concat,
-	  mask: _mask,
-	  toArrayBuffer,
-	  toBuffer,
-	  unmask: _unmask
-	};
-
-	/* istanbul ignore else  */
-	if (!process.env.WS_NO_BUFFER_UTIL) {
-	  try {
-	    const bufferUtil$1 = require('bufferutil');
-
-	    bufferUtil.exports.mask = function (source, mask, output, offset, length) {
-	      if (length < 48) _mask(source, mask, output, offset, length);
-	      else bufferUtil$1.mask(source, mask, output, offset, length);
-	    };
-
-	    bufferUtil.exports.unmask = function (buffer, mask) {
-	      if (buffer.length < 32) _unmask(buffer, mask);
-	      else bufferUtil$1.unmask(buffer, mask);
-	    };
-	  } catch (e) {
-	    // Continue regardless of the error.
-	  }
-	}
-	return bufferUtil.exports;
+// Helper: Get nth weekday of month in UTC
+/**
+ * Returns the nth weekday of a given month in UTC.
+ * @param year - Year
+ * @param month - 1-based month (e.g. March = 3)
+ * @param weekday - 0=Sunday, 1=Monday, ...
+ * @param n - nth occurrence
+ * @returns Date object for the nth weekday
+ */
+function getNthWeekdayOfMonth(year, month, weekday, n) {
+    let count = 0;
+    for (let d = 1; d <= 31; d++) {
+        const date = new Date(Date.UTC(year, month - 1, d));
+        if (date.getUTCMonth() !== month - 1)
+            break;
+        if (date.getUTCDay() === weekday) {
+            count++;
+            if (count === n)
+                return date;
+        }
+    }
+    // fallback: last day of month
+    return new Date(Date.UTC(year, month - 1, 28));
 }
-
-var limiter;
-var hasRequiredLimiter;
-
-function requireLimiter () {
-	if (hasRequiredLimiter) return limiter;
-	hasRequiredLimiter = 1;
-
-	const kDone = Symbol('kDone');
-	const kRun = Symbol('kRun');
-
-	/**
-	 * A very simple job queue with adjustable concurrency. Adapted from
-	 * https://github.com/STRML/async-limiter
-	 */
-	class Limiter {
-	  /**
-	   * Creates a new `Limiter`.
-	   *
-	   * @param {Number} [concurrency=Infinity] The maximum number of jobs allowed
-	   *     to run concurrently
-	   */
-	  constructor(concurrency) {
-	    this[kDone] = () => {
-	      this.pending--;
-	      this[kRun]();
-	    };
-	    this.concurrency = concurrency || Infinity;
-	    this.jobs = [];
-	    this.pending = 0;
-	  }
-
-	  /**
-	   * Adds a job to the queue.
-	   *
-	   * @param {Function} job The job to run
-	   * @public
-	   */
-	  add(job) {
-	    this.jobs.push(job);
-	    this[kRun]();
-	  }
-
-	  /**
-	   * Removes a job from the queue and runs it if possible.
-	   *
-	   * @private
-	   */
-	  [kRun]() {
-	    if (this.pending === this.concurrency) return;
-
-	    if (this.jobs.length) {
-	      const job = this.jobs.shift();
-
-	      this.pending++;
-	      job(this[kDone]);
-	    }
-	  }
-	}
-
-	limiter = Limiter;
-	return limiter;
+// Helper: Convert UTC date to NY time (returns new Date object)
+/**
+ * Converts a UTC date to NY time (returns a new Date object).
+ * @param date - UTC date
+ * @returns Date object in NY time
+ */
+function toNYTime(date) {
+    const offset = getNYOffset(date);
+    // NY offset in hours
+    const utcMillis = date.getTime();
+    const nyMillis = utcMillis + offset * 60 * 60 * 1000;
+    return new Date(nyMillis);
 }
-
-var permessageDeflate;
-var hasRequiredPermessageDeflate;
-
-function requirePermessageDeflate () {
-	if (hasRequiredPermessageDeflate) return permessageDeflate;
-	hasRequiredPermessageDeflate = 1;
-
-	const zlib = require$$0;
-
-	const bufferUtil = requireBufferUtil();
-	const Limiter = requireLimiter();
-	const { kStatusCode } = requireConstants();
-
-	const FastBuffer = Buffer[Symbol.species];
-	const TRAILER = Buffer.from([0x00, 0x00, 0xff, 0xff]);
-	const kPerMessageDeflate = Symbol('permessage-deflate');
-	const kTotalLength = Symbol('total-length');
-	const kCallback = Symbol('callback');
-	const kBuffers = Symbol('buffers');
-	const kError = Symbol('error');
-
-	//
-	// We limit zlib concurrency, which prevents severe memory fragmentation
-	// as documented in https://github.com/nodejs/node/issues/8871#issuecomment-250915913
-	// and https://github.com/websockets/ws/issues/1202
-	//
-	// Intentionally global; it's the global thread pool that's an issue.
-	//
-	let zlibLimiter;
-
-	/**
-	 * permessage-deflate implementation.
-	 */
-	class PerMessageDeflate {
-	  /**
-	   * Creates a PerMessageDeflate instance.
-	   *
-	   * @param {Object} [options] Configuration options
-	   * @param {(Boolean|Number)} [options.clientMaxWindowBits] Advertise support
-	   *     for, or request, a custom client window size
-	   * @param {Boolean} [options.clientNoContextTakeover=false] Advertise/
-	   *     acknowledge disabling of client context takeover
-	   * @param {Number} [options.concurrencyLimit=10] The number of concurrent
-	   *     calls to zlib
-	   * @param {(Boolean|Number)} [options.serverMaxWindowBits] Request/confirm the
-	   *     use of a custom server window size
-	   * @param {Boolean} [options.serverNoContextTakeover=false] Request/accept
-	   *     disabling of server context takeover
-	   * @param {Number} [options.threshold=1024] Size (in bytes) below which
-	   *     messages should not be compressed if context takeover is disabled
-	   * @param {Object} [options.zlibDeflateOptions] Options to pass to zlib on
-	   *     deflate
-	   * @param {Object} [options.zlibInflateOptions] Options to pass to zlib on
-	   *     inflate
-	   * @param {Boolean} [isServer=false] Create the instance in either server or
-	   *     client mode
-	   * @param {Number} [maxPayload=0] The maximum allowed message length
-	   */
-	  constructor(options, isServer, maxPayload) {
-	    this._maxPayload = maxPayload | 0;
-	    this._options = options || {};
-	    this._threshold =
-	      this._options.threshold !== undefined ? this._options.threshold : 1024;
-	    this._isServer = !!isServer;
-	    this._deflate = null;
-	    this._inflate = null;
-
-	    this.params = null;
-
-	    if (!zlibLimiter) {
-	      const concurrency =
-	        this._options.concurrencyLimit !== undefined
-	          ? this._options.concurrencyLimit
-	          : 10;
-	      zlibLimiter = new Limiter(concurrency);
-	    }
-	  }
-
-	  /**
-	   * @type {String}
-	   */
-	  static get extensionName() {
-	    return 'permessage-deflate';
-	  }
-
-	  /**
-	   * Create an extension negotiation offer.
-	   *
-	   * @return {Object} Extension parameters
-	   * @public
-	   */
-	  offer() {
-	    const params = {};
-
-	    if (this._options.serverNoContextTakeover) {
-	      params.server_no_context_takeover = true;
+// Helper: Convert NY time to UTC (returns new Date object)
+/**
+ * Converts a NY time date to UTC (returns a new Date object).
+ * @param date - NY time date
+ * @returns Date object in UTC
+ */
+function fromNYTime(date) {
+    const offset = getNYOffset(date);
+    const nyMillis = date.getTime();
+    const utcMillis = nyMillis - offset * 60 * 60 * 1000;
+    return new Date(utcMillis);
+}
+// Helper: Format date in ISO, unix, etc.
+/**
+ * Formats a date in ISO, unix-seconds, or unix-ms format.
+ * @param date - Date object
+ * @param outputFormat - Output format ('iso', 'unix-seconds', 'unix-ms')
+ * @returns Formatted date string or number
+ */
+function formatDate(date, outputFormat = 'iso') {
+    switch (outputFormat) {
+        case 'unix-seconds':
+            return Math.floor(date.getTime() / 1000);
+        case 'unix-ms':
+            return date.getTime();
+        case 'iso':
+        default:
+            return date.toISOString();
+    }
+}
+// Helper: Format date in NY locale string
+/**
+ * Formats a date in NY locale string.
+ * @param date - Date object
+ * @returns NY locale string
+ */
+function formatNYLocale(date) {
+    return date.toLocaleString('en-US', { timeZone: 'America/New_York' });
+}
+// Market calendar logic
+/**
+ * Market calendar logic for holidays, weekends, and market days.
+ */
+class MarketCalendar {
+    /**
+     * Checks if a date is a weekend in NY time.
+     * @param date - Date object
+     * @returns true if weekend, false otherwise
+     */
+    isWeekend(date) {
+        const day = toNYTime(date).getUTCDay();
+        return day === 0 || day === 6;
+    }
+    /**
+     * Checks if a date is a market holiday in NY time.
+     * @param date - Date object
+     * @returns true if holiday, false otherwise
+     */
+    isHoliday(date) {
+        const nyDate = toNYTime(date);
+        const year = nyDate.getUTCFullYear();
+        const month = nyDate.getUTCMonth() + 1;
+        const day = nyDate.getUTCDate();
+        const formattedDate = `${year}-${String(month).padStart(2, '0')}-${String(day).padStart(2, '0')}`;
+        const yearHolidays = marketHolidays[year];
+        if (!yearHolidays)
+            return false;
+        return Object.values(yearHolidays).some((holiday) => holiday.date === formattedDate);
+    }
+    /**
+     * Checks if a date is an early close day in NY time.
+     * @param date - Date object
+     * @returns true if early close, false otherwise
+     */
+    isEarlyCloseDay(date) {
+        const nyDate = toNYTime(date);
+        const year = nyDate.getUTCFullYear();
+        const month = nyDate.getUTCMonth() + 1;
+        const day = nyDate.getUTCDate();
+        const formattedDate = `${year}-${String(month).padStart(2, '0')}-${String(day).padStart(2, '0')}`;
+        const yearEarlyCloses = marketEarlyCloses[year];
+        return yearEarlyCloses && yearEarlyCloses[formattedDate] !== undefined;
+    }
+    /**
+     * Gets the early close time (in minutes from midnight) for a given date.
+     * @param date - Date object
+     * @returns minutes from midnight or null
+     */
+    getEarlyCloseTime(date) {
+        const nyDate = toNYTime(date);
+        const year = nyDate.getUTCFullYear();
+        const month = nyDate.getUTCMonth() + 1;
+        const day = nyDate.getUTCDate();
+        const formattedDate = `${year}-${String(month).padStart(2, '0')}-${String(day).padStart(2, '0')}`;
+        const yearEarlyCloses = marketEarlyCloses[year];
+        if (yearEarlyCloses && yearEarlyCloses[formattedDate]) {
+            const [hours, minutes] = yearEarlyCloses[formattedDate].time.split(':').map(Number);
+            return hours * 60 + minutes;
+        }
+        return null;
+    }
+    /**
+     * Checks if a date is a market day (not weekend or holiday).
+     * @param date - Date object
+     * @returns true if market day, false otherwise
+     */
+    isMarketDay(date) {
+        return !this.isWeekend(date) && !this.isHoliday(date);
+    }
+    /**
+     * Gets the next market day after the given date.
+     * @param date - Date object
+     * @returns Date object for next market day
+     */
+    getNextMarketDay(date) {
+        let nextDay = new Date(date.getTime() + 24 * 60 * 60 * 1000);
+        while (!this.isMarketDay(nextDay)) {
+            nextDay = new Date(nextDay.getTime() + 24 * 60 * 60 * 1000);
+        }
+        return nextDay;
+    }
+    /**
+     * Gets the previous market day before the given date.
+     * @param date - Date object
+     * @returns Date object for previous market day
+     */
+    getPreviousMarketDay(date) {
+        let prevDay = new Date(date.getTime() - 24 * 60 * 60 * 1000);
+        while (!this.isMarketDay(prevDay)) {
+            prevDay = new Date(prevDay.getTime() - 24 * 60 * 60 * 1000);
+        }
+        return prevDay;
+    }
+}
+// Market open/close times
+/**
+ * Returns market open/close times for a given date, including extended and early closes.
+ * @param date - Date object
+ * @returns MarketOpenCloseResult
+ */
+function getMarketTimes(date) {
+    const calendar = new MarketCalendar();
+    const nyDate = toNYTime(date);
+    if (!calendar.isMarketDay(date)) {
+        return {
+            marketOpen: false,
+            open: null,
+            close: null,
+            openExt: null,
+            closeExt: null,
+        };
+    }
+    const year = nyDate.getUTCFullYear();
+    const month = nyDate.getUTCMonth();
+    const day = nyDate.getUTCDate();
+    // Helper to build NY time for a given hour/minute
+    function buildNYTime(hour, minute) {
+        const d = new Date(Date.UTC(year, month, day, hour, minute, 0, 0));
+        return fromNYTime(d);
+    }
+    let open = buildNYTime(MARKET_CONFIG.TIMES.MARKET_OPEN.hour, MARKET_CONFIG.TIMES.MARKET_OPEN.minute);
+    let close = buildNYTime(MARKET_CONFIG.TIMES.MARKET_CLOSE.hour, MARKET_CONFIG.TIMES.MARKET_CLOSE.minute);
+    let openExt = buildNYTime(MARKET_CONFIG.TIMES.EXTENDED_START.hour, MARKET_CONFIG.TIMES.EXTENDED_START.minute);
+    let closeExt = buildNYTime(MARKET_CONFIG.TIMES.EXTENDED_END.hour, MARKET_CONFIG.TIMES.EXTENDED_END.minute);
+    if (calendar.isEarlyCloseDay(date)) {
+        close = buildNYTime(MARKET_CONFIG.TIMES.EARLY_CLOSE.hour, MARKET_CONFIG.TIMES.EARLY_CLOSE.minute);
+        closeExt = buildNYTime(MARKET_CONFIG.TIMES.EARLY_EXTENDED_END.hour, MARKET_CONFIG.TIMES.EARLY_EXTENDED_END.minute);
+    }
+    return {
+        marketOpen: true,
+        open,
+        close,
+        openExt,
+        closeExt,
+    };
+}
+// Is within market hours
+/**
+ * Checks if a date/time is within market hours, extended hours, or continuous.
+ * @param date - Date object
+ * @param intradayReporting - 'market_hours', 'extended_hours', or 'continuous'
+ * @returns true if within hours, false otherwise
+ */
+function isWithinMarketHours(date, intradayReporting = 'market_hours') {
+    const calendar = new MarketCalendar();
+    if (!calendar.isMarketDay(date))
+        return false;
+    const nyDate = toNYTime(date);
+    const minutes = nyDate.getUTCHours() * 60 + nyDate.getUTCMinutes();
+    switch (intradayReporting) {
+        case 'extended_hours': {
+            let endMinutes = MARKET_CONFIG.TIMES.EXTENDED_END.hour * 60 + MARKET_CONFIG.TIMES.EXTENDED_END.minute;
+            if (calendar.isEarlyCloseDay(date)) {
+                endMinutes = MARKET_CONFIG.TIMES.EARLY_EXTENDED_END.hour * 60 + MARKET_CONFIG.TIMES.EARLY_EXTENDED_END.minute;
+            }
+            const startMinutes = MARKET_CONFIG.TIMES.EXTENDED_START.hour * 60 + MARKET_CONFIG.TIMES.EXTENDED_START.minute;
+            return minutes >= startMinutes && minutes <= endMinutes;
+        }
+        case 'continuous':
+            return true;
+        default: {
+            let endMinutes = MARKET_CONFIG.TIMES.MARKET_CLOSE.hour * 60 + MARKET_CONFIG.TIMES.MARKET_CLOSE.minute;
+            if (calendar.isEarlyCloseDay(date)) {
+                endMinutes = MARKET_CONFIG.TIMES.EARLY_CLOSE.hour * 60 + MARKET_CONFIG.TIMES.EARLY_CLOSE.minute;
+            }
+            const startMinutes = MARKET_CONFIG.TIMES.MARKET_OPEN.hour * 60 + MARKET_CONFIG.TIMES.MARKET_OPEN.minute;
+            return minutes >= startMinutes && minutes <= endMinutes;
+        }
+    }
+}
+// Get last full trading date
+/**
+ * Returns the last full trading date (market close) for a given date.
+ * @param currentDate - Date object (default: now)
+ * @returns Date object for last full trading date
+ */
+function getLastFullTradingDateImpl(currentDate = new Date()) {
+    const calendar = new MarketCalendar();
+    const nyDate = toNYTime(currentDate);
+    const minutes = nyDate.getUTCHours() * 60 + nyDate.getUTCMinutes();
+    const marketOpenMinutes = MARKET_CONFIG.TIMES.MARKET_OPEN.hour * 60 + MARKET_CONFIG.TIMES.MARKET_OPEN.minute;
+    let marketCloseMinutes = MARKET_CONFIG.TIMES.MARKET_CLOSE.hour * 60 + MARKET_CONFIG.TIMES.MARKET_CLOSE.minute;
+    if (calendar.isEarlyCloseDay(currentDate)) {
+        marketCloseMinutes = MARKET_CONFIG.TIMES.EARLY_CLOSE.hour * 60 + MARKET_CONFIG.TIMES.EARLY_CLOSE.minute;
+    }
+    // If not a market day, or before open, or during market hours, return previous market day's close
+    if (!calendar.isMarketDay(currentDate) ||
+        minutes < marketOpenMinutes ||
+        (minutes >= marketOpenMinutes && minutes < marketCloseMinutes)) {
+        const prevMarketDay = calendar.getPreviousMarketDay(currentDate);
+        let prevCloseMinutes = MARKET_CONFIG.TIMES.MARKET_CLOSE.hour * 60 + MARKET_CONFIG.TIMES.MARKET_CLOSE.minute;
+        if (calendar.isEarlyCloseDay(prevMarketDay)) {
+            prevCloseMinutes = MARKET_CONFIG.TIMES.EARLY_CLOSE.hour * 60 + MARKET_CONFIG.TIMES.EARLY_CLOSE.minute;
+        }
+        const year = prevMarketDay.getUTCFullYear();
+        const month = prevMarketDay.getUTCMonth();
+        const day = prevMarketDay.getUTCDate();
+        const closeHour = Math.floor(prevCloseMinutes / 60);
+        const closeMinute = prevCloseMinutes % 60;
+        return fromNYTime(new Date(Date.UTC(year, month, day, closeHour, closeMinute, 0, 0)));
+    }
+    // After market close or after extended hours, return today's close
+    const year = nyDate.getUTCFullYear();
+    const month = nyDate.getUTCMonth();
+    const day = nyDate.getUTCDate();
+    const closeHour = Math.floor(marketCloseMinutes / 60);
+    const closeMinute = marketCloseMinutes % 60;
+    return fromNYTime(new Date(Date.UTC(year, month, day, closeHour, closeMinute, 0, 0)));
+}
+// Get day boundaries
+/**
+ * Returns the start and end boundaries for a market day, extended hours, or continuous.
+ * @param date - Date object
+ * @param intradayReporting - 'market_hours', 'extended_hours', or 'continuous'
+ * @returns Object with start and end Date
+ */
+function getDayBoundaries(date, intradayReporting = 'market_hours') {
+    const calendar = new MarketCalendar();
+    const nyDate = toNYTime(date);
+    const year = nyDate.getUTCFullYear();
+    const month = nyDate.getUTCMonth();
+    const day = nyDate.getUTCDate();
+    function buildNYTime(hour, minute, sec = 0, ms = 0) {
+        const d = new Date(Date.UTC(year, month, day, hour, minute, sec, ms));
+        return fromNYTime(d);
+    }
+    let start;
+    let end;
+    switch (intradayReporting) {
+        case 'extended_hours':
+            start = buildNYTime(MARKET_CONFIG.TIMES.EXTENDED_START.hour, MARKET_CONFIG.TIMES.EXTENDED_START.minute, 0, 0);
+            end = buildNYTime(MARKET_CONFIG.TIMES.EXTENDED_END.hour, MARKET_CONFIG.TIMES.EXTENDED_END.minute, 59, 999);
+            if (calendar.isEarlyCloseDay(date)) {
+                end = buildNYTime(MARKET_CONFIG.TIMES.EARLY_EXTENDED_END.hour, MARKET_CONFIG.TIMES.EARLY_EXTENDED_END.minute, 59, 999);
+            }
+            break;
+        case 'continuous':
+            start = new Date(Date.UTC(year, month, day, 0, 0, 0, 0));
+            end = new Date(Date.UTC(year, month, day, 23, 59, 59, 999));
+            break;
+        default:
+            start = buildNYTime(MARKET_CONFIG.TIMES.MARKET_OPEN.hour, MARKET_CONFIG.TIMES.MARKET_OPEN.minute, 0, 0);
+            end = buildNYTime(MARKET_CONFIG.TIMES.MARKET_CLOSE.hour, MARKET_CONFIG.TIMES.MARKET_CLOSE.minute, 59, 999);
+            if (calendar.isEarlyCloseDay(date)) {
+                end = buildNYTime(MARKET_CONFIG.TIMES.EARLY_CLOSE.hour, MARKET_CONFIG.TIMES.EARLY_CLOSE.minute, 59, 999);
+            }
+            break;
+    }
+    return { start, end };
+}
+// Period calculator
+/**
+ * Calculates the start date for a given period ending at endDate.
+ * @param endDate - Date object
+ * @param period - Period string
+ * @returns Date object for period start
+ */
+function calculatePeriodStartDate(endDate, period) {
+    const calendar = new MarketCalendar();
+    let startDate;
+    switch (period) {
+        case 'YTD':
+            startDate = new Date(Date.UTC(endDate.getUTCFullYear(), 0, 1));
+            break;
+        case '1D':
+            startDate = calendar.getPreviousMarketDay(endDate);
+            break;
+        case '3D':
+            startDate = new Date(endDate.getTime() - 3 * 24 * 60 * 60 * 1000);
+            break;
+        case '1W':
+            startDate = new Date(endDate.getTime() - 7 * 24 * 60 * 60 * 1000);
+            break;
+        case '2W':
+            startDate = new Date(endDate.getTime() - 14 * 24 * 60 * 60 * 1000);
+            break;
+        case '1M':
+            startDate = new Date(Date.UTC(endDate.getUTCFullYear(), endDate.getUTCMonth() - 1, endDate.getUTCDate()));
+            break;
+        case '3M':
+            startDate = new Date(Date.UTC(endDate.getUTCFullYear(), endDate.getUTCMonth() - 3, endDate.getUTCDate()));
+            break;
+        case '6M':
+            startDate = new Date(Date.UTC(endDate.getUTCFullYear(), endDate.getUTCMonth() - 6, endDate.getUTCDate()));
+            break;
+        case '1Y':
+            startDate = new Date(Date.UTC(endDate.getUTCFullYear() - 1, endDate.getUTCMonth(), endDate.getUTCDate()));
+            break;
+        default:
+            throw new Error(`Invalid period: ${period}`);
+    }
+    // Ensure start date is a market day
+    while (!calendar.isMarketDay(startDate)) {
+        startDate = calendar.getNextMarketDay(startDate);
+    }
+    return startDate;
+}
+// Get market time period
+/**
+ * Returns the start and end dates for a market time period.
+ * @param params - MarketTimeParams
+ * @returns PeriodDates object
+ */
+function getMarketTimePeriod(params) {
+    const { period, end = new Date(), intraday_reporting = 'market_hours', outputFormat = 'iso' } = params;
+    if (!period)
+        throw new Error('Period is required');
+    const calendar = new MarketCalendar();
+    const nyEndDate = toNYTime(end);
+    let endDate;
+    const isCurrentMarketDay = calendar.isMarketDay(end);
+    const isWithinHours = isWithinMarketHours(end, intraday_reporting);
+    const minutes = nyEndDate.getUTCHours() * 60 + nyEndDate.getUTCMinutes();
+    const marketStartMinutes = MARKET_CONFIG.TIMES.MARKET_OPEN.hour * 60 + MARKET_CONFIG.TIMES.MARKET_OPEN.minute;
+    if (isCurrentMarketDay) {
+        if (minutes < marketStartMinutes) {
+            // Before market open - use previous day's close
+            const lastMarketDay = calendar.getPreviousMarketDay(end);
+            const { end: dayEnd } = getDayBoundaries(lastMarketDay, intraday_reporting);
+            endDate = dayEnd;
+        }
+        else if (isWithinHours) {
+            // During market hours - use current time
+            endDate = end;
+        }
+        else {
+            // After market close - use today's close
+            const { end: dayEnd } = getDayBoundaries(end, intraday_reporting);
+            endDate = dayEnd;
+        }
+    }
+    else {
+        // Not a market day - use previous market day's close
+        const lastMarketDay = calendar.getPreviousMarketDay(end);
+        const { end: dayEnd } = getDayBoundaries(lastMarketDay, intraday_reporting);
+        endDate = dayEnd;
+    }
+    // Calculate start date
+    const periodStartDate = calculatePeriodStartDate(endDate, period);
+    const { start: dayStart } = getDayBoundaries(periodStartDate, intraday_reporting);
+    if (endDate.getTime() < dayStart.getTime()) {
+        throw new Error('Start date cannot be after end date');
+    }
+    return {
+        start: formatDate(dayStart, outputFormat),
+        end: formatDate(endDate, outputFormat),
+    };
+}
+// Market status
+/**
+ * Returns the current market status for a given date.
+ * @param date - Date object (default: now)
+ * @returns MarketStatus object
+ */
+function getMarketStatusImpl(date = new Date()) {
+    const calendar = new MarketCalendar();
+    const nyDate = toNYTime(date);
+    const minutes = nyDate.getUTCHours() * 60 + nyDate.getUTCMinutes();
+    const isMarketDay = calendar.isMarketDay(date);
+    const isEarlyCloseDay = calendar.isEarlyCloseDay(date);
+    const extendedStartMinutes = MARKET_CONFIG.TIMES.EXTENDED_START.hour * 60 + MARKET_CONFIG.TIMES.EXTENDED_START.minute;
+    const marketStartMinutes = MARKET_CONFIG.TIMES.MARKET_OPEN.hour * 60 + MARKET_CONFIG.TIMES.MARKET_OPEN.minute;
+    const earlyMarketEndMinutes = MARKET_CONFIG.TIMES.EARLY_MARKET_END.hour * 60 + MARKET_CONFIG.TIMES.EARLY_MARKET_END.minute;
+    let marketCloseMinutes = MARKET_CONFIG.TIMES.MARKET_CLOSE.hour * 60 + MARKET_CONFIG.TIMES.MARKET_CLOSE.minute;
+    let extendedEndMinutes = MARKET_CONFIG.TIMES.EXTENDED_END.hour * 60 + MARKET_CONFIG.TIMES.EXTENDED_END.minute;
+    if (isEarlyCloseDay) {
+        marketCloseMinutes = MARKET_CONFIG.TIMES.EARLY_CLOSE.hour * 60 + MARKET_CONFIG.TIMES.EARLY_CLOSE.minute;
+        extendedEndMinutes =
+            MARKET_CONFIG.TIMES.EARLY_EXTENDED_END.hour * 60 + MARKET_CONFIG.TIMES.EARLY_EXTENDED_END.minute;
+    }
+    let status;
+    let nextStatus;
+    let nextStatusTime;
+    let marketPeriod;
+    if (!isMarketDay) {
+        status = 'closed';
+        nextStatus = 'extended hours';
+        marketPeriod = 'closed';
+        const nextMarketDay = calendar.getNextMarketDay(date);
+        nextStatusTime = getDayBoundaries(nextMarketDay, 'extended_hours').start;
+    }
+    else if (minutes < extendedStartMinutes) {
+        status = 'closed';
+        nextStatus = 'extended hours';
+        marketPeriod = 'closed';
+        nextStatusTime = getDayBoundaries(date, 'extended_hours').start;
+    }
+    else if (minutes < marketStartMinutes) {
+        status = 'extended hours';
+        nextStatus = 'open';
+        marketPeriod = 'preMarket';
+        nextStatusTime = getDayBoundaries(date, 'market_hours').start;
+    }
+    else if (minutes < marketCloseMinutes) {
+        status = 'open';
+        nextStatus = 'extended hours';
+        marketPeriod = minutes < earlyMarketEndMinutes ? 'earlyMarket' : 'regularMarket';
+        nextStatusTime = getDayBoundaries(date, 'market_hours').end;
+    }
+    else if (minutes < extendedEndMinutes) {
+        status = 'extended hours';
+        nextStatus = 'closed';
+        marketPeriod = 'afterMarket';
+        nextStatusTime = getDayBoundaries(date, 'extended_hours').end;
+    }
+    else {
+        status = 'closed';
+        nextStatus = 'extended hours';
+        marketPeriod = 'closed';
+        const nextMarketDay = calendar.getNextMarketDay(date);
+        nextStatusTime = getDayBoundaries(nextMarketDay, 'extended_hours').start;
+    }
+    // I think using nyDate here may be wrong - should use current time? i.e. date.getTime()
+    const nextStatusTimeDifference = nextStatusTime.getTime() - date.getTime();
+    return {
+        time: date,
+        timeString: formatNYLocale(nyDate),
+        status,
+        nextStatus,
+        marketPeriod,
+        nextStatusTime,
+        nextStatusTimeDifference,
+        nextStatusTimeString: formatNYLocale(nextStatusTime),
+    };
+}
+// API exports
+/**
+ * Returns market open/close times for a given date.
+ * @param options - { date?: Date }
+ * @returns MarketOpenCloseResult
+ */
+function getMarketOpenClose(options = {}) {
+    const { date = new Date() } = options;
+    return getMarketTimes(date);
+}
+/**
+ * Returns the start and end dates for a market time period as Date objects.
+ * @param params - MarketTimeParams
+ * @returns Object with start and end Date
+ */
+function getStartAndEndDates(params = {}) {
+    const { start, end } = getMarketTimePeriod(params);
+    return {
+        start: typeof start === 'string' || typeof start === 'number' ? new Date(start) : start,
+        end: typeof end === 'string' || typeof end === 'number' ? new Date(end) : end,
+    };
+}
+/**
+ * Returns the last full trading date as a Date object.
+ */
+/**
+ * Returns the last full trading date as a Date object.
+ * @param currentDate - Date object (default: now)
+ * @returns Date object for last full trading date
+ */
+function getLastFullTradingDate(currentDate = new Date()) {
+    return getLastFullTradingDateImpl(currentDate);
+}
+/**
+ * Returns the last full trading date and formatted YYYYMMDD string.
+ */
+/**
+ * Returns the last full trading date and formatted YYYY-MM-DD string.
+ * @param currentDate - Date object (default: now)
+ * @returns Object with date and YYYYMMDD string
+ */
+function getLastFullTradingDateInfo(currentDate = new Date()) {
+    const date = getLastFullTradingDateImpl(currentDate);
+    return {
+        date,
+        YYYYMMDD: `${date.getUTCFullYear()}-${String(date.getUTCMonth() + 1).padStart(2, '0')}-${String(date.getUTCDate()).padStart(2, '0')}`,
+    };
+}
+/**
+ * Returns the next market day after the reference date.
+ * @param referenceDate - Date object (default: now)
+ * @returns Object with date, yyyymmdd string, and ISO string
+ */
+function getNextMarketDay({ referenceDate } = {}) {
+    const calendar = new MarketCalendar();
+    const startDate = referenceDate ?? new Date();
+    // Find the next trading day (UTC Date object)
+    const nextDate = calendar.getNextMarketDay(startDate);
+    // Convert to NY time before extracting Y-M-D parts
+    const nyNext = toNYTime(nextDate);
+    const yyyymmdd = `${nyNext.getUTCFullYear()}-${String(nyNext.getUTCMonth() + 1).padStart(2, '0')}-${String(nyNext.getUTCDate()).padStart(2, '0')}`;
+    return {
+        date: nextDate, // raw Date, unchanged
+        yyyymmdd, // correct trading date string
+        dateISOString: nextDate.toISOString(),
+    };
+}
+/**
+ * Returns the previous market day before the reference date.
+ * @param referenceDate - Date object (default: now)
+ * @returns Object with date, yyyymmdd string, and ISO string
+ */
+function getPreviousMarketDay({ referenceDate } = {}) {
+    const calendar = new MarketCalendar();
+    const startDate = referenceDate || new Date();
+    const prevDate = calendar.getPreviousMarketDay(startDate);
+    // convert to NY time first
+    const nyPrev = toNYTime(prevDate); // ← already in this file
+    const yyyymmdd = `${nyPrev.getUTCFullYear()}-${String(nyPrev.getUTCMonth() + 1).padStart(2, '0')}-${String(nyPrev.getUTCDate()).padStart(2, '0')}`;
+    return {
+        date: prevDate,
+        yyyymmdd,
+        dateISOString: prevDate.toISOString(),
+    };
+}
+/**
+ * Returns the trading date for a given time. Note: Just trims the date string; does not validate if the date is a market day.
+ * @param time - a string, number (unix timestamp), or Date object representing the time
+ * @returns the trading date as a string in YYYY-MM-DD format
+ */
+/**
+ * Returns the trading date for a given time in YYYY-MM-DD format (NY time).
+ * @param time - string, number, or Date
+ * @returns trading date string
+ */
+function getTradingDate(time) {
+    const date = typeof time === 'number' ? new Date(time) : typeof time === 'string' ? new Date(time) : time;
+    const nyDate = toNYTime(date);
+    return `${nyDate.getUTCFullYear()}-${String(nyDate.getUTCMonth() + 1).padStart(2, '0')}-${String(nyDate.getUTCDate()).padStart(2, '0')}`;
+}
+/**
+ * Returns the NY timezone offset string for a given date.
+ * @param date - Date object (default: now)
+ * @returns '-04:00' for EDT, '-05:00' for EST
+ */
+function getNYTimeZone(date) {
+    const offset = getNYOffset(date || new Date());
+    return offset === -4 ? '-04:00' : '-05:00';
+}
+/**
+ * Converts any date to the market time zone (America/New_York, Eastern Time).
+ * Returns a new Date object representing the same moment in time but adjusted to NY/Eastern timezone.
+ * Automatically handles daylight saving time transitions (EST/EDT).
+ *
+ * @param date - Date object to convert to market time zone
+ * @returns Date object in NY/Eastern time zone
+ * @example
+ * ```typescript
+ * const utcDate = new Date('2024-01-15T15:30:00Z'); // 3:30 PM UTC
+ * const nyDate = convertDateToMarketTimeZone(utcDate); // 10:30 AM EST (winter) or 11:30 AM EDT (summer)
+ * ```
+ */
+function convertDateToMarketTimeZone(date) {
+    return toNYTime(date);
+}
+/**
+ * Returns the current market status for a given date.
+ * @param options - { date?: Date }
+ * @returns MarketStatus object
+ */
+function getMarketStatus(options = {}) {
+    const { date = new Date() } = options;
+    return getMarketStatusImpl(date);
+}
+/**
+ * Checks if a date is a market day.
+ * @param date - Date object
+ * @returns true if market day, false otherwise
+ */
+function isMarketDay(date) {
+    const calendar = new MarketCalendar();
+    return calendar.isMarketDay(date);
+}
+/**
+ * Returns full trading days from market open to market close.
+ * endDate is always the most recent market close (previous day's close if before open, today's close if after open).
+ * days: 1 or not specified = that day's open; 2 = previous market day's open, etc.
+ */
+/**
+ * Returns full trading days from market open to market close.
+ * @param options - { endDate?: Date, days?: number }
+ * @returns Object with startDate and endDate
+ */
+function getTradingStartAndEndDates(options = {}) {
+    const { endDate = new Date(), days = 1 } = options;
+    const calendar = new MarketCalendar();
+    // Find the most recent market close
+    let endMarketDay = endDate;
+    const nyEnd = toNYTime(endDate);
+    const marketOpenMinutes = MARKET_CONFIG.TIMES.MARKET_OPEN.hour * 60 + MARKET_CONFIG.TIMES.MARKET_OPEN.minute;
+    const marketCloseMinutes = MARKET_CONFIG.TIMES.MARKET_CLOSE.hour * 60 + MARKET_CONFIG.TIMES.MARKET_CLOSE.minute;
+    const minutes = nyEnd.getUTCHours() * 60 + nyEnd.getUTCMinutes();
+    if (!calendar.isMarketDay(endDate) ||
+        minutes < marketOpenMinutes ||
+        (minutes >= marketOpenMinutes && minutes < marketCloseMinutes)) {
+        // Before market open, not a market day, or during market hours: use previous market day
+        endMarketDay = calendar.getPreviousMarketDay(endDate);
+    }
+    else {
+        // After market close: use today
+        endMarketDay = endDate;
+    }
+    // Get market close for endMarketDay
+    const endClose = getMarketOpenClose({ date: endMarketDay }).close;
+    // Find start market day by iterating back over market days
+    let startMarketDay = endMarketDay;
+    let count = Math.max(1, days);
+    for (let i = 1; i < count; i++) {
+        startMarketDay = calendar.getPreviousMarketDay(startMarketDay);
+    }
+    // If days > 1, we need to go back (days-1) market days from endMarketDay
+    if (days > 1) {
+        startMarketDay = endMarketDay;
+        for (let i = 1; i < days; i++) {
+            startMarketDay = calendar.getPreviousMarketDay(startMarketDay);
+        }
+    }
+    const startOpen = getMarketOpenClose({ date: startMarketDay }).open;
+    return { startDate: startOpen, endDate: endClose };
+}
+/**
+ * Counts trading time between two dates (passed as standard Date objects), excluding weekends and holidays, and closed market hours, using other functions in this library.
+ *
+ * This function calculates the actual trading time between two dates by:
+ * 1. Iterating through each calendar day between startDate and endDate (inclusive)
+ * 2. For each day that is a market day (not weekend/holiday), getting market open/close times
+ * 3. Calculating the overlap between the time range and market hours for that day
+ * 4. Summing up all the trading minutes across all days
+ *
+ * The function automatically handles:
+ * - Weekends (Saturday/Sunday) - skipped entirely
+ * - Market holidays - skipped entirely
+ * - Early close days (e.g. day before holidays) - uses early close time
+ * - Times outside market hours - only counts time within 9:30am-4pm ET (or early close)
+ *
+ * Examples:
+ * - 12pm to 3:30pm same day = 3.5 hours = 210 minutes = 0.54 days
+ * - 9:30am to 4pm same day = 6.5 hours = 390 minutes = 1 day
+ * - Friday 2pm to Monday 2pm = 6.5 hours (Friday 2pm-4pm + Monday 9:30am-2pm)
+ *
+ * @param startDate - Start date/time
+ * @param endDate - End date/time (default: now)
+ * @returns Object containing:
+ *   - days: Trading time as fraction of full trading days (6.5 hours = 1 day)
+ *   - hours: Trading time in hours
+ *   - minutes: Trading time in minutes
+ */
+function countTradingDays(startDate, endDate = new Date()) {
+    const calendar = new MarketCalendar();
+    // Ensure start is before end
+    if (startDate.getTime() > endDate.getTime()) {
+        throw new Error('Start date must be before end date');
+    }
+    let totalMinutes = 0;
+    // Get the NY dates for iteration
+    const startNY = toNYTime(startDate);
+    const endNY = toNYTime(endDate);
+    // Create date at start of first day (in NY time)
+    const currentNY = new Date(Date.UTC(startNY.getUTCFullYear(), startNY.getUTCMonth(), startNY.getUTCDate(), 0, 0, 0, 0));
+    // Iterate through each calendar day
+    while (currentNY.getTime() <= endNY.getTime()) {
+        const currentUTC = fromNYTime(currentNY);
+        // Check if this is a market day
+        if (calendar.isMarketDay(currentUTC)) {
+            // Get market hours for this day
+            const marketTimes = getMarketTimes(currentUTC);
+            if (marketTimes.marketOpen && marketTimes.open && marketTimes.close) {
+                // Calculate the overlap between our time range and market hours
+                const dayStart = Math.max(startDate.getTime(), marketTimes.open.getTime());
+                const dayEnd = Math.min(endDate.getTime(), marketTimes.close.getTime());
+                // Only count if there's actual overlap
+                if (dayStart < dayEnd) {
+                    totalMinutes += (dayEnd - dayStart) / (1000 * 60);
+                }
+            }
+        }
+        // Move to next day
+        currentNY.setUTCDate(currentNY.getUTCDate() + 1);
+    }
+    // Convert to days, hours, minutes
+    const MINUTES_PER_TRADING_DAY = 390; // 6.5 hours
+    const days = totalMinutes / MINUTES_PER_TRADING_DAY;
+    const hours = totalMinutes / 60;
+    const minutes = totalMinutes;
+    return {
+        days: Math.round(days * 1000) / 1000, // Round to 3 decimal places
+        hours: Math.round(hours * 100) / 100, // Round to 2 decimal places
+        minutes: Math.round(minutes),
+    };
+}
+// Export MARKET_TIMES for compatibility
+const MARKET_TIMES = {
+    TIMEZONE: MARKET_CONFIG.TIMEZONE,
+    PRE: {
+        START: { HOUR: 4, MINUTE: 0, MINUTES: 240 },
+        END: { HOUR: 9, MINUTE: 30, MINUTES: 570 },
+    },
+    EARLY_MORNING: {
+        START: { HOUR: 9, MINUTE: 30, MINUTES: 570 },
+        END: { HOUR: 10, MINUTE: 0, MINUTES: 600 },
+    },
+    EARLY_CLOSE_BEFORE_HOLIDAY: {
+        START: { HOUR: 9, MINUTE: 30, MINUTES: 570 },
+        END: { HOUR: 13, MINUTE: 0, MINUTES: 780 },
+    },
+    EARLY_EXTENDED_BEFORE_HOLIDAY: {
+        START: { HOUR: 13, MINUTE: 0, MINUTES: 780 },
+        END: { HOUR: 17, MINUTE: 0, MINUTES: 1020 },
+    },
+    REGULAR: {
+        START: { HOUR: 9, MINUTE: 30, MINUTES: 570 },
+        END: { HOUR: 16, MINUTE: 0, MINUTES: 960 },
+    },
+    EXTENDED: {
+        START: { HOUR: 4, MINUTE: 0, MINUTES: 240 },
+        END: { HOUR: 20, MINUTE: 0, MINUTES: 1200 },
+    },
+};
+
+var time = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    MARKET_CONFIG: MARKET_CONFIG,
+    MARKET_TIMES: MARKET_TIMES,
+    convertDateToMarketTimeZone: convertDateToMarketTimeZone,
+    countTradingDays: countTradingDays,
+    getLastFullTradingDate: getLastFullTradingDate,
+    getLastFullTradingDateInfo: getLastFullTradingDateInfo,
+    getMarketOpenClose: getMarketOpenClose,
+    getMarketStatus: getMarketStatus,
+    getMarketTimePeriod: getMarketTimePeriod,
+    getNYTimeZone: getNYTimeZone,
+    getNextMarketDay: getNextMarketDay,
+    getPreviousMarketDay: getPreviousMarketDay,
+    getStartAndEndDates: getStartAndEndDates,
+    getTradingDate: getTradingDate,
+    getTradingStartAndEndDates: getTradingStartAndEndDates,
+    isMarketDay: isMarketDay,
+    isWithinMarketHours: isWithinMarketHours
+});
+
+function getDefaultExportFromCjs (x) {
+	return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, 'default') ? x['default'] : x;
+}
+
+var bufferUtil = {exports: {}};
+
+var constants;
+var hasRequiredConstants;
+
+function requireConstants () {
+	if (hasRequiredConstants) return constants;
+	hasRequiredConstants = 1;
+
+	const BINARY_TYPES = ['nodebuffer', 'arraybuffer', 'fragments'];
+	const hasBlob = typeof Blob !== 'undefined';
+
+	if (hasBlob) BINARY_TYPES.push('blob');
+
+	constants = {
+	  BINARY_TYPES,
+	  EMPTY_BUFFER: Buffer.alloc(0),
+	  GUID: '258EAFA5-E914-47DA-95CA-C5AB0DC85B11',
+	  hasBlob,
+	  kForOnEventAttribute: Symbol('kIsForOnEventAttribute'),
+	  kListener: Symbol('kListener'),
+	  kStatusCode: Symbol('status-code'),
+	  kWebSocket: Symbol('websocket'),
+	  NOOP: () => {}
+	};
+	return constants;
+}
+
+var hasRequiredBufferUtil;
+
+function requireBufferUtil () {
+	if (hasRequiredBufferUtil) return bufferUtil.exports;
+	hasRequiredBufferUtil = 1;
+
+	const { EMPTY_BUFFER } = requireConstants();
+
+	const FastBuffer = Buffer[Symbol.species];
+
+	/**
+	 * Merges an array of buffers into a new buffer.
+	 *
+	 * @param {Buffer[]} list The array of buffers to concat
+	 * @param {Number} totalLength The total length of buffers in the list
+	 * @return {Buffer} The resulting buffer
+	 * @public
+	 */
+	function concat(list, totalLength) {
+	  if (list.length === 0) return EMPTY_BUFFER;
+	  if (list.length === 1) return list[0];
+
+	  const target = Buffer.allocUnsafe(totalLength);
+	  let offset = 0;
+
+	  for (let i = 0; i < list.length; i++) {
+	    const buf = list[i];
+	    target.set(buf, offset);
+	    offset += buf.length;
+	  }
+
+	  if (offset < totalLength) {
+	    return new FastBuffer(target.buffer, target.byteOffset, offset);
+	  }
+
+	  return target;
+	}
+
+	/**
+	 * Masks a buffer using the given mask.
+	 *
+	 * @param {Buffer} source The buffer to mask
+	 * @param {Buffer} mask The mask to use
+	 * @param {Buffer} output The buffer where to store the result
+	 * @param {Number} offset The offset at which to start writing
+	 * @param {Number} length The number of bytes to mask.
+	 * @public
+	 */
+	function _mask(source, mask, output, offset, length) {
+	  for (let i = 0; i < length; i++) {
+	    output[offset + i] = source[i] ^ mask[i & 3];
+	  }
+	}
+
+	/**
+	 * Unmasks a buffer using the given mask.
+	 *
+	 * @param {Buffer} buffer The buffer to unmask
+	 * @param {Buffer} mask The mask to use
+	 * @public
+	 */
+	function _unmask(buffer, mask) {
+	  for (let i = 0; i < buffer.length; i++) {
+	    buffer[i] ^= mask[i & 3];
+	  }
+	}
+
+	/**
+	 * Converts a buffer to an `ArrayBuffer`.
+	 *
+	 * @param {Buffer} buf The buffer to convert
+	 * @return {ArrayBuffer} Converted buffer
+	 * @public
+	 */
+	function toArrayBuffer(buf) {
+	  if (buf.length === buf.buffer.byteLength) {
+	    return buf.buffer;
+	  }
+
+	  return buf.buffer.slice(buf.byteOffset, buf.byteOffset + buf.length);
+	}
+
+	/**
+	 * Converts `data` to a `Buffer`.
+	 *
+	 * @param {*} data The data to convert
+	 * @return {Buffer} The buffer
+	 * @throws {TypeError}
+	 * @public
+	 */
+	function toBuffer(data) {
+	  toBuffer.readOnly = true;
+
+	  if (Buffer.isBuffer(data)) return data;
+
+	  let buf;
+
+	  if (data instanceof ArrayBuffer) {
+	    buf = new FastBuffer(data);
+	  } else if (ArrayBuffer.isView(data)) {
+	    buf = new FastBuffer(data.buffer, data.byteOffset, data.byteLength);
+	  } else {
+	    buf = Buffer.from(data);
+	    toBuffer.readOnly = false;
+	  }
+
+	  return buf;
+	}
+
+	bufferUtil.exports = {
+	  concat,
+	  mask: _mask,
+	  toArrayBuffer,
+	  toBuffer,
+	  unmask: _unmask
+	};
+
+	/* istanbul ignore else  */
+	if (!process.env.WS_NO_BUFFER_UTIL) {
+	  try {
+	    const bufferUtil$1 = require('bufferutil');
+
+	    bufferUtil.exports.mask = function (source, mask, output, offset, length) {
+	      if (length < 48) _mask(source, mask, output, offset, length);
+	      else bufferUtil$1.mask(source, mask, output, offset, length);
+	    };
+
+	    bufferUtil.exports.unmask = function (buffer, mask) {
+	      if (buffer.length < 32) _unmask(buffer, mask);
+	      else bufferUtil$1.unmask(buffer, mask);
+	    };
+	  } catch (e) {
+	    // Continue regardless of the error.
+	  }
+	}
+	return bufferUtil.exports;
+}
+
+var limiter;
+var hasRequiredLimiter;
+
+function requireLimiter () {
+	if (hasRequiredLimiter) return limiter;
+	hasRequiredLimiter = 1;
+
+	const kDone = Symbol('kDone');
+	const kRun = Symbol('kRun');
+
+	/**
+	 * A very simple job queue with adjustable concurrency. Adapted from
+	 * https://github.com/STRML/async-limiter
+	 */
+	class Limiter {
+	  /**
+	   * Creates a new `Limiter`.
+	   *
+	   * @param {Number} [concurrency=Infinity] The maximum number of jobs allowed
+	   *     to run concurrently
+	   */
+	  constructor(concurrency) {
+	    this[kDone] = () => {
+	      this.pending--;
+	      this[kRun]();
+	    };
+	    this.concurrency = concurrency || Infinity;
+	    this.jobs = [];
+	    this.pending = 0;
+	  }
+
+	  /**
+	   * Adds a job to the queue.
+	   *
+	   * @param {Function} job The job to run
+	   * @public
+	   */
+	  add(job) {
+	    this.jobs.push(job);
+	    this[kRun]();
+	  }
+
+	  /**
+	   * Removes a job from the queue and runs it if possible.
+	   *
+	   * @private
+	   */
+	  [kRun]() {
+	    if (this.pending === this.concurrency) return;
+
+	    if (this.jobs.length) {
+	      const job = this.jobs.shift();
+
+	      this.pending++;
+	      job(this[kDone]);
+	    }
+	  }
+	}
+
+	limiter = Limiter;
+	return limiter;
+}
+
+var permessageDeflate;
+var hasRequiredPermessageDeflate;
+
+function requirePermessageDeflate () {
+	if (hasRequiredPermessageDeflate) return permessageDeflate;
+	hasRequiredPermessageDeflate = 1;
+
+	const zlib = require$$0;
+
+	const bufferUtil = requireBufferUtil();
+	const Limiter = requireLimiter();
+	const { kStatusCode } = requireConstants();
+
+	const FastBuffer = Buffer[Symbol.species];
+	const TRAILER = Buffer.from([0x00, 0x00, 0xff, 0xff]);
+	const kPerMessageDeflate = Symbol('permessage-deflate');
+	const kTotalLength = Symbol('total-length');
+	const kCallback = Symbol('callback');
+	const kBuffers = Symbol('buffers');
+	const kError = Symbol('error');
+
+	//
+	// We limit zlib concurrency, which prevents severe memory fragmentation
+	// as documented in https://github.com/nodejs/node/issues/8871#issuecomment-250915913
+	// and https://github.com/websockets/ws/issues/1202
+	//
+	// Intentionally global; it's the global thread pool that's an issue.
+	//
+	let zlibLimiter;
+
+	/**
+	 * permessage-deflate implementation.
+	 */
+	class PerMessageDeflate {
+	  /**
+	   * Creates a PerMessageDeflate instance.
+	   *
+	   * @param {Object} [options] Configuration options
+	   * @param {(Boolean|Number)} [options.clientMaxWindowBits] Advertise support
+	   *     for, or request, a custom client window size
+	   * @param {Boolean} [options.clientNoContextTakeover=false] Advertise/
+	   *     acknowledge disabling of client context takeover
+	   * @param {Number} [options.concurrencyLimit=10] The number of concurrent
+	   *     calls to zlib
+	   * @param {(Boolean|Number)} [options.serverMaxWindowBits] Request/confirm the
+	   *     use of a custom server window size
+	   * @param {Boolean} [options.serverNoContextTakeover=false] Request/accept
+	   *     disabling of server context takeover
+	   * @param {Number} [options.threshold=1024] Size (in bytes) below which
+	   *     messages should not be compressed if context takeover is disabled
+	   * @param {Object} [options.zlibDeflateOptions] Options to pass to zlib on
+	   *     deflate
+	   * @param {Object} [options.zlibInflateOptions] Options to pass to zlib on
+	   *     inflate
+	   * @param {Boolean} [isServer=false] Create the instance in either server or
+	   *     client mode
+	   * @param {Number} [maxPayload=0] The maximum allowed message length
+	   */
+	  constructor(options, isServer, maxPayload) {
+	    this._maxPayload = maxPayload | 0;
+	    this._options = options || {};
+	    this._threshold =
+	      this._options.threshold !== undefined ? this._options.threshold : 1024;
+	    this._isServer = !!isServer;
+	    this._deflate = null;
+	    this._inflate = null;
+
+	    this.params = null;
+
+	    if (!zlibLimiter) {
+	      const concurrency =
+	        this._options.concurrencyLimit !== undefined
+	          ? this._options.concurrencyLimit
+	          : 10;
+	      zlibLimiter = new Limiter(concurrency);
+	    }
+	  }
+
+	  /**
+	   * @type {String}
+	   */
+	  static get extensionName() {
+	    return 'permessage-deflate';
+	  }
+
+	  /**
+	   * Create an extension negotiation offer.
+	   *
+	   * @return {Object} Extension parameters
+	   * @public
+	   */
+	  offer() {
+	    const params = {};
+
+	    if (this._options.serverNoContextTakeover) {
+	      params.server_no_context_takeover = true;
 	    }
 	    if (this._options.clientNoContextTakeover) {
 	      params.client_no_context_takeover = true;
@@ -12060,1975 +13036,1607 @@ function requireWebsocket () {
 	    if (websocket._socket) websocket._sender._bufferedBytes += length;
 	    else websocket._bufferedAmount += length;
 	  }
-
-	  if (cb) {
-	    const err = new Error(
-	      `WebSocket is not open: readyState ${websocket.readyState} ` +
-	        `(${readyStates[websocket.readyState]})`
-	    );
-	    process.nextTick(cb, err);
-	  }
-	}
-
-	/**
-	 * The listener of the `Receiver` `'conclude'` event.
-	 *
-	 * @param {Number} code The status code
-	 * @param {Buffer} reason The reason for closing
-	 * @private
-	 */
-	function receiverOnConclude(code, reason) {
-	  const websocket = this[kWebSocket];
-
-	  websocket._closeFrameReceived = true;
-	  websocket._closeMessage = reason;
-	  websocket._closeCode = code;
-
-	  if (websocket._socket[kWebSocket] === undefined) return;
-
-	  websocket._socket.removeListener('data', socketOnData);
-	  process.nextTick(resume, websocket._socket);
-
-	  if (code === 1005) websocket.close();
-	  else websocket.close(code, reason);
-	}
-
-	/**
-	 * The listener of the `Receiver` `'drain'` event.
-	 *
-	 * @private
-	 */
-	function receiverOnDrain() {
-	  const websocket = this[kWebSocket];
-
-	  if (!websocket.isPaused) websocket._socket.resume();
-	}
-
-	/**
-	 * The listener of the `Receiver` `'error'` event.
-	 *
-	 * @param {(RangeError|Error)} err The emitted error
-	 * @private
-	 */
-	function receiverOnError(err) {
-	  const websocket = this[kWebSocket];
-
-	  if (websocket._socket[kWebSocket] !== undefined) {
-	    websocket._socket.removeListener('data', socketOnData);
-
-	    //
-	    // On Node.js < 14.0.0 the `'error'` event is emitted synchronously. See
-	    // https://github.com/websockets/ws/issues/1940.
-	    //
-	    process.nextTick(resume, websocket._socket);
-
-	    websocket.close(err[kStatusCode]);
-	  }
-
-	  if (!websocket._errorEmitted) {
-	    websocket._errorEmitted = true;
-	    websocket.emit('error', err);
-	  }
-	}
-
-	/**
-	 * The listener of the `Receiver` `'finish'` event.
-	 *
-	 * @private
-	 */
-	function receiverOnFinish() {
-	  this[kWebSocket].emitClose();
-	}
-
-	/**
-	 * The listener of the `Receiver` `'message'` event.
-	 *
-	 * @param {Buffer|ArrayBuffer|Buffer[])} data The message
-	 * @param {Boolean} isBinary Specifies whether the message is binary or not
-	 * @private
-	 */
-	function receiverOnMessage(data, isBinary) {
-	  this[kWebSocket].emit('message', data, isBinary);
-	}
-
-	/**
-	 * The listener of the `Receiver` `'ping'` event.
-	 *
-	 * @param {Buffer} data The data included in the ping frame
-	 * @private
-	 */
-	function receiverOnPing(data) {
-	  const websocket = this[kWebSocket];
-
-	  if (websocket._autoPong) websocket.pong(data, !this._isServer, NOOP);
-	  websocket.emit('ping', data);
-	}
-
-	/**
-	 * The listener of the `Receiver` `'pong'` event.
-	 *
-	 * @param {Buffer} data The data included in the pong frame
-	 * @private
-	 */
-	function receiverOnPong(data) {
-	  this[kWebSocket].emit('pong', data);
-	}
-
-	/**
-	 * Resume a readable stream
-	 *
-	 * @param {Readable} stream The readable stream
-	 * @private
-	 */
-	function resume(stream) {
-	  stream.resume();
-	}
-
-	/**
-	 * The `Sender` error event handler.
-	 *
-	 * @param {Error} The error
-	 * @private
-	 */
-	function senderOnError(err) {
-	  const websocket = this[kWebSocket];
-
-	  if (websocket.readyState === WebSocket.CLOSED) return;
-	  if (websocket.readyState === WebSocket.OPEN) {
-	    websocket._readyState = WebSocket.CLOSING;
-	    setCloseTimer(websocket);
-	  }
-
-	  //
-	  // `socket.end()` is used instead of `socket.destroy()` to allow the other
-	  // peer to finish sending queued data. There is no need to set a timer here
-	  // because `CLOSING` means that it is already set or not needed.
-	  //
-	  this._socket.end();
-
-	  if (!websocket._errorEmitted) {
-	    websocket._errorEmitted = true;
-	    websocket.emit('error', err);
-	  }
-	}
-
-	/**
-	 * Set a timer to destroy the underlying raw socket of a WebSocket.
-	 *
-	 * @param {WebSocket} websocket The WebSocket instance
-	 * @private
-	 */
-	function setCloseTimer(websocket) {
-	  websocket._closeTimer = setTimeout(
-	    websocket._socket.destroy.bind(websocket._socket),
-	    closeTimeout
-	  );
-	}
-
-	/**
-	 * The listener of the socket `'close'` event.
-	 *
-	 * @private
-	 */
-	function socketOnClose() {
-	  const websocket = this[kWebSocket];
-
-	  this.removeListener('close', socketOnClose);
-	  this.removeListener('data', socketOnData);
-	  this.removeListener('end', socketOnEnd);
-
-	  websocket._readyState = WebSocket.CLOSING;
-
-	  let chunk;
-
-	  //
-	  // The close frame might not have been received or the `'end'` event emitted,
-	  // for example, if the socket was destroyed due to an error. Ensure that the
-	  // `receiver` stream is closed after writing any remaining buffered data to
-	  // it. If the readable side of the socket is in flowing mode then there is no
-	  // buffered data as everything has been already written and `readable.read()`
-	  // will return `null`. If instead, the socket is paused, any possible buffered
-	  // data will be read as a single chunk.
-	  //
-	  if (
-	    !this._readableState.endEmitted &&
-	    !websocket._closeFrameReceived &&
-	    !websocket._receiver._writableState.errorEmitted &&
-	    (chunk = websocket._socket.read()) !== null
-	  ) {
-	    websocket._receiver.write(chunk);
-	  }
-
-	  websocket._receiver.end();
-
-	  this[kWebSocket] = undefined;
-
-	  clearTimeout(websocket._closeTimer);
-
-	  if (
-	    websocket._receiver._writableState.finished ||
-	    websocket._receiver._writableState.errorEmitted
-	  ) {
-	    websocket.emitClose();
-	  } else {
-	    websocket._receiver.on('error', receiverOnFinish);
-	    websocket._receiver.on('finish', receiverOnFinish);
-	  }
+
+	  if (cb) {
+	    const err = new Error(
+	      `WebSocket is not open: readyState ${websocket.readyState} ` +
+	        `(${readyStates[websocket.readyState]})`
+	    );
+	    process.nextTick(cb, err);
+	  }
 	}
 
 	/**
-	 * The listener of the socket `'data'` event.
+	 * The listener of the `Receiver` `'conclude'` event.
 	 *
-	 * @param {Buffer} chunk A chunk of data
+	 * @param {Number} code The status code
+	 * @param {Buffer} reason The reason for closing
 	 * @private
 	 */
-	function socketOnData(chunk) {
-	  if (!this[kWebSocket]._receiver.write(chunk)) {
-	    this.pause();
-	  }
+	function receiverOnConclude(code, reason) {
+	  const websocket = this[kWebSocket];
+
+	  websocket._closeFrameReceived = true;
+	  websocket._closeMessage = reason;
+	  websocket._closeCode = code;
+
+	  if (websocket._socket[kWebSocket] === undefined) return;
+
+	  websocket._socket.removeListener('data', socketOnData);
+	  process.nextTick(resume, websocket._socket);
+
+	  if (code === 1005) websocket.close();
+	  else websocket.close(code, reason);
 	}
 
 	/**
-	 * The listener of the socket `'end'` event.
+	 * The listener of the `Receiver` `'drain'` event.
 	 *
 	 * @private
 	 */
-	function socketOnEnd() {
+	function receiverOnDrain() {
 	  const websocket = this[kWebSocket];
 
-	  websocket._readyState = WebSocket.CLOSING;
-	  websocket._receiver.end();
-	  this.end();
+	  if (!websocket.isPaused) websocket._socket.resume();
 	}
 
 	/**
-	 * The listener of the socket `'error'` event.
+	 * The listener of the `Receiver` `'error'` event.
 	 *
+	 * @param {(RangeError|Error)} err The emitted error
 	 * @private
 	 */
-	function socketOnError() {
+	function receiverOnError(err) {
 	  const websocket = this[kWebSocket];
 
-	  this.removeListener('error', socketOnError);
-	  this.on('error', NOOP);
-
-	  if (websocket) {
-	    websocket._readyState = WebSocket.CLOSING;
-	    this.destroy();
-	  }
-	}
-	return websocket;
-}
-
-/* eslint no-unused-vars: ["error", { "varsIgnorePattern": "^WebSocket$" }] */
+	  if (websocket._socket[kWebSocket] !== undefined) {
+	    websocket._socket.removeListener('data', socketOnData);
 
-var stream;
-var hasRequiredStream;
+	    //
+	    // On Node.js < 14.0.0 the `'error'` event is emitted synchronously. See
+	    // https://github.com/websockets/ws/issues/1940.
+	    //
+	    process.nextTick(resume, websocket._socket);
 
-function requireStream () {
-	if (hasRequiredStream) return stream;
-	hasRequiredStream = 1;
+	    websocket.close(err[kStatusCode]);
+	  }
 
-	requireWebsocket();
-	const { Duplex } = require$$0$2;
+	  if (!websocket._errorEmitted) {
+	    websocket._errorEmitted = true;
+	    websocket.emit('error', err);
+	  }
+	}
 
 	/**
-	 * Emits the `'close'` event on a stream.
+	 * The listener of the `Receiver` `'finish'` event.
 	 *
-	 * @param {Duplex} stream The stream.
 	 * @private
 	 */
-	function emitClose(stream) {
-	  stream.emit('close');
+	function receiverOnFinish() {
+	  this[kWebSocket].emitClose();
 	}
 
 	/**
-	 * The listener of the `'end'` event.
+	 * The listener of the `Receiver` `'message'` event.
 	 *
+	 * @param {Buffer|ArrayBuffer|Buffer[])} data The message
+	 * @param {Boolean} isBinary Specifies whether the message is binary or not
 	 * @private
 	 */
-	function duplexOnEnd() {
-	  if (!this.destroyed && this._writableState.finished) {
-	    this.destroy();
-	  }
+	function receiverOnMessage(data, isBinary) {
+	  this[kWebSocket].emit('message', data, isBinary);
 	}
 
 	/**
-	 * The listener of the `'error'` event.
+	 * The listener of the `Receiver` `'ping'` event.
 	 *
-	 * @param {Error} err The error
+	 * @param {Buffer} data The data included in the ping frame
 	 * @private
 	 */
-	function duplexOnError(err) {
-	  this.removeListener('error', duplexOnError);
-	  this.destroy();
-	  if (this.listenerCount('error') === 0) {
-	    // Do not suppress the throwing behavior.
-	    this.emit('error', err);
-	  }
+	function receiverOnPing(data) {
+	  const websocket = this[kWebSocket];
+
+	  if (websocket._autoPong) websocket.pong(data, !this._isServer, NOOP);
+	  websocket.emit('ping', data);
 	}
 
 	/**
-	 * Wraps a `WebSocket` in a duplex stream.
+	 * The listener of the `Receiver` `'pong'` event.
 	 *
-	 * @param {WebSocket} ws The `WebSocket` to wrap
-	 * @param {Object} [options] The options for the `Duplex` constructor
-	 * @return {Duplex} The duplex stream
-	 * @public
+	 * @param {Buffer} data The data included in the pong frame
+	 * @private
 	 */
-	function createWebSocketStream(ws, options) {
-	  let terminateOnDestroy = true;
-
-	  const duplex = new Duplex({
-	    ...options,
-	    autoDestroy: false,
-	    emitClose: false,
-	    objectMode: false,
-	    writableObjectMode: false
-	  });
-
-	  ws.on('message', function message(msg, isBinary) {
-	    const data =
-	      !isBinary && duplex._readableState.objectMode ? msg.toString() : msg;
-
-	    if (!duplex.push(data)) ws.pause();
-	  });
-
-	  ws.once('error', function error(err) {
-	    if (duplex.destroyed) return;
-
-	    // Prevent `ws.terminate()` from being called by `duplex._destroy()`.
-	    //
-	    // - If the `'error'` event is emitted before the `'open'` event, then
-	    //   `ws.terminate()` is a noop as no socket is assigned.
-	    // - Otherwise, the error is re-emitted by the listener of the `'error'`
-	    //   event of the `Receiver` object. The listener already closes the
-	    //   connection by calling `ws.close()`. This allows a close frame to be
-	    //   sent to the other peer. If `ws.terminate()` is called right after this,
-	    //   then the close frame might not be sent.
-	    terminateOnDestroy = false;
-	    duplex.destroy(err);
-	  });
-
-	  ws.once('close', function close() {
-	    if (duplex.destroyed) return;
-
-	    duplex.push(null);
-	  });
-
-	  duplex._destroy = function (err, callback) {
-	    if (ws.readyState === ws.CLOSED) {
-	      callback(err);
-	      process.nextTick(emitClose, duplex);
-	      return;
-	    }
-
-	    let called = false;
-
-	    ws.once('error', function error(err) {
-	      called = true;
-	      callback(err);
-	    });
-
-	    ws.once('close', function close() {
-	      if (!called) callback(err);
-	      process.nextTick(emitClose, duplex);
-	    });
-
-	    if (terminateOnDestroy) ws.terminate();
-	  };
-
-	  duplex._final = function (callback) {
-	    if (ws.readyState === ws.CONNECTING) {
-	      ws.once('open', function open() {
-	        duplex._final(callback);
-	      });
-	      return;
-	    }
-
-	    // If the value of the `_socket` property is `null` it means that `ws` is a
-	    // client websocket and the handshake failed. In fact, when this happens, a
-	    // socket is never assigned to the websocket. Wait for the `'error'` event
-	    // that will be emitted by the websocket.
-	    if (ws._socket === null) return;
-
-	    if (ws._socket._writableState.finished) {
-	      callback();
-	      if (duplex._readableState.endEmitted) duplex.destroy();
-	    } else {
-	      ws._socket.once('finish', function finish() {
-	        // `duplex` is not destroyed here because the `'end'` event will be
-	        // emitted on `duplex` after this `'finish'` event. The EOF signaling
-	        // `null` chunk is, in fact, pushed when the websocket emits `'close'`.
-	        callback();
-	      });
-	      ws.close();
-	    }
-	  };
-
-	  duplex._read = function () {
-	    if (ws.isPaused) ws.resume();
-	  };
-
-	  duplex._write = function (chunk, encoding, callback) {
-	    if (ws.readyState === ws.CONNECTING) {
-	      ws.once('open', function open() {
-	        duplex._write(chunk, encoding, callback);
-	      });
-	      return;
-	    }
-
-	    ws.send(chunk, callback);
-	  };
-
-	  duplex.on('end', duplexOnEnd);
-	  duplex.on('error', duplexOnError);
-	  return duplex;
+	function receiverOnPong(data) {
+	  this[kWebSocket].emit('pong', data);
 	}
 
-	stream = createWebSocketStream;
-	return stream;
-}
-
-requireStream();
-
-requireReceiver();
-
-requireSender();
+	/**
+	 * Resume a readable stream
+	 *
+	 * @param {Readable} stream The readable stream
+	 * @private
+	 */
+	function resume(stream) {
+	  stream.resume();
+	}
 
-var websocketExports = requireWebsocket();
-var WebSocket = /*@__PURE__*/getDefaultExportFromCjs(websocketExports);
+	/**
+	 * The `Sender` error event handler.
+	 *
+	 * @param {Error} The error
+	 * @private
+	 */
+	function senderOnError(err) {
+	  const websocket = this[kWebSocket];
 
-var subprotocol;
-var hasRequiredSubprotocol;
+	  if (websocket.readyState === WebSocket.CLOSED) return;
+	  if (websocket.readyState === WebSocket.OPEN) {
+	    websocket._readyState = WebSocket.CLOSING;
+	    setCloseTimer(websocket);
+	  }
 
-function requireSubprotocol () {
-	if (hasRequiredSubprotocol) return subprotocol;
-	hasRequiredSubprotocol = 1;
+	  //
+	  // `socket.end()` is used instead of `socket.destroy()` to allow the other
+	  // peer to finish sending queued data. There is no need to set a timer here
+	  // because `CLOSING` means that it is already set or not needed.
+	  //
+	  this._socket.end();
 
-	const { tokenChars } = requireValidation();
+	  if (!websocket._errorEmitted) {
+	    websocket._errorEmitted = true;
+	    websocket.emit('error', err);
+	  }
+	}
 
 	/**
-	 * Parses the `Sec-WebSocket-Protocol` header into a set of subprotocol names.
+	 * Set a timer to destroy the underlying raw socket of a WebSocket.
 	 *
-	 * @param {String} header The field value of the header
-	 * @return {Set} The subprotocol names
-	 * @public
+	 * @param {WebSocket} websocket The WebSocket instance
+	 * @private
 	 */
-	function parse(header) {
-	  const protocols = new Set();
-	  let start = -1;
-	  let end = -1;
-	  let i = 0;
-
-	  for (i; i < header.length; i++) {
-	    const code = header.charCodeAt(i);
+	function setCloseTimer(websocket) {
+	  websocket._closeTimer = setTimeout(
+	    websocket._socket.destroy.bind(websocket._socket),
+	    closeTimeout
+	  );
+	}
 
-	    if (end === -1 && tokenChars[code] === 1) {
-	      if (start === -1) start = i;
-	    } else if (
-	      i !== 0 &&
-	      (code === 0x20 /* ' ' */ || code === 0x09) /* '\t' */
-	    ) {
-	      if (end === -1 && start !== -1) end = i;
-	    } else if (code === 0x2c /* ',' */) {
-	      if (start === -1) {
-	        throw new SyntaxError(`Unexpected character at index ${i}`);
-	      }
+	/**
+	 * The listener of the socket `'close'` event.
+	 *
+	 * @private
+	 */
+	function socketOnClose() {
+	  const websocket = this[kWebSocket];
 
-	      if (end === -1) end = i;
+	  this.removeListener('close', socketOnClose);
+	  this.removeListener('data', socketOnData);
+	  this.removeListener('end', socketOnEnd);
 
-	      const protocol = header.slice(start, end);
+	  websocket._readyState = WebSocket.CLOSING;
 
-	      if (protocols.has(protocol)) {
-	        throw new SyntaxError(`The "${protocol}" subprotocol is duplicated`);
-	      }
+	  let chunk;
 
-	      protocols.add(protocol);
-	      start = end = -1;
-	    } else {
-	      throw new SyntaxError(`Unexpected character at index ${i}`);
-	    }
+	  //
+	  // The close frame might not have been received or the `'end'` event emitted,
+	  // for example, if the socket was destroyed due to an error. Ensure that the
+	  // `receiver` stream is closed after writing any remaining buffered data to
+	  // it. If the readable side of the socket is in flowing mode then there is no
+	  // buffered data as everything has been already written and `readable.read()`
+	  // will return `null`. If instead, the socket is paused, any possible buffered
+	  // data will be read as a single chunk.
+	  //
+	  if (
+	    !this._readableState.endEmitted &&
+	    !websocket._closeFrameReceived &&
+	    !websocket._receiver._writableState.errorEmitted &&
+	    (chunk = websocket._socket.read()) !== null
+	  ) {
+	    websocket._receiver.write(chunk);
 	  }
 
-	  if (start === -1 || end !== -1) {
-	    throw new SyntaxError('Unexpected end of input');
-	  }
+	  websocket._receiver.end();
 
-	  const protocol = header.slice(start, i);
+	  this[kWebSocket] = undefined;
 
-	  if (protocols.has(protocol)) {
-	    throw new SyntaxError(`The "${protocol}" subprotocol is duplicated`);
+	  clearTimeout(websocket._closeTimer);
+
+	  if (
+	    websocket._receiver._writableState.finished ||
+	    websocket._receiver._writableState.errorEmitted
+	  ) {
+	    websocket.emitClose();
+	  } else {
+	    websocket._receiver.on('error', receiverOnFinish);
+	    websocket._receiver.on('finish', receiverOnFinish);
 	  }
+	}
 
-	  protocols.add(protocol);
-	  return protocols;
+	/**
+	 * The listener of the socket `'data'` event.
+	 *
+	 * @param {Buffer} chunk A chunk of data
+	 * @private
+	 */
+	function socketOnData(chunk) {
+	  if (!this[kWebSocket]._receiver.write(chunk)) {
+	    this.pause();
+	  }
 	}
 
-	subprotocol = { parse };
-	return subprotocol;
-}
+	/**
+	 * The listener of the socket `'end'` event.
+	 *
+	 * @private
+	 */
+	function socketOnEnd() {
+	  const websocket = this[kWebSocket];
 
-/* eslint no-unused-vars: ["error", { "varsIgnorePattern": "^Duplex$", "caughtErrors": "none" }] */
+	  websocket._readyState = WebSocket.CLOSING;
+	  websocket._receiver.end();
+	  this.end();
+	}
 
-var websocketServer;
-var hasRequiredWebsocketServer;
+	/**
+	 * The listener of the socket `'error'` event.
+	 *
+	 * @private
+	 */
+	function socketOnError() {
+	  const websocket = this[kWebSocket];
 
-function requireWebsocketServer () {
-	if (hasRequiredWebsocketServer) return websocketServer;
-	hasRequiredWebsocketServer = 1;
+	  this.removeListener('error', socketOnError);
+	  this.on('error', NOOP);
 
-	const EventEmitter = require$$0$3;
-	const http = require$$2;
-	const { Duplex } = require$$0$2;
-	const { createHash } = require$$3;
+	  if (websocket) {
+	    websocket._readyState = WebSocket.CLOSING;
+	    this.destroy();
+	  }
+	}
+	return websocket;
+}
 
-	const extension = requireExtension();
-	const PerMessageDeflate = requirePermessageDeflate();
-	const subprotocol = requireSubprotocol();
-	const WebSocket = requireWebsocket();
-	const { GUID, kWebSocket } = requireConstants();
+/* eslint no-unused-vars: ["error", { "varsIgnorePattern": "^WebSocket$" }] */
 
-	const keyRegex = /^[+/0-9A-Za-z]{22}==$/;
+var stream;
+var hasRequiredStream;
 
-	const RUNNING = 0;
-	const CLOSING = 1;
-	const CLOSED = 2;
+function requireStream () {
+	if (hasRequiredStream) return stream;
+	hasRequiredStream = 1;
+
+	requireWebsocket();
+	const { Duplex } = require$$0$2;
 
 	/**
-	 * Class representing a WebSocket server.
+	 * Emits the `'close'` event on a stream.
 	 *
-	 * @extends EventEmitter
+	 * @param {Duplex} stream The stream.
+	 * @private
 	 */
-	class WebSocketServer extends EventEmitter {
-	  /**
-	   * Create a `WebSocketServer` instance.
-	   *
-	   * @param {Object} options Configuration options
-	   * @param {Boolean} [options.allowSynchronousEvents=true] Specifies whether
-	   *     any of the `'message'`, `'ping'`, and `'pong'` events can be emitted
-	   *     multiple times in the same tick
-	   * @param {Boolean} [options.autoPong=true] Specifies whether or not to
-	   *     automatically send a pong in response to a ping
-	   * @param {Number} [options.backlog=511] The maximum length of the queue of
-	   *     pending connections
-	   * @param {Boolean} [options.clientTracking=true] Specifies whether or not to
-	   *     track clients
-	   * @param {Function} [options.handleProtocols] A hook to handle protocols
-	   * @param {String} [options.host] The hostname where to bind the server
-	   * @param {Number} [options.maxPayload=104857600] The maximum allowed message
-	   *     size
-	   * @param {Boolean} [options.noServer=false] Enable no server mode
-	   * @param {String} [options.path] Accept only connections matching this path
-	   * @param {(Boolean|Object)} [options.perMessageDeflate=false] Enable/disable
-	   *     permessage-deflate
-	   * @param {Number} [options.port] The port where to bind the server
-	   * @param {(http.Server|https.Server)} [options.server] A pre-created HTTP/S
-	   *     server to use
-	   * @param {Boolean} [options.skipUTF8Validation=false] Specifies whether or
-	   *     not to skip UTF-8 validation for text and close messages
-	   * @param {Function} [options.verifyClient] A hook to reject connections
-	   * @param {Function} [options.WebSocket=WebSocket] Specifies the `WebSocket`
-	   *     class to use. It must be the `WebSocket` class or class that extends it
-	   * @param {Function} [callback] A listener for the `listening` event
-	   */
-	  constructor(options, callback) {
-	    super();
-
-	    options = {
-	      allowSynchronousEvents: true,
-	      autoPong: true,
-	      maxPayload: 100 * 1024 * 1024,
-	      skipUTF8Validation: false,
-	      perMessageDeflate: false,
-	      handleProtocols: null,
-	      clientTracking: true,
-	      verifyClient: null,
-	      noServer: false,
-	      backlog: null, // use default (511 as implemented in net.js)
-	      server: null,
-	      host: null,
-	      path: null,
-	      port: null,
-	      WebSocket,
-	      ...options
-	    };
+	function emitClose(stream) {
+	  stream.emit('close');
+	}
 
-	    if (
-	      (options.port == null && !options.server && !options.noServer) ||
-	      (options.port != null && (options.server || options.noServer)) ||
-	      (options.server && options.noServer)
-	    ) {
-	      throw new TypeError(
-	        'One and only one of the "port", "server", or "noServer" options ' +
-	          'must be specified'
-	      );
-	    }
+	/**
+	 * The listener of the `'end'` event.
+	 *
+	 * @private
+	 */
+	function duplexOnEnd() {
+	  if (!this.destroyed && this._writableState.finished) {
+	    this.destroy();
+	  }
+	}
 
-	    if (options.port != null) {
-	      this._server = http.createServer((req, res) => {
-	        const body = http.STATUS_CODES[426];
+	/**
+	 * The listener of the `'error'` event.
+	 *
+	 * @param {Error} err The error
+	 * @private
+	 */
+	function duplexOnError(err) {
+	  this.removeListener('error', duplexOnError);
+	  this.destroy();
+	  if (this.listenerCount('error') === 0) {
+	    // Do not suppress the throwing behavior.
+	    this.emit('error', err);
+	  }
+	}
 
-	        res.writeHead(426, {
-	          'Content-Length': body.length,
-	          'Content-Type': 'text/plain'
-	        });
-	        res.end(body);
-	      });
-	      this._server.listen(
-	        options.port,
-	        options.host,
-	        options.backlog,
-	        callback
-	      );
-	    } else if (options.server) {
-	      this._server = options.server;
-	    }
+	/**
+	 * Wraps a `WebSocket` in a duplex stream.
+	 *
+	 * @param {WebSocket} ws The `WebSocket` to wrap
+	 * @param {Object} [options] The options for the `Duplex` constructor
+	 * @return {Duplex} The duplex stream
+	 * @public
+	 */
+	function createWebSocketStream(ws, options) {
+	  let terminateOnDestroy = true;
 
-	    if (this._server) {
-	      const emitConnection = this.emit.bind(this, 'connection');
+	  const duplex = new Duplex({
+	    ...options,
+	    autoDestroy: false,
+	    emitClose: false,
+	    objectMode: false,
+	    writableObjectMode: false
+	  });
 
-	      this._removeListeners = addListeners(this._server, {
-	        listening: this.emit.bind(this, 'listening'),
-	        error: this.emit.bind(this, 'error'),
-	        upgrade: (req, socket, head) => {
-	          this.handleUpgrade(req, socket, head, emitConnection);
-	        }
-	      });
-	    }
+	  ws.on('message', function message(msg, isBinary) {
+	    const data =
+	      !isBinary && duplex._readableState.objectMode ? msg.toString() : msg;
 
-	    if (options.perMessageDeflate === true) options.perMessageDeflate = {};
-	    if (options.clientTracking) {
-	      this.clients = new Set();
-	      this._shouldEmitClose = false;
-	    }
+	    if (!duplex.push(data)) ws.pause();
+	  });
 
-	    this.options = options;
-	    this._state = RUNNING;
-	  }
+	  ws.once('error', function error(err) {
+	    if (duplex.destroyed) return;
 
-	  /**
-	   * Returns the bound address, the address family name, and port of the server
-	   * as reported by the operating system if listening on an IP socket.
-	   * If the server is listening on a pipe or UNIX domain socket, the name is
-	   * returned as a string.
-	   *
-	   * @return {(Object|String|null)} The address of the server
-	   * @public
-	   */
-	  address() {
-	    if (this.options.noServer) {
-	      throw new Error('The server is operating in "noServer" mode');
-	    }
+	    // Prevent `ws.terminate()` from being called by `duplex._destroy()`.
+	    //
+	    // - If the `'error'` event is emitted before the `'open'` event, then
+	    //   `ws.terminate()` is a noop as no socket is assigned.
+	    // - Otherwise, the error is re-emitted by the listener of the `'error'`
+	    //   event of the `Receiver` object. The listener already closes the
+	    //   connection by calling `ws.close()`. This allows a close frame to be
+	    //   sent to the other peer. If `ws.terminate()` is called right after this,
+	    //   then the close frame might not be sent.
+	    terminateOnDestroy = false;
+	    duplex.destroy(err);
+	  });
 
-	    if (!this._server) return null;
-	    return this._server.address();
-	  }
+	  ws.once('close', function close() {
+	    if (duplex.destroyed) return;
 
-	  /**
-	   * Stop the server from accepting new connections and emit the `'close'` event
-	   * when all existing connections are closed.
-	   *
-	   * @param {Function} [cb] A one-time listener for the `'close'` event
-	   * @public
-	   */
-	  close(cb) {
-	    if (this._state === CLOSED) {
-	      if (cb) {
-	        this.once('close', () => {
-	          cb(new Error('The server is not running'));
-	        });
-	      }
+	    duplex.push(null);
+	  });
 
-	      process.nextTick(emitClose, this);
+	  duplex._destroy = function (err, callback) {
+	    if (ws.readyState === ws.CLOSED) {
+	      callback(err);
+	      process.nextTick(emitClose, duplex);
 	      return;
 	    }
 
-	    if (cb) this.once('close', cb);
-
-	    if (this._state === CLOSING) return;
-	    this._state = CLOSING;
+	    let called = false;
 
-	    if (this.options.noServer || this.options.server) {
-	      if (this._server) {
-	        this._removeListeners();
-	        this._removeListeners = this._server = null;
-	      }
+	    ws.once('error', function error(err) {
+	      called = true;
+	      callback(err);
+	    });
 
-	      if (this.clients) {
-	        if (!this.clients.size) {
-	          process.nextTick(emitClose, this);
-	        } else {
-	          this._shouldEmitClose = true;
-	        }
-	      } else {
-	        process.nextTick(emitClose, this);
-	      }
-	    } else {
-	      const server = this._server;
+	    ws.once('close', function close() {
+	      if (!called) callback(err);
+	      process.nextTick(emitClose, duplex);
+	    });
 
-	      this._removeListeners();
-	      this._removeListeners = this._server = null;
+	    if (terminateOnDestroy) ws.terminate();
+	  };
 
-	      //
-	      // The HTTP/S server was created internally. Close it, and rely on its
-	      // `'close'` event.
-	      //
-	      server.close(() => {
-	        emitClose(this);
+	  duplex._final = function (callback) {
+	    if (ws.readyState === ws.CONNECTING) {
+	      ws.once('open', function open() {
+	        duplex._final(callback);
 	      });
+	      return;
 	    }
-	  }
 
-	  /**
-	   * See if a given request should be handled by this server instance.
-	   *
-	   * @param {http.IncomingMessage} req Request object to inspect
-	   * @return {Boolean} `true` if the request is valid, else `false`
-	   * @public
-	   */
-	  shouldHandle(req) {
-	    if (this.options.path) {
-	      const index = req.url.indexOf('?');
-	      const pathname = index !== -1 ? req.url.slice(0, index) : req.url;
+	    // If the value of the `_socket` property is `null` it means that `ws` is a
+	    // client websocket and the handshake failed. In fact, when this happens, a
+	    // socket is never assigned to the websocket. Wait for the `'error'` event
+	    // that will be emitted by the websocket.
+	    if (ws._socket === null) return;
 
-	      if (pathname !== this.options.path) return false;
+	    if (ws._socket._writableState.finished) {
+	      callback();
+	      if (duplex._readableState.endEmitted) duplex.destroy();
+	    } else {
+	      ws._socket.once('finish', function finish() {
+	        // `duplex` is not destroyed here because the `'end'` event will be
+	        // emitted on `duplex` after this `'finish'` event. The EOF signaling
+	        // `null` chunk is, in fact, pushed when the websocket emits `'close'`.
+	        callback();
+	      });
+	      ws.close();
 	    }
+	  };
 
-	    return true;
-	  }
-
-	  /**
-	   * Handle a HTTP Upgrade request.
-	   *
-	   * @param {http.IncomingMessage} req The request object
-	   * @param {Duplex} socket The network socket between the server and client
-	   * @param {Buffer} head The first packet of the upgraded stream
-	   * @param {Function} cb Callback
-	   * @public
-	   */
-	  handleUpgrade(req, socket, head, cb) {
-	    socket.on('error', socketOnError);
-
-	    const key = req.headers['sec-websocket-key'];
-	    const upgrade = req.headers.upgrade;
-	    const version = +req.headers['sec-websocket-version'];
+	  duplex._read = function () {
+	    if (ws.isPaused) ws.resume();
+	  };
 
-	    if (req.method !== 'GET') {
-	      const message = 'Invalid HTTP method';
-	      abortHandshakeOrEmitwsClientError(this, req, socket, 405, message);
+	  duplex._write = function (chunk, encoding, callback) {
+	    if (ws.readyState === ws.CONNECTING) {
+	      ws.once('open', function open() {
+	        duplex._write(chunk, encoding, callback);
+	      });
 	      return;
 	    }
 
-	    if (upgrade === undefined || upgrade.toLowerCase() !== 'websocket') {
-	      const message = 'Invalid Upgrade header';
-	      abortHandshakeOrEmitwsClientError(this, req, socket, 400, message);
-	      return;
-	    }
+	    ws.send(chunk, callback);
+	  };
 
-	    if (key === undefined || !keyRegex.test(key)) {
-	      const message = 'Missing or invalid Sec-WebSocket-Key header';
-	      abortHandshakeOrEmitwsClientError(this, req, socket, 400, message);
-	      return;
-	    }
+	  duplex.on('end', duplexOnEnd);
+	  duplex.on('error', duplexOnError);
+	  return duplex;
+	}
+
+	stream = createWebSocketStream;
+	return stream;
+}
+
+requireStream();
 
-	    if (version !== 13 && version !== 8) {
-	      const message = 'Missing or invalid Sec-WebSocket-Version header';
-	      abortHandshakeOrEmitwsClientError(this, req, socket, 400, message, {
-	        'Sec-WebSocket-Version': '13, 8'
-	      });
-	      return;
-	    }
+requireReceiver();
 
-	    if (!this.shouldHandle(req)) {
-	      abortHandshake(socket, 400);
-	      return;
-	    }
+requireSender();
 
-	    const secWebSocketProtocol = req.headers['sec-websocket-protocol'];
-	    let protocols = new Set();
+var websocketExports = requireWebsocket();
+var WebSocket = /*@__PURE__*/getDefaultExportFromCjs(websocketExports);
 
-	    if (secWebSocketProtocol !== undefined) {
-	      try {
-	        protocols = subprotocol.parse(secWebSocketProtocol);
-	      } catch (err) {
-	        const message = 'Invalid Sec-WebSocket-Protocol header';
-	        abortHandshakeOrEmitwsClientError(this, req, socket, 400, message);
-	        return;
-	      }
-	    }
+var subprotocol;
+var hasRequiredSubprotocol;
 
-	    const secWebSocketExtensions = req.headers['sec-websocket-extensions'];
-	    const extensions = {};
+function requireSubprotocol () {
+	if (hasRequiredSubprotocol) return subprotocol;
+	hasRequiredSubprotocol = 1;
 
-	    if (
-	      this.options.perMessageDeflate &&
-	      secWebSocketExtensions !== undefined
-	    ) {
-	      const perMessageDeflate = new PerMessageDeflate(
-	        this.options.perMessageDeflate,
-	        true,
-	        this.options.maxPayload
-	      );
+	const { tokenChars } = requireValidation();
 
-	      try {
-	        const offers = extension.parse(secWebSocketExtensions);
+	/**
+	 * Parses the `Sec-WebSocket-Protocol` header into a set of subprotocol names.
+	 *
+	 * @param {String} header The field value of the header
+	 * @return {Set} The subprotocol names
+	 * @public
+	 */
+	function parse(header) {
+	  const protocols = new Set();
+	  let start = -1;
+	  let end = -1;
+	  let i = 0;
 
-	        if (offers[PerMessageDeflate.extensionName]) {
-	          perMessageDeflate.accept(offers[PerMessageDeflate.extensionName]);
-	          extensions[PerMessageDeflate.extensionName] = perMessageDeflate;
-	        }
-	      } catch (err) {
-	        const message =
-	          'Invalid or unacceptable Sec-WebSocket-Extensions header';
-	        abortHandshakeOrEmitwsClientError(this, req, socket, 400, message);
-	        return;
+	  for (i; i < header.length; i++) {
+	    const code = header.charCodeAt(i);
+
+	    if (end === -1 && tokenChars[code] === 1) {
+	      if (start === -1) start = i;
+	    } else if (
+	      i !== 0 &&
+	      (code === 0x20 /* ' ' */ || code === 0x09) /* '\t' */
+	    ) {
+	      if (end === -1 && start !== -1) end = i;
+	    } else if (code === 0x2c /* ',' */) {
+	      if (start === -1) {
+	        throw new SyntaxError(`Unexpected character at index ${i}`);
 	      }
-	    }
 
-	    //
-	    // Optionally call external client verification handler.
-	    //
-	    if (this.options.verifyClient) {
-	      const info = {
-	        origin:
-	          req.headers[`${version === 8 ? 'sec-websocket-origin' : 'origin'}`],
-	        secure: !!(req.socket.authorized || req.socket.encrypted),
-	        req
-	      };
+	      if (end === -1) end = i;
 
-	      if (this.options.verifyClient.length === 2) {
-	        this.options.verifyClient(info, (verified, code, message, headers) => {
-	          if (!verified) {
-	            return abortHandshake(socket, code || 401, message, headers);
-	          }
+	      const protocol = header.slice(start, end);
 
-	          this.completeUpgrade(
-	            extensions,
-	            key,
-	            protocols,
-	            req,
-	            socket,
-	            head,
-	            cb
-	          );
-	        });
-	        return;
+	      if (protocols.has(protocol)) {
+	        throw new SyntaxError(`The "${protocol}" subprotocol is duplicated`);
 	      }
 
-	      if (!this.options.verifyClient(info)) return abortHandshake(socket, 401);
+	      protocols.add(protocol);
+	      start = end = -1;
+	    } else {
+	      throw new SyntaxError(`Unexpected character at index ${i}`);
 	    }
+	  }
 
-	    this.completeUpgrade(extensions, key, protocols, req, socket, head, cb);
+	  if (start === -1 || end !== -1) {
+	    throw new SyntaxError('Unexpected end of input');
 	  }
 
-	  /**
-	   * Upgrade the connection to WebSocket.
-	   *
-	   * @param {Object} extensions The accepted extensions
-	   * @param {String} key The value of the `Sec-WebSocket-Key` header
-	   * @param {Set} protocols The subprotocols
-	   * @param {http.IncomingMessage} req The request object
-	   * @param {Duplex} socket The network socket between the server and client
-	   * @param {Buffer} head The first packet of the upgraded stream
-	   * @param {Function} cb Callback
-	   * @throws {Error} If called more than once with the same socket
-	   * @private
-	   */
-	  completeUpgrade(extensions, key, protocols, req, socket, head, cb) {
-	    //
-	    // Destroy the socket if the client has already sent a FIN packet.
-	    //
-	    if (!socket.readable || !socket.writable) return socket.destroy();
+	  const protocol = header.slice(start, i);
 
-	    if (socket[kWebSocket]) {
-	      throw new Error(
-	        'server.handleUpgrade() was called more than once with the same ' +
-	          'socket, possibly due to a misconfiguration'
-	      );
-	    }
+	  if (protocols.has(protocol)) {
+	    throw new SyntaxError(`The "${protocol}" subprotocol is duplicated`);
+	  }
 
-	    if (this._state > RUNNING) return abortHandshake(socket, 503);
+	  protocols.add(protocol);
+	  return protocols;
+	}
 
-	    const digest = createHash('sha1')
-	      .update(key + GUID)
-	      .digest('base64');
+	subprotocol = { parse };
+	return subprotocol;
+}
 
-	    const headers = [
-	      'HTTP/1.1 101 Switching Protocols',
-	      'Upgrade: websocket',
-	      'Connection: Upgrade',
-	      `Sec-WebSocket-Accept: ${digest}`
-	    ];
+/* eslint no-unused-vars: ["error", { "varsIgnorePattern": "^Duplex$", "caughtErrors": "none" }] */
 
-	    const ws = new this.options.WebSocket(null, undefined, this.options);
+var websocketServer;
+var hasRequiredWebsocketServer;
 
-	    if (protocols.size) {
-	      //
-	      // Optionally call external protocol selection handler.
-	      //
-	      const protocol = this.options.handleProtocols
-	        ? this.options.handleProtocols(protocols, req)
-	        : protocols.values().next().value;
+function requireWebsocketServer () {
+	if (hasRequiredWebsocketServer) return websocketServer;
+	hasRequiredWebsocketServer = 1;
 
-	      if (protocol) {
-	        headers.push(`Sec-WebSocket-Protocol: ${protocol}`);
-	        ws._protocol = protocol;
-	      }
-	    }
+	const EventEmitter = require$$0$3;
+	const http = require$$2;
+	const { Duplex } = require$$0$2;
+	const { createHash } = require$$3;
+
+	const extension = requireExtension();
+	const PerMessageDeflate = requirePermessageDeflate();
+	const subprotocol = requireSubprotocol();
+	const WebSocket = requireWebsocket();
+	const { GUID, kWebSocket } = requireConstants();
+
+	const keyRegex = /^[+/0-9A-Za-z]{22}==$/;
+
+	const RUNNING = 0;
+	const CLOSING = 1;
+	const CLOSED = 2;
+
+	/**
+	 * Class representing a WebSocket server.
+	 *
+	 * @extends EventEmitter
+	 */
+	class WebSocketServer extends EventEmitter {
+	  /**
+	   * Create a `WebSocketServer` instance.
+	   *
+	   * @param {Object} options Configuration options
+	   * @param {Boolean} [options.allowSynchronousEvents=true] Specifies whether
+	   *     any of the `'message'`, `'ping'`, and `'pong'` events can be emitted
+	   *     multiple times in the same tick
+	   * @param {Boolean} [options.autoPong=true] Specifies whether or not to
+	   *     automatically send a pong in response to a ping
+	   * @param {Number} [options.backlog=511] The maximum length of the queue of
+	   *     pending connections
+	   * @param {Boolean} [options.clientTracking=true] Specifies whether or not to
+	   *     track clients
+	   * @param {Function} [options.handleProtocols] A hook to handle protocols
+	   * @param {String} [options.host] The hostname where to bind the server
+	   * @param {Number} [options.maxPayload=104857600] The maximum allowed message
+	   *     size
+	   * @param {Boolean} [options.noServer=false] Enable no server mode
+	   * @param {String} [options.path] Accept only connections matching this path
+	   * @param {(Boolean|Object)} [options.perMessageDeflate=false] Enable/disable
+	   *     permessage-deflate
+	   * @param {Number} [options.port] The port where to bind the server
+	   * @param {(http.Server|https.Server)} [options.server] A pre-created HTTP/S
+	   *     server to use
+	   * @param {Boolean} [options.skipUTF8Validation=false] Specifies whether or
+	   *     not to skip UTF-8 validation for text and close messages
+	   * @param {Function} [options.verifyClient] A hook to reject connections
+	   * @param {Function} [options.WebSocket=WebSocket] Specifies the `WebSocket`
+	   *     class to use. It must be the `WebSocket` class or class that extends it
+	   * @param {Function} [callback] A listener for the `listening` event
+	   */
+	  constructor(options, callback) {
+	    super();
+
+	    options = {
+	      allowSynchronousEvents: true,
+	      autoPong: true,
+	      maxPayload: 100 * 1024 * 1024,
+	      skipUTF8Validation: false,
+	      perMessageDeflate: false,
+	      handleProtocols: null,
+	      clientTracking: true,
+	      verifyClient: null,
+	      noServer: false,
+	      backlog: null, // use default (511 as implemented in net.js)
+	      server: null,
+	      host: null,
+	      path: null,
+	      port: null,
+	      WebSocket,
+	      ...options
+	    };
 
-	    if (extensions[PerMessageDeflate.extensionName]) {
-	      const params = extensions[PerMessageDeflate.extensionName].params;
-	      const value = extension.format({
-	        [PerMessageDeflate.extensionName]: [params]
-	      });
-	      headers.push(`Sec-WebSocket-Extensions: ${value}`);
-	      ws._extensions = extensions;
+	    if (
+	      (options.port == null && !options.server && !options.noServer) ||
+	      (options.port != null && (options.server || options.noServer)) ||
+	      (options.server && options.noServer)
+	    ) {
+	      throw new TypeError(
+	        'One and only one of the "port", "server", or "noServer" options ' +
+	          'must be specified'
+	      );
 	    }
 
-	    //
-	    // Allow external modification/inspection of handshake headers.
-	    //
-	    this.emit('headers', headers, req);
-
-	    socket.write(headers.concat('\r\n').join('\r\n'));
-	    socket.removeListener('error', socketOnError);
+	    if (options.port != null) {
+	      this._server = http.createServer((req, res) => {
+	        const body = http.STATUS_CODES[426];
 
-	    ws.setSocket(socket, head, {
-	      allowSynchronousEvents: this.options.allowSynchronousEvents,
-	      maxPayload: this.options.maxPayload,
-	      skipUTF8Validation: this.options.skipUTF8Validation
-	    });
+	        res.writeHead(426, {
+	          'Content-Length': body.length,
+	          'Content-Type': 'text/plain'
+	        });
+	        res.end(body);
+	      });
+	      this._server.listen(
+	        options.port,
+	        options.host,
+	        options.backlog,
+	        callback
+	      );
+	    } else if (options.server) {
+	      this._server = options.server;
+	    }
 
-	    if (this.clients) {
-	      this.clients.add(ws);
-	      ws.on('close', () => {
-	        this.clients.delete(ws);
+	    if (this._server) {
+	      const emitConnection = this.emit.bind(this, 'connection');
 
-	        if (this._shouldEmitClose && !this.clients.size) {
-	          process.nextTick(emitClose, this);
+	      this._removeListeners = addListeners(this._server, {
+	        listening: this.emit.bind(this, 'listening'),
+	        error: this.emit.bind(this, 'error'),
+	        upgrade: (req, socket, head) => {
+	          this.handleUpgrade(req, socket, head, emitConnection);
 	        }
 	      });
 	    }
 
-	    cb(ws, req);
-	  }
-	}
-
-	websocketServer = WebSocketServer;
-
-	/**
-	 * Add event listeners on an `EventEmitter` using a map of <event, listener>
-	 * pairs.
-	 *
-	 * @param {EventEmitter} server The event emitter
-	 * @param {Object.<String, Function>} map The listeners to add
-	 * @return {Function} A function that will remove the added listeners when
-	 *     called
-	 * @private
-	 */
-	function addListeners(server, map) {
-	  for (const event of Object.keys(map)) server.on(event, map[event]);
-
-	  return function removeListeners() {
-	    for (const event of Object.keys(map)) {
-	      server.removeListener(event, map[event]);
+	    if (options.perMessageDeflate === true) options.perMessageDeflate = {};
+	    if (options.clientTracking) {
+	      this.clients = new Set();
+	      this._shouldEmitClose = false;
 	    }
-	  };
-	}
-
-	/**
-	 * Emit a `'close'` event on an `EventEmitter`.
-	 *
-	 * @param {EventEmitter} server The event emitter
-	 * @private
-	 */
-	function emitClose(server) {
-	  server._state = CLOSED;
-	  server.emit('close');
-	}
-
-	/**
-	 * Handle socket errors.
-	 *
-	 * @private
-	 */
-	function socketOnError() {
-	  this.destroy();
-	}
-
-	/**
-	 * Close the connection when preconditions are not fulfilled.
-	 *
-	 * @param {Duplex} socket The socket of the upgrade request
-	 * @param {Number} code The HTTP response status code
-	 * @param {String} [message] The HTTP response body
-	 * @param {Object} [headers] Additional HTTP response headers
-	 * @private
-	 */
-	function abortHandshake(socket, code, message, headers) {
-	  //
-	  // The socket is writable unless the user destroyed or ended it before calling
-	  // `server.handleUpgrade()` or in the `verifyClient` function, which is a user
-	  // error. Handling this does not make much sense as the worst that can happen
-	  // is that some of the data written by the user might be discarded due to the
-	  // call to `socket.end()` below, which triggers an `'error'` event that in
-	  // turn causes the socket to be destroyed.
-	  //
-	  message = message || http.STATUS_CODES[code];
-	  headers = {
-	    Connection: 'close',
-	    'Content-Type': 'text/html',
-	    'Content-Length': Buffer.byteLength(message),
-	    ...headers
-	  };
-
-	  socket.once('finish', socket.destroy);
-
-	  socket.end(
-	    `HTTP/1.1 ${code} ${http.STATUS_CODES[code]}\r\n` +
-	      Object.keys(headers)
-	        .map((h) => `${h}: ${headers[h]}`)
-	        .join('\r\n') +
-	      '\r\n\r\n' +
-	      message
-	  );
-	}
-
-	/**
-	 * Emit a `'wsClientError'` event on a `WebSocketServer` if there is at least
-	 * one listener for it, otherwise call `abortHandshake()`.
-	 *
-	 * @param {WebSocketServer} server The WebSocket server
-	 * @param {http.IncomingMessage} req The request object
-	 * @param {Duplex} socket The socket of the upgrade request
-	 * @param {Number} code The HTTP response status code
-	 * @param {String} message The HTTP response body
-	 * @param {Object} [headers] The HTTP response headers
-	 * @private
-	 */
-	function abortHandshakeOrEmitwsClientError(
-	  server,
-	  req,
-	  socket,
-	  code,
-	  message,
-	  headers
-	) {
-	  if (server.listenerCount('wsClientError')) {
-	    const err = new Error(message);
-	    Error.captureStackTrace(err, abortHandshakeOrEmitwsClientError);
 
-	    server.emit('wsClientError', err, socket, req);
-	  } else {
-	    abortHandshake(socket, code, message, headers);
+	    this.options = options;
+	    this._state = RUNNING;
 	  }
-	}
-	return websocketServer;
-}
-
-requireWebsocketServer();
-
-/**
- * Logs a message to the console.
- * @param message The message to log.
- * @param options Optional options.
- * @param options.source The source of the message.
- * @param options.type The type of message to log.
- * @param options.symbol The trading symbol associated with this log.
- * @param options.account The account associated with this log.
- */
-function log$1(message, options = { source: 'App', type: 'info' }) {
-    // Format the timestamp
-    const date = new Date();
-    const timestamp = date.toLocaleString('en-US', { timeZone: 'America/New_York' });
-    const account = options?.account;
-    const symbol = options?.symbol;
-    // Build the log message
-    const logMessage = `[${timestamp}]${options?.source ? ` [${options.source}] ` : ''}${account ? ` [${account}] ` : ''}${symbol ? ` [${symbol}] ` : ''}${message}`;
-    // Use appropriate console method based on type
-    if (options?.type === 'error') {
-        console.error(logMessage);
-    }
-    else if (options?.type === 'warn') {
-        console.warn(logMessage);
-    }
-    else {
-        console.log(logMessage);
-    }
-}
-
-var config = {};
 
-var main = {exports: {}};
+	  /**
+	   * Returns the bound address, the address family name, and port of the server
+	   * as reported by the operating system if listening on an IP socket.
+	   * If the server is listening on a pipe or UNIX domain socket, the name is
+	   * returned as a string.
+	   *
+	   * @return {(Object|String|null)} The address of the server
+	   * @public
+	   */
+	  address() {
+	    if (this.options.noServer) {
+	      throw new Error('The server is operating in "noServer" mode');
+	    }
 
-var version = "17.2.3";
-var require$$4 = {
-	version: version};
+	    if (!this._server) return null;
+	    return this._server.address();
+	  }
 
-var hasRequiredMain;
+	  /**
+	   * Stop the server from accepting new connections and emit the `'close'` event
+	   * when all existing connections are closed.
+	   *
+	   * @param {Function} [cb] A one-time listener for the `'close'` event
+	   * @public
+	   */
+	  close(cb) {
+	    if (this._state === CLOSED) {
+	      if (cb) {
+	        this.once('close', () => {
+	          cb(new Error('The server is not running'));
+	        });
+	      }
 
-function requireMain () {
-	if (hasRequiredMain) return main.exports;
-	hasRequiredMain = 1;
-	const fs = require$$0$4;
-	const path = require$$1$1;
-	const os = require$$2$1;
-	const crypto = require$$3;
-	const packageJson = require$$4;
+	      process.nextTick(emitClose, this);
+	      return;
+	    }
 
-	const version = packageJson.version;
+	    if (cb) this.once('close', cb);
 
-	// Array of tips to display randomly
-	const TIPS = [
-	  '🔐 encrypt with Dotenvx: https://dotenvx.com',
-	  '🔐 prevent committing .env to code: https://dotenvx.com/precommit',
-	  '🔐 prevent building .env in docker: https://dotenvx.com/prebuild',
-	  '📡 add observability to secrets: https://dotenvx.com/ops',
-	  '👥 sync secrets across teammates & machines: https://dotenvx.com/ops',
-	  '🗂️ backup and recover secrets: https://dotenvx.com/ops',
-	  '✅ audit secrets and track compliance: https://dotenvx.com/ops',
-	  '🔄 add secrets lifecycle management: https://dotenvx.com/ops',
-	  '🔑 add access controls to secrets: https://dotenvx.com/ops',
-	  '🛠️  run anywhere with `dotenvx run -- yourcommand`',
-	  '⚙️  specify custom .env file path with { path: \'/custom/path/.env\' }',
-	  '⚙️  enable debug logging with { debug: true }',
-	  '⚙️  override existing env vars with { override: true }',
-	  '⚙️  suppress all logs with { quiet: true }',
-	  '⚙️  write to custom object with { processEnv: myObject }',
-	  '⚙️  load multiple .env files with { path: [\'.env.local\', \'.env\'] }'
-	];
+	    if (this._state === CLOSING) return;
+	    this._state = CLOSING;
 
-	// Get a random tip from the tips array
-	function _getRandomTip () {
-	  return TIPS[Math.floor(Math.random() * TIPS.length)]
-	}
+	    if (this.options.noServer || this.options.server) {
+	      if (this._server) {
+	        this._removeListeners();
+	        this._removeListeners = this._server = null;
+	      }
 
-	function parseBoolean (value) {
-	  if (typeof value === 'string') {
-	    return !['false', '0', 'no', 'off', ''].includes(value.toLowerCase())
+	      if (this.clients) {
+	        if (!this.clients.size) {
+	          process.nextTick(emitClose, this);
+	        } else {
+	          this._shouldEmitClose = true;
+	        }
+	      } else {
+	        process.nextTick(emitClose, this);
+	      }
+	    } else {
+	      const server = this._server;
+
+	      this._removeListeners();
+	      this._removeListeners = this._server = null;
+
+	      //
+	      // The HTTP/S server was created internally. Close it, and rely on its
+	      // `'close'` event.
+	      //
+	      server.close(() => {
+	        emitClose(this);
+	      });
+	    }
 	  }
-	  return Boolean(value)
-	}
 
-	function supportsAnsi () {
-	  return process.stdout.isTTY // && process.env.TERM !== 'dumb'
-	}
+	  /**
+	   * See if a given request should be handled by this server instance.
+	   *
+	   * @param {http.IncomingMessage} req Request object to inspect
+	   * @return {Boolean} `true` if the request is valid, else `false`
+	   * @public
+	   */
+	  shouldHandle(req) {
+	    if (this.options.path) {
+	      const index = req.url.indexOf('?');
+	      const pathname = index !== -1 ? req.url.slice(0, index) : req.url;
 
-	function dim (text) {
-	  return supportsAnsi() ? `\x1b[2m${text}\x1b[0m` : text
-	}
+	      if (pathname !== this.options.path) return false;
+	    }
 
-	const LINE = /(?:^|^)\s*(?:export\s+)?([\w.-]+)(?:\s*=\s*?|:\s+?)(\s*'(?:\\'|[^'])*'|\s*"(?:\\"|[^"])*"|\s*`(?:\\`|[^`])*`|[^#\r\n]+)?\s*(?:#.*)?(?:$|$)/mg;
+	    return true;
+	  }
 
-	// Parse src into an Object
-	function parse (src) {
-	  const obj = {};
+	  /**
+	   * Handle a HTTP Upgrade request.
+	   *
+	   * @param {http.IncomingMessage} req The request object
+	   * @param {Duplex} socket The network socket between the server and client
+	   * @param {Buffer} head The first packet of the upgraded stream
+	   * @param {Function} cb Callback
+	   * @public
+	   */
+	  handleUpgrade(req, socket, head, cb) {
+	    socket.on('error', socketOnError);
 
-	  // Convert buffer to string
-	  let lines = src.toString();
+	    const key = req.headers['sec-websocket-key'];
+	    const upgrade = req.headers.upgrade;
+	    const version = +req.headers['sec-websocket-version'];
 
-	  // Convert line breaks to same format
-	  lines = lines.replace(/\r\n?/mg, '\n');
+	    if (req.method !== 'GET') {
+	      const message = 'Invalid HTTP method';
+	      abortHandshakeOrEmitwsClientError(this, req, socket, 405, message);
+	      return;
+	    }
 
-	  let match;
-	  while ((match = LINE.exec(lines)) != null) {
-	    const key = match[1];
+	    if (upgrade === undefined || upgrade.toLowerCase() !== 'websocket') {
+	      const message = 'Invalid Upgrade header';
+	      abortHandshakeOrEmitwsClientError(this, req, socket, 400, message);
+	      return;
+	    }
 
-	    // Default undefined or null to empty string
-	    let value = (match[2] || '');
+	    if (key === undefined || !keyRegex.test(key)) {
+	      const message = 'Missing or invalid Sec-WebSocket-Key header';
+	      abortHandshakeOrEmitwsClientError(this, req, socket, 400, message);
+	      return;
+	    }
 
-	    // Remove whitespace
-	    value = value.trim();
+	    if (version !== 13 && version !== 8) {
+	      const message = 'Missing or invalid Sec-WebSocket-Version header';
+	      abortHandshakeOrEmitwsClientError(this, req, socket, 400, message, {
+	        'Sec-WebSocket-Version': '13, 8'
+	      });
+	      return;
+	    }
 
-	    // Check if double quoted
-	    const maybeQuote = value[0];
+	    if (!this.shouldHandle(req)) {
+	      abortHandshake(socket, 400);
+	      return;
+	    }
 
-	    // Remove surrounding quotes
-	    value = value.replace(/^(['"`])([\s\S]*)\1$/mg, '$2');
+	    const secWebSocketProtocol = req.headers['sec-websocket-protocol'];
+	    let protocols = new Set();
 
-	    // Expand newlines if double quoted
-	    if (maybeQuote === '"') {
-	      value = value.replace(/\\n/g, '\n');
-	      value = value.replace(/\\r/g, '\r');
+	    if (secWebSocketProtocol !== undefined) {
+	      try {
+	        protocols = subprotocol.parse(secWebSocketProtocol);
+	      } catch (err) {
+	        const message = 'Invalid Sec-WebSocket-Protocol header';
+	        abortHandshakeOrEmitwsClientError(this, req, socket, 400, message);
+	        return;
+	      }
 	    }
 
-	    // Add to object
-	    obj[key] = value;
-	  }
+	    const secWebSocketExtensions = req.headers['sec-websocket-extensions'];
+	    const extensions = {};
 
-	  return obj
-	}
+	    if (
+	      this.options.perMessageDeflate &&
+	      secWebSocketExtensions !== undefined
+	    ) {
+	      const perMessageDeflate = new PerMessageDeflate(
+	        this.options.perMessageDeflate,
+	        true,
+	        this.options.maxPayload
+	      );
 
-	function _parseVault (options) {
-	  options = options || {};
+	      try {
+	        const offers = extension.parse(secWebSocketExtensions);
 
-	  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
-	  }
+	        if (offers[PerMessageDeflate.extensionName]) {
+	          perMessageDeflate.accept(offers[PerMessageDeflate.extensionName]);
+	          extensions[PerMessageDeflate.extensionName] = perMessageDeflate;
+	        }
+	      } catch (err) {
+	        const message =
+	          'Invalid or unacceptable Sec-WebSocket-Extensions header';
+	        abortHandshakeOrEmitwsClientError(this, req, socket, 400, message);
+	        return;
+	      }
+	    }
 
-	  // 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;
+	    //
+	    // Optionally call external client verification handler.
+	    //
+	    if (this.options.verifyClient) {
+	      const info = {
+	        origin:
+	          req.headers[`${version === 8 ? 'sec-websocket-origin' : 'origin'}`],
+	        secure: !!(req.socket.authorized || req.socket.encrypted),
+	        req
+	      };
 
-	  let decrypted;
-	  for (let i = 0; i < length; i++) {
-	    try {
-	      // Get full key
-	      const key = keys[i].trim();
+	      if (this.options.verifyClient.length === 2) {
+	        this.options.verifyClient(info, (verified, code, message, headers) => {
+	          if (!verified) {
+	            return abortHandshake(socket, code || 401, message, headers);
+	          }
 
-	      // Get instructions for decrypt
-	      const attrs = _instructions(result, key);
+	          this.completeUpgrade(
+	            extensions,
+	            key,
+	            protocols,
+	            req,
+	            socket,
+	            head,
+	            cb
+	          );
+	        });
+	        return;
+	      }
 
-	      // Decrypt
-	      decrypted = DotenvModule.decrypt(attrs.ciphertext, attrs.key);
+	      if (!this.options.verifyClient(info)) return abortHandshake(socket, 401);
+	    }
+
+	    this.completeUpgrade(extensions, key, protocols, req, socket, head, cb);
+	  }
+
+	  /**
+	   * Upgrade the connection to WebSocket.
+	   *
+	   * @param {Object} extensions The accepted extensions
+	   * @param {String} key The value of the `Sec-WebSocket-Key` header
+	   * @param {Set} protocols The subprotocols
+	   * @param {http.IncomingMessage} req The request object
+	   * @param {Duplex} socket The network socket between the server and client
+	   * @param {Buffer} head The first packet of the upgraded stream
+	   * @param {Function} cb Callback
+	   * @throws {Error} If called more than once with the same socket
+	   * @private
+	   */
+	  completeUpgrade(extensions, key, protocols, req, socket, head, cb) {
+	    //
+	    // Destroy the socket if the client has already sent a FIN packet.
+	    //
+	    if (!socket.readable || !socket.writable) return socket.destroy();
 
-	      break
-	    } catch (error) {
-	      // last key
-	      if (i + 1 >= length) {
-	        throw error
-	      }
-	      // try next key
+	    if (socket[kWebSocket]) {
+	      throw new Error(
+	        'server.handleUpgrade() was called more than once with the same ' +
+	          'socket, possibly due to a misconfiguration'
+	      );
 	    }
-	  }
-
-	  // Parse decrypted .env string
-	  return DotenvModule.parse(decrypted)
-	}
-
-	function _warn (message) {
-	  console.error(`[dotenv@${version}][WARN] ${message}`);
-	}
 
-	function _debug (message) {
-	  console.log(`[dotenv@${version}][DEBUG] ${message}`);
-	}
+	    if (this._state > RUNNING) return abortHandshake(socket, 503);
 
-	function _log (message) {
-	  console.log(`[dotenv@${version}] ${message}`);
-	}
+	    const digest = createHash('sha1')
+	      .update(key + GUID)
+	      .digest('base64');
 
-	function _dotenvKey (options) {
-	  // prioritize developer directly setting options.DOTENV_KEY
-	  if (options && options.DOTENV_KEY && options.DOTENV_KEY.length > 0) {
-	    return options.DOTENV_KEY
-	  }
+	    const headers = [
+	      'HTTP/1.1 101 Switching Protocols',
+	      'Upgrade: websocket',
+	      'Connection: Upgrade',
+	      `Sec-WebSocket-Accept: ${digest}`
+	    ];
 
-	  // 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
-	  }
+	    const ws = new this.options.WebSocket(null, undefined, this.options);
 
-	  // fallback to empty string
-	  return ''
-	}
+	    if (protocols.size) {
+	      //
+	      // Optionally call external protocol selection handler.
+	      //
+	      const protocol = this.options.handleProtocols
+	        ? this.options.handleProtocols(protocols, req)
+	        : protocols.values().next().value;
 
-	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
+	      if (protocol) {
+	        headers.push(`Sec-WebSocket-Protocol: ${protocol}`);
+	        ws._protocol = protocol;
+	      }
 	    }
 
-	    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
-	  }
+	    if (extensions[PerMessageDeflate.extensionName]) {
+	      const params = extensions[PerMessageDeflate.extensionName].params;
+	      const value = extension.format({
+	        [PerMessageDeflate.extensionName]: [params]
+	      });
+	      headers.push(`Sec-WebSocket-Extensions: ${value}`);
+	      ws._extensions = extensions;
+	    }
 
-	  // 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
-	  }
+	    //
+	    // Allow external modification/inspection of handshake headers.
+	    //
+	    this.emit('headers', headers, req);
 
-	  // 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
-	  }
+	    socket.write(headers.concat('\r\n').join('\r\n'));
+	    socket.removeListener('error', socketOnError);
 
-	  return { ciphertext, key }
-	}
+	    ws.setSocket(socket, head, {
+	      allowSynchronousEvents: this.options.allowSynchronousEvents,
+	      maxPayload: this.options.maxPayload,
+	      skipUTF8Validation: this.options.skipUTF8Validation
+	    });
 
-	function _vaultPath (options) {
-	  let possibleVaultPath = null;
+	    if (this.clients) {
+	      this.clients.add(ws);
+	      ws.on('close', () => {
+	        this.clients.delete(ws);
 
-	  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`;
+	        if (this._shouldEmitClose && !this.clients.size) {
+	          process.nextTick(emitClose, this);
 	        }
-	      }
-	    } 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
+	    cb(ws, req);
 	  }
-
-	  return null
 	}
 
-	function _resolveHome (envPath) {
-	  return envPath[0] === '~' ? path.join(os.homedir(), envPath.slice(1)) : envPath
-	}
+	websocketServer = WebSocketServer;
 
-	function _configVault (options) {
-	  const debug = parseBoolean(process.env.DOTENV_CONFIG_DEBUG || (options && options.debug));
-	  const quiet = parseBoolean(process.env.DOTENV_CONFIG_QUIET || (options && options.quiet));
+	/**
+	 * Add event listeners on an `EventEmitter` using a map of <event, listener>
+	 * pairs.
+	 *
+	 * @param {EventEmitter} server The event emitter
+	 * @param {Object.<String, Function>} map The listeners to add
+	 * @return {Function} A function that will remove the added listeners when
+	 *     called
+	 * @private
+	 */
+	function addListeners(server, map) {
+	  for (const event of Object.keys(map)) server.on(event, map[event]);
 
-	  if (debug || !quiet) {
-	    _log('Loading env from encrypted .env.vault');
-	  }
+	  return function removeListeners() {
+	    for (const event of Object.keys(map)) {
+	      server.removeListener(event, map[event]);
+	    }
+	  };
+	}
 
-	  const parsed = DotenvModule._parseVault(options);
+	/**
+	 * Emit a `'close'` event on an `EventEmitter`.
+	 *
+	 * @param {EventEmitter} server The event emitter
+	 * @private
+	 */
+	function emitClose(server) {
+	  server._state = CLOSED;
+	  server.emit('close');
+	}
 
-	  let processEnv = process.env;
-	  if (options && options.processEnv != null) {
-	    processEnv = options.processEnv;
-	  }
+	/**
+	 * Handle socket errors.
+	 *
+	 * @private
+	 */
+	function socketOnError() {
+	  this.destroy();
+	}
 
-	  DotenvModule.populate(processEnv, parsed, options);
+	/**
+	 * Close the connection when preconditions are not fulfilled.
+	 *
+	 * @param {Duplex} socket The socket of the upgrade request
+	 * @param {Number} code The HTTP response status code
+	 * @param {String} [message] The HTTP response body
+	 * @param {Object} [headers] Additional HTTP response headers
+	 * @private
+	 */
+	function abortHandshake(socket, code, message, headers) {
+	  //
+	  // The socket is writable unless the user destroyed or ended it before calling
+	  // `server.handleUpgrade()` or in the `verifyClient` function, which is a user
+	  // error. Handling this does not make much sense as the worst that can happen
+	  // is that some of the data written by the user might be discarded due to the
+	  // call to `socket.end()` below, which triggers an `'error'` event that in
+	  // turn causes the socket to be destroyed.
+	  //
+	  message = message || http.STATUS_CODES[code];
+	  headers = {
+	    Connection: 'close',
+	    'Content-Type': 'text/html',
+	    'Content-Length': Buffer.byteLength(message),
+	    ...headers
+	  };
 
-	  return { parsed }
+	  socket.once('finish', socket.destroy);
+
+	  socket.end(
+	    `HTTP/1.1 ${code} ${http.STATUS_CODES[code]}\r\n` +
+	      Object.keys(headers)
+	        .map((h) => `${h}: ${headers[h]}`)
+	        .join('\r\n') +
+	      '\r\n\r\n' +
+	      message
+	  );
 	}
 
-	function configDotenv (options) {
-	  const dotenvPath = path.resolve(process.cwd(), '.env');
-	  let encoding = 'utf8';
-	  let processEnv = process.env;
-	  if (options && options.processEnv != null) {
-	    processEnv = options.processEnv;
-	  }
-	  let debug = parseBoolean(processEnv.DOTENV_CONFIG_DEBUG || (options && options.debug));
-	  let quiet = parseBoolean(processEnv.DOTENV_CONFIG_QUIET || (options && options.quiet));
+	/**
+	 * Emit a `'wsClientError'` event on a `WebSocketServer` if there is at least
+	 * one listener for it, otherwise call `abortHandshake()`.
+	 *
+	 * @param {WebSocketServer} server The WebSocket server
+	 * @param {http.IncomingMessage} req The request object
+	 * @param {Duplex} socket The socket of the upgrade request
+	 * @param {Number} code The HTTP response status code
+	 * @param {String} message The HTTP response body
+	 * @param {Object} [headers] The HTTP response headers
+	 * @private
+	 */
+	function abortHandshakeOrEmitwsClientError(
+	  server,
+	  req,
+	  socket,
+	  code,
+	  message,
+	  headers
+	) {
+	  if (server.listenerCount('wsClientError')) {
+	    const err = new Error(message);
+	    Error.captureStackTrace(err, abortHandshakeOrEmitwsClientError);
 
-	  if (options && options.encoding) {
-	    encoding = options.encoding;
+	    server.emit('wsClientError', err, socket, req);
 	  } else {
-	    if (debug) {
-	      _debug('No encoding is specified. UTF-8 is used by default');
-	    }
+	    abortHandshake(socket, code, message, headers);
 	  }
+	}
+	return websocketServer;
+}
 
-	  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));
-	      }
-	    }
-	  }
+requireWebsocketServer();
 
-	  // 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 }));
+var config = {};
 
-	      DotenvModule.populate(parsedAll, parsed, options);
-	    } catch (e) {
-	      if (debug) {
-	        _debug(`Failed to load ${path} ${e.message}`);
-	      }
-	      lastError = e;
-	    }
-	  }
+var main = {exports: {}};
 
-	  const populated = DotenvModule.populate(processEnv, parsedAll, options);
+var version = "17.2.3";
+var require$$4 = {
+	version: version};
 
-	  // handle user settings DOTENV_CONFIG_ options inside .env file(s)
-	  debug = parseBoolean(processEnv.DOTENV_CONFIG_DEBUG || debug);
-	  quiet = parseBoolean(processEnv.DOTENV_CONFIG_QUIET || quiet);
+var hasRequiredMain;
 
-	  if (debug || !quiet) {
-	    const keysCount = Object.keys(populated).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;
-	      }
-	    }
+function requireMain () {
+	if (hasRequiredMain) return main.exports;
+	hasRequiredMain = 1;
+	const fs = require$$0$4;
+	const path = require$$1$1;
+	const os = require$$2$1;
+	const crypto = require$$3;
+	const packageJson = require$$4;
 
-	    _log(`injecting env (${keysCount}) from ${shortPaths.join(',')} ${dim(`-- tip: ${_getRandomTip()}`)}`);
-	  }
+	const version = packageJson.version;
 
-	  if (lastError) {
-	    return { parsed: parsedAll, error: lastError }
-	  } else {
-	    return { parsed: parsedAll }
-	  }
+	// Array of tips to display randomly
+	const TIPS = [
+	  '🔐 encrypt with Dotenvx: https://dotenvx.com',
+	  '🔐 prevent committing .env to code: https://dotenvx.com/precommit',
+	  '🔐 prevent building .env in docker: https://dotenvx.com/prebuild',
+	  '📡 add observability to secrets: https://dotenvx.com/ops',
+	  '👥 sync secrets across teammates & machines: https://dotenvx.com/ops',
+	  '🗂️ backup and recover secrets: https://dotenvx.com/ops',
+	  '✅ audit secrets and track compliance: https://dotenvx.com/ops',
+	  '🔄 add secrets lifecycle management: https://dotenvx.com/ops',
+	  '🔑 add access controls to secrets: https://dotenvx.com/ops',
+	  '🛠️  run anywhere with `dotenvx run -- yourcommand`',
+	  '⚙️  specify custom .env file path with { path: \'/custom/path/.env\' }',
+	  '⚙️  enable debug logging with { debug: true }',
+	  '⚙️  override existing env vars with { override: true }',
+	  '⚙️  suppress all logs with { quiet: true }',
+	  '⚙️  write to custom object with { processEnv: myObject }',
+	  '⚙️  load multiple .env files with { path: [\'.env.local\', \'.env\'] }'
+	];
+
+	// Get a random tip from the tips array
+	function _getRandomTip () {
+	  return TIPS[Math.floor(Math.random() * TIPS.length)]
 	}
 
-	// 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)
+	function parseBoolean (value) {
+	  if (typeof value === 'string') {
+	    return !['false', '0', 'no', 'off', ''].includes(value.toLowerCase())
 	  }
+	  return Boolean(value)
+	}
 
-	  const vaultPath = _vaultPath(options);
+	function supportsAnsi () {
+	  return process.stdout.isTTY // && process.env.TERM !== 'dumb'
+	}
 
-	  // 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?`);
+	function dim (text) {
+	  return supportsAnsi() ? `\x1b[2m${text}\x1b[0m` : text
+	}
 
-	    return DotenvModule.configDotenv(options)
-	  }
+	const LINE = /(?:^|^)\s*(?:export\s+)?([\w.-]+)(?:\s*=\s*?|:\s+?)(\s*'(?:\\'|[^'])*'|\s*"(?:\\"|[^"])*"|\s*`(?:\\`|[^`])*`|[^#\r\n]+)?\s*(?:#.*)?(?:$|$)/mg;
 
-	  return DotenvModule._configVault(options)
-	}
+	// Parse src into an Object
+	function parse (src) {
+	  const obj = {};
 
-	function decrypt (encrypted, keyStr) {
-	  const key = Buffer.from(keyStr.slice(-64), 'hex');
-	  let ciphertext = Buffer.from(encrypted, 'base64');
+	  // Convert buffer to string
+	  let lines = src.toString();
 
-	  const nonce = ciphertext.subarray(0, 12);
-	  const authTag = ciphertext.subarray(-16);
-	  ciphertext = ciphertext.subarray(12, -16);
+	  // Convert line breaks to same format
+	  lines = lines.replace(/\r\n?/mg, '\n');
 
-	  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';
+	  let match;
+	  while ((match = LINE.exec(lines)) != null) {
+	    const key = match[1];
 
-	    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
-	    }
-	  }
-	}
+	    // Default undefined or null to empty string
+	    let value = (match[2] || '');
 
-	// Populate process.env with parsed values
-	function populate (processEnv, parsed, options = {}) {
-	  const debug = Boolean(options && options.debug);
-	  const override = Boolean(options && options.override);
-	  const populated = {};
+	    // Remove whitespace
+	    value = value.trim();
 
-	  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
-	  }
+	    // Check if double quoted
+	    const maybeQuote = value[0];
 
-	  // Set process.env
-	  for (const key of Object.keys(parsed)) {
-	    if (Object.prototype.hasOwnProperty.call(processEnv, key)) {
-	      if (override === true) {
-	        processEnv[key] = parsed[key];
-	        populated[key] = parsed[key];
-	      }
+	    // Remove surrounding quotes
+	    value = value.replace(/^(['"`])([\s\S]*)\1$/mg, '$2');
 
-	      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];
-	      populated[key] = parsed[key];
+	    // 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 populated
+	  return obj
 	}
 
-	const DotenvModule = {
-	  configDotenv,
-	  _configVault,
-	  _parseVault,
-	  config,
-	  decrypt,
-	  parse,
-	  populate
-	};
+	function _parseVault (options) {
+	  options = options || {};
 
-	main.exports.configDotenv = DotenvModule.configDotenv;
-	main.exports._configVault = DotenvModule._configVault;
-	main.exports._parseVault = DotenvModule._parseVault;
-	main.exports.config = DotenvModule.config;
-	main.exports.decrypt = DotenvModule.decrypt;
-	main.exports.parse = DotenvModule.parse;
-	main.exports.populate = DotenvModule.populate;
+	  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
+	  }
 
-	main.exports = DotenvModule;
-	return main.exports;
-}
+	  // 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);
 
-var envOptions;
-var hasRequiredEnvOptions;
+	      // Decrypt
+	      decrypted = DotenvModule.decrypt(attrs.ciphertext, attrs.key);
 
-function requireEnvOptions () {
-	if (hasRequiredEnvOptions) return envOptions;
-	hasRequiredEnvOptions = 1;
-	// ../config.js accepts options via environment variables
-	const options = {};
+	      break
+	    } catch (error) {
+	      // last key
+	      if (i + 1 >= length) {
+	        throw error
+	      }
+	      // try next key
+	    }
+	  }
 
-	if (process.env.DOTENV_CONFIG_ENCODING != null) {
-	  options.encoding = process.env.DOTENV_CONFIG_ENCODING;
+	  // Parse decrypted .env string
+	  return DotenvModule.parse(decrypted)
 	}
 
-	if (process.env.DOTENV_CONFIG_PATH != null) {
-	  options.path = process.env.DOTENV_CONFIG_PATH;
+	function _warn (message) {
+	  console.error(`[dotenv@${version}][WARN] ${message}`);
 	}
 
-	if (process.env.DOTENV_CONFIG_QUIET != null) {
-	  options.quiet = process.env.DOTENV_CONFIG_QUIET;
+	function _debug (message) {
+	  console.log(`[dotenv@${version}][DEBUG] ${message}`);
 	}
 
-	if (process.env.DOTENV_CONFIG_DEBUG != null) {
-	  options.debug = process.env.DOTENV_CONFIG_DEBUG;
+	function _log (message) {
+	  console.log(`[dotenv@${version}] ${message}`);
 	}
 
-	if (process.env.DOTENV_CONFIG_OVERRIDE != null) {
-	  options.override = process.env.DOTENV_CONFIG_OVERRIDE;
-	}
+	function _dotenvKey (options) {
+	  // prioritize developer directly setting options.DOTENV_KEY
+	  if (options && options.DOTENV_KEY && options.DOTENV_KEY.length > 0) {
+	    return options.DOTENV_KEY
+	  }
 
-	if (process.env.DOTENV_CONFIG_DOTENV_KEY != null) {
-	  options.DOTENV_KEY = process.env.DOTENV_CONFIG_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 ''
 	}
 
-	envOptions = options;
-	return envOptions;
-}
+	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
+	    }
 
-var cliOptions;
-var hasRequiredCliOptions;
+	    throw error
+	  }
 
-function requireCliOptions () {
-	if (hasRequiredCliOptions) return cliOptions;
-	hasRequiredCliOptions = 1;
-	const re = /^dotenv_config_(encoding|path|quiet|debug|override|DOTENV_KEY)=(.+)$/;
+	  // 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
+	  }
 
-	cliOptions = function optionMatcher (args) {
-	  const options = args.reduce(function (acc, cur) {
-	    const matches = cur.match(re);
-	    if (matches) {
-	      acc[matches[1]] = matches[2];
-	    }
-	    return acc
-	  }, {});
+	  // 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
+	  }
 
-	  if (!('quiet' in options)) {
-	    options.quiet = 'true';
+	  // 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 options
-	};
-	return cliOptions;
-}
+	  return { ciphertext, key }
+	}
 
-var hasRequiredConfig;
+	function _vaultPath (options) {
+	  let possibleVaultPath = null;
 
-function requireConfig () {
-	if (hasRequiredConfig) return config;
-	hasRequiredConfig = 1;
-	(function () {
-	  requireMain().config(
-	    Object.assign(
-	      {},
-	      requireEnvOptions(),
-	      requireCliOptions()(process.argv)
-	    )
-	  );
-	})();
-	return config;
-}
+	  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');
+	  }
 
-requireConfig();
+	  if (fs.existsSync(possibleVaultPath)) {
+	    return possibleVaultPath
+	  }
 
-// market-hours.ts
-const marketHolidays = {
-    2024: {
-        "New Year's Day": { date: '2024-01-01' },
-        'Martin Luther King, Jr. Day': { date: '2024-01-15' },
-        "Washington's Birthday": { date: '2024-02-19' },
-        'Good Friday': { date: '2024-03-29' },
-        'Memorial Day': { date: '2024-05-27' },
-        'Juneteenth National Independence Day': { date: '2024-06-19' },
-        'Independence Day': { date: '2024-07-04' },
-        'Labor Day': { date: '2024-09-02' },
-        'Thanksgiving Day': { date: '2024-11-28' },
-        'Christmas Day': { date: '2024-12-25' },
-    },
-    2025: {
-        "New Year's Day": { date: '2025-01-01' },
-        'Jimmy Carter Memorial Day': { date: '2025-01-09' },
-        'Martin Luther King, Jr. Day': { date: '2025-01-20' },
-        "Washington's Birthday": { date: '2025-02-17' },
-        'Good Friday': { date: '2025-04-18' },
-        'Memorial Day': { date: '2025-05-26' },
-        'Juneteenth National Independence Day': { date: '2025-06-19' },
-        'Independence Day': { date: '2025-07-04' },
-        'Labor Day': { date: '2025-09-01' },
-        'Thanksgiving Day': { date: '2025-11-27' },
-        'Christmas Day': { date: '2025-12-25' },
-    },
-    2026: {
-        "New Year's Day": { date: '2026-01-01' },
-        'Martin Luther King, Jr. Day': { date: '2026-01-19' },
-        "Washington's Birthday": { date: '2026-02-16' },
-        'Good Friday': { date: '2026-04-03' },
-        'Memorial Day': { date: '2026-05-25' },
-        'Juneteenth National Independence Day': { date: '2026-06-19' },
-        'Independence Day': { date: '2026-07-03' },
-        'Labor Day': { date: '2026-09-07' },
-        'Thanksgiving Day': { date: '2026-11-26' },
-        'Christmas Day': { date: '2026-12-25' },
-    },
-};
-const marketEarlyCloses = {
-    2024: {
-        '2024-07-03': {
-            date: '2024-07-03',
-            time: '13:00',
-            optionsTime: '13:15',
-            notes: 'Market closes early on Wednesday, July 3, 2024 at 1:00 p.m. (1:15 p.m. for eligible options). NYSE American Equities, NYSE Arca Equities, NYSE Chicago, and NYSE National late trading sessions will close at 5:00 p.m. Eastern Time.',
-        },
-        '2024-11-29': {
-            date: '2024-11-29',
-            time: '13:00',
-            optionsTime: '13:15',
-            notes: 'Market closes early on Friday, November 29, 2024 at 1:00 p.m. (1:15 p.m. for eligible options). NYSE American Equities, NYSE Arca Equities, NYSE Chicago, and NYSE National late trading sessions will close at 5:00 p.m. Eastern Time.',
-        },
-        '2024-12-24': {
-            date: '2024-12-24',
-            time: '13:00',
-            optionsTime: '13:15',
-            notes: 'Market closes early on Tuesday, December 24, 2024 at 1:00 p.m. (1:15 p.m. for eligible options). NYSE American Equities, NYSE Arca Equities, NYSE Chicago, and NYSE National late trading sessions will close at 5:00 p.m. Eastern Time.',
-        },
-    },
-    2025: {
-        '2025-07-03': {
-            date: '2025-07-03',
-            time: '13:00',
-            optionsTime: '13:15',
-            notes: 'Market closes early on Thursday, July 3, 2025 at 1:00 p.m. (1:15 p.m. for eligible options). NYSE American Equities, NYSE Arca Equities, NYSE Chicago, and NYSE National late trading sessions will close at 5:00 p.m. Eastern Time.',
-        },
-        '2025-11-28': {
-            date: '2025-11-28',
-            time: '13:00',
-            optionsTime: '13:15',
-            notes: 'Market closes early on Friday, November 28, 2025 at 1:00 p.m. (1:15 p.m. for eligible options). NYSE American Equities, NYSE Arca Equities, NYSE Chicago, and NYSE National late trading sessions will close at 5:00 p.m. Eastern Time.',
-        },
-        '2025-12-24': {
-            date: '2025-12-24',
-            time: '13:00',
-            optionsTime: '13:15',
-            notes: 'Market closes early on Wednesday, December 24, 2025 at 1:00 p.m. (1:15 p.m. for eligible options). NYSE American Equities, NYSE Arca Equities, NYSE Chicago, and NYSE National late trading sessions will close at 5:00 p.m. Eastern Time.',
-        },
-    },
-    2026: {
-        '2026-07-02': {
-            date: '2026-07-02',
-            time: '13:00',
-            optionsTime: '13:15',
-            notes: 'Independence Day observed, market closes early at 1:00 p.m. (1:15 p.m. for eligible options). NYSE American Equities, NYSE Arca Equities, NYSE Chicago, and NYSE National late trading sessions will close at 5:00 p.m. Eastern Time.',
-        },
-        '2026-11-27': {
-            date: '2026-11-27',
-            time: '13:00',
-            optionsTime: '13:15',
-            notes: 'Market closes early on Friday, November 27, 2026 at 1:00 p.m. (1:15 p.m. for eligible options). NYSE American Equities, NYSE Arca Equities, NYSE Chicago, and NYSE National late trading sessions will close at 5:00 p.m. Eastern Time.',
-        },
-        '2026-12-24': {
-            date: '2026-12-24',
-            time: '13:00',
-            optionsTime: '13:15',
-            notes: 'Market closes early on Thursday, December 24, 2026 at 1:00 p.m. (1:15 p.m. for eligible options). NYSE American Equities, NYSE Arca Equities, NYSE Chicago, and NYSE National late trading sessions will close at 5:00 p.m. Eastern Time.',
-        },
-    },
-};
+	  return null
+	}
+
+	function _resolveHome (envPath) {
+	  return envPath[0] === '~' ? path.join(os.homedir(), envPath.slice(1)) : envPath
+	}
+
+	function _configVault (options) {
+	  const debug = parseBoolean(process.env.DOTENV_CONFIG_DEBUG || (options && options.debug));
+	  const quiet = parseBoolean(process.env.DOTENV_CONFIG_QUIET || (options && options.quiet));
 
-// Constants for NY market times (Eastern Time)
-const MARKET_CONFIG = {
-    UTC_OFFSET_STANDARD: -5, // EST
-    UTC_OFFSET_DST: -4, // EDT
-    TIMES: {
-        MARKET_OPEN: { hour: 9, minute: 30 },
-        MARKET_CLOSE: { hour: 16, minute: 0 },
-        EARLY_CLOSE: { hour: 13, minute: 0 }},
-};
-// Helper: Get NY offset for a given UTC date (DST rules for US)
-/**
- * Returns the NY timezone offset (in hours) for a given UTC date, accounting for US DST rules.
- * @param date - UTC date
- * @returns offset in hours (-5 for EST, -4 for EDT)
- */
-function getNYOffset(date) {
-    // US DST starts 2nd Sunday in March, ends 1st Sunday in November
-    const year = date.getUTCFullYear();
-    const dstStart = getNthWeekdayOfMonth(year, 3, 0, 2); // March, Sunday, 2nd
-    const dstEnd = getNthWeekdayOfMonth(year, 11, 0, 1); // November, Sunday, 1st
-    const utcTime = date.getTime();
-    if (utcTime >= dstStart.getTime() && utcTime < dstEnd.getTime()) {
-        return MARKET_CONFIG.UTC_OFFSET_DST;
-    }
-    return MARKET_CONFIG.UTC_OFFSET_STANDARD;
-}
-// Helper: Get nth weekday of month in UTC
-/**
- * Returns the nth weekday of a given month in UTC.
- * @param year - Year
- * @param month - 1-based month (e.g. March = 3)
- * @param weekday - 0=Sunday, 1=Monday, ...
- * @param n - nth occurrence
- * @returns Date object for the nth weekday
- */
-function getNthWeekdayOfMonth(year, month, weekday, n) {
-    let count = 0;
-    for (let d = 1; d <= 31; d++) {
-        const date = new Date(Date.UTC(year, month - 1, d));
-        if (date.getUTCMonth() !== month - 1)
-            break;
-        if (date.getUTCDay() === weekday) {
-            count++;
-            if (count === n)
-                return date;
-        }
-    }
-    // fallback: last day of month
-    return new Date(Date.UTC(year, month - 1, 28));
-}
-// Helper: Convert UTC date to NY time (returns new Date object)
-/**
- * Converts a UTC date to NY time (returns a new Date object).
- * @param date - UTC date
- * @returns Date object in NY time
- */
-function toNYTime(date) {
-    const offset = getNYOffset(date);
-    // NY offset in hours
-    const utcMillis = date.getTime();
-    const nyMillis = utcMillis + offset * 60 * 60 * 1000;
-    return new Date(nyMillis);
-}
-// Helper: Convert NY time to UTC (returns new Date object)
-/**
- * Converts a NY time date to UTC (returns a new Date object).
- * @param date - NY time date
- * @returns Date object in UTC
- */
-function fromNYTime(date) {
-    const offset = getNYOffset(date);
-    const nyMillis = date.getTime();
-    const utcMillis = nyMillis - offset * 60 * 60 * 1000;
-    return new Date(utcMillis);
-}
-// Market calendar logic
-/**
- * Market calendar logic for holidays, weekends, and market days.
- */
-class MarketCalendar {
-    /**
-     * Checks if a date is a weekend in NY time.
-     * @param date - Date object
-     * @returns true if weekend, false otherwise
-     */
-    isWeekend(date) {
-        const day = toNYTime(date).getUTCDay();
-        return day === 0 || day === 6;
-    }
-    /**
-     * Checks if a date is a market holiday in NY time.
-     * @param date - Date object
-     * @returns true if holiday, false otherwise
-     */
-    isHoliday(date) {
-        const nyDate = toNYTime(date);
-        const year = nyDate.getUTCFullYear();
-        const month = nyDate.getUTCMonth() + 1;
-        const day = nyDate.getUTCDate();
-        const formattedDate = `${year}-${String(month).padStart(2, '0')}-${String(day).padStart(2, '0')}`;
-        const yearHolidays = marketHolidays[year];
-        if (!yearHolidays)
-            return false;
-        return Object.values(yearHolidays).some((holiday) => holiday.date === formattedDate);
-    }
-    /**
-     * Checks if a date is an early close day in NY time.
-     * @param date - Date object
-     * @returns true if early close, false otherwise
-     */
-    isEarlyCloseDay(date) {
-        const nyDate = toNYTime(date);
-        const year = nyDate.getUTCFullYear();
-        const month = nyDate.getUTCMonth() + 1;
-        const day = nyDate.getUTCDate();
-        const formattedDate = `${year}-${String(month).padStart(2, '0')}-${String(day).padStart(2, '0')}`;
-        const yearEarlyCloses = marketEarlyCloses[year];
-        return yearEarlyCloses && yearEarlyCloses[formattedDate] !== undefined;
-    }
-    /**
-     * Gets the early close time (in minutes from midnight) for a given date.
-     * @param date - Date object
-     * @returns minutes from midnight or null
-     */
-    getEarlyCloseTime(date) {
-        const nyDate = toNYTime(date);
-        const year = nyDate.getUTCFullYear();
-        const month = nyDate.getUTCMonth() + 1;
-        const day = nyDate.getUTCDate();
-        const formattedDate = `${year}-${String(month).padStart(2, '0')}-${String(day).padStart(2, '0')}`;
-        const yearEarlyCloses = marketEarlyCloses[year];
-        if (yearEarlyCloses && yearEarlyCloses[formattedDate]) {
-            const [hours, minutes] = yearEarlyCloses[formattedDate].time.split(':').map(Number);
-            return hours * 60 + minutes;
-        }
-        return null;
-    }
-    /**
-     * Checks if a date is a market day (not weekend or holiday).
-     * @param date - Date object
-     * @returns true if market day, false otherwise
-     */
-    isMarketDay(date) {
-        return !this.isWeekend(date) && !this.isHoliday(date);
-    }
-    /**
-     * Gets the next market day after the given date.
-     * @param date - Date object
-     * @returns Date object for next market day
-     */
-    getNextMarketDay(date) {
-        let nextDay = new Date(date.getTime() + 24 * 60 * 60 * 1000);
-        while (!this.isMarketDay(nextDay)) {
-            nextDay = new Date(nextDay.getTime() + 24 * 60 * 60 * 1000);
-        }
-        return nextDay;
-    }
-    /**
-     * Gets the previous market day before the given date.
-     * @param date - Date object
-     * @returns Date object for previous market day
-     */
-    getPreviousMarketDay(date) {
-        let prevDay = new Date(date.getTime() - 24 * 60 * 60 * 1000);
-        while (!this.isMarketDay(prevDay)) {
-            prevDay = new Date(prevDay.getTime() - 24 * 60 * 60 * 1000);
-        }
-        return prevDay;
-    }
+	  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';
+	  let processEnv = process.env;
+	  if (options && options.processEnv != null) {
+	    processEnv = options.processEnv;
+	  }
+	  let debug = parseBoolean(processEnv.DOTENV_CONFIG_DEBUG || (options && options.debug));
+	  let quiet = parseBoolean(processEnv.DOTENV_CONFIG_QUIET || (options && options.quiet));
+
+	  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;
+	    }
+	  }
+
+	  const populated = DotenvModule.populate(processEnv, parsedAll, options);
+
+	  // handle user settings DOTENV_CONFIG_ options inside .env file(s)
+	  debug = parseBoolean(processEnv.DOTENV_CONFIG_DEBUG || debug);
+	  quiet = parseBoolean(processEnv.DOTENV_CONFIG_QUIET || quiet);
+
+	  if (debug || !quiet) {
+	    const keysCount = Object.keys(populated).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(',')} ${dim(`-- tip: ${_getRandomTip()}`)}`);
+	  }
+
+	  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);
+	  const populated = {};
+
+	  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];
+	        populated[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];
+	      populated[key] = parsed[key];
+	    }
+	  }
+
+	  return populated
+	}
+
+	const DotenvModule = {
+	  configDotenv,
+	  _configVault,
+	  _parseVault,
+	  config,
+	  decrypt,
+	  parse,
+	  populate
+	};
+
+	main.exports.configDotenv = DotenvModule.configDotenv;
+	main.exports._configVault = DotenvModule._configVault;
+	main.exports._parseVault = DotenvModule._parseVault;
+	main.exports.config = DotenvModule.config;
+	main.exports.decrypt = DotenvModule.decrypt;
+	main.exports.parse = DotenvModule.parse;
+	main.exports.populate = DotenvModule.populate;
+
+	main.exports = DotenvModule;
+	return main.exports;
 }
-// Get last full trading date
-/**
- * Returns the last full trading date (market close) for a given date.
- * @param currentDate - Date object (default: now)
- * @returns Date object for last full trading date
- */
-function getLastFullTradingDateImpl(currentDate = new Date()) {
-    const calendar = new MarketCalendar();
-    const nyDate = toNYTime(currentDate);
-    const minutes = nyDate.getUTCHours() * 60 + nyDate.getUTCMinutes();
-    const marketOpenMinutes = MARKET_CONFIG.TIMES.MARKET_OPEN.hour * 60 + MARKET_CONFIG.TIMES.MARKET_OPEN.minute;
-    let marketCloseMinutes = MARKET_CONFIG.TIMES.MARKET_CLOSE.hour * 60 + MARKET_CONFIG.TIMES.MARKET_CLOSE.minute;
-    if (calendar.isEarlyCloseDay(currentDate)) {
-        marketCloseMinutes = MARKET_CONFIG.TIMES.EARLY_CLOSE.hour * 60 + MARKET_CONFIG.TIMES.EARLY_CLOSE.minute;
-    }
-    // If not a market day, or before open, or during market hours, return previous market day's close
-    if (!calendar.isMarketDay(currentDate) ||
-        minutes < marketOpenMinutes ||
-        (minutes >= marketOpenMinutes && minutes < marketCloseMinutes)) {
-        const prevMarketDay = calendar.getPreviousMarketDay(currentDate);
-        let prevCloseMinutes = MARKET_CONFIG.TIMES.MARKET_CLOSE.hour * 60 + MARKET_CONFIG.TIMES.MARKET_CLOSE.minute;
-        if (calendar.isEarlyCloseDay(prevMarketDay)) {
-            prevCloseMinutes = MARKET_CONFIG.TIMES.EARLY_CLOSE.hour * 60 + MARKET_CONFIG.TIMES.EARLY_CLOSE.minute;
-        }
-        const year = prevMarketDay.getUTCFullYear();
-        const month = prevMarketDay.getUTCMonth();
-        const day = prevMarketDay.getUTCDate();
-        const closeHour = Math.floor(prevCloseMinutes / 60);
-        const closeMinute = prevCloseMinutes % 60;
-        return fromNYTime(new Date(Date.UTC(year, month, day, closeHour, closeMinute, 0, 0)));
-    }
-    // After market close or after extended hours, return today's close
-    const year = nyDate.getUTCFullYear();
-    const month = nyDate.getUTCMonth();
-    const day = nyDate.getUTCDate();
-    const closeHour = Math.floor(marketCloseMinutes / 60);
-    const closeMinute = marketCloseMinutes % 60;
-    return fromNYTime(new Date(Date.UTC(year, month, day, closeHour, closeMinute, 0, 0)));
+
+var envOptions;
+var hasRequiredEnvOptions;
+
+function requireEnvOptions () {
+	if (hasRequiredEnvOptions) return envOptions;
+	hasRequiredEnvOptions = 1;
+	// ../config.js accepts options via environment variables
+	const options = {};
+
+	if (process.env.DOTENV_CONFIG_ENCODING != null) {
+	  options.encoding = process.env.DOTENV_CONFIG_ENCODING;
+	}
+
+	if (process.env.DOTENV_CONFIG_PATH != null) {
+	  options.path = process.env.DOTENV_CONFIG_PATH;
+	}
+
+	if (process.env.DOTENV_CONFIG_QUIET != null) {
+	  options.quiet = process.env.DOTENV_CONFIG_QUIET;
+	}
+
+	if (process.env.DOTENV_CONFIG_DEBUG != null) {
+	  options.debug = process.env.DOTENV_CONFIG_DEBUG;
+	}
+
+	if (process.env.DOTENV_CONFIG_OVERRIDE != null) {
+	  options.override = process.env.DOTENV_CONFIG_OVERRIDE;
+	}
+
+	if (process.env.DOTENV_CONFIG_DOTENV_KEY != null) {
+	  options.DOTENV_KEY = process.env.DOTENV_CONFIG_DOTENV_KEY;
+	}
+
+	envOptions = options;
+	return envOptions;
 }
-/**
- * Returns the last full trading date as a Date object.
- */
-/**
- * Returns the last full trading date as a Date object.
- * @param currentDate - Date object (default: now)
- * @returns Date object for last full trading date
- */
-function getLastFullTradingDate(currentDate = new Date()) {
-    return getLastFullTradingDateImpl(currentDate);
+
+var cliOptions;
+var hasRequiredCliOptions;
+
+function requireCliOptions () {
+	if (hasRequiredCliOptions) return cliOptions;
+	hasRequiredCliOptions = 1;
+	const re = /^dotenv_config_(encoding|path|quiet|debug|override|DOTENV_KEY)=(.+)$/;
+
+	cliOptions = function optionMatcher (args) {
+	  const options = args.reduce(function (acc, cur) {
+	    const matches = cur.match(re);
+	    if (matches) {
+	      acc[matches[1]] = matches[2];
+	    }
+	    return acc
+	  }, {});
+
+	  if (!('quiet' in options)) {
+	    options.quiet = 'true';
+	  }
+
+	  return options
+	};
+	return cliOptions;
 }
-/**
- * Returns the trading date for a given time. Note: Just trims the date string; does not validate if the date is a market day.
- * @param time - a string, number (unix timestamp), or Date object representing the time
- * @returns the trading date as a string in YYYY-MM-DD format
- */
-/**
- * Returns the trading date for a given time in YYYY-MM-DD format (NY time).
- * @param time - string, number, or Date
- * @returns trading date string
- */
-function getTradingDate(time) {
-    const date = typeof time === 'number' ? new Date(time) : typeof time === 'string' ? new Date(time) : time;
-    const nyDate = toNYTime(date);
-    return `${nyDate.getUTCFullYear()}-${String(nyDate.getUTCMonth() + 1).padStart(2, '0')}-${String(nyDate.getUTCDate()).padStart(2, '0')}`;
+
+var hasRequiredConfig;
+
+function requireConfig () {
+	if (hasRequiredConfig) return config;
+	hasRequiredConfig = 1;
+	(function () {
+	  requireMain().config(
+	    Object.assign(
+	      {},
+	      requireEnvOptions(),
+	      requireCliOptions()(process.argv)
+	    )
+	  );
+	})();
+	return config;
 }
 
+requireConfig();
+
 const log = (message, options = { type: 'info' }) => {
     log$1(message, { ...options, source: 'AlpacaMarketDataAPI' });
 };
@@ -16634,6 +17242,9 @@ class AlpacaTradingAPI {
     }
 }
 
+/* Front-end only exports.
+Import these with `import { disco } from 'disco-core/frontend'`
+*/
 const disco = {
     types: Types,
     llm: {
@@ -16641,6 +17252,7 @@ const disco = {
         seek: makeDeepseekCall,
         images: makeImagesCall,
     },
+    time,
 };
 
 export { AlpacaMarketDataAPI, AlpacaTradingAPI, disco, isOpenRouterModel };