@discomedia/utils 1.0.5 → 1.0.7

package/dist/test.js

@@ -1,15 +1,538 @@
-import { format, sub, set, add, startOfDay, endOfDay, isBefore } from 'date-fns';
-import { formatInTimeZone, toZonedTime, fromZonedTime } from 'date-fns-tz';
-import require$$0$3, { EventEmitter } from 'events';
+import require$$0 from 'fs';
+import require$$1 from 'path';
+import require$$2 from 'os';
+import require$$3 from 'crypto';
+import { startOfDay, set, endOfDay, add, sub } from 'date-fns';
+import { toZonedTime, fromZonedTime, formatInTimeZone } from 'date-fns-tz';
+import require$$0$4, { EventEmitter } from 'events';
 import require$$1$1 from 'https';
-import require$$2 from 'http';
-import require$$3 from 'net';
-import require$$4 from 'tls';
-import require$$1 from 'crypto';
-import require$$0$2 from 'stream';
+import require$$2$1 from 'http';
+import require$$3$1 from 'net';
+import require$$4$1 from 'tls';
+import require$$0$3 from 'stream';
 import require$$7 from 'url';
-import require$$0 from 'zlib';
-import require$$0$1 from 'buffer';
+import require$$0$1 from 'zlib';
+import require$$0$2 from 'buffer';
+
+function getDefaultExportFromCjs (x) {
+	return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, 'default') ? x['default'] : x;
+}
+
+var config = {};
+
+var main = {exports: {}};
+
+var version = "17.1.0";
+var require$$4 = {
+	version: version};
+
+var hasRequiredMain;
+
+function requireMain () {
+	if (hasRequiredMain) return main.exports;
+	hasRequiredMain = 1;
+	const fs = require$$0;
+	const path = require$$1;
+	const os = require$$2;
+	const crypto = require$$3;
+	const packageJson = require$$4;
+
+	const version = packageJson.version;
+
+	// 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',
+	  '🛠️  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)]
+	}
+
+	function supportsAnsi () {
+	  return process.stdout.isTTY // && process.env.TERM !== 'dumb'
+	}
+
+	function dim (text) {
+	  return supportsAnsi() ? `\x1b[2m${text}\x1b[0m` : text
+	}
+
+	const LINE = /(?:^|^)\s*(?:export\s+)?([\w.-]+)(?:\s*=\s*?|:\s+?)(\s*'(?:\\'|[^'])*'|\s*"(?:\\"|[^"])*"|\s*`(?:\\`|[^`])*`|[^#\r\n]+)?\s*(?:#.*)?(?:$|$)/mg;
+
+	// Parse src into an Object
+	function parse (src) {
+	  const obj = {};
+
+	  // Convert buffer to string
+	  let lines = src.toString();
+
+	  // Convert line breaks to same format
+	  lines = lines.replace(/\r\n?/mg, '\n');
+
+	  let match;
+	  while ((match = LINE.exec(lines)) != null) {
+	    const key = match[1];
+
+	    // Default undefined or null to empty string
+	    let value = (match[2] || '');
+
+	    // Remove whitespace
+	    value = value.trim();
+
+	    // Check if double quoted
+	    const maybeQuote = value[0];
+
+	    // Remove surrounding quotes
+	    value = value.replace(/^(['"`])([\s\S]*)\1$/mg, '$2');
+
+	    // Expand newlines if double quoted
+	    if (maybeQuote === '"') {
+	      value = value.replace(/\\n/g, '\n');
+	      value = value.replace(/\\r/g, '\r');
+	    }
+
+	    // Add to object
+	    obj[key] = value;
+	  }
+
+	  return obj
+	}
+
+	function _parseVault (options) {
+	  options = options || {};
+
+	  const vaultPath = _vaultPath(options);
+	  options.path = vaultPath; // parse .env.vault
+	  const result = DotenvModule.configDotenv(options);
+	  if (!result.parsed) {
+	    const err = new Error(`MISSING_DATA: Cannot parse ${vaultPath} for an unknown reason`);
+	    err.code = 'MISSING_DATA';
+	    throw err
+	  }
+
+	  // handle scenario for comma separated keys - for use with key rotation
+	  // example: DOTENV_KEY="dotenv://:key_1234@dotenvx.com/vault/.env.vault?environment=prod,dotenv://:key_7890@dotenvx.com/vault/.env.vault?environment=prod"
+	  const keys = _dotenvKey(options).split(',');
+	  const length = keys.length;
+
+	  let decrypted;
+	  for (let i = 0; i < length; i++) {
+	    try {
+	      // Get full key
+	      const key = keys[i].trim();
+
+	      // Get instructions for decrypt
+	      const attrs = _instructions(result, key);
+
+	      // Decrypt
+	      decrypted = DotenvModule.decrypt(attrs.ciphertext, attrs.key);
+
+	      break
+	    } catch (error) {
+	      // last key
+	      if (i + 1 >= length) {
+	        throw error
+	      }
+	      // try next key
+	    }
+	  }
+
+	  // Parse decrypted .env string
+	  return DotenvModule.parse(decrypted)
+	}
+
+	function _warn (message) {
+	  console.error(`[dotenv@${version}][WARN] ${message}`);
+	}
+
+	function _debug (message) {
+	  console.log(`[dotenv@${version}][DEBUG] ${message}`);
+	}
+
+	function _log (message) {
+	  console.log(`[dotenv@${version}] ${message}`);
+	}
+
+	function _dotenvKey (options) {
+	  // prioritize developer directly setting options.DOTENV_KEY
+	  if (options && options.DOTENV_KEY && options.DOTENV_KEY.length > 0) {
+	    return options.DOTENV_KEY
+	  }
+
+	  // secondary infra already contains a DOTENV_KEY environment variable
+	  if (process.env.DOTENV_KEY && process.env.DOTENV_KEY.length > 0) {
+	    return process.env.DOTENV_KEY
+	  }
+
+	  // fallback to empty string
+	  return ''
+	}
+
+	function _instructions (result, dotenvKey) {
+	  // Parse DOTENV_KEY. Format is a URI
+	  let uri;
+	  try {
+	    uri = new URL(dotenvKey);
+	  } catch (error) {
+	    if (error.code === 'ERR_INVALID_URL') {
+	      const err = new Error('INVALID_DOTENV_KEY: Wrong format. Must be in valid uri format like dotenv://:key_1234@dotenvx.com/vault/.env.vault?environment=development');
+	      err.code = 'INVALID_DOTENV_KEY';
+	      throw err
+	    }
+
+	    throw error
+	  }
+
+	  // Get decrypt key
+	  const key = uri.password;
+	  if (!key) {
+	    const err = new Error('INVALID_DOTENV_KEY: Missing key part');
+	    err.code = 'INVALID_DOTENV_KEY';
+	    throw err
+	  }
+
+	  // Get environment
+	  const environment = uri.searchParams.get('environment');
+	  if (!environment) {
+	    const err = new Error('INVALID_DOTENV_KEY: Missing environment part');
+	    err.code = 'INVALID_DOTENV_KEY';
+	    throw err
+	  }
+
+	  // Get ciphertext payload
+	  const environmentKey = `DOTENV_VAULT_${environment.toUpperCase()}`;
+	  const ciphertext = result.parsed[environmentKey]; // DOTENV_VAULT_PRODUCTION
+	  if (!ciphertext) {
+	    const err = new Error(`NOT_FOUND_DOTENV_ENVIRONMENT: Cannot locate environment ${environmentKey} in your .env.vault file.`);
+	    err.code = 'NOT_FOUND_DOTENV_ENVIRONMENT';
+	    throw err
+	  }
+
+	  return { ciphertext, key }
+	}
+
+	function _vaultPath (options) {
+	  let possibleVaultPath = null;
+
+	  if (options && options.path && options.path.length > 0) {
+	    if (Array.isArray(options.path)) {
+	      for (const filepath of options.path) {
+	        if (fs.existsSync(filepath)) {
+	          possibleVaultPath = filepath.endsWith('.vault') ? filepath : `${filepath}.vault`;
+	        }
+	      }
+	    } else {
+	      possibleVaultPath = options.path.endsWith('.vault') ? options.path : `${options.path}.vault`;
+	    }
+	  } else {
+	    possibleVaultPath = path.resolve(process.cwd(), '.env.vault');
+	  }
+
+	  if (fs.existsSync(possibleVaultPath)) {
+	    return possibleVaultPath
+	  }
+
+	  return null
+	}
+
+	function _resolveHome (envPath) {
+	  return envPath[0] === '~' ? path.join(os.homedir(), envPath.slice(1)) : envPath
+	}
+
+	function _configVault (options) {
+	  const debug = Boolean(options && options.debug);
+	  const quiet = Boolean(options && options.quiet);
+
+	  if (debug || !quiet) {
+	    _log('Loading env from encrypted .env.vault');
+	  }
+
+	  const parsed = DotenvModule._parseVault(options);
+
+	  let processEnv = process.env;
+	  if (options && options.processEnv != null) {
+	    processEnv = options.processEnv;
+	  }
+
+	  DotenvModule.populate(processEnv, parsed, options);
+
+	  return { parsed }
+	}
+
+	function configDotenv (options) {
+	  const dotenvPath = path.resolve(process.cwd(), '.env');
+	  let encoding = 'utf8';
+	  const debug = Boolean(options && options.debug);
+	  const quiet = Boolean(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;
+	    }
+	  }
+
+	  let processEnv = process.env;
+	  if (options && options.processEnv != null) {
+	    processEnv = options.processEnv;
+	  }
+
+	  const populated = DotenvModule.populate(processEnv, parsedAll, options);
+
+	  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;
+}
+
+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;
+}
+
+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;
+}
+
+var hasRequiredConfig;
+
+function requireConfig () {
+	if (hasRequiredConfig) return config;
+	hasRequiredConfig = 1;
+	(function () {
+	  requireMain().config(
+	    Object.assign(
+	      {},
+	      requireEnvOptions(),
+	      requireCliOptions()(process.argv)
+	    )
+	  );
+	})();
+	return config;
+}
+
+requireConfig();
 
 /**
  * Logs a message to the console.
@@ -143,89 +666,65 @@ const marketEarlyCloses = {
     },
 };
 
-// market-time.ts
+// market-time.ts - Refactored for better organization and usability
+// ===== CONFIGURATION =====
 /**
- * Market times for NYSE
- * Regular market hours are 9:30am-4:00pm
- * Early market hours are 9:30am-10:00am (first 30 minutes)
- * Extended market hours are 4:00am to 9:30am and 4:00pm-8:00pm
- * On days before some holidays, the market closes early at 1:00pm
- * Early extended market hours are 1:00pm-5:00pm on early close days
+ * Market configuration constants
  */
-const MARKET_TIMES = {
+const MARKET_CONFIG = {
     TIMEZONE: 'America/New_York',
-    REGULAR: { START: { HOUR: 9, MINUTE: 30}, END: { HOUR: 16, MINUTE: 0} },
-    EXTENDED: { START: { HOUR: 4, MINUTE: 0}, END: { HOUR: 20, MINUTE: 0} },
+    TIMES: {
+        EXTENDED_START: { hour: 4, minute: 0 },
+        MARKET_OPEN: { hour: 9, minute: 30 },
+        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 },
+    },
 };
+// ===== MARKET CALENDAR SERVICE =====
 /**
- * Utility class for handling market time-related operations
+ * Service for handling market calendar operations (holidays, early closes, market days)
  */
-class MarketTimeUtil {
+class MarketCalendar {
     timezone;
-    intradayReporting;
-    /**
-     * Creates a new MarketTimeUtil instance
-     * @param {string} [timezone='America/New_York'] - The timezone to use for market time calculations
-     * @param {IntradayReporting} [intradayReporting='market_hours'] - The intraday reporting mode
-     */
-    constructor(timezone = MARKET_TIMES.TIMEZONE, intradayReporting = 'market_hours') {
-        this.validateTimezone(timezone);
+    constructor(timezone = MARKET_CONFIG.TIMEZONE) {
         this.timezone = timezone;
-        this.intradayReporting = intradayReporting;
     }
     /**
-     * Validates the provided timezone
-     * @private
-     * @param {string} timezone - The timezone to validate
-     * @throws {Error} If the timezone is invalid
+     * Check if a date is a weekend
      */
-    validateTimezone(timezone) {
-        try {
-            Intl.DateTimeFormat(undefined, { timeZone: timezone });
-        }
-        catch (error) {
-            throw new Error(`Invalid timezone: ${timezone}`);
-        }
-    }
-    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 with timezone offset
-                return formatInTimeZone(date, this.timezone, "yyyy-MM-dd'T'HH:mm:ssXXX");
-        }
-    }
     isWeekend(date) {
         const day = date.getDay();
-        return day === 0 || day === 6;
+        return day === 0 || day === 6; // Sunday or Saturday
     }
+    /**
+     * Check if a date is a market holiday
+     */
     isHoliday(date) {
-        const formattedDate = format(date, 'yyyy-MM-dd');
-        const yearHolidays = marketHolidays[date.getFullYear()];
-        for (const holiday in yearHolidays) {
-            if (yearHolidays[holiday].date === formattedDate) {
-                return true;
-            }
-        }
-        return false;
+        const formattedDate = formatInTimeZone(date, this.timezone, 'yyyy-MM-dd');
+        const year = toZonedTime(date, this.timezone).getFullYear();
+        const yearHolidays = marketHolidays[year];
+        if (!yearHolidays)
+            return false;
+        return Object.values(yearHolidays).some(holiday => holiday.date === formattedDate);
     }
+    /**
+     * Check if a date is an early close day
+     */
     isEarlyCloseDay(date) {
-        const formattedDate = format(date, 'yyyy-MM-dd');
-        const yearEarlyCloses = marketEarlyCloses[date.getFullYear()];
+        const formattedDate = formatInTimeZone(date, this.timezone, 'yyyy-MM-dd');
+        const year = toZonedTime(date, this.timezone).getFullYear();
+        const yearEarlyCloses = marketEarlyCloses[year];
         return yearEarlyCloses && yearEarlyCloses[formattedDate] !== undefined;
     }
     /**
-     * Get the early close time for a given date
-     * @param date - The date to get the early close time for
-     * @returns The early close time in minutes from midnight, or null if there is no early close
+     * Get the early close time for a date (in minutes from midnight)
      */
     getEarlyCloseTime(date) {
-        const formattedDate = format(date, 'yyyy-MM-dd');
-        const yearEarlyCloses = marketEarlyCloses[date.getFullYear()];
+        const formattedDate = formatInTimeZone(date, this.timezone, 'yyyy-MM-dd');
+        const year = toZonedTime(date, this.timezone).getFullYear();
+        const yearEarlyCloses = marketEarlyCloses[year];
         if (yearEarlyCloses && yearEarlyCloses[formattedDate]) {
             const [hours, minutes] = yearEarlyCloses[formattedDate].time.split(':').map(Number);
             return hours * 60 + minutes;
@@ -233,357 +732,280 @@ class MarketTimeUtil {
         return null;
     }
     /**
-     * Check if a given date is a market day
-     * @param date - The date to check
-     * @returns true if the date is a market day, false otherwise
+     * Check if a date is a market day (not weekend or holiday)
      */
     isMarketDay(date) {
-        const isWeekendDay = this.isWeekend(date);
-        const isHolidayDay = this.isHoliday(date);
-        const returner = !isWeekendDay && !isHolidayDay;
-        return returner;
+        return !this.isWeekend(date) && !this.isHoliday(date);
     }
     /**
-     * Check if a given date is within market hours
-     * @param date - The date to check
-     * @returns true if the date is within market hours, false otherwise
+     * Get the next market day from a given date
      */
-    isWithinMarketHours(date) {
-        // Check for holidays first
-        if (this.isHoliday(date)) {
-            return false;
+    getNextMarketDay(date) {
+        let nextDay = add(date, { days: 1 });
+        while (!this.isMarketDay(nextDay)) {
+            nextDay = add(nextDay, { days: 1 });
         }
-        const timeInMinutes = date.getHours() * 60 + date.getMinutes();
-        // Check for early closure
-        if (this.isEarlyCloseDay(date)) {
-            const earlyCloseMinutes = this.getEarlyCloseTime(date);
-            if (earlyCloseMinutes !== null && timeInMinutes > earlyCloseMinutes) {
-                return false;
-            }
+        return nextDay;
+    }
+    /**
+     * Get the previous market day from a given date
+     */
+    getPreviousMarketDay(date) {
+        let prevDay = sub(date, { days: 1 });
+        while (!this.isMarketDay(prevDay)) {
+            prevDay = sub(prevDay, { days: 1 });
         }
-        // Regular market hours logic
-        let returner;
-        switch (this.intradayReporting) {
-            case 'extended_hours': {
-                const extendedStartMinutes = MARKET_TIMES.EXTENDED.START.HOUR * 60 + MARKET_TIMES.EXTENDED.START.MINUTE;
-                const extendedEndMinutes = MARKET_TIMES.EXTENDED.END.HOUR * 60 + MARKET_TIMES.EXTENDED.END.MINUTE;
-                // Comprehensive handling of times crossing midnight
-                const adjustedDate = timeInMinutes < extendedStartMinutes ? sub(date, { days: 1 }) : date;
-                const adjustedTimeInMinutes = adjustedDate.getHours() * 60 + adjustedDate.getMinutes();
-                returner = adjustedTimeInMinutes >= extendedStartMinutes && adjustedTimeInMinutes <= extendedEndMinutes;
-                break;
-            }
-            case 'continuous':
-                returner = true;
-                break;
-            default: {
-                // market_hours
-                const regularStartMinutes = MARKET_TIMES.REGULAR.START.HOUR * 60 + MARKET_TIMES.REGULAR.START.MINUTE;
-                const regularEndMinutes = MARKET_TIMES.REGULAR.END.HOUR * 60 + MARKET_TIMES.REGULAR.END.MINUTE;
-                returner = timeInMinutes >= regularStartMinutes && timeInMinutes <= regularEndMinutes;
-                break;
-            }
+        return prevDay;
+    }
+}
+// ===== TIME FORMATTER SERVICE =====
+/**
+ * Service for formatting time outputs
+ */
+class TimeFormatter {
+    timezone;
+    constructor(timezone = MARKET_CONFIG.TIMEZONE) {
+        this.timezone = timezone;
+    }
+    /**
+     * Format a date based on the output format
+     */
+    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 formatInTimeZone(date, this.timezone, "yyyy-MM-dd'T'HH:mm:ssXXX");
         }
-        return returner;
     }
     /**
-     * Check if a given date is before market hours
-     * @param date - The date to check
-     * @returns true if the date is before market hours, false otherwise
+     * Get New York timezone offset
      */
-    isBeforeMarketHours(date) {
-        const timeInMinutes = date.getHours() * 60 + date.getMinutes();
-        const startMinutes = this.intradayReporting === 'extended_hours'
-            ? MARKET_TIMES.EXTENDED.START.HOUR * 60 + MARKET_TIMES.EXTENDED.START.MINUTE
-            : MARKET_TIMES.REGULAR.START.HOUR * 60 + MARKET_TIMES.REGULAR.START.MINUTE;
-        return timeInMinutes < startMinutes;
+    getNYTimeZone(date = new Date()) {
+        const dtf = new Intl.DateTimeFormat('en-US', {
+            timeZone: this.timezone,
+            timeZoneName: 'shortOffset',
+        });
+        const parts = dtf.formatToParts(date);
+        const tz = parts.find(p => p.type === 'timeZoneName')?.value;
+        if (!tz) {
+            throw new Error('Could not determine New York offset');
+        }
+        const shortOffset = tz.replace('GMT', '');
+        if (shortOffset === '-4') {
+            return '-04:00';
+        }
+        else if (shortOffset === '-5') {
+            return '-05:00';
+        }
+        else {
+            throw new Error(`Unexpected timezone offset: ${shortOffset}`);
+        }
     }
     /**
-     * Get the last trading date, i.e. the last date that was a market day
-     * @param currentDate - The current date
-     * @returns The last trading date
+     * Get trading date in YYYY-MM-DD format
      */
-    getLastTradingDate(currentDate = new Date()) {
-        const nowET = toZonedTime(currentDate, this.timezone);
-        const isMarketDayToday = this.isMarketDay(nowET);
-        const currentMinutes = nowET.getHours() * 60 + nowET.getMinutes();
-        const marketOpenMinutes = MARKET_TIMES.REGULAR.START.HOUR * 60 + MARKET_TIMES.REGULAR.START.MINUTE;
-        if (isMarketDayToday && currentMinutes >= marketOpenMinutes) {
-            // After market open on a market day, return today
-            return nowET;
+    getTradingDate(time) {
+        let date;
+        if (typeof time === 'number') {
+            date = new Date(time);
+        }
+        else if (typeof time === 'string') {
+            date = new Date(time);
         }
         else {
-            // Before market open, or not a market day, return previous trading day
-            let lastTradingDate = sub(nowET, { days: 1 });
-            while (!this.isMarketDay(lastTradingDate)) {
-                lastTradingDate = sub(lastTradingDate, { days: 1 });
-            }
-            return lastTradingDate;
+            date = time;
         }
+        return formatInTimeZone(date, this.timezone, 'yyyy-MM-dd');
+    }
+}
+// ===== MARKET TIME CALCULATOR =====
+/**
+ * Service for core market time calculations
+ */
+class MarketTimeCalculator {
+    calendar;
+    formatter;
+    timezone;
+    constructor(timezone = MARKET_CONFIG.TIMEZONE) {
+        this.timezone = timezone;
+        this.calendar = new MarketCalendar(timezone);
+        this.formatter = new TimeFormatter(timezone);
     }
-    getLastMarketDay(date) {
-        let currentDate = sub(date, { days: 1 });
-        while (!this.isMarketDay(currentDate)) {
-            currentDate = sub(currentDate, { days: 1 });
+    /**
+     * Get market open/close times for a date
+     */
+    getMarketTimes(date) {
+        const zonedDate = toZonedTime(date, this.timezone);
+        // Market closed on weekends and holidays
+        if (!this.calendar.isMarketDay(zonedDate)) {
+            return {
+                marketOpen: false,
+                open: null,
+                close: null,
+                openExt: null,
+                closeExt: null,
+            };
+        }
+        const dayStart = startOfDay(zonedDate);
+        // Regular market times
+        const open = fromZonedTime(set(dayStart, { hours: MARKET_CONFIG.TIMES.MARKET_OPEN.hour, minutes: MARKET_CONFIG.TIMES.MARKET_OPEN.minute }), this.timezone);
+        let close = fromZonedTime(set(dayStart, { hours: MARKET_CONFIG.TIMES.MARKET_CLOSE.hour, minutes: MARKET_CONFIG.TIMES.MARKET_CLOSE.minute }), this.timezone);
+        // Extended hours
+        const openExt = fromZonedTime(set(dayStart, { hours: MARKET_CONFIG.TIMES.EXTENDED_START.hour, minutes: MARKET_CONFIG.TIMES.EXTENDED_START.minute }), this.timezone);
+        let closeExt = fromZonedTime(set(dayStart, { hours: MARKET_CONFIG.TIMES.EXTENDED_END.hour, minutes: MARKET_CONFIG.TIMES.EXTENDED_END.minute }), this.timezone);
+        // Handle early close days
+        if (this.calendar.isEarlyCloseDay(zonedDate)) {
+            close = fromZonedTime(set(dayStart, { hours: MARKET_CONFIG.TIMES.EARLY_CLOSE.hour, minutes: MARKET_CONFIG.TIMES.EARLY_CLOSE.minute }), this.timezone);
+            closeExt = fromZonedTime(set(dayStart, { hours: MARKET_CONFIG.TIMES.EARLY_EXTENDED_END.hour, minutes: MARKET_CONFIG.TIMES.EARLY_EXTENDED_END.minute }), this.timezone);
+        }
+        return {
+            marketOpen: true,
+            open,
+            close,
+            openExt,
+            closeExt,
+        };
+    }
+    /**
+     * Check if a time is within market hours based on intraday reporting mode
+     */
+    isWithinMarketHours(date, intradayReporting = 'market_hours') {
+        const zonedDate = toZonedTime(date, this.timezone);
+        // Not a market day
+        if (!this.calendar.isMarketDay(zonedDate)) {
+            return false;
+        }
+        const timeInMinutes = zonedDate.getHours() * 60 + zonedDate.getMinutes();
+        switch (intradayReporting) {
+            case 'extended_hours': {
+                const startMinutes = MARKET_CONFIG.TIMES.EXTENDED_START.hour * 60 + MARKET_CONFIG.TIMES.EXTENDED_START.minute;
+                let endMinutes = MARKET_CONFIG.TIMES.EXTENDED_END.hour * 60 + MARKET_CONFIG.TIMES.EXTENDED_END.minute;
+                // Handle early close
+                if (this.calendar.isEarlyCloseDay(zonedDate)) {
+                    endMinutes = MARKET_CONFIG.TIMES.EARLY_EXTENDED_END.hour * 60 + MARKET_CONFIG.TIMES.EARLY_EXTENDED_END.minute;
+                }
+                return timeInMinutes >= startMinutes && timeInMinutes <= endMinutes;
+            }
+            case 'continuous':
+                return true;
+            default: {
+                // 'market_hours'
+                const startMinutes = MARKET_CONFIG.TIMES.MARKET_OPEN.hour * 60 + MARKET_CONFIG.TIMES.MARKET_OPEN.minute;
+                let endMinutes = MARKET_CONFIG.TIMES.MARKET_CLOSE.hour * 60 + MARKET_CONFIG.TIMES.MARKET_CLOSE.minute;
+                // Handle early close
+                if (this.calendar.isEarlyCloseDay(zonedDate)) {
+                    endMinutes = MARKET_CONFIG.TIMES.EARLY_CLOSE.hour * 60 + MARKET_CONFIG.TIMES.EARLY_CLOSE.minute;
+                }
+                return timeInMinutes >= startMinutes && timeInMinutes <= endMinutes;
+            }
         }
-        return currentDate;
     }
+    /**
+     * Get the last full trading date
+     */
     getLastFullTradingDate(currentDate = new Date()) {
         const nowET = toZonedTime(currentDate, this.timezone);
-        // If today is a market day and we're after extended hours close
-        // then return today since it's a completed trading day
-        if (this.isMarketDay(nowET)) {
+        // If today is a market day and we're after extended hours close, return today
+        if (this.calendar.isMarketDay(nowET)) {
             const timeInMinutes = nowET.getHours() * 60 + nowET.getMinutes();
-            const extendedEndMinutes = MARKET_TIMES.EXTENDED.END.HOUR * 60 + MARKET_TIMES.EXTENDED.END.MINUTE;
-            // Check if we're after market close (including extended hours)
+            let extendedEndMinutes = MARKET_CONFIG.TIMES.EXTENDED_END.hour * 60 + MARKET_CONFIG.TIMES.EXTENDED_END.minute;
+            if (this.calendar.isEarlyCloseDay(nowET)) {
+                extendedEndMinutes = MARKET_CONFIG.TIMES.EARLY_EXTENDED_END.hour * 60 + MARKET_CONFIG.TIMES.EARLY_EXTENDED_END.minute;
+            }
             if (timeInMinutes >= extendedEndMinutes) {
-                // Set to midnight ET while preserving the date
                 return fromZonedTime(set(nowET, { hours: 0, minutes: 0, seconds: 0, milliseconds: 0 }), this.timezone);
             }
         }
-        // In all other cases (during trading hours, before market open, holidays, weekends),
-        // we want the last completed trading day
-        let lastFullDate = this.getLastMarketDay(nowET);
-        // Set to midnight ET while preserving the date
-        return fromZonedTime(set(lastFullDate, { hours: 0, minutes: 0, seconds: 0, milliseconds: 0 }), this.timezone);
+        // Return the last completed trading day
+        const lastMarketDay = this.calendar.getPreviousMarketDay(nowET);
+        return fromZonedTime(set(lastMarketDay, { hours: 0, minutes: 0, seconds: 0, milliseconds: 0 }), this.timezone);
     }
     /**
-     * Gets the next market day from a reference date
-     * @param {Object} [options] - Options object
-     * @param {Date} [options.referenceDate] - The reference date (defaults to current date)
-     * @returns {Object} The next market day information
-     * @property {Date} date - The date object (start of day in NY time)
-     * @property {string} yyyymmdd - The date in YYYY-MM-DD format
-     * @property {string} dateISOString - Full ISO date string
+     * Get day boundaries based on intraday reporting mode
      */
-    getNextMarketDay(date) {
-        let currentDate = add(date, { days: 1 });
-        while (!this.isMarketDay(currentDate)) {
-            currentDate = add(currentDate, { days: 1 });
-        }
-        return currentDate;
-    }
-    getDayBoundaries(date) {
+    getDayBoundaries(date, intradayReporting = 'market_hours') {
+        const zonedDate = toZonedTime(date, this.timezone);
         let start;
         let end;
-        switch (this.intradayReporting) {
+        switch (intradayReporting) {
             case 'extended_hours': {
-                start = set(date, {
-                    hours: MARKET_TIMES.EXTENDED.START.HOUR,
-                    minutes: MARKET_TIMES.EXTENDED.START.MINUTE,
+                start = set(zonedDate, {
+                    hours: MARKET_CONFIG.TIMES.EXTENDED_START.hour,
+                    minutes: MARKET_CONFIG.TIMES.EXTENDED_START.minute,
                     seconds: 0,
                     milliseconds: 0,
                 });
-                end = set(date, {
-                    hours: MARKET_TIMES.EXTENDED.END.HOUR,
-                    minutes: MARKET_TIMES.EXTENDED.END.MINUTE,
+                end = set(zonedDate, {
+                    hours: MARKET_CONFIG.TIMES.EXTENDED_END.hour,
+                    minutes: MARKET_CONFIG.TIMES.EXTENDED_END.minute,
                     seconds: 59,
                     milliseconds: 999,
                 });
+                // Handle early close
+                if (this.calendar.isEarlyCloseDay(zonedDate)) {
+                    end = set(zonedDate, {
+                        hours: MARKET_CONFIG.TIMES.EARLY_EXTENDED_END.hour,
+                        minutes: MARKET_CONFIG.TIMES.EARLY_EXTENDED_END.minute,
+                        seconds: 59,
+                        milliseconds: 999,
+                    });
+                }
                 break;
             }
             case 'continuous': {
-                start = startOfDay(date);
-                end = endOfDay(date);
+                start = startOfDay(zonedDate);
+                end = endOfDay(zonedDate);
                 break;
             }
             default: {
-                // market_hours
-                start = set(date, {
-                    hours: MARKET_TIMES.REGULAR.START.HOUR,
-                    minutes: MARKET_TIMES.REGULAR.START.MINUTE,
+                // 'market_hours'
+                start = set(zonedDate, {
+                    hours: MARKET_CONFIG.TIMES.MARKET_OPEN.hour,
+                    minutes: MARKET_CONFIG.TIMES.MARKET_OPEN.minute,
                     seconds: 0,
                     milliseconds: 0,
                 });
-                // Check for early close
-                if (this.isEarlyCloseDay(date)) {
-                    const earlyCloseMinutes = this.getEarlyCloseTime(date);
-                    if (earlyCloseMinutes !== null) {
-                        const earlyCloseHours = Math.floor(earlyCloseMinutes / 60);
-                        const earlyCloseMinutesRemainder = earlyCloseMinutes % 60;
-                        end = set(date, {
-                            hours: earlyCloseHours,
-                            minutes: earlyCloseMinutesRemainder,
-                            seconds: 59,
-                            milliseconds: 999,
-                        });
-                        break;
-                    }
-                }
-                end = set(date, {
-                    hours: MARKET_TIMES.REGULAR.END.HOUR,
-                    minutes: MARKET_TIMES.REGULAR.END.MINUTE,
+                end = set(zonedDate, {
+                    hours: MARKET_CONFIG.TIMES.MARKET_CLOSE.hour,
+                    minutes: MARKET_CONFIG.TIMES.MARKET_CLOSE.minute,
                     seconds: 59,
                     milliseconds: 999,
                 });
+                // Handle early close
+                if (this.calendar.isEarlyCloseDay(zonedDate)) {
+                    end = set(zonedDate, {
+                        hours: MARKET_CONFIG.TIMES.EARLY_CLOSE.hour,
+                        minutes: MARKET_CONFIG.TIMES.EARLY_CLOSE.minute,
+                        seconds: 59,
+                        milliseconds: 999,
+                    });
+                }
                 break;
             }
         }
-        return { start, end };
-    }
-    calculatePeriodStartDate(endDate, period) {
-        let startDate;
-        switch (period) {
-            case 'YTD':
-                startDate = set(endDate, { month: 0, date: 1 });
-                break;
-            case '1D':
-                startDate = this.getLastMarketDay(endDate);
-                break;
-            case '3D':
-                startDate = sub(endDate, { days: 3 });
-                break;
-            case '1W':
-                startDate = sub(endDate, { weeks: 1 });
-                break;
-            case '2W':
-                startDate = sub(endDate, { weeks: 2 });
-                break;
-            case '1M':
-                startDate = sub(endDate, { months: 1 });
-                break;
-            case '3M':
-                startDate = sub(endDate, { months: 3 });
-                break;
-            case '6M':
-                startDate = sub(endDate, { months: 6 });
-                break;
-            case '1Y':
-                startDate = sub(endDate, { years: 1 });
-                break;
-            default:
-                throw new Error(`Invalid period: ${period}`);
-        }
-        while (!this.isMarketDay(startDate)) {
-            startDate = this.getNextMarketDay(startDate);
-        }
-        return startDate;
-    }
-    getMarketTimePeriod({ period, end = new Date(), intraday_reporting, outputFormat = 'iso', }) {
-        if (!period) {
-            throw new Error('Period is required');
-        }
-        if (intraday_reporting) {
-            this.intradayReporting = intraday_reporting;
-        }
-        // Convert end date to specified timezone
-        const zonedEndDate = toZonedTime(end, this.timezone);
-        let startDate;
-        let endDate;
-        const isCurrentMarketDay = this.isMarketDay(zonedEndDate);
-        const isWithinHours = this.isWithinMarketHours(zonedEndDate);
-        const isBeforeHours = this.isBeforeMarketHours(zonedEndDate);
-        // First determine the end date based on current market conditions
-        if (isCurrentMarketDay) {
-            if (isBeforeHours) {
-                // Case 1: Market day before open hours - use previous full trading day
-                const lastMarketDay = this.getLastMarketDay(zonedEndDate);
-                const { end: dayEnd } = this.getDayBoundaries(lastMarketDay);
-                endDate = dayEnd;
-            }
-            else if (isWithinHours) {
-                // Case 2: Market day during hours - use current time
-                endDate = zonedEndDate;
-            }
-            else {
-                // Case 3: Market day after close - use today's close
-                const { end: dayEnd } = this.getDayBoundaries(zonedEndDate);
-                endDate = dayEnd;
-            }
-        }
-        else {
-            // Case 4: Not a market day - use previous market day's close
-            const lastMarketDay = this.getLastMarketDay(zonedEndDate);
-            const { end: dayEnd } = this.getDayBoundaries(lastMarketDay);
-            endDate = dayEnd;
-        }
-        // Now calculate the start date based on the period
-        const periodStartDate = this.calculatePeriodStartDate(endDate, period);
-        const { start: dayStart } = this.getDayBoundaries(periodStartDate);
-        startDate = dayStart;
-        // Convert boundaries back to UTC for final output
-        const utcStart = fromZonedTime(startDate, this.timezone);
-        const utcEnd = fromZonedTime(endDate, this.timezone);
-        // Ensure start is not after end
-        if (isBefore(utcEnd, utcStart)) {
-            throw new Error('Start date cannot be after end date');
-        }
-        return {
-            start: this.formatDate(utcStart, outputFormat),
-            end: this.formatDate(utcEnd, outputFormat),
-        };
-    }
-    getMarketOpenClose(options = {}) {
-        const { date = new Date() } = options;
-        const zonedDate = toZonedTime(date, this.timezone);
-        // Check if market is closed for the day
-        if (this.isWeekend(zonedDate) || this.isHoliday(zonedDate)) {
-            return {
-                marketOpen: false,
-                open: null,
-                close: null,
-                openExt: null,
-                closeExt: null,
-            };
-        }
-        const dayStart = startOfDay(zonedDate);
-        const regularOpenTime = MARKET_TIMES.REGULAR.START;
-        let regularCloseTime = MARKET_TIMES.REGULAR.END;
-        const extendedOpenTime = MARKET_TIMES.EXTENDED.START;
-        let extendedCloseTime = MARKET_TIMES.EXTENDED.END;
-        // Check for early close
-        const isEarlyClose = this.isEarlyCloseDay(zonedDate);
-        if (isEarlyClose) {
-            const earlyCloseMinutes = this.getEarlyCloseTime(zonedDate);
-            if (earlyCloseMinutes !== null) {
-                // For regular hours, use the early close time
-                regularCloseTime = {
-                    HOUR: Math.floor(earlyCloseMinutes / 60),
-                    MINUTE: earlyCloseMinutes % 60,
-                    MINUTES: earlyCloseMinutes,
-                };
-                // For extended hours on early close days, close at 5:00 PM
-                extendedCloseTime = {
-                    HOUR: 17,
-                    MINUTE: 0,
-                    MINUTES: 1020,
-                };
-            }
-        }
-        const open = fromZonedTime(set(dayStart, { hours: regularOpenTime.HOUR, minutes: regularOpenTime.MINUTE }), this.timezone);
-        const close = fromZonedTime(set(dayStart, { hours: regularCloseTime.HOUR, minutes: regularCloseTime.MINUTE }), this.timezone);
-        const openExt = fromZonedTime(set(dayStart, { hours: extendedOpenTime.HOUR, minutes: extendedOpenTime.MINUTE }), this.timezone);
-        const closeExt = fromZonedTime(set(dayStart, { hours: extendedCloseTime.HOUR, minutes: extendedCloseTime.MINUTE }), this.timezone);
         return {
-            marketOpen: true,
-            open,
-            close,
-            openExt,
-            closeExt,
+            start: fromZonedTime(start, this.timezone),
+            end: fromZonedTime(end, this.timezone),
         };
     }
 }
+const marketTimeCalculator = new MarketTimeCalculator();
+const timeFormatter = new TimeFormatter();
 /**
- * Gets the last full trading date
- * @param {Date} [currentDate] - The current date (defaults to now)
- * @returns {Object} The last full trading date
- * @property {Date} date - The date object
- * @property {string} YYYYMMDD - The date in YYYY-MM-DD format
+ * Get the last full trading date
  */
 function getLastFullTradingDate(currentDate = new Date()) {
-    const util = new MarketTimeUtil();
-    const date = util.getLastFullTradingDate(currentDate);
-    // Format the date in NY timezone to ensure consistency
+    const date = marketTimeCalculator.getLastFullTradingDate(currentDate);
     return {
         date,
-        YYYYMMDD: formatInTimeZone(date, MARKET_TIMES.TIMEZONE, 'yyyy-MM-dd'),
+        YYYYMMDD: timeFormatter.getTradingDate(date),
     };
 }
 
-function getDefaultExportFromCjs (x) {
-	return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, 'default') ? x['default'] : x;
-}
-
 var bufferUtil = {exports: {}};
 
 var constants;
@@ -820,7 +1242,7 @@ function requirePermessageDeflate () {
 	if (hasRequiredPermessageDeflate) return permessageDeflate;
 	hasRequiredPermessageDeflate = 1;
 
-	const zlib = require$$0;
+	const zlib = require$$0$1;
 
 	const bufferUtil = requireBufferUtil();
 	const Limiter = requireLimiter();
@@ -1357,7 +1779,7 @@ function requireValidation () {
 	if (hasRequiredValidation) return validation.exports;
 	hasRequiredValidation = 1;
 
-	const { isUtf8 } = require$$0$1;
+	const { isUtf8 } = require$$0$2;
 
 	const { hasBlob } = requireConstants();
 
@@ -1517,7 +1939,7 @@ function requireReceiver () {
 	if (hasRequiredReceiver) return receiver;
 	hasRequiredReceiver = 1;
 
-	const { Writable } = require$$0$2;
+	const { Writable } = require$$0$3;
 
 	const PerMessageDeflate = requirePermessageDeflate();
 	const {
@@ -2233,8 +2655,8 @@ function requireSender () {
 	if (hasRequiredSender) return sender;
 	hasRequiredSender = 1;
 
-	const { Duplex } = require$$0$2;
-	const { randomFillSync } = require$$1;
+	const { Duplex } = require$$0$3;
+	const { randomFillSync } = require$$3;
 
 	const PerMessageDeflate = requirePermessageDeflate();
 	const { EMPTY_BUFFER, kWebSocket, NOOP } = requireConstants();
@@ -3354,13 +3776,13 @@ function requireWebsocket () {
 	if (hasRequiredWebsocket) return websocket;
 	hasRequiredWebsocket = 1;
 
-	const EventEmitter = require$$0$3;
+	const EventEmitter = require$$0$4;
 	const https = require$$1$1;
-	const http = require$$2;
-	const net = require$$3;
-	const tls = require$$4;
-	const { randomBytes, createHash } = require$$1;
-	const { Duplex, Readable } = require$$0$2;
+	const http = require$$2$1;
+	const net = require$$3$1;
+	const tls = require$$4$1;
+	const { randomBytes, createHash } = require$$3;
+	const { Duplex, Readable } = require$$0$3;
 	const { URL } = require$$7;
 
 	const PerMessageDeflate = requirePermessageDeflate();
@@ -4751,7 +5173,7 @@ function requireStream () {
 	hasRequiredStream = 1;
 
 	requireWebsocket();
-	const { Duplex } = require$$0$2;
+	const { Duplex } = require$$0$3;
 
 	/**
 	 * Emits the `'close'` event on a stream.
@@ -4999,10 +5421,10 @@ function requireWebsocketServer () {
 	if (hasRequiredWebsocketServer) return websocketServer;
 	hasRequiredWebsocketServer = 1;
 
-	const EventEmitter = require$$0$3;
-	const http = require$$2;
-	const { Duplex } = require$$0$2;
-	const { createHash } = require$$1;
+	const EventEmitter = require$$0$4;
+	const http = require$$2$1;
+	const { Duplex } = require$$0$3;
+	const { createHash } = require$$3;
 
 	const extension = requireExtension();
 	const PerMessageDeflate = requirePermessageDeflate();
@@ -5573,22 +5995,16 @@ class AlpacaMarketDataAPI extends EventEmitter {
     optionWs = null;
     stockSubscriptions = { trades: [], quotes: [], bars: [] };
     optionSubscriptions = { trades: [], quotes: [], bars: [] };
-    apiKey;
-    secretKey;
-    accountType;
     setMode(mode = 'production') {
-        if (mode === 'sandbox') {
-            // sandbox mode
+        if (mode === 'sandbox') { // sandbox mode
             this.stockStreamUrl = 'wss://stream.data.sandbox.alpaca.markets/v2/sip';
             this.optionStreamUrl = 'wss://stream.data.sandbox.alpaca.markets/v1beta3/options';
         }
-        else if (mode === 'test') {
-            // test mode, can only use ticker FAKEPACA
+        else if (mode === 'test') { // test mode, can only use ticker FAKEPACA
             this.stockStreamUrl = 'wss://stream.data.alpaca.markets/v2/test';
             this.optionStreamUrl = 'wss://stream.data.alpaca.markets/v1beta3/options'; // there's no test mode for options
         }
-        else {
-            // production
+        else { // production
             this.stockStreamUrl = 'wss://stream.data.alpaca.markets/v2/sip';
             this.optionStreamUrl = 'wss://stream.data.alpaca.markets/v1beta3/options';
         }
@@ -5604,30 +6020,24 @@ class AlpacaMarketDataAPI extends EventEmitter {
             return 'production';
         }
     }
-    constructor(config) {
+    constructor() {
         super();
-        this.apiKey = config.apiKey;
-        this.secretKey = config.secretKey;
-        this.accountType = config.accountType || 'LIVE';
         this.dataURL = 'https://data.alpaca.markets/v2';
         this.apiURL =
-            this.accountType === 'PAPER'
+            process.env.ALPACA_ACCOUNT_TYPE === 'PAPER'
                 ? 'https://paper-api.alpaca.markets/v2'
                 : 'https://api.alpaca.markets/v2'; // used by some, e.g. getAssets
         this.v1beta1url = 'https://data.alpaca.markets/v1beta1'; // used for options endpoints
         this.setMode('production'); // sets stockStreamUrl and optionStreamUrl
         this.headers = {
-            'APCA-API-KEY-ID': this.apiKey,
-            'APCA-API-SECRET-KEY': this.secretKey,
+            'APCA-API-KEY-ID': process.env.ALPACA_API_KEY,
+            'APCA-API-SECRET-KEY': process.env.ALPACA_SECRET_KEY,
             'Content-Type': 'application/json',
         };
     }
-    static getInstance(config) {
+    static getInstance() {
         if (!AlpacaMarketDataAPI.instance) {
-            if (!config) {
-                throw new Error('AlpacaMarketDataAPI config is required for first initialization');
-            }
-            AlpacaMarketDataAPI.instance = new AlpacaMarketDataAPI(config);
+            AlpacaMarketDataAPI.instance = new AlpacaMarketDataAPI();
         }
         return AlpacaMarketDataAPI.instance;
     }
@@ -5650,8 +6060,8 @@ class AlpacaMarketDataAPI extends EventEmitter {
             log$1(`${streamType} stream connected`, { type: 'info' });
             const authMessage = {
                 action: 'auth',
-                key: this.apiKey,
-                secret: this.secretKey,
+                key: process.env.ALPACA_API_KEY,
+                secret: process.env.ALPACA_SECRET_KEY,
             };
             ws.send(JSON.stringify(authMessage));
         });
@@ -5742,7 +6152,7 @@ class AlpacaMarketDataAPI extends EventEmitter {
         const currentSubscriptions = streamType === 'stock' ? this.stockSubscriptions : this.optionSubscriptions;
         Object.entries(subscriptions).forEach(([key, value]) => {
             if (value) {
-                currentSubscriptions[key] = (currentSubscriptions[key] || []).filter((s) => !value.includes(s));
+                currentSubscriptions[key] = (currentSubscriptions[key] || []).filter(s => !value.includes(s));
             }
         });
         const unsubMessage = {
@@ -5805,11 +6215,11 @@ class AlpacaMarketDataAPI extends EventEmitter {
         let pageCount = 0;
         let currency = '';
         // Initialize bar arrays for each symbol
-        symbols.forEach((symbol) => {
+        symbols.forEach(symbol => {
             allBars[symbol] = [];
         });
         log$1(`Starting historical bars fetch for ${symbolsStr} (${params.timeframe}, ${params.start || 'no start'} to ${params.end || 'no end'})`, {
-            type: 'info',
+            type: 'info'
         });
         while (hasMorePages) {
             pageCount++;
@@ -5837,7 +6247,7 @@ class AlpacaMarketDataAPI extends EventEmitter {
                     allBars[symbol] = [...allBars[symbol], ...bars];
                     pageBarsCount += bars.length;
                     // Track date range for this page
-                    bars.forEach((bar) => {
+                    bars.forEach(bar => {
                         const barDate = new Date(bar.t);
                         if (!earliestTimestamp || barDate < earliestTimestamp) {
                             earliestTimestamp = barDate;
@@ -5856,7 +6266,7 @@ class AlpacaMarketDataAPI extends EventEmitter {
                 ? `${earliestTimestamp.toLocaleDateString('en-US', { timeZone: 'America/New_York' })} to ${latestTimestamp.toLocaleDateString('en-US', { timeZone: 'America/New_York' })}`
                 : 'unknown range';
             log$1(`Page ${pageCount}: Fetched ${pageBarsCount.toLocaleString()} bars (total: ${totalBarsCount.toLocaleString()}) for ${symbolsStr}, date range: ${dateRangeStr}${hasMorePages ? ', more pages available' : ', complete'}`, {
-                type: 'info',
+                type: 'info'
             });
             // Prevent infinite loops
             if (pageCount > 1000) {
@@ -5865,11 +6275,9 @@ class AlpacaMarketDataAPI extends EventEmitter {
             }
         }
         // Final summary
-        const symbolCounts = Object.entries(allBars)
-            .map(([symbol, bars]) => `${symbol}: ${bars.length}`)
-            .join(', ');
+        const symbolCounts = Object.entries(allBars).map(([symbol, bars]) => `${symbol}: ${bars.length}`).join(', ');
         log$1(`Historical bars fetch complete: ${totalBarsCount.toLocaleString()} total bars across ${pageCount} pages (${symbolCounts})`, {
-            type: 'info',
+            type: 'info'
         });
         return {
             bars: allBars,
@@ -6137,11 +6545,11 @@ class AlpacaMarketDataAPI extends EventEmitter {
         let totalBarsCount = 0;
         let pageCount = 0;
         // Initialize bar arrays for each symbol
-        symbols.forEach((symbol) => {
+        symbols.forEach(symbol => {
             allBars[symbol] = [];
         });
         log$1(`Starting historical options bars fetch for ${symbolsStr} (${params.timeframe}, ${params.start || 'no start'} to ${params.end || 'no end'})`, {
-            type: 'info',
+            type: 'info'
         });
         while (hasMorePages) {
             pageCount++;
@@ -6163,7 +6571,7 @@ class AlpacaMarketDataAPI extends EventEmitter {
                     allBars[symbol] = [...allBars[symbol], ...bars];
                     pageBarsCount += bars.length;
                     // Track date range for this page
-                    bars.forEach((bar) => {
+                    bars.forEach(bar => {
                         const barDate = new Date(bar.t);
                         if (!earliestTimestamp || barDate < earliestTimestamp) {
                             earliestTimestamp = barDate;
@@ -6182,7 +6590,7 @@ class AlpacaMarketDataAPI extends EventEmitter {
                 ? `${earliestTimestamp.toLocaleDateString('en-US', { timeZone: 'America/New_York' })} to ${latestTimestamp.toLocaleDateString('en-US', { timeZone: 'America/New_York' })}`
                 : 'unknown range';
             log$1(`Page ${pageCount}: Fetched ${pageBarsCount.toLocaleString()} option bars (total: ${totalBarsCount.toLocaleString()}) for ${symbolsStr}, date range: ${dateRangeStr}${hasMorePages ? ', more pages available' : ', complete'}`, {
-                type: 'info',
+                type: 'info'
             });
             // Prevent infinite loops
             if (pageCount > 1000) {
@@ -6191,11 +6599,9 @@ class AlpacaMarketDataAPI extends EventEmitter {
             }
         }
         // Final summary
-        const symbolCounts = Object.entries(allBars)
-            .map(([symbol, bars]) => `${symbol}: ${bars.length}`)
-            .join(', ');
+        const symbolCounts = Object.entries(allBars).map(([symbol, bars]) => `${symbol}: ${bars.length}`).join(', ');
         log$1(`Historical options bars fetch complete: ${totalBarsCount.toLocaleString()} total bars across ${pageCount} pages (${symbolCounts})`, {
-            type: 'info',
+            type: 'info'
         });
         return {
             bars: allBars,
@@ -6219,11 +6625,11 @@ class AlpacaMarketDataAPI extends EventEmitter {
         let totalTradesCount = 0;
         let pageCount = 0;
         // Initialize trades arrays for each symbol
-        symbols.forEach((symbol) => {
+        symbols.forEach(symbol => {
             allTrades[symbol] = [];
         });
         log$1(`Starting historical options trades fetch for ${symbolsStr} (${params.start || 'no start'} to ${params.end || 'no end'})`, {
-            type: 'info',
+            type: 'info'
         });
         while (hasMorePages) {
             pageCount++;
@@ -6245,7 +6651,7 @@ class AlpacaMarketDataAPI extends EventEmitter {
                     allTrades[symbol] = [...allTrades[symbol], ...trades];
                     pageTradesCount += trades.length;
                     // Track date range for this page
-                    trades.forEach((trade) => {
+                    trades.forEach(trade => {
                         const tradeDate = new Date(trade.t);
                         if (!earliestTimestamp || tradeDate < earliestTimestamp) {
                             earliestTimestamp = tradeDate;
@@ -6264,7 +6670,7 @@ class AlpacaMarketDataAPI extends EventEmitter {
                 ? `${earliestTimestamp.toLocaleDateString('en-US', { timeZone: 'America/New_York' })} to ${latestTimestamp.toLocaleDateString('en-US', { timeZone: 'America/New_York' })}`
                 : 'unknown range';
             log$1(`Page ${pageCount}: Fetched ${pageTradesCount.toLocaleString()} option trades (total: ${totalTradesCount.toLocaleString()}) for ${symbolsStr}, date range: ${dateRangeStr}${hasMorePages ? ', more pages available' : ', complete'}`, {
-                type: 'info',
+                type: 'info'
             });
             // Prevent infinite loops
             if (pageCount > 1000) {
@@ -6273,11 +6679,9 @@ class AlpacaMarketDataAPI extends EventEmitter {
             }
         }
         // Final summary
-        const symbolCounts = Object.entries(allTrades)
-            .map(([symbol, trades]) => `${symbol}: ${trades.length}`)
-            .join(', ');
+        const symbolCounts = Object.entries(allTrades).map(([symbol, trades]) => `${symbol}: ${trades.length}`).join(', ');
         log$1(`Historical options trades fetch complete: ${totalTradesCount.toLocaleString()} total trades across ${pageCount} pages (${symbolCounts})`, {
-            type: 'info',
+            type: 'info'
         });
         return {
             trades: allTrades,
@@ -6422,9 +6826,7 @@ class AlpacaMarketDataAPI extends EventEmitter {
                 ...(symbol && { symbols: symbol }),
                 ...(mergedParams.limit && { limit: Math.min(50, maxLimit - fetchedCount).toString() }),
                 ...(mergedParams.sort && { sort: mergedParams.sort }),
-                ...(mergedParams.include_content !== undefined
-                    ? { include_content: mergedParams.include_content.toString() }
-                    : {}),
+                ...(mergedParams.include_content !== undefined ? { include_content: mergedParams.include_content.toString() } : {}),
                 ...(pageToken && { page_token: pageToken }),
             });
             const url = `${this.v1beta1url}/news?${queryParams}`;
@@ -6468,316 +6870,18 @@ class AlpacaMarketDataAPI extends EventEmitter {
         return newsArticles;
     }
 }
-
-// format-tools.ts
-/**
- * Capitalizes the first letter of a string
- * @param {string} str - The string to capitalize
- * @returns {string} The capitalized string, or original value if not a string
- * @example
- * capitalize('hello') // 'Hello'
- * capitalize(123) // 123
- */
-/**
- * Formats a number as US currency
- * @param {number} value - The number to format
- * @returns {string} The formatted currency string (e.g. '$1,234.56')
- * @example
- * formatCurrency(1234.56) // '$1,234.56'
- * formatCurrency(NaN) // '$0.00'
- */
-function formatCurrency(value) {
-    if (isNaN(value)) {
-        return '$0.00';
-    }
-    return new Intl.NumberFormat('en-US', {
-        style: 'currency',
-        currency: 'USD',
-    }).format(value);
-}
-/**
- * Formats a number with commas
- * @param {number} value - The number to format
- * @returns {string} The formatted number string (e.g. '1,234.56')
- * @example
- * formatNumber(1234.56) // '1,234.56'
- * formatNumber(NaN) // '0'
- */
-function formatNumber(value) {
-    if (isNaN(value)) {
-        return '0';
-    }
-    return new Intl.NumberFormat('en-US').format(value);
-}
+// Export the singleton instance
+AlpacaMarketDataAPI.getInstance();
 
 const log = (message) => {
     console.log(`[${new Date().toLocaleString('en-US', { timeZone: 'America/New_York' })}] ${message}`);
 };
-// async function testCreateEquitiesTrade() {
-//   try {
-//     log('Starting createEquitiesTrade test...');
-//     // Create credentials using environment variables
-//     const credentials: AlpacaCredentials = {
-//       accountName: 'test',
-//       apiKey: process.env.ALPACA_API_KEY || '',
-//       apiSecret: process.env.ALPACA_SECRET_KEY || '',
-//       type: 'PAPER',
-//       orderType: 'market',
-//       engine: 'quant'
-//     };
-//     if (!credentials.apiKey || !credentials.apiSecret) {
-//       throw new Error('ALPACA_API_KEY and ALPACA_SECRET_KEY environment variables must be set');
-//     }
-//     // Create a new instance of the trading API
-//     const alpacaAPI = createAlpacaTradingAPI(credentials);
-//     // Get current account details
-//     const accountDetails = await alpacaAPI.getAccountDetails();
-//     log(`Account equity: $${parseFloat(accountDetails.equity).toFixed(2)}`);
-//     log(`Buying power: $${parseFloat(accountDetails.buying_power).toFixed(2)}`);
-//     const testSymbols = ['AAPL', 'MSFT', 'GOOGL', 'TSLA', 'NVDA', 'META', 'AMZN']; // Multiple symbols to avoid wash trade detection
-//     const referencePrice = 150.00; // Mock reference price for testing
-//     log('=== Testing createEquitiesTrade function ===');
-//     // Test 1: Simple market order (long position)
-//     log('\n1. Testing simple market order (long)...');
-//     try {
-//       const order1 = await alpacaAPI.createEquitiesTrade(
-//         { symbol: testSymbols[0], qty: 1, side: 'buy' }
-//       );
-//       log(`✅ Created simple market buy order: ${order1.id}`);
-//     } catch (error) {
-//       log(`❌ Failed to create simple market order: ${error}`);
-//     }
-//     // Test 2: Simple market order (short position)
-//     log('\n2. Testing simple market order (short)...');
-//     try {
-//       const order2 = await alpacaAPI.createEquitiesTrade(
-//         { symbol: testSymbols[1], qty: 1, side: 'sell' }
-//       );
-//       log(`✅ Created simple market sell order: ${order2.id}`);
-//     } catch (error) {
-//       log(`❌ Failed to create simple market sell order: ${error}`);
-//     }
-//     // Test 3: Limit order with percentage-based stop loss (long)
-//     log('\n3. Testing limit order with percentage-based stop loss (long)...');
-//     try {
-//       const order3 = await alpacaAPI.createEquitiesTrade(
-//         { symbol: testSymbols[2], qty: 1, side: 'buy', referencePrice },
-//         {
-//           type: 'limit',
-//           limitPrice: 149.50,
-//           useStopLoss: true,
-//           stopPercent100: 3.0 // 3% stop loss
-//         }
-//       );
-//       log(`✅ Created limit buy order with stop loss: ${order3.id}`);
-//     } catch (error) {
-//       log(`❌ Failed to create limit order with stop loss: ${error}`);
-//     }
-//     // Test 4: Limit order with percentage-based take profit (short)
-//     log('\n4. Testing limit order with percentage-based take profit (short)...');
-//     try {
-//       const order4 = await alpacaAPI.createEquitiesTrade(
-//         { symbol: testSymbols[3], qty: 1, side: 'sell', referencePrice },
-//         {
-//           type: 'limit',
-//           limitPrice: 150.50,
-//           useTakeProfit: true,
-//           takeProfitPercent100: 2.5 // 2.5% take profit
-//         }
-//       );
-//       log(`✅ Created limit sell order with take profit: ${order4.id}`);
-//     } catch (error) {
-//       log(`❌ Failed to create limit order with take profit: ${error}`);
-//     }
-//     // Test 5: Bracket order with both stop loss and take profit (long)
-//     log('\n5. Testing bracket order with both stop loss and take profit (long)...');
-//     try {
-//       const order5 = await alpacaAPI.createEquitiesTrade(
-//         { symbol: testSymbols[4], qty: 1, side: 'buy', referencePrice },
-//         {
-//           type: 'limit',
-//           limitPrice: 149.00,
-//           useStopLoss: true,
-//           stopPercent100: 4.0, // 4% stop loss
-//           useTakeProfit: true,
-//           takeProfitPercent100: 6.0 // 6% take profit
-//         }
-//       );
-//       log(`✅ Created bracket order (long): ${order5.id}`);
-//     } catch (error) {
-//       log(`❌ Failed to create bracket order: ${error}`);
-//     }
-//     // Test 6: Bracket order with fixed prices (short)
-//     log('\n6. Testing bracket order with fixed prices (short)...');
-//     try {
-//       const order6 = await alpacaAPI.createEquitiesTrade(
-//         { symbol: testSymbols[5], qty: 1, side: 'sell' },
-//         {
-//           type: 'limit',
-//           limitPrice: 151.00,
-//           useStopLoss: true,
-//           stopPrice: 155.00, // Fixed stop price
-//           useTakeProfit: true,
-//           takeProfitPrice: 145.00 // Fixed take profit price
-//         }
-//       );
-//       log(`✅ Created bracket order with fixed prices (short): ${order6.id}`);
-//     } catch (error) {
-//       log(`❌ Failed to create bracket order with fixed prices: ${error}`);
-//     }
-//     // Test 7: Extended hours limit order
-//     log('\n7. Testing extended hours limit order...');
-//     try {
-//       const order7 = await alpacaAPI.createEquitiesTrade(
-//         { symbol: testSymbols[6], qty: 1, side: 'buy' },
-//         {
-//           type: 'limit',
-//           limitPrice: 148.00,
-//           extendedHours: true
-//         }
-//       );
-//       log(`✅ Created extended hours limit order: ${order7.id}`);
-//     } catch (error) {
-//       log(`❌ Failed to create extended hours order: ${error}`);
-//     }
-//     // Test 8: Error condition - market order with extended hours (should fail)
-//     log('\n8. Testing error condition - market order with extended hours (should fail)...');
-//     try {
-//       await alpacaAPI.createEquitiesTrade(
-//         { symbol: testSymbols[0], qty: 1, side: 'buy' },
-//         {
-//           type: 'market',
-//           extendedHours: true // This should trigger an error
-//         }
-//       );
-//       log(`❌ Unexpected success - should have failed!`);
-//     } catch (error) {
-//       log(`✅ Correctly caught error: ${error instanceof Error ? error.message : error}`);
-//     }
-//     // Test 9: Error condition - missing referencePrice for percentage (should fail)
-//     log('\n9. Testing error condition - missing referencePrice for percentage (should fail)...');
-//     try {
-//       await alpacaAPI.createEquitiesTrade(
-//         { symbol: testSymbols[0], qty: 1, side: 'buy' }, // No referencePrice
-//         {
-//           useStopLoss: true,
-//           stopPercent100: 3.0 // Requires referencePrice
-//         }
-//       );
-//       log(`❌ Unexpected success - should have failed!`);
-//     } catch (error) {
-//       log(`✅ Correctly caught error: ${error instanceof Error ? error.message : error}`);
-//     }
-//     // Wait a moment for all orders to process
-//     await new Promise(resolve => setTimeout(resolve, 2000));
-//     // Get all orders to see what was created
-//     log('\n=== Checking created orders ===');
-//     const orders = await alpacaAPI.getOrders({ status: 'open', limit: 20 });
-//     log(`Found ${orders.length} open orders`);
-//     orders.forEach((order, index) => {
-//       log(`Order ${index + 1}: ${order.order_class} ${order.type} ${order.side} ${order.qty} ${order.symbol} @ $${order.limit_price || 'market'}`);
-//       if (order.legs && order.legs.length > 0) {
-//         log(`  Stop Loss: $${order.legs.find(leg => leg.type === 'stop')?.stop_price || 'N/A'}`);
-//         log(`  Take Profit: $${order.legs.find(leg => leg.type === 'limit')?.limit_price || 'N/A'}`);
-//       }
-//     });
-//     // Cancel all orders to clean up
-//     log('\n=== Cleaning up - canceling all orders ===');
-//     await alpacaAPI.cancelAllOrders();
-//     log('✅ All orders canceled');
-//     log('\n=== Test completed successfully! ===');
-//   } catch (error) {
-//     log(`❌ Error in createEquitiesTrade test: ${error instanceof Error ? error.message : 'Unknown error'}`);
-//     process.exit(1);
-//   }
-// }
-// async function testAlpacaWebSocket() {
-//   try {
-//     log('Starting Alpaca WebSocket test...');
-//     // Create credentials using environment variables
-//     const credentials: AlpacaCredentials = {
-//       accountName: 'test',
-//       apiKey: process.env.ALPACA_API_KEY || '',
-//       apiSecret: process.env.ALPACA_SECRET_KEY || '',
-//       type: 'PAPER',
-//       orderType: 'market',
-//       engine: 'quant'
-//     };
-//     if (!credentials.apiKey || !credentials.apiSecret) {
-//       throw new Error('ALPACA_API_KEY and ALPACA_SECRET_KEY environment variables must be set');
-//     }
-//     // Create a new instance of the trading API
-//     const alpacaAPI = createAlpacaTradingAPI(credentials); // type AlpacaCredentials
-//     // Set up trade update callback
-//     alpacaAPI.onTradeUpdate((update: TradeUpdate) => {
-//       log(`Received trade update: event ${update.event} for an order to ${update.order.side} ${update.order.qty} of ${update.order.symbol}`);
-//     });
-//     // Connect to WebSocket
-//     alpacaAPI.connectWebsocket(); // necessary to connect to the WebSocket
-//     // create an order
-//     const order = await alpacaAPI.createMarketOrder('AAPL', 1, 'buy', 'buy_to_open');
-//     // cancel the order
-//     await alpacaAPI.cancelAllOrders();
-//     // Keep the process running
-//     log('WebSocket connected and listening for trade updates...');
-//     log('Press Ctrl+C to exit');
-//     // Keep the process running
-//     await new Promise(() => {});
-//   } catch (error) {
-//     log(`Error in WebSocket test: ${error instanceof Error ? error.message : 'Unknown error'}`);
-//     process.exit(1);
-//   }
-// }
-// // Run the test
-// testAlpacaWebSocket();
-// Run the createEquitiesTrade test
-//testCreateEquitiesTrade();
-// testing retrieving pre-market data (just 9:00am to 9:30am on 1 july 2025 for SPY) using the market data api
-async function testPreMarketData() {
-    try {
-        log('Starting pre-market data test for SPY (9:00am-9:30am, July 1, 2025)...');
-        // Create market data API config (you would typically get these from environment variables)
-        const marketDataConfig = {
-            apiKey: 'your-api-key',
-            secretKey: 'your-secret-key',
-            accountType: 'PAPER'
-        };
-        const marketDataAPI = AlpacaMarketDataAPI.getInstance(marketDataConfig);
-        // Set up the time range in America/New_York, convert to UTC ISO strings
-        const symbol = 'SPY';
-        const nyTimeZone = 'America/New_York';
-        // 9:00am and 9:30am in NY time
-        const startNY = new Date('2025-07-01T09:00:00-04:00');
-        const endNY = new Date('2025-07-01T09:30:00-04:00');
-        const startUTC = startNY.toISOString();
-        const endUTC = endNY.toISOString();
-        const barsResponse = await marketDataAPI.getHistoricalBars({
-            symbols: [symbol],
-            timeframe: '1Min',
-            start: startUTC,
-            end: endUTC,
-            limit: 1000,
-        });
-        const bars = barsResponse.bars[symbol] || [];
-        log(`Fetched ${bars.length} 1-min bars for SPY from 9:00am to 9:30am (NY) on 2025-07-01.`);
-        if (bars.length === 0) {
-            log('No pre-market bars returned.');
-            return;
-        }
-        // Print each bar
-        bars.forEach((bar, i) => {
-            const barTime = new Date(bar.t).toLocaleString('en-US', { timeZone: nyTimeZone });
-            log(`Bar ${i + 1}: ${barTime} | O: ${formatCurrency(bar.o)} H: ${formatCurrency(bar.h)} L: ${formatCurrency(bar.l)} C: ${formatCurrency(bar.c)} V: ${formatNumber(bar.v)} VWAP: ${formatCurrency(bar.vw)} N: ${bar.n}`);
-        });
-        // Print summary
-        const summary = AlpacaMarketDataAPI.analyzeBars(bars);
-        if (summary)
-            log(`Summary: ${summary}`);
-        log('Pre-market data test complete.');
-    }
-    catch (error) {
-        log(`❌ Error in testPreMarketData: ${error instanceof Error ? error.message : error}`);
-    }
-}
-testPreMarketData();
+const marketDataAPI = AlpacaMarketDataAPI.getInstance();
+const response = await marketDataAPI.getHistoricalBars({
+    symbols: ['AAPL'],
+    timeframe: '1Min',
+    start: '2025-07-08T09:30:00-04:00',
+    end: '2025-07-08T10:30:00-04:00',
+});
+log(`Received ${response.bars.length} response: ${JSON.stringify(response.bars)}`);
 //# sourceMappingURL=test.js.map