@utilarium/dreadcabinet 0.0.16-dev.0

package/dist/dreadcabinet.cjs

@@ -0,0 +1,1793 @@
+'use strict';
+
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+const dayjs = require('dayjs');
+const timezone = require('dayjs/plugin/timezone.js');
+const utc = require('dayjs/plugin/utc.js');
+const fs = require('node:fs');
+const glob = require('glob');
+const path = require('node:path');
+const crypto = require('node:crypto');
+const zod = require('zod');
+
+function _interopNamespaceDefault(e) {
+    const n = Object.create(null, { [Symbol.toStringTag]: { value: 'Module' } });
+    if (e) {
+        for (const k in e) {
+            if (k !== 'default') {
+                const d = Object.getOwnPropertyDescriptor(e, k);
+                Object.defineProperty(n, k, d.get ? d : {
+                    enumerable: true,
+                    get: () => e[k]
+                });
+            }
+        }
+    }
+    n.default = e;
+    return Object.freeze(n);
+}
+
+const fs__namespace = /*#__PURE__*/_interopNamespaceDefault(fs);
+const path__namespace = /*#__PURE__*/_interopNamespaceDefault(path);
+const crypto__namespace = /*#__PURE__*/_interopNamespaceDefault(crypto);
+
+const PROGRAM_NAME = 'dreadcabinet';
+const DEFAULT_TIMEZONE = 'Etc/UTC';
+const DATE_FORMAT_MONTH_DAY = 'M-D';
+const DATE_FORMAT_YEAR = 'YYYY';
+const DATE_FORMAT_YEAR_MONTH_DAY = 'YYYY-M-D';
+const DATE_FORMAT_MONTH = 'M';
+const DATE_FORMAT_DAY = 'D';
+const DEFAULT_RECURSIVE = false;
+const DEFAULT_INPUT_DIRECTORY = './';
+const DEFAULT_OUTPUT_DIRECTORY = './';
+const DEFAULT_CONCURRENCY = 1;
+const DEFAULT_OUTPUT_STRUCTURE = 'month';
+const DEFAULT_OUTPUT_FILENAME_OPTIONS = [
+    'date',
+    'subject'
+];
+const DEFAULT_INPUT_STRUCTURE = 'month';
+const DEFAULT_INPUT_FILENAME_OPTIONS = [
+    'date',
+    'subject'
+];
+const DEFAULT_EXTENSIONS = [
+    'md'
+];
+const ALLOWED_INPUT_STRUCTURES = [
+    'none',
+    'year',
+    'month',
+    'day'
+];
+const ALLOWED_INPUT_FILENAME_OPTIONS = [
+    'date',
+    'time',
+    'subject'
+];
+const ALLOWED_OUTPUT_STRUCTURES = [
+    'none',
+    'year',
+    'month',
+    'day'
+];
+const ALLOWED_OUTPUT_FILENAME_OPTIONS = [
+    'date',
+    'time',
+    'subject'
+];
+const ALLOWED_EXTENSIONS = [
+    'md',
+    'txt'
+];
+
+function _define_property(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    } else {
+        obj[key] = value;
+    }
+    return obj;
+}
+class ArgumentError extends Error {
+    get argument() {
+        return this.argumentName;
+    }
+    constructor(argumentName, message){
+        super(`${message}`), _define_property(this, "argumentName", void 0);
+        this.name = 'ArgumentError';
+        this.argumentName = argumentName;
+    }
+}
+
+const addOption = (command, option, description, addDefaults, defaultValue)=>{
+    if (addDefaults) {
+        command.option(option, description, defaultValue);
+    } else {
+        const defaultDesc = defaultValue === undefined ? 'undefined' : Array.isArray(defaultValue) ? defaultValue.join(',') : defaultValue;
+        const descriptionWithDefaults = `${description} (default: ${defaultDesc})`;
+        command.option(option, descriptionWithDefaults);
+    }
+};
+const configure = async (command, defaults, addDefaults, features)=>{
+    const tzDefault = (defaults === null || defaults === void 0 ? void 0 : defaults.timezone) || DEFAULT_TIMEZONE;
+    if (addDefaults) {
+        command.option('--timezone <timezone>', 'timezone for date calculations', tzDefault);
+    } else {
+        command.option('--timezone <timezone>', `timezone for date calculations (default: ${tzDefault})`);
+    }
+    if (features.includes('input')) {
+        addOption(command, '-r, --recursive', 'recursive mode, process all files in the input directory', addDefaults, (defaults === null || defaults === void 0 ? void 0 : defaults.recursive) !== undefined ? defaults.recursive : DEFAULT_RECURSIVE);
+        addOption(command, '-i, --input-directory <inputDirectory>', 'input directory', addDefaults, (defaults === null || defaults === void 0 ? void 0 : defaults.inputDirectory) || DEFAULT_INPUT_DIRECTORY);
+        addOption(command, '--limit <limit>', 'limit the number of files to process', addDefaults, (defaults === null || defaults === void 0 ? void 0 : defaults.limit) ? defaults === null || defaults === void 0 ? void 0 : defaults.limit.toString() : undefined);
+        addOption(command, '--concurrency <concurrency>', 'concurrency level for processing files', addDefaults, (defaults === null || defaults === void 0 ? void 0 : defaults.concurrency) ? defaults === null || defaults === void 0 ? void 0 : defaults.concurrency.toString() : undefined);
+    }
+    if (features.includes('output')) {
+        addOption(command, '-o, --output-directory <outputDirectory>', 'output directory', addDefaults, (defaults === null || defaults === void 0 ? void 0 : defaults.outputDirectory) || DEFAULT_OUTPUT_DIRECTORY);
+    }
+    if (features.includes('structured-output')) {
+        addOption(command, '--output-structure <type>', 'output directory structure (none/year/month/day)', addDefaults, (defaults === null || defaults === void 0 ? void 0 : defaults.outputStructure) || DEFAULT_OUTPUT_STRUCTURE);
+        addOption(command, '--output-filename-options [outputFilenameOptions...]', 'filename format options (space-separated list of: date,time,subject) example \'date subject\'', addDefaults, (defaults === null || defaults === void 0 ? void 0 : defaults.outputFilenameOptions) || DEFAULT_OUTPUT_FILENAME_OPTIONS);
+    }
+    if (features.includes('extensions')) {
+        addOption(command, '--extensions [extensions...]', 'file extensions to process (space-separated list of: mp3,mp4,mpeg,mpga,m4a,wav,webm)', addDefaults, (defaults === null || defaults === void 0 ? void 0 : defaults.extensions) || DEFAULT_EXTENSIONS);
+    }
+    if (features.includes('structured-input')) {
+        addOption(command, '--input-structure <type>', 'input directory structure (none/year/month/day)', addDefaults, (defaults === null || defaults === void 0 ? void 0 : defaults.inputStructure) || DEFAULT_INPUT_STRUCTURE);
+        addOption(command, '--input-filename-options [options...]', 'filename format options (space-separated list of: date,time,subject)', addDefaults, (defaults === null || defaults === void 0 ? void 0 : defaults.inputFilenameOptions) || DEFAULT_INPUT_FILENAME_OPTIONS);
+        addOption(command, '--start <date>', `start date filter (${DATE_FORMAT_YEAR_MONTH_DAY})`, addDefaults, undefined);
+        addOption(command, '--end <date>', `end date filter (${DATE_FORMAT_YEAR_MONTH_DAY}), defaults to today`, addDefaults, undefined);
+    }
+};
+
+const applyDefaults = (config, features, defaults)=>{
+    const configWithDefaults = {
+        ...config
+    };
+    configWithDefaults.timezone = config.timezone || (defaults === null || defaults === void 0 ? void 0 : defaults.timezone) || DEFAULT_TIMEZONE;
+    if (features.includes('input')) {
+        var _ref;
+        configWithDefaults.recursive = config.recursive === undefined ? (_ref = defaults === null || defaults === void 0 ? void 0 : defaults.recursive) !== null && _ref !== void 0 ? _ref : DEFAULT_RECURSIVE : config.recursive;
+        configWithDefaults.inputDirectory = config.inputDirectory || (defaults === null || defaults === void 0 ? void 0 : defaults.inputDirectory) || DEFAULT_INPUT_DIRECTORY;
+        configWithDefaults.concurrency = config.concurrency || (defaults === null || defaults === void 0 ? void 0 : defaults.concurrency) || DEFAULT_CONCURRENCY;
+    }
+    if (features.includes('output')) {
+        configWithDefaults.outputDirectory = config.outputDirectory || (defaults === null || defaults === void 0 ? void 0 : defaults.outputDirectory) || DEFAULT_OUTPUT_DIRECTORY;
+    }
+    if (features.includes('structured-output')) {
+        configWithDefaults.outputStructure = config.outputStructure || (defaults === null || defaults === void 0 ? void 0 : defaults.outputStructure) || DEFAULT_OUTPUT_STRUCTURE;
+        configWithDefaults.outputFilenameOptions = config.outputFilenameOptions || (defaults === null || defaults === void 0 ? void 0 : defaults.outputFilenameOptions) || DEFAULT_OUTPUT_FILENAME_OPTIONS;
+    }
+    if (features.includes('extensions')) {
+        configWithDefaults.extensions = config.extensions || (defaults === null || defaults === void 0 ? void 0 : defaults.extensions) || DEFAULT_EXTENSIONS;
+    }
+    if (features.includes('structured-input')) {
+        configWithDefaults.inputStructure = config.inputStructure || (defaults === null || defaults === void 0 ? void 0 : defaults.inputStructure) || DEFAULT_INPUT_STRUCTURE;
+        configWithDefaults.inputFilenameOptions = config.inputFilenameOptions || (defaults === null || defaults === void 0 ? void 0 : defaults.inputFilenameOptions) || DEFAULT_INPUT_FILENAME_OPTIONS;
+    }
+    return configWithDefaults;
+};
+
+function clean(obj) {
+    return Object.fromEntries(Object.entries(obj).filter(([_, v])=>v !== undefined));
+}
+const read = async (args, features)=>{
+    const config = {};
+    config.timezone = args.timezone;
+    if (features.includes('input')) {
+        config.inputDirectory = args.inputDirectory;
+        config.limit = args.limit;
+    }
+    if (features.includes('structured-input')) {
+        config.inputStructure = args.inputStructure;
+        config.inputFilenameOptions = args.inputFilenameOptions;
+    }
+    if (features.includes('output')) {
+        config.outputDirectory = args.outputDirectory;
+    }
+    if (features.includes('structured-output')) {
+        config.outputStructure = args.outputStructure;
+        config.outputFilenameOptions = args.outputFilenameOptions;
+    }
+    if (features.includes('extensions')) {
+        config.extensions = args.extensions;
+    }
+    // Returning a clean object to avoid undefined values
+    return clean(config);
+};
+
+// eslint-disable-next-line no-restricted-imports
+dayjs.extend(utc);
+dayjs.extend(timezone);
+// Static list of IANA timezone names (replaces moment-timezone dependency)
+const TIMEZONE_NAMES = [
+    'Africa/Abidjan',
+    'Africa/Accra',
+    'Africa/Addis_Ababa',
+    'Africa/Algiers',
+    'Africa/Asmara',
+    'Africa/Asmera',
+    'Africa/Bamako',
+    'Africa/Bangui',
+    'Africa/Banjul',
+    'Africa/Bissau',
+    'Africa/Blantyre',
+    'Africa/Brazzaville',
+    'Africa/Bujumbura',
+    'Africa/Cairo',
+    'Africa/Casablanca',
+    'Africa/Ceuta',
+    'Africa/Conakry',
+    'Africa/Dakar',
+    'Africa/Dar_es_Salaam',
+    'Africa/Djibouti',
+    'Africa/Douala',
+    'Africa/El_Aaiun',
+    'Africa/Freetown',
+    'Africa/Gaborone',
+    'Africa/Harare',
+    'Africa/Johannesburg',
+    'Africa/Juba',
+    'Africa/Kampala',
+    'Africa/Khartoum',
+    'Africa/Kigali',
+    'Africa/Kinshasa',
+    'Africa/Lagos',
+    'Africa/Libreville',
+    'Africa/Lome',
+    'Africa/Luanda',
+    'Africa/Lubumbashi',
+    'Africa/Lusaka',
+    'Africa/Malabo',
+    'Africa/Maputo',
+    'Africa/Maseru',
+    'Africa/Mbabane',
+    'Africa/Mogadishu',
+    'Africa/Monrovia',
+    'Africa/Nairobi',
+    'Africa/Ndjamena',
+    'Africa/Niamey',
+    'Africa/Nouakchott',
+    'Africa/Ouagadougou',
+    'Africa/Porto-Novo',
+    'Africa/Sao_Tome',
+    'Africa/Timbuktu',
+    'Africa/Tripoli',
+    'Africa/Tunis',
+    'Africa/Windhoek',
+    'America/Adak',
+    'America/Anchorage',
+    'America/Anguilla',
+    'America/Antigua',
+    'America/Araguaina',
+    'America/Argentina/Buenos_Aires',
+    'America/Argentina/Catamarca',
+    'America/Argentina/ComodRivadavia',
+    'America/Argentina/Cordoba',
+    'America/Argentina/Jujuy',
+    'America/Argentina/La_Rioja',
+    'America/Argentina/Mendoza',
+    'America/Argentina/Rio_Gallegos',
+    'America/Argentina/Salta',
+    'America/Argentina/San_Juan',
+    'America/Argentina/San_Luis',
+    'America/Argentina/Tucuman',
+    'America/Argentina/Ushuaia',
+    'America/Aruba',
+    'America/Asuncion',
+    'America/Atikokan',
+    'America/Atka',
+    'America/Bahia',
+    'America/Bahia_Banderas',
+    'America/Barbados',
+    'America/Belem',
+    'America/Belize',
+    'America/Blanc-Sablon',
+    'America/Boa_Vista',
+    'America/Bogota',
+    'America/Boise',
+    'America/Buenos_Aires',
+    'America/Cambridge_Bay',
+    'America/Campo_Grande',
+    'America/Cancun',
+    'America/Caracas',
+    'America/Catamarca',
+    'America/Cayenne',
+    'America/Cayman',
+    'America/Chicago',
+    'America/Chihuahua',
+    'America/Coral_Harbour',
+    'America/Cordoba',
+    'America/Costa_Rica',
+    'America/Creston',
+    'America/Cuiaba',
+    'America/Curacao',
+    'America/Danmarkshavn',
+    'America/Dawson',
+    'America/Dawson_Creek',
+    'America/Denver',
+    'America/Detroit',
+    'America/Dominica',
+    'America/Edmonton',
+    'America/Eirunepe',
+    'America/El_Salvador',
+    'America/Ensenada',
+    'America/Fort_Nelson',
+    'America/Fort_Wayne',
+    'America/Fortaleza',
+    'America/Glace_Bay',
+    'America/Godthab',
+    'America/Goose_Bay',
+    'America/Grand_Turk',
+    'America/Grenada',
+    'America/Guadeloupe',
+    'America/Guatemala',
+    'America/Guayaquil',
+    'America/Guyana',
+    'America/Halifax',
+    'America/Havana',
+    'America/Hermosillo',
+    'America/Indiana/Indianapolis',
+    'America/Indiana/Knox',
+    'America/Indiana/Marengo',
+    'America/Indiana/Petersburg',
+    'America/Indiana/Tell_City',
+    'America/Indiana/Vevay',
+    'America/Indiana/Vincennes',
+    'America/Indiana/Winamac',
+    'America/Indianapolis',
+    'America/Inuvik',
+    'America/Iqaluit',
+    'America/Jamaica',
+    'America/Jujuy',
+    'America/Juneau',
+    'America/Kentucky/Louisville',
+    'America/Kentucky/Monticello',
+    'America/Knox_IN',
+    'America/Kralendijk',
+    'America/La_Paz',
+    'America/Lima',
+    'America/Los_Angeles',
+    'America/Louisville',
+    'America/Lower_Princes',
+    'America/Maceio',
+    'America/Managua',
+    'America/Manaus',
+    'America/Marigot',
+    'America/Martinique',
+    'America/Matamoros',
+    'America/Mazatlan',
+    'America/Mendoza',
+    'America/Menominee',
+    'America/Merida',
+    'America/Metlakatla',
+    'America/Mexico_City',
+    'America/Miquelon',
+    'America/Moncton',
+    'America/Monterrey',
+    'America/Montevideo',
+    'America/Montreal',
+    'America/Montserrat',
+    'America/Nassau',
+    'America/New_York',
+    'America/Nipigon',
+    'America/Nome',
+    'America/Noronha',
+    'America/North_Dakota/Beulah',
+    'America/North_Dakota/Center',
+    'America/North_Dakota/New_Salem',
+    'America/Ojinaga',
+    'America/Panama',
+    'America/Pangnirtung',
+    'America/Paramaribo',
+    'America/Phoenix',
+    'America/Port-au-Prince',
+    'America/Port_of_Spain',
+    'America/Porto_Acre',
+    'America/Porto_Velho',
+    'America/Puerto_Rico',
+    'America/Punta_Arenas',
+    'America/Rainy_River',
+    'America/Rankin_Inlet',
+    'America/Recife',
+    'America/Regina',
+    'America/Resolute',
+    'America/Rio_Branco',
+    'America/Rosario',
+    'America/Santa_Isabel',
+    'America/Santarem',
+    'America/Santiago',
+    'America/Santo_Domingo',
+    'America/Sao_Paulo',
+    'America/Scoresbysund',
+    'America/Shiprock',
+    'America/Sitka',
+    'America/St_Barthelemy',
+    'America/St_Johns',
+    'America/St_Kitts',
+    'America/St_Lucia',
+    'America/St_Thomas',
+    'America/St_Vincent',
+    'America/Swift_Current',
+    'America/Tegucigalpa',
+    'America/Thule',
+    'America/Thunder_Bay',
+    'America/Tijuana',
+    'America/Toronto',
+    'America/Tortola',
+    'America/Vancouver',
+    'America/Virgin',
+    'America/Whitehorse',
+    'America/Winnipeg',
+    'America/Yakutat',
+    'America/Yellowknife',
+    'Antarctica/Casey',
+    'Antarctica/Davis',
+    'Antarctica/DumontDUrville',
+    'Antarctica/Macquarie',
+    'Antarctica/Mawson',
+    'Antarctica/McMurdo',
+    'Antarctica/Palmer',
+    'Antarctica/Rothera',
+    'Antarctica/South_Pole',
+    'Antarctica/Syowa',
+    'Antarctica/Troll',
+    'Antarctica/Vostok',
+    'Arctic/Longyearbyen',
+    'Asia/Aden',
+    'Asia/Almaty',
+    'Asia/Amman',
+    'Asia/Anadyr',
+    'Asia/Aqtau',
+    'Asia/Aqtobe',
+    'Asia/Ashgabat',
+    'Asia/Ashkhabad',
+    'Asia/Atyrau',
+    'Asia/Baghdad',
+    'Asia/Bahrain',
+    'Asia/Baku',
+    'Asia/Bangkok',
+    'Asia/Barnaul',
+    'Asia/Beirut',
+    'Asia/Bishkek',
+    'Asia/Brunei',
+    'Asia/Calcutta',
+    'Asia/Chita',
+    'Asia/Choibalsan',
+    'Asia/Chongqing',
+    'Asia/Chungking',
+    'Asia/Colombo',
+    'Asia/Dacca',
+    'Asia/Damascus',
+    'Asia/Dhaka',
+    'Asia/Dili',
+    'Asia/Dubai',
+    'Asia/Dushanbe',
+    'Asia/Famagusta',
+    'Asia/Gaza',
+    'Asia/Harbin',
+    'Asia/Hebron',
+    'Asia/Ho_Chi_Minh',
+    'Asia/Hong_Kong',
+    'Asia/Hovd',
+    'Asia/Irkutsk',
+    'Asia/Istanbul',
+    'Asia/Jakarta',
+    'Asia/Jayapura',
+    'Asia/Jerusalem',
+    'Asia/Kabul',
+    'Asia/Kamchatka',
+    'Asia/Karachi',
+    'Asia/Kashgar',
+    'Asia/Kathmandu',
+    'Asia/Katmandu',
+    'Asia/Khandyga',
+    'Asia/Kolkata',
+    'Asia/Krasnoyarsk',
+    'Asia/Kuala_Lumpur',
+    'Asia/Kuching',
+    'Asia/Kuwait',
+    'Asia/Macao',
+    'Asia/Macau',
+    'Asia/Magadan',
+    'Asia/Makassar',
+    'Asia/Manila',
+    'Asia/Muscat',
+    'Asia/Nicosia',
+    'Asia/Novokuznetsk',
+    'Asia/Novosibirsk',
+    'Asia/Omsk',
+    'Asia/Oral',
+    'Asia/Phnom_Penh',
+    'Asia/Pontianak',
+    'Asia/Pyongyang',
+    'Asia/Qatar',
+    'Asia/Qyzylorda',
+    'Asia/Rangoon',
+    'Asia/Riyadh',
+    'Asia/Saigon',
+    'Asia/Sakhalin',
+    'Asia/Samarkand',
+    'Asia/Seoul',
+    'Asia/Shanghai',
+    'Asia/Singapore',
+    'Asia/Srednekolymsk',
+    'Asia/Taipei',
+    'Asia/Tashkent',
+    'Asia/Tbilisi',
+    'Asia/Tehran',
+    'Asia/Tel_Aviv',
+    'Asia/Thimbu',
+    'Asia/Thimphu',
+    'Asia/Tokyo',
+    'Asia/Tomsk',
+    'Asia/Ujung_Pandang',
+    'Asia/Ulaanbaatar',
+    'Asia/Ulan_Bator',
+    'Asia/Urumqi',
+    'Asia/Ust-Nera',
+    'Asia/Vientiane',
+    'Asia/Vladivostok',
+    'Asia/Yakutsk',
+    'Asia/Yangon',
+    'Asia/Yekaterinburg',
+    'Asia/Yerevan',
+    'Atlantic/Azores',
+    'Atlantic/Bermuda',
+    'Atlantic/Canary',
+    'Atlantic/Cape_Verde',
+    'Atlantic/Faeroe',
+    'Atlantic/Faroe',
+    'Atlantic/Jan_Mayen',
+    'Atlantic/Madeira',
+    'Atlantic/Reykjavik',
+    'Atlantic/South_Georgia',
+    'Atlantic/St_Helena',
+    'Atlantic/Stanley',
+    'Australia/ACT',
+    'Australia/Adelaide',
+    'Australia/Brisbane',
+    'Australia/Broken_Hill',
+    'Australia/Canberra',
+    'Australia/Currie',
+    'Australia/Darwin',
+    'Australia/Eucla',
+    'Australia/Hobart',
+    'Australia/LHI',
+    'Australia/Lindeman',
+    'Australia/Lord_Howe',
+    'Australia/Melbourne',
+    'Australia/NSW',
+    'Australia/North',
+    'Australia/Perth',
+    'Australia/Queensland',
+    'Australia/South',
+    'Australia/Sydney',
+    'Australia/Tasmania',
+    'Australia/Victoria',
+    'Australia/West',
+    'Australia/Yancowinna',
+    'Brazil/Acre',
+    'Brazil/DeNoronha',
+    'Brazil/East',
+    'Brazil/West',
+    'CET',
+    'CST6CDT',
+    'Canada/Atlantic',
+    'Canada/Central',
+    'Canada/Eastern',
+    'Canada/Mountain',
+    'Canada/Newfoundland',
+    'Canada/Pacific',
+    'Canada/Saskatchewan',
+    'Canada/Yukon',
+    'Chile/Continental',
+    'Chile/EasterIsland',
+    'Cuba',
+    'EET',
+    'EST',
+    'EST5EDT',
+    'Egypt',
+    'Eire',
+    'Etc/GMT',
+    'Etc/GMT+0',
+    'Etc/GMT+1',
+    'Etc/GMT+10',
+    'Etc/GMT+11',
+    'Etc/GMT+12',
+    'Etc/GMT+2',
+    'Etc/GMT+3',
+    'Etc/GMT+4',
+    'Etc/GMT+5',
+    'Etc/GMT+6',
+    'Etc/GMT+7',
+    'Etc/GMT+8',
+    'Etc/GMT+9',
+    'Etc/GMT-0',
+    'Etc/GMT-1',
+    'Etc/GMT-10',
+    'Etc/GMT-11',
+    'Etc/GMT-12',
+    'Etc/GMT-13',
+    'Etc/GMT-14',
+    'Etc/GMT-2',
+    'Etc/GMT-3',
+    'Etc/GMT-4',
+    'Etc/GMT-5',
+    'Etc/GMT-6',
+    'Etc/GMT-7',
+    'Etc/GMT-8',
+    'Etc/GMT-9',
+    'Etc/GMT0',
+    'Etc/Greenwich',
+    'Etc/UCT',
+    'Etc/UTC',
+    'Etc/Universal',
+    'Etc/Zulu',
+    'Europe/Amsterdam',
+    'Europe/Andorra',
+    'Europe/Astrakhan',
+    'Europe/Athens',
+    'Europe/Belfast',
+    'Europe/Belgrade',
+    'Europe/Berlin',
+    'Europe/Bratislava',
+    'Europe/Brussels',
+    'Europe/Bucharest',
+    'Europe/Budapest',
+    'Europe/Busingen',
+    'Europe/Chisinau',
+    'Europe/Copenhagen',
+    'Europe/Dublin',
+    'Europe/Gibraltar',
+    'Europe/Guernsey',
+    'Europe/Helsinki',
+    'Europe/Isle_of_Man',
+    'Europe/Istanbul',
+    'Europe/Jersey',
+    'Europe/Kaliningrad',
+    'Europe/Kiev',
+    'Europe/Kirov',
+    'Europe/Lisbon',
+    'Europe/Ljubljana',
+    'Europe/London',
+    'Europe/Luxembourg',
+    'Europe/Madrid',
+    'Europe/Malta',
+    'Europe/Mariehamn',
+    'Europe/Minsk',
+    'Europe/Monaco',
+    'Europe/Moscow',
+    'Europe/Nicosia',
+    'Europe/Oslo',
+    'Europe/Paris',
+    'Europe/Podgorica',
+    'Europe/Prague',
+    'Europe/Riga',
+    'Europe/Rome',
+    'Europe/Samara',
+    'Europe/San_Marino',
+    'Europe/Sarajevo',
+    'Europe/Saratov',
+    'Europe/Simferopol',
+    'Europe/Skopje',
+    'Europe/Sofia',
+    'Europe/Stockholm',
+    'Europe/Tallinn',
+    'Europe/Tirane',
+    'Europe/Tiraspol',
+    'Europe/Ulyanovsk',
+    'Europe/Uzhgorod',
+    'Europe/Vaduz',
+    'Europe/Vatican',
+    'Europe/Vienna',
+    'Europe/Vilnius',
+    'Europe/Volgograd',
+    'Europe/Warsaw',
+    'Europe/Zagreb',
+    'Europe/Zaporozhye',
+    'Europe/Zurich',
+    'GB',
+    'GB-Eire',
+    'GMT',
+    'GMT+0',
+    'GMT-0',
+    'GMT0',
+    'Greenwich',
+    'HST',
+    'Hongkong',
+    'Iceland',
+    'Indian/Antananarivo',
+    'Indian/Chagos',
+    'Indian/Christmas',
+    'Indian/Cocos',
+    'Indian/Comoro',
+    'Indian/Kerguelen',
+    'Indian/Mahe',
+    'Indian/Maldives',
+    'Indian/Mauritius',
+    'Indian/Mayotte',
+    'Indian/Reunion',
+    'Iran',
+    'Israel',
+    'Jamaica',
+    'Japan',
+    'Kwajalein',
+    'Libya',
+    'MET',
+    'MST',
+    'MST7MDT',
+    'Mexico/BajaNorte',
+    'Mexico/BajaSur',
+    'Mexico/General',
+    'NZ',
+    'NZ-CHAT',
+    'Navajo',
+    'PRC',
+    'PST8PDT',
+    'Pacific/Apia',
+    'Pacific/Auckland',
+    'Pacific/Bougainville',
+    'Pacific/Chatham',
+    'Pacific/Chuuk',
+    'Pacific/Easter',
+    'Pacific/Efate',
+    'Pacific/Enderbury',
+    'Pacific/Fakaofo',
+    'Pacific/Fiji',
+    'Pacific/Funafuti',
+    'Pacific/Galapagos',
+    'Pacific/Gambier',
+    'Pacific/Guadalcanal',
+    'Pacific/Guam',
+    'Pacific/Honolulu',
+    'Pacific/Johnston',
+    'Pacific/Kiritimati',
+    'Pacific/Kosrae',
+    'Pacific/Kwajalein',
+    'Pacific/Majuro',
+    'Pacific/Marquesas',
+    'Pacific/Midway',
+    'Pacific/Nauru',
+    'Pacific/Niue',
+    'Pacific/Norfolk',
+    'Pacific/Noumea',
+    'Pacific/Pago_Pago',
+    'Pacific/Palau',
+    'Pacific/Pitcairn',
+    'Pacific/Pohnpei',
+    'Pacific/Ponape',
+    'Pacific/Port_Moresby',
+    'Pacific/Rarotonga',
+    'Pacific/Saipan',
+    'Pacific/Samoa',
+    'Pacific/Tahiti',
+    'Pacific/Tarawa',
+    'Pacific/Tongatapu',
+    'Pacific/Truk',
+    'Pacific/Wake',
+    'Pacific/Wallis',
+    'Pacific/Yap',
+    'Poland',
+    'Portugal',
+    'ROC',
+    'ROK',
+    'Singapore',
+    'Turkey',
+    'UCT',
+    'US/Alaska',
+    'US/Aleutian',
+    'US/Arizona',
+    'US/Central',
+    'US/East-Indiana',
+    'US/Eastern',
+    'US/Hawaii',
+    'US/Indiana-Starke',
+    'US/Michigan',
+    'US/Mountain',
+    'US/Pacific',
+    'US/Pacific-New',
+    'US/Samoa',
+    'UTC',
+    'Universal',
+    'W-SU',
+    'WET',
+    'Zulu'
+];
+const create$5 = (parameters)=>{
+    const { timezone } = parameters;
+    const now = ()=>{
+        return dayjs().tz(timezone).toDate();
+    };
+    const today = ()=>{
+        // Return today's date formatted as YYYY-M-D in the specified timezone
+        return dayjs().tz(timezone).format('YYYY-M-D');
+    };
+    const date = (date)=>{
+        let value;
+        if (date) {
+            value = dayjs.tz(date, timezone);
+        } else {
+            value = dayjs().tz(timezone);
+        }
+        if (!value.isValid()) {
+            throw new Error(`Invalid date: ${date}`);
+        }
+        return value.toDate();
+    };
+    const parse = (date, format)=>{
+        const value = dayjs.tz(date, format, timezone);
+        if (!value.isValid()) {
+            throw new Error(`Invalid date: ${date}, expected format: ${format}`);
+        }
+        return value.toDate();
+    };
+    const isValidDate = (date, format)=>{
+        return dayjs(date, format, true).isValid(); // Use strict parsing
+    };
+    const addDays = (date, days)=>{
+        return dayjs.tz(date, timezone).add(days, 'day').toDate();
+    };
+    const addMonths = (date, months)=>{
+        return dayjs.tz(date, timezone).add(months, 'month').toDate();
+    };
+    const addYears = (date, years)=>{
+        return dayjs.tz(date, timezone).add(years, 'year').toDate();
+    };
+    const format = (date, format)=>{
+        return dayjs.tz(date, timezone).format(format);
+    };
+    const subDays = (date, days)=>{
+        return dayjs.tz(date, timezone).subtract(days, 'day').toDate();
+    };
+    const subMonths = (date, months)=>{
+        return dayjs.tz(date, timezone).subtract(months, 'month').toDate();
+    };
+    const subYears = (date, years)=>{
+        return dayjs.tz(date, timezone).subtract(years, 'year').toDate();
+    };
+    const startOfMonth = (date)=>{
+        return dayjs.tz(date, timezone).startOf('month').toDate();
+    };
+    const endOfMonth = (date)=>{
+        return dayjs.tz(date, timezone).endOf('month').toDate();
+    };
+    const startOfYear = (date)=>{
+        return dayjs.tz(date, timezone).startOf('year').toDate();
+    };
+    const endOfYear = (date)=>{
+        return dayjs.tz(date, timezone).endOf('year').toDate();
+    };
+    const isBefore = (date, other)=>{
+        return dayjs.tz(date, timezone).isBefore(dayjs.tz(other, timezone));
+    };
+    const isAfter = (date, other)=>{
+        return dayjs.tz(date, timezone).isAfter(dayjs.tz(other, timezone));
+    };
+    return {
+        now,
+        today,
+        date,
+        parse,
+        isValidDate,
+        addDays,
+        addMonths,
+        addYears,
+        format,
+        subDays,
+        subMonths,
+        subYears,
+        startOfMonth,
+        endOfMonth,
+        startOfYear,
+        endOfYear,
+        isBefore,
+        isAfter
+    };
+};
+const validTimezones = ()=>{
+    return TIMEZONE_NAMES;
+};
+
+const create$4 = (params)=>{
+    // eslint-disable-next-line no-console
+    const log = params.log || console.log;
+    const exists = async (path)=>{
+        try {
+            await fs__namespace.promises.stat(path);
+            return true;
+        // eslint-disable-next-line @typescript-eslint/no-unused-vars
+        } catch (error) {
+            return false;
+        }
+    };
+    const isDirectory = async (path)=>{
+        const stats = await fs__namespace.promises.stat(path);
+        if (!stats.isDirectory()) {
+            log(`${path} is not a directory`);
+            return false;
+        }
+        return true;
+    };
+    const isFile = async (path)=>{
+        const stats = await fs__namespace.promises.stat(path);
+        if (!stats.isFile()) {
+            log(`${path} is not a file`);
+            return false;
+        }
+        return true;
+    };
+    const isReadable = async (path)=>{
+        try {
+            await fs__namespace.promises.access(path, fs__namespace.constants.R_OK);
+        } catch (error) {
+            log(`${path} is not readable: %s %s`, error.message, error.stack);
+            return false;
+        }
+        return true;
+    };
+    const isWritable = async (path)=>{
+        try {
+            await fs__namespace.promises.access(path, fs__namespace.constants.W_OK);
+        } catch (error) {
+            log(`${path} is not writable: %s %s`, error.message, error.stack);
+            return false;
+        }
+        return true;
+    };
+    const isFileReadable = async (path)=>{
+        return await exists(path) && await isFile(path) && await isReadable(path);
+    };
+    const isDirectoryWritable = async (path)=>{
+        return await exists(path) && await isDirectory(path) && await isWritable(path);
+    };
+    const isDirectoryReadable = async (path)=>{
+        return await exists(path) && await isDirectory(path) && await isReadable(path);
+    };
+    const createDirectory = async (path)=>{
+        try {
+            await fs__namespace.promises.mkdir(path, {
+                recursive: true
+            });
+        } catch (mkdirError) {
+            throw new Error(`Failed to create output directory ${path}: ${mkdirError.message} ${mkdirError.stack}`);
+        }
+    };
+    const readFile = async (path, encoding)=>{
+        return await fs__namespace.promises.readFile(path, {
+            encoding: encoding
+        });
+    };
+    const writeFile = async (path, data, encoding)=>{
+        await fs__namespace.promises.writeFile(path, data, {
+            encoding: encoding
+        });
+    };
+    const forEachFileIn = async (directory, callback, options = {
+        pattern: '*.*'
+    })=>{
+        try {
+            let filesProcessed = 0;
+            const files = await glob.glob(options.pattern, {
+                cwd: directory,
+                nodir: true
+            });
+            const concurrency = options.concurrency || 1;
+            let index = 0;
+            async function worker() {
+                while(index < files.length && (!options.limit || filesProcessed < options.limit)){
+                    const i = index++;
+                    if (options.limit && filesProcessed >= options.limit) break;
+                    await callback(path__namespace.join(directory, files[i]));
+                    filesProcessed++;
+                }
+            }
+            const workers = Array.from({
+                length: concurrency
+            }, ()=>worker());
+            await Promise.all(workers);
+            if (options.limit && filesProcessed >= options.limit) {
+                log(`Reached limit of ${options.limit} files, stopping`);
+            }
+        } catch (err) {
+            throw new Error(`Failed to glob pattern ${options.pattern} in ${directory}: ${err.message}`);
+        }
+    };
+    const readStream = async (path)=>{
+        return fs__namespace.createReadStream(path);
+    };
+    const hashFile = async (path, length)=>{
+        const file = await readFile(path, 'utf8');
+        return crypto__namespace.createHash('sha256').update(file).digest('hex').slice(0, length);
+    };
+    const listFiles = async (directory)=>{
+        return await fs__namespace.promises.readdir(directory);
+    };
+    return {
+        exists,
+        isDirectory,
+        isFile,
+        isReadable,
+        isWritable,
+        isFileReadable,
+        isDirectoryWritable,
+        isDirectoryReadable,
+        createDirectory,
+        readFile,
+        readStream,
+        writeFile,
+        forEachFileIn,
+        hashFile,
+        listFiles
+    };
+};
+
+const validate = async (config, options)=>{
+    const logger = console;
+    const storage = create$4({
+        log: logger.debug
+    });
+    const validateInputDirectory = async (inputDirectory)=>{
+        // eslint-disable-next-line no-console
+        const storage = create$4({
+            log: console.log
+        });
+        if (!storage.isDirectoryReadable(inputDirectory)) {
+            throw new Error(`Input directory does not exist: ${inputDirectory}`);
+        }
+    };
+    const validateOutputDirectory = async (outputDirectory)=>{
+        const isDirectoryWritable = await storage.isDirectoryWritable(outputDirectory);
+        if (!isDirectoryWritable) {
+            throw new Error(`Output directory does not exist: ${outputDirectory}`);
+        }
+    };
+    const validateOutputStructure = (outputStructure)=>{
+        var _options_allowed;
+        const validOptions = ((_options_allowed = options.allowed) === null || _options_allowed === void 0 ? void 0 : _options_allowed.outputStructures) || ALLOWED_OUTPUT_STRUCTURES;
+        if (outputStructure && !validOptions.includes(outputStructure)) {
+            throw new ArgumentError('--output-structure', `Invalid output structure: ${outputStructure}. Valid options are: ${validOptions.join(', ')}`);
+        }
+    };
+    const validateOutputFilenameOptions = (outputFilenameOptions, outputStructure)=>{
+        if (outputFilenameOptions) {
+            var _options_allowed;
+            // Check if first argument contains commas - likely a comma-separated list
+            if (outputFilenameOptions[0].includes(',')) {
+                throw new ArgumentError('--output-filename-options', 'Filename options should be space-separated, not comma-separated. Example: --output-filename-options date time subject');
+            }
+            // Check if first argument looks like a quoted string containing multiple options
+            if (outputFilenameOptions.length === 1 && outputFilenameOptions[0].split(' ').length > 1) {
+                throw new ArgumentError('--output-filename-options', 'Filename options should not be quoted. Use: --output-filename-options date time subject instead of --output-filename-options "date time subject"');
+            }
+            const validOptions = ((_options_allowed = options.allowed) === null || _options_allowed === void 0 ? void 0 : _options_allowed.outputFilenameOptions) || ALLOWED_OUTPUT_FILENAME_OPTIONS;
+            const invalidOptions = outputFilenameOptions.filter((opt)=>!validOptions.includes(opt));
+            if (invalidOptions.length > 0) {
+                throw new ArgumentError('--output-filename-options', `Invalid filename options: ${invalidOptions.join(', ')}. Valid options are: ${validOptions.join(', ')}`);
+            }
+            // Validate date option against output structure
+            if (outputFilenameOptions.includes('date')) {
+                if (outputStructure && outputStructure === 'day') {
+                    throw new ArgumentError('--output-filename-options', 'Cannot use date in filename when output structure is "day"');
+                }
+            }
+        }
+    };
+    const validateInputStructure = (inputStructure)=>{
+        var _options_allowed;
+        const validOptions = ((_options_allowed = options.allowed) === null || _options_allowed === void 0 ? void 0 : _options_allowed.inputStructures) || ALLOWED_INPUT_STRUCTURES;
+        if (inputStructure && !validOptions.includes(inputStructure)) {
+            throw new ArgumentError('--input-structure', `Invalid input structure: ${inputStructure}. Valid options are: ${validOptions.join(', ')}`);
+        }
+    };
+    const validateInputFilenameOptions = (inputFilenameOptions, inputStructure)=>{
+        if (inputFilenameOptions) {
+            var _options_allowed;
+            // Check if first argument contains commas - likely a comma-separated list
+            if (inputFilenameOptions[0].includes(',')) {
+                throw new ArgumentError('--input-filename-options', 'Filename options should be space-separated, not comma-separated. Example: --input-filename-options date time subject');
+            }
+            // Check if first argument looks like a quoted string containing multiple options
+            if (inputFilenameOptions.length === 1 && inputFilenameOptions[0].split(' ').length > 1) {
+                throw new ArgumentError('--input-filename-options', 'Filename options should not be quoted. Use: --input-filename-options date time subject instead of --input-filename-options "date time subject"');
+            }
+            const validOptions = ((_options_allowed = options.allowed) === null || _options_allowed === void 0 ? void 0 : _options_allowed.inputFilenameOptions) || ALLOWED_INPUT_FILENAME_OPTIONS;
+            const invalidOptions = inputFilenameOptions.filter((opt)=>!validOptions.includes(opt));
+            if (invalidOptions.length > 0) {
+                throw new ArgumentError('--input-filename-options', `Invalid filename options: ${invalidOptions.join(', ')}. Valid options are: ${validOptions.join(', ')}`);
+            }
+            // Validate date option against input structure
+            if (inputFilenameOptions.includes('date')) {
+                if (inputStructure && inputStructure === 'day') {
+                    throw new ArgumentError('--input-filename-options', 'Cannot use date in filename when input structure is "day"');
+                }
+            }
+        }
+    };
+    const validateTimezone = (timezone)=>{
+        const validOptions = validTimezones();
+        if (validOptions.includes(timezone)) {
+            return;
+        }
+        throw new ArgumentError('--timezone', `Invalid timezone: ${timezone}. Valid options are: ${validOptions.join(', ')}`);
+    };
+    const validateExtensions = (extensions)=>{
+        var _options_allowed;
+        const validOptions = ((_options_allowed = options.allowed) === null || _options_allowed === void 0 ? void 0 : _options_allowed.extensions) || ALLOWED_EXTENSIONS;
+        if (extensions) {
+            const invalidOptions = extensions.filter((ext)=>!validOptions.includes(ext));
+            if (invalidOptions.length > 0) {
+                throw new ArgumentError('--extensions', `Invalid extensions: ${invalidOptions.join(', ')}. Valid options are: ${validOptions.join(', ')}`);
+            }
+        }
+    };
+    // Validate timezone
+    validateTimezone(config.timezone);
+    if (options.features.includes('input') && config.inputDirectory) {
+        await validateInputDirectory(config.inputDirectory);
+    }
+    if (options.features.includes('input') && config.limit) {
+        if (config.limit < 1) {
+            throw new ArgumentError('--limit', 'Limit must be greater than 0');
+        }
+    }
+    if (options.features.includes('output') && config.outputDirectory) {
+        await validateOutputDirectory(config.outputDirectory);
+    }
+    if (options.features.includes('structured-output')) {
+        // Validate filename options if provided
+        validateOutputStructure(config.outputStructure);
+        validateOutputFilenameOptions(config.outputFilenameOptions, config.outputStructure);
+    }
+    if (options.features.includes('extensions')) {
+        validateExtensions(config.extensions);
+    }
+    if (options.features.includes('structured-input')) {
+        validateInputStructure(config.inputStructure);
+        validateInputFilenameOptions(config.inputFilenameOptions, config.inputStructure);
+    }
+    return;
+};
+
+zod.z.object({
+    start: zod.z.date(),
+    end: zod.z.date()
+});
+// Get the appropriate file pattern based on config and options
+const getFilePattern = (features, extensions, logger)=>{
+    // Validate extensions: they should not start with a dot.
+    if (extensions && extensions.length > 0) {
+        for (const ext of extensions){
+            if (ext.startsWith('.')) {
+                // Throw an error as the dot is added automatically by the pattern generation.
+                // Using ArgumentError might be more consistent if available and appropriate here.
+                throw new Error(`Invalid extension format: "${ext}". Extensions should not start with a dot ('.').`);
+            }
+        }
+    }
+    let pattern = '**/*'; // Start with a broad pattern for recursive search
+    if (features.includes('extensions') && extensions && extensions.length > 0) {
+        if (extensions.length === 1) {
+            pattern = `**/*.${extensions[0]}`;
+        } else {
+            pattern = `**/*.{${extensions.join(',')}}`;
+        }
+        logger.debug(`Applying extension filter: ${extensions.join(',')}`);
+    } else {
+        pattern = `**/*.*`;
+        logger.debug(`No extension filter applied, using pattern: ${pattern}`);
+    }
+    return pattern;
+};
+// Helper function to parse date string based on expected format
+// Returns null if parsing fails
+const parseDateFromString = (dateStr, format, shouldParseTime, year, month, day)=>{
+    // Basic validation
+    if (!dateStr) return null;
+    try {
+        let y = year !== null && year !== void 0 ? year : 0;
+        let mo = month !== null && month !== void 0 ? month : 0; // JS months are 0-indexed
+        let d = day !== null && day !== void 0 ? day : 1; // JS days are 1-indexed
+        let h = 0; // Default to 0
+        let mi = 0; // Default to 0
+        // Remove potential leading/trailing non-alphanumeric if needed, split by common separators
+        const cleanedDateStr = dateStr.replace(/^[^\p{L}\p{N}]+|[^\p{L}\p{N}]+$/gu, '');
+        const parts = cleanedDateStr.split(/[-_]/); // Allow dash or underscore
+        switch(format){
+            case 'YYYY-M-D-HHmm':
+                {
+                    if (parts.length < 4 && shouldParseTime) return null; // Need time part if parsing it
+                    if (parts.length < 3 && !shouldParseTime) return null; // Need at least date part
+                    y = parseInt(parts[0], 10);
+                    mo = parseInt(parts[1], 10) - 1; // Adjust month
+                    d = parseInt(parts[2], 10);
+                    if (shouldParseTime) {
+                        const timePartYD = parts[3];
+                        if (timePartYD.length < 4) return null; // Ensure HHmm exists
+                        h = parseInt(timePartYD.substring(0, 2), 10);
+                        mi = parseInt(timePartYD.substring(2, 4), 10);
+                    }
+                    break;
+                }
+            case 'M-D-HHmm':
+                {
+                    if (year === undefined) return null;
+                    if (parts.length < 3 && shouldParseTime) return null;
+                    if (parts.length < 2 && !shouldParseTime) return null;
+                    mo = parseInt(parts[0], 10) - 1; // Adjust month
+                    d = parseInt(parts[1], 10);
+                    if (shouldParseTime) {
+                        const timePartMD = parts[2];
+                        if (timePartMD.length < 4) return null; // Ensure HHmm exists
+                        h = parseInt(timePartMD.substring(0, 2), 10);
+                        mi = parseInt(timePartMD.substring(2, 4), 10);
+                    }
+                    break;
+                }
+            case 'D-HHmm':
+                {
+                    if (year === undefined || month === undefined) return null;
+                    if (parts.length < 2 && shouldParseTime) return null;
+                    if (parts.length < 1 && !shouldParseTime) return null;
+                    d = parseInt(parts[0], 10);
+                    if (shouldParseTime) {
+                        const timePartD = parts[1];
+                        if (timePartD.length < 4) return null; // Ensure HHmm exists
+                        h = parseInt(timePartD.substring(0, 2), 10);
+                        mi = parseInt(timePartD.substring(2, 4), 10);
+                    }
+                    break;
+                }
+            case 'HHmm':
+                if (year === undefined || month === undefined || day === undefined) return null;
+                if (shouldParseTime) {
+                    if (parts[0].length !== 4) return null;
+                    h = parseInt(parts[0].substring(0, 2), 10);
+                    mi = parseInt(parts[0].substring(2, 4), 10);
+                } // Else h=0, mi=0 (set by defaults)
+                break;
+            default:
+                return null;
+        }
+        // Validate parsed numbers
+        if (isNaN(y) || isNaN(mo) || isNaN(d)) {
+            throw new Error(`Invalid date components in date string "${dateStr}" with format ${format}: Y:${y} M:${mo} D:${d}`);
+        }
+        // Set hour and minute to 0 if not provided
+        if (isNaN(h)) {
+            h = 0;
+        }
+        if (isNaN(mi)) {
+            mi = 0;
+        }
+        if (mo < 0 || mo > 11 || d < 1 || d > 31 || h < 0 || h > 23 || mi < 0 || mi > 59) {
+            throw new Error(`Invalid date components in date string "${dateStr}" with format ${format}: Y:${y} M:${mo + 1} D:${d} H:${h} m:${mi}`);
+        }
+        const date = new Date(Date.UTC(y, mo, d, h, mi));
+        // Double check components as Date object might adjust invalid dates (e.g. Feb 30th -> Mar 2nd)
+        if (date.getUTCFullYear() !== y || date.getUTCMonth() !== mo || date.getUTCDate() !== d || date.getUTCHours() !== h || date.getUTCMinutes() !== mi) {
+            // console.debug(`Date validation failed for Y:${y} M:${mo} D:${d} H:${h} m:${mi}. JS Date adjusted it.`);
+            return null;
+        }
+        return date;
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    } catch (e) {
+        // console.error(`Error parsing date string "${dateStr}" with format ${format}:`, e);
+        return null;
+    }
+};
+// Helper to check if date is within range (start inclusive, end exclusive)
+const isDateInRange = (date, range)=>{
+    if (!range || !range.start && !range.end) return true; // No range or empty range means all dates are valid
+    // Ensure range dates are Date objects
+    const startDate = range.start ? range.start instanceof Date ? range.start : new Date(range.start) : null;
+    const endDate = range.end ? range.end instanceof Date ? range.end : new Date(range.end) : null;
+    // Validate parsed range dates
+    const isStartDateValid = startDate && !isNaN(startDate.getTime());
+    const isEndDateValid = endDate && !isNaN(endDate.getTime());
+    if (isStartDateValid && date < startDate) {
+        return false;
+    }
+    // End date is exclusive
+    if (isEndDateValid && date >= endDate) {
+        return false;
+    }
+    return true;
+};
+const calculateDateRange = (timezone, startDate, endDate)=>{
+    // Create date utility after timezone is validated
+    const dateUtil = create$5({
+        timezone
+    });
+    const now = dateUtil.now();
+    const range = {
+        start: dateUtil.subDays(now, 31),
+        end: now
+    };
+    // Note: Validation ensures dates are valid and start <= end if both are provided
+    if (startDate || endDate) {
+        // Handle end date
+        if (endDate) {
+            range.end = dateUtil.parse(endDate, DATE_FORMAT_YEAR_MONTH_DAY);
+        }
+        // Handle start date
+        if (startDate) {
+            range.start = dateUtil.parse(startDate, DATE_FORMAT_YEAR_MONTH_DAY);
+        }
+        // We re-check the order here after defaults might have been applied,
+        // although validateStartEndDates should catch explicit invalid orders.
+        if (dateUtil.isBefore(range.end, range.start)) {
+            // This case should theoretically not be reachable due to prior validation
+            // but is kept as a safeguard.
+            throw new ArgumentError('--start', `Start date (${dateUtil.format(range.start, DATE_FORMAT_YEAR_MONTH_DAY)}) cannot be after end date (${dateUtil.format(range.end, DATE_FORMAT_YEAR_MONTH_DAY)}).`);
+        }
+    }
+    return range;
+};
+// Parse date from file path based on the input structure
+const parseDateFromFilePath = (relativePath, filename, structure, shouldParseTime, logger)=>{
+    const pathParts = relativePath.split(path__namespace.sep);
+    const filenameWithoutExt = path__namespace.basename(filename, path__namespace.extname(filename));
+    let parsedDate = null;
+    let year;
+    let month; // 0-indexed month for Date constructor
+    let day;
+    switch(structure){
+        case 'none':
+            // Filename format: YYYY-M-D-HHmm...
+            parsedDate = parseDateFromString(filenameWithoutExt, 'YYYY-M-D-HHmm', shouldParseTime);
+            break;
+        case 'year':
+            // Path: YYYY / M-D-HHmm...
+            if (pathParts.length >= 1) {
+                year = parseInt(pathParts[0], 10);
+                if (!isNaN(year)) {
+                    parsedDate = parseDateFromString(filenameWithoutExt, 'M-D-HHmm', shouldParseTime, year);
+                } else {
+                    logger.warn(`Invalid year format in path: ${pathParts[0]}`);
+                }
+            } else {
+                logger.warn(`File path does not match expected 'year' structure (YYYY/...)`);
+            }
+            break;
+        case 'month':
+            // Path: YYYY / MM / D-HHmm...
+            if (pathParts.length >= 2) {
+                year = parseInt(pathParts[0], 10);
+                const monthDir = parseInt(pathParts[1], 10); // Month from dir (1-indexed)
+                if (!isNaN(year) && !isNaN(monthDir) && monthDir >= 1 && monthDir <= 12) {
+                    month = monthDir - 1; // Adjust month for Date object (0-indexed)
+                    parsedDate = parseDateFromString(filenameWithoutExt, 'D-HHmm', shouldParseTime, year, month);
+                } else {
+                    logger.warn(`Invalid year/month format in path: ${pathParts[0]}/${pathParts[1]}`);
+                }
+            } else {
+                logger.warn(`File path does not match expected 'month' structure (YYYY/MM/...)`);
+            }
+            break;
+        case 'day':
+            // Path: YYYY / MM / DD / HHmm...
+            if (pathParts.length >= 3) {
+                year = parseInt(pathParts[0], 10);
+                const monthDir = parseInt(pathParts[1], 10); // Month from dir (1-indexed)
+                day = parseInt(pathParts[2], 10); // Day from dir (1-indexed)
+                if (!isNaN(year) && !isNaN(monthDir) && monthDir >= 1 && monthDir <= 12 && !isNaN(day) && day >= 1 && day <= 31) {
+                    month = monthDir - 1; // Adjust month (0-indexed)
+                    parsedDate = parseDateFromString(filenameWithoutExt, 'HHmm', shouldParseTime, year, month, day);
+                } else {
+                    logger.warn(`Invalid year/month/day format in path: ${pathParts[0]}/${pathParts[1]}/${pathParts[2]}`);
+                }
+            } else {
+                logger.warn(`File path does not match expected 'day' structure (YYYY/MM/DD/...)`);
+            }
+            break;
+        default:
+            logger.error(`Fatal: Unknown input structure "${structure}" specified in config.`);
+            throw new Error(`Unknown input structure "${structure}" specified.`);
+    }
+    return parsedDate;
+};
+// Process a single file from the structured input
+const processStructuredFile = async (filePath, inputDirectory, structure, shouldParseTime, callback, pattern, dateRange, logger)=>{
+    // Skip if filePath somehow points to the inputDirectory itself or is not a file
+    if (filePath === inputDirectory || !path__namespace.extname(filePath) && pattern.endsWith('*.*')) {
+        return false;
+    }
+    const relativePath = path__namespace.relative(inputDirectory, filePath);
+    const pathParts = relativePath.split(path__namespace.sep);
+    const filename = pathParts.pop(); // Filename is the last part
+    if (!filename) {
+        logger.warn(`Could not determine filename for path: ${filePath}`);
+        return false;
+    }
+    try {
+        const parsedDate = parseDateFromFilePath(relativePath, filename, structure, shouldParseTime, logger);
+        if (parsedDate) {
+            // Apply date range filtering
+            if (isDateInRange(parsedDate, dateRange)) {
+                logger.debug('Processing file %s with date %s', filePath, parsedDate.toISOString());
+                await callback(filePath, parsedDate);
+                return true;
+            } else {
+                const dateRangeDisplay = dateRange ? `from ${dateRange.start ? new Date(dateRange.start).toISOString() : 'beginning'} up to ${dateRange.end ? new Date(dateRange.end).toISOString() : 'end'}` : 'all dates';
+                logger.debug('Skipping file %s, date %s out of range %s', filePath, parsedDate.toISOString(), dateRangeDisplay);
+            }
+        } else {
+            logger.warn('Could not parse date for file %s with structure "%s" (filename base: "%s", path parts: %s)', filePath, structure, path__namespace.basename(filename, path__namespace.extname(filename)), pathParts.join('/'));
+        }
+    } catch (error) {
+        // Log error from the callback or date parsing/filtering itself
+        if (error instanceof Error) {
+            logger.error('Error processing file %s: %s\n%s', filePath, error.message, error.stack);
+        } else {
+            logger.error('Error processing file %s: %s', filePath, error);
+        }
+    }
+    return false;
+};
+const process$2 = async (inputStructure, inputFilenameOptions, extensions, timezone, start, end, limit, features, logger, inputDirectory, callback, concurrency)=>{
+    var _ref;
+    const storage = create$4({
+        log: logger.debug
+    });
+    const dateRange = calculateDateRange(timezone, start, end);
+    let fileCount = 0;
+    // Validate date range dates if provided
+    if ((dateRange === null || dateRange === void 0 ? void 0 : dateRange.start) && (!dateRange.start || isNaN(dateRange.start.getTime()))) {
+        logger.warn(`Invalid start date provided in dateRange: ${dateRange.start}`);
+    }
+    if ((dateRange === null || dateRange === void 0 ? void 0 : dateRange.end) && (!dateRange.end || isNaN(dateRange.end.getTime()))) {
+        logger.warn(`Invalid end date provided in dateRange: ${dateRange.end}`);
+    }
+    // Structured Input Logic
+    const structure = inputStructure !== null && inputStructure !== void 0 ? inputStructure : 'none'; // Default to 'none' if not specified
+    logger.info(`Processing structured input with structure "${structure}" in %s for date range: ${JSON.stringify(dateRange)}`, inputDirectory);
+    // Determine if time should be parsed from filenames
+    const shouldParseTime = (_ref = inputFilenameOptions === null || inputFilenameOptions === void 0 ? void 0 : inputFilenameOptions.includes('time')) !== null && _ref !== void 0 ? _ref : false;
+    if (shouldParseTime) {
+        logger.debug('Filename time parsing enabled based on inputFilenameOptions.');
+    } else {
+        logger.debug('Filename time parsing disabled; defaulting times to 00:00 UTC.');
+    }
+    const filePattern = getFilePattern(features, extensions || [], logger);
+    logger.debug('Processing Structured Input with pattern %s from %s', filePattern, inputDirectory);
+    await storage.forEachFileIn(inputDirectory, async (filePath)=>{
+        const processed = await processStructuredFile(filePath, inputDirectory, structure, shouldParseTime, callback, filePattern, dateRange, logger);
+        if (processed) {
+            fileCount++;
+        }
+    }, {
+        pattern: filePattern,
+        limit,
+        concurrency
+    });
+    return fileCount;
+};
+
+// Process files with unstructured input pattern
+const process$1 = async (inputDirectory, recursive, extensions, limit, logger, callback, concurrency)=>{
+    const storage = create$4({
+        log: logger.debug
+    });
+    let fileCount = 0;
+    let filePattern = `${recursive ? '**/' : ''}*`;
+    if (extensions && extensions.length > 0) {
+        // Ensure the pattern correctly handles extensions with or without recursion
+        if (recursive) {
+            filePattern = `**/*.{${extensions.join(',')}}`;
+        } else {
+            filePattern = `*.{${extensions.join(',')}}`;
+        }
+        logger.debug(`Applying extension filter: ${extensions.join(',')}`);
+    } else if (!recursive) {
+        // Non-recursive without extension filter: only files in the top directory
+        filePattern = `*.*`; // Adjust if files without extensions need matching
+    }
+    logger.info('Processing unstructured files %s in %s with pattern %s', recursive ? 'recursively' : 'non-recursively', inputDirectory, filePattern);
+    await storage.forEachFileIn(inputDirectory, async (file)=>{
+        try {
+            logger.debug('Processing file %s', file);
+            // Call callback without date for unstructured input
+            await callback(file); // Pass undefined for the date parameter
+            fileCount++;
+        } catch (error) {
+            if (error instanceof Error) {
+                logger.error('Error processing file %s: %s\n%s', file, error.message, error.stack);
+            } else {
+                logger.error('Error processing file %s: %s', file, error);
+            }
+        }
+    }, {
+        pattern: filePattern,
+        limit,
+        concurrency
+    });
+    return fileCount;
+};
+
+const process = async (config, features, logger, callback, { start, end } = {})=>{
+    if (!features.includes('input')) {
+        throw new Error('Input feature is not enabled, skipping input processing');
+    }
+    const concurrency = config.concurrency;
+    if (!concurrency) {
+        throw new Error('Concurrency is not configured');
+    }
+    const inputDirectory = config.inputDirectory;
+    if (!inputDirectory) {
+        throw new Error('Input directory is not configured');
+    }
+    let fileCount = 0;
+    if (features.includes('structured-input')) {
+        logger.debug('Processing Structured Input from %s with start date %s and end date %s', inputDirectory, start, end);
+        if (!start || !end) {
+            throw new Error('Start or end date are both required for structured input');
+        } else {
+            fileCount = await process$2(config.inputStructure, config.inputFilenameOptions, config.extensions, config.timezone, start, end, config.limit, features, logger, inputDirectory, callback, concurrency);
+        }
+    } else {
+        // Original Unstructured Input Logic
+        logger.debug('Processing Unstructured Input from %s', inputDirectory);
+        if (start || end) {
+            throw new Error('Start or end date is not allowed for unstructured input');
+        }
+        fileCount = await process$1(inputDirectory, config.recursive || false, config.extensions || [], config.limit, logger, callback, concurrency);
+    }
+    logger.info('Processed %d files matching criteria.', fileCount);
+};
+
+const create$3 = (config, options)=>{
+    return {
+        process: (callback, { start, end } = {})=>process(config, options.features, options.logger, callback, {
+                start,
+                end
+            })
+    };
+};
+
+const create$2 = (config, options)=>{
+    const logger = options.logger;
+    const timezone = (config === null || config === void 0 ? void 0 : config.timezone) || 'UTC';
+    const dates = create$5({
+        timezone
+    });
+    const storage = create$4({
+        log: logger.debug
+    });
+    const { outputDirectory, outputStructure, outputFilenameOptions } = config;
+    function formatDate(date, outputStructure) {
+        if (!outputStructure) {
+            throw new Error('Unable to Create Output: Output structure is not set');
+        }
+        switch(outputStructure){
+            case 'none':
+                return dates.format(date, DATE_FORMAT_YEAR_MONTH_DAY);
+            case 'year':
+                return dates.format(date, DATE_FORMAT_MONTH_DAY);
+            case 'month':
+                return dates.format(date, DATE_FORMAT_DAY);
+            case 'day':
+                throw new Error('Cannot use date in filename when output structure is "day"');
+        }
+    }
+    function sanitizeFilenameString(str) {
+        // Replace any character that is not alphanumeric, hyphen, underscore, or dot with an underscore
+        return str.replace(/[^a-zA-Z0-9\-_.]/g, '_')// Replace multiple consecutive underscores with a single underscore
+        .replace(/_+/g, '_')// Remove leading and trailing underscores
+        .replace(/^_+|_+$/g, '')// Ensure the string is not empty
+        .replace(/^$/, 'untitled');
+    }
+    function constructFilename(date, type, hash, options = {}) {
+        const parts = [];
+        // Add date if requested
+        if (outputFilenameOptions === null || outputFilenameOptions === void 0 ? void 0 : outputFilenameOptions.includes('date')) {
+            const dateStr = formatDate(date, outputStructure);
+            parts.push(dateStr);
+        }
+        // Add time if requested
+        if (outputFilenameOptions === null || outputFilenameOptions === void 0 ? void 0 : outputFilenameOptions.includes('time')) {
+            const dates = create$5({
+                timezone
+            });
+            const timeStr = dates.format(date, 'HHmm');
+            parts.push(timeStr);
+        }
+        // Add message ID
+        parts.push(hash);
+        parts.push(type);
+        // Add subject if requested
+        if (outputFilenameOptions === null || outputFilenameOptions === void 0 ? void 0 : outputFilenameOptions.includes('subject')) {
+            // Sanitize the provided subject, defaulting to empty string if undefined/null
+            parts.push(sanitizeFilenameString(options.subject || ''));
+        }
+        return parts.join('-');
+    }
+    function constructOutputDirectory(creationTime) {
+        // Throw this error to ensure that we don't success if outputDirectory or outputStructure are not set
+        if (!outputDirectory) {
+            throw new Error('Unable to Create Output: Output directory is not set');
+        }
+        if (!outputStructure) {
+            throw new Error('Unable to Create Output: Output structure is not set');
+        }
+        const date = dates.date(creationTime);
+        const year = dates.format(date, DATE_FORMAT_YEAR);
+        const month = dates.format(date, DATE_FORMAT_MONTH);
+        const day = dates.format(date, DATE_FORMAT_DAY);
+        let outputPath;
+        switch(outputStructure){
+            case 'year':
+                outputPath = path__namespace.join(outputDirectory, year);
+                break;
+            case 'month':
+                outputPath = path__namespace.join(outputDirectory, year, month);
+                break;
+            case 'day':
+                outputPath = path__namespace.join(outputDirectory, year, month, day);
+                break;
+            default:
+                outputPath = outputDirectory;
+        }
+        storage.createDirectory(outputPath);
+        return outputPath;
+    }
+    return {
+        constructFilename,
+        constructOutputDirectory
+    };
+};
+
+const create$1 = async (config, args, options)=>{
+    const output = create$2(config, options);
+    const input = create$3(config, options);
+    const constructFilename = async (createDate, type, hash, context)=>{
+        if (!options.features.includes('output')) {
+            throw new Error('Output feature is not enabled, skipping output construction');
+        }
+        return output.constructFilename(createDate, type, hash, context);
+    };
+    const constructOutputDirectory = async (createDate)=>{
+        if (!options.features.includes('output')) {
+            throw new Error('Output feature is not enabled, skipping output construction');
+        }
+        return output.constructOutputDirectory(createDate);
+    };
+    return {
+        process: input.process,
+        constructFilename,
+        constructOutputDirectory
+    };
+};
+
+const wrapLogger = (toWrap)=>{
+    const log = (level, message, ...args)=>{
+        message = `[${PROGRAM_NAME}] ${message}`;
+        toWrap[level](message, ...args);
+    };
+    return {
+        debug: (message, ...args)=>log('debug', message, ...args),
+        info: (message, ...args)=>log('info', message, ...args),
+        warn: (message, ...args)=>log('warn', message, ...args),
+        error: (message, ...args)=>log('error', message, ...args),
+        verbose: (message, ...args)=>log('verbose', message, ...args),
+        silly: (message, ...args)=>log('silly', message, ...args)
+    };
+};
+
+const FilenameOptionSchema = zod.z.enum([
+    'date',
+    'time',
+    'subject'
+]);
+const FilesystemStructureSchema = zod.z.enum([
+    'none',
+    'year',
+    'month',
+    'day'
+]);
+const DEFAULT_APP_OPTIONS = {
+    timezone: DEFAULT_TIMEZONE,
+    recursive: DEFAULT_RECURSIVE,
+    inputDirectory: DEFAULT_INPUT_DIRECTORY,
+    inputStructure: DEFAULT_INPUT_STRUCTURE,
+    inputFilenameOptions: DEFAULT_INPUT_FILENAME_OPTIONS,
+    outputDirectory: DEFAULT_OUTPUT_DIRECTORY,
+    outputStructure: DEFAULT_OUTPUT_STRUCTURE,
+    outputFilenameOptions: DEFAULT_OUTPUT_FILENAME_OPTIONS,
+    extensions: DEFAULT_EXTENSIONS,
+    concurrency: DEFAULT_CONCURRENCY
+};
+const DEFAULT_ALLOWED_OPTIONS = {
+    inputStructures: ALLOWED_INPUT_STRUCTURES,
+    inputFilenameOptions: ALLOWED_INPUT_FILENAME_OPTIONS,
+    outputStructures: ALLOWED_OUTPUT_STRUCTURES,
+    outputFilenameOptions: ALLOWED_OUTPUT_FILENAME_OPTIONS,
+    extensions: ALLOWED_EXTENSIONS
+};
+const DEFAULT_FEATURES = [
+    'output',
+    'structured-output',
+    'input',
+    'extensions'
+];
+const DEFAULT_LOGGER = {
+    // eslint-disable-next-line no-console
+    debug: (message, ...args)=>console.debug(message, ...args),
+    // eslint-disable-next-line no-console
+    info: (message, ...args)=>console.info(message, ...args),
+    // eslint-disable-next-line no-console
+    warn: (message, ...args)=>console.warn(message, ...args),
+    // eslint-disable-next-line no-console
+    error: (message, ...args)=>console.error(message, ...args),
+    // eslint-disable-next-line no-console
+    verbose: (message, ...args)=>console.log(message, ...args),
+    // eslint-disable-next-line no-console
+    silly: (message, ...args)=>console.log(message, ...args)
+};
+const DEFAULT_OPTIONS = {
+    defaults: DEFAULT_APP_OPTIONS,
+    allowed: DEFAULT_ALLOWED_OPTIONS,
+    features: DEFAULT_FEATURES,
+    addDefaults: true,
+    logger: DEFAULT_LOGGER
+};
+const ConfigSchema = zod.z.object({
+    timezone: zod.z.string(),
+    inputDirectory: zod.z.string().optional(),
+    inputStructure: FilesystemStructureSchema.optional(),
+    inputFilenameOptions: zod.z.array(FilenameOptionSchema).optional(),
+    recursive: zod.z.boolean().optional(),
+    outputDirectory: zod.z.string().optional(),
+    outputStructure: FilesystemStructureSchema.optional(),
+    outputFilenameOptions: zod.z.array(FilenameOptionSchema).optional(),
+    extensions: zod.z.array(zod.z.string()).optional(),
+    limit: zod.z.number().optional(),
+    concurrency: zod.z.number().optional()
+});
+const create = (creationOptsParam = {})=>{
+    let args;
+    const options = {
+        defaults: {
+            ...DEFAULT_APP_OPTIONS,
+            ...creationOptsParam.defaults
+        },
+        allowed: {
+            ...DEFAULT_ALLOWED_OPTIONS,
+            ...creationOptsParam.allowed
+        },
+        features: creationOptsParam.features || DEFAULT_FEATURES,
+        addDefaults: creationOptsParam.addDefaults === undefined ? DEFAULT_OPTIONS.addDefaults : creationOptsParam.addDefaults,
+        logger: wrapLogger(creationOptsParam.logger || DEFAULT_OPTIONS.logger)
+    };
+    return {
+        configure: async (command)=>configure(command, options.defaults || {}, options.addDefaults, options.features),
+        setLogger: (logger)=>{
+            options.logger = wrapLogger(logger);
+        },
+        read: async (pArgs)=>{
+            args = pArgs;
+            return read(args, options.features);
+        },
+        applyDefaults: (config)=>applyDefaults(config, options.features, options.defaults || {}),
+        validate: async (config)=>validate(config, options),
+        operate: async (config)=>create$1(config, args, options)
+    };
+};
+
+exports.ConfigSchema = ConfigSchema;
+exports.DEFAULT_ALLOWED_OPTIONS = DEFAULT_ALLOWED_OPTIONS;
+exports.DEFAULT_APP_OPTIONS = DEFAULT_APP_OPTIONS;
+exports.DEFAULT_FEATURES = DEFAULT_FEATURES;
+exports.DEFAULT_LOGGER = DEFAULT_LOGGER;
+exports.DEFAULT_OPTIONS = DEFAULT_OPTIONS;
+exports.FilenameOptionSchema = FilenameOptionSchema;
+exports.FilesystemStructureSchema = FilesystemStructureSchema;
+exports.create = create;
+//# sourceMappingURL=dreadcabinet.cjs.map