@atmosx/event-product-parser 2.0.1

package/src/@dictionaries/icao.ts

@@ -0,0 +1,250 @@
+/*
+                                            _               _     __   __
+         /\  | |                           | |             (_)    \ \ / /
+        /  \ | |_ _ __ ___   ___  ___ _ __ | |__   ___ _ __ _  ___ \ V / 
+       / /\ \| __| "_ ` _ \ / _ \/ __| "_ \| "_ \ / _ \ "__| |/ __| > <  
+      / ____ \ |_| | | | | | (_) \__ \ |_) | | | |  __/ |  | | (__ / . \ 
+     /_/    \_\__|_| |_| |_|\___/|___/ .__/|_| |_|\___|_|  |_|\___/_/ \_\
+                                     | |                                 
+                                     |_|                                                                                                                
+    
+    Written by: KiyoWx (k3yomi)                
+*/
+
+export const icaos: Record<string, string> = {
+    "KLCH": "Lake Charles, LA",
+    "TSTL": "St. Louis, MO", 
+    "PABC": "Bethel, AK", 
+    "TCMH": "Columbus, OH", 
+    "KEPZ": "El Paso, TX", 
+    "KCYS": "Cheyenne, WY", 
+    "KJKL": "Jackson, KY", 
+    "KPAH": "Paducah, KY", 
+    "KEMX": "Tucson, AZ",
+    "KMHX": "Morehead City, NC",
+    "PAPD": "Fairbanks, AK",
+    "KDLH": "Duluth, MN",
+    "TADW": "Andrews Air Force Base, MD",
+    "KOKX": "Brookhaven, NY",
+    "KLZK": "Little Rock, AR",
+    "KHGX": "Houston, TX",
+    "TMSY": "New Orleans, LA",
+    "KDGX": "Jackson/Brandon, MS",
+    "KCTP": "Caribou, ME",
+    "KAMA": "Amarillo, TX",
+    "PGUA": "Andersen AFB, GU",
+    "KAPX": "Gaylord, MI",
+    "PAHG": "Kenai, AK",
+    "KLWX": "Sterling, VA",
+    "HWPA2": "Homer, AK",
+    "KGRK": "Fort Hood, TX",
+    "KAKQ": "Wakefield, VA",
+    "ROCO2": "Norman, OK",
+    "KCLX": "Charleston, SC",
+    "TPHX": "Phoenix, AZ",
+    "KNKX": "San Diego, CA",
+    "TDEN": "Denver, CO",
+    "TLAS": "Las Vegas, NV",
+    "KBUF": "Buffalo, NY",
+    "KTLX": "Norman, OK",
+    "KILX": "Lincoln, IL",
+    "KHDC": "Hammond, LA",
+    "KVWX": "Evansville, IN",
+    "TCLT": "Charlotte, NC",
+    "TEWR": "Newark, NJ",
+    "KFSD": "Sioux Falls, SD",
+    "KEAX": "Pleasant Hill, MO",
+    "KICX": "Cedar City, UT",
+    "KHTX": "Huntsville, AL",
+    "PACG": "Sitka, AK",
+    "KSOX": "Santa Ana Mountains, CA",
+    "TPBI": "West Palm Beach, FL",
+    "TSLC": "Salt Lake City, UT",
+    "KGLD": "Goodland, KS",
+    "TRDU": "Raleigh-Durham, NC",
+    "KATX": "Seattle, WA",
+    "TICH": "Wichita, KS",
+    "TSDF": "Louisville, KY",
+    "TBOS": "Boston, MA",
+    "TDCA": "Washington, DC",
+    "KUEX": "Grand Island, NE",
+    "TLKA2": "Talkeetna, AK",
+    "KBGM": "Binghamton, NY",
+    "TLVE": "Cleveland, OH",
+    "KCAE": "Columbia, SC",
+    "KDVN": "Quad Cities, IA",
+    "KABR": "Aberdeen, SD",
+    "KBYX": "Key West, FL",
+    "KMPX": "Minneapolis, MN",
+    "KCRP": "Corpus Christi, TX",
+    "KCBW": "Caribou, ME",
+    "KMRX": "Knoxville, TN",
+    "KSHV": "Shreveport, LA",
+    "KIWA": "Phoenix, AZ",
+    "KRGX": "Reno, NV",
+    "PHKM": "Kamuela, HI",
+    "KABX": "Albuquerque, NM",
+    "KBMX": "Birmingham, AL",
+    "TMDW": "Chicago Midway, IL",
+    "KVAX": "Moody AFB, GA",
+    "KHDX": "Holloman AFB, NM",
+    "KBRO": "Brownsville, TX",
+    "KTWX": "Topeka, KS",
+    "KRTX": "Portland, OR",
+    "KCXX": "Burlington, VT",
+    "KFCX": "Roanoke, VA",
+    "KFFC": "Atlanta, GA",
+    "KBOX": "Boston, MA",
+    "KTLH": "Tallahassee, FL",
+    "KPUX": "Pueblo, CO",
+    "KFDR": "Altus AFB, OK",
+    "KGJX": "Grand Junction, CO",
+    "KDTX": "Detroit, MI",
+    "PHWA": "Waimea, HI",
+    "KMQT": "Marquette, MI",
+    "KSJT": "San Angelo, TX",
+    "KUDX": "Rapid City, SD",
+    "TIAH": "Houston, TX",
+    "KSRX": "Fort Smith, AR",
+    "TJFK": "New York City, NY",
+    "KDDC": "Dodge City, KS",
+    "PAKC": "King Salmon, AK",
+    "PAIH": "Middleton Island, AK",
+    "RODN": "Kadena AB, JA",
+    "TBWI": "Baltimore/Washington, MD",
+    "KIWX": "Northern Indiana, IN",
+    "KFDX": "Cannon AFB, NM",
+    "TMIA": "Miami, FL",
+    "KICT": "Wichita, KS",
+    "TMKE": "Milwaukee, WI",
+    "TFLL": "Fort Lauderdale, FL",
+    "KARX": "La Crosse, WI",
+    "KLRX": "Elko, NV",
+    "KDAX": "Sacramento, CA",
+    "KGRB": "Green Bay, WI",
+    "KLGX": "Langley Hill, WA",
+    "KFTG": "Denver, CO",
+    "KMKX": "Milwaukee, WI",
+    "TTUL": "Tulsa, OK",
+    "TDFW": "Dallas/Fort Worth, TX",
+    "TTPA": "Tampa Bay, FL",
+    "TDAL": "Dallas Love Field, TX",
+    "KDFX": "Laughlin AFB, TX",
+    "KSFX": "Pocatello, ID",
+    "KMTX": "Salt Lake City, UT",
+    "PAEC": "Nome, AK",
+    "RKSG": "Camp Humphreys, KR",
+    "KOAX": "Omaha, NE",
+    "PHMO": "Molokai, HI",
+    "TDTW": "Detroit, MI",
+    "THOU": "Houston, TX",
+    "AWPA2": "Anchorage, AK",
+    "KTYX": "Fort Drum, NY",
+    "KCCX": "State College, PA",
+    "TMSP": "Minneapolis, MN",
+    "KMVX": "Grand Forks, ND",
+    "KBIS": "Bismarck, ND",
+    "KBBX": "Beale AFB, CA",
+    "KVBX": "Vandenberg AFB, CA",
+    "KPOE": "Fort Polk, LA",
+    "KMOB": "Mobile, AL",
+    "KJGX": "Robins AFB, GA",
+    "KMUX": "San Francisco, CA",
+    "TMCI": "Kansas City, MO",
+    "KLSX": "St. Louis, MO",
+    "KMAX": "Medford, OR",
+    "KRAX": "Raleigh/Durham, NC",
+    "KINX": "Tulsa, OK",
+    "RKJK": "Kunsan AB, KR",
+    "KSGF": "Springfield, MO",
+    "TDAY": "Dayton, OH",
+    "KDOX": "Dover AFB, DE",
+    "KGGW": "Glasgow, MT",
+    "KAMX": "Miami, FL",
+    "KENX": "Albany, NY",
+    "KTFX": "Great Falls, MT",
+    "KPBZ": "Pittsburgh, PA",
+    "KMAF": "Midland/Odessa, TX",
+    "KPDT": "Pendleton, OR",
+    "KLNX": "North Platte, NE",
+    "KEOX": "Fort Rucker, AL",
+    "KGSP": "Greer, SC",
+    "KHPX": "Fort Campbell, KY",
+    "KGRR": "Grand Rapids, MI",
+    "KLOT": "Chicago, IL",
+    "TPIT": "Pittsburgh, PA",
+    "KEYX": "Edwards AFB, CA",
+    "TIAD": "Dulles, VA",
+    "KFWS": "Dallas/Fort Worth, TX",
+    "KMLB": "Melbourne, FL",
+    "KMBX": "Minot AFB, ND",
+    "KDMX": "Des Moines, IA",
+    "KEVX": "Eglin AFB, FL",
+    "TBNA": "Nashville, TN",
+    "KDYX": "Dyess AFB, TX",
+    "TOKC": "Oklahoma City, OK",
+    "PHKI": "South Kauai, HI",
+    "TMCO": "Orlando, FL",
+    "KDIX": "Philadelphia, PA",
+    "TORD": "Chicago, IL",
+    "KYUX": "Yuma, AZ",
+    "KVNX": "Vance AFB, OK",
+    "TJUA": "San Juan, PR",
+    "TATL": "Atlanta, GA",
+    "KVTX": "Los Angeles, CA",
+    "KIND": "Indianapolis, IN",
+    "KCBX": "Boise, ID",
+    "KGYX": "Portland, ME",
+    "KMXX": "Maxwell AFB, AL",
+    "TSJU": "San Juan, PR",
+    "KHNX": "San Joaquin Valley, CA",
+    "KLVX": "Louisville, KY",
+    "KMSX": "Missoula, MT",
+    "KJAX": "Jacksonville, FL",
+    "KNQA": "Memphis, TN",
+    "KRIW": "Riverton/Lander, WY",
+    "TCVG": "Covington, KY",
+    "KBLX": "Billings, MT",
+    "TPHL": "Philadelphia, PA",
+    "KRLX": "Charleston, WV",
+    "TMEM": "Memphis, TN",
+    "KCLE": "Cleveland, OH",
+    "KBHX": "Eureka, CA",
+    "KLBB": "Lubbock, TX",
+    "KOTX": "Spokane, WA",
+    "KEWX": "Austin/San Antonio, TX",
+    "KGWX": "Columbus AFB, MS",
+    "KESX": "Las Vegas, NV",
+    "KTBW": "Tampa, FL",
+    "KOHX": "Nashville, TN",
+    "KLTX": "Wilmington, NC",
+    "KFSX": "Flagstaff, AZ",
+    "TIDS": "Indianapolis, IN",
+    "KILN": "Cincinnati, OH",
+    "PAFG": "Fairbanks, AK",
+    "KPQR": "Portland, OR",
+    "KILM": "Wilmington, NC",
+    "KEKA": "Eureka, CA",
+    "KCHS": "Charleston, SC",
+    "KPHI": "Philadelphia/Mt. Holly, NJ",
+    "KUNR": "Rapid City, SD",
+    "KMFL": "Miami, FL",
+    "TJSJ": "San Juan, PR",
+    "KFGF": "Grand Forks, ND",
+    "KSEW": "Seattle, WA",
+    "PAFC": "Anchorage, AK",
+    "KLMK": "Louisville, KY",
+    "PHFO": "Honolulu, HI",
+    "KLIX": "New Orleans/Baton Rouge, LA",
+    "KBOI": "Boise, ID",
+    "KPIH": "Pocatello, ID",
+    "KMTR": "San Francisco/Monterey, CA",
+    "KGJT": "Grand Junction, CO",
+    "PAAQ": "Anchorage, AK",
+    "KABQ": "Albuquerque, NM",
+    "KTAE": "Tallahassee, FL",
+    "KCAR": "Caribou, ME",
+    "KMFR": "Medford, OR",
+    "PGUM": "Guam, GU",
+    "PAJK": "Juneau, AK"
+};

package/src/@dictionaries/signatures.ts

@@ -0,0 +1,139 @@
+/*
+                                            _               _     __   __
+         /\  | |                           | |             (_)    \ \ / /
+        /  \ | |_ _ __ ___   ___  ___ _ __ | |__   ___ _ __ _  ___ \ V / 
+       / /\ \| __| "_ ` _ \ / _ \/ __| "_ \| "_ \ / _ \ "__| |/ __| > <  
+      / ____ \ |_| | | | | | (_) \__ \ |_) | | | |  __/ |  | | (__ / . \ 
+     /_/    \_\__|_| |_| |_|\___/|___/ .__/|_| |_|\___|_|  |_|\___/_/ \_\
+                                     | |                                 
+                                     |_|                                                                                                                
+    
+    Written by: KiyoWx (k3yomi)                
+*/
+
+export const tags: Record<string, string> = {
+    "FROSTBITE AND HYPOTHERMIA ARE LIKELY": "Frostbite and Hypothermia Likely",
+    "LICKELY BECOME SLICK AND HAZARDOUS": "Slick and Hazardous Roads",
+    "SLIPPERY ROAD CONDITIONS": "Slippery Roads",
+    "BLOWING SNOW WHICH COULD REDUCE VISIBILITY": "Blowing Snow Reducing Visibility",
+    "TRAVEL COULD BE VERY DIFFICULT": "Difficult Travel Conditions",
+    "DIFFICULT TRAVEL CONDITIONS": "Difficult Travel Conditions",
+    "EXPECT DISRUPTIONS": "Expect Disruptions to Travel",
+    "A LARGE AND EXTREMELY DANGEROUS TORNADO": "Large and Dangerous Tornado",
+    "THIS IS A PARTICULARLY DANGEROUS SITUATION": "Particularly Dangerous Situation",
+    "RADAR INDICATED ROTATION": "Radar Indicated Tornado",
+    "WEATHER SPOTTERS CONFIRMED TORNADO": "Confirmed by Storm Spotters",
+    "A SEVERE THUNDERSTORM CAPABLE OF PRODUCING A TORNADO": "Developing Tornado",
+    "LAW ENFORCEMENT CONFIRMED TORNADO": "Reported by Law Enforcement",
+    "A TORNADO IS ON THE GROUND": "Confirmed Tornado",
+    "WEATHER SPOTTERS REPORTED FUNNEL CLOUD": "Confirmed Funnel Cloud by Storm Spotters",
+    "PUBLIC CONFIRMED TORNADO": "Public reports of Tornado",
+    "RADAR CONFIRMED": "Radar Confirmed",
+    "TORNADO WAS REPORTED BRIEFLY ON THE GROUND": "Tornado no longer on ground",
+    "SPOTTERS INDICATE THAT A FUNNEL CLOUD CONTINUES WITH THIS STORM": "Funnel Cloud Continues",
+    "A TORNADO MAY DEVELOP AT ANY TIME": "Potentional still exists for Tornado to form",
+    "LIFE-THREATENING SITUATION": "Life Threating Situation",
+    "COMPLETE DESTRUCTION IS POSSIBLE": "Extremly Damaging Tornado",
+    "POTENTIALLY DEADLY TORNADO": "Deadly Tornado",
+    "RADAR INDICATED": "Radar Indicated",
+    "HAIL DAMAGE TO VEHICLES IS EXPECTED": "Damaging to Vehicles",
+    "EXPECT WIND DAMAGE": "Wind Damage",
+    "FREQUENT LIGHTNING": "Frequent Lightning",
+    "PEOPLE AND ANIMALS OUTDOORS WILL BE INJURED": "Capable of Injuring People and Animals",
+    "TRAINED WEATHER SPOTTERS": "Confirmed by Storm Spotters",
+    "SOURCE...PUBLIC": "Confirmed by Public",
+    "SMALL CRAFT COULD BE DAMAGED": "Potential Damage to Small Craft",
+    "A TORNADO WATCH REMAINS IN EFFECT": "Active Tornado Watch",
+    "TENNIS BALL SIZE HAIL": "Tennis Ball Size Hail",
+    "BASEBALL SIZE HAIL": "Baseball Size Hail",
+    "GOLF BALL SIZE HAIL": "Golf Ball Size Hail",
+    "QUARTER SIZE HAIL": "Quarter Size Hail",
+    "PING PONG BALL SIZE HAIL": "Ping Pong Ball Size Hail",
+    "NICKEL SIZE HAIL": "Nickel Size Hail",
+    "DOPPLER RADAR.": "Confirmed by Radar",
+    "DOPPLER RADAR AND AUTOMATED GAUGES.": "Confirmed by Radar and Gauges",
+    "FLASH FLOODING CAUSED BY THUNDERSTORMS.": "Caused by Thunderstorm",
+    "SOURCE...EMERGENCY MANAGEMENT.": "Confirmed by Emergency Management",
+    "FLASH FLOODING CAUSED BY HEAVY RAIN.": "Caused by heavy rain",
+    "SOURCE...LAW ENFORCEMENT REPORTED.": "Confirmed by Law Enforcement",
+    "MINOR FLOODING IS OCCURING": "Minor Flooding Occurring",
+    "VERY COLD TEMPERATURES CAN LEAD TO HYPOTHERMIA": "Hypothermia Risk",
+    "SENSITIVE VEGETATION AND POSSIBLY DAMAGE UNPROTECTED OUTDOOR": "Vegetation and Outdoor Plumbing Risk",
+    "RIP CURRENTS CAN SWEEP EVEN THE BEST SWIMMER": "Hazardous to All Swimmers",
+    "HYPOTHERMIA IF PRECAUTIONS ARE NOT TAKEN.": "Hypothermia Risk",
+    "FROSTBITE AND HYPOTHERMIA WILL OCCUR IF UNPROTECTED SKIN": "Frostbite and Hypothermia Risk on Unprotected Skin",
+    "TEMPERATURES COULD CAUSE RUPTURED WATER PIPES": "Risk of Ruptured Water Pipes",
+    "COULD RESULT IN HYPOTHERMIA OR FROSTBITE ON EXPOSED SKIN IF": "Hypothermia or Frostbite Risk on Exposed Skin",
+    "WINDS WILL STRENGTHEN": "Strengthening Winds",
+    "EXPECT ROADS TO RE-FREEZE": "Roads May Re-Freeze",
+    "SLICK AND ICY SPOTS ON ROADS": "Slick and Icy Roads",
+    "ICY PATCHES MAY BE MORE COMMON ON BRIDGES": "Icy Patches Likely on Bridges",
+    "SLICK SPOTS ON UNTREATED ROADS": "Slick Spots on Untreated Roads",
+    "TEMPERATURES ARE EXPECTED TO FALL BELOW FREEZING": "Temperatures Expected Below Freezing",
+    "HAZARDOUS ROADWAYS AND BLACK ICE": "Hazardous Roadways and Black Ice",
+    "SLOW DOWN AND ALLOW EXTRA TIME": "Slow Down and Allow Extra Time",
+    "SHOULD EXERCISE CAUTION": "Should Exercise Caution",
+    "LAKE EFFECT SNOW EXPECTED": "Lake Effect Snow Expected",
+    "MODERATE LAKE EFFECT SNOWFALL RATES AND BLOWING SNOW": "Moderate Lake Effect Snowfall and Blowing Snow",
+}
+
+export const cancel_signatures: string[] = [
+    "subsided sufficiently for the advisory to be cancelled", 
+    "has been cancelled", 
+    "will be allowed to expire", 
+    "has diminished", 
+    "and no longer", 
+    "has been replaced", 
+    "The threat has ended", 
+    "has weakened below severe"
+]
+
+export const message_signatures: { regex: RegExp, replacement: string }[] = [
+    { regex: /\*/g, replacement: "" },
+    { regex: /\.{3,}/g, replacement: "" },
+    { regex: /\bUTC\b/g, replacement: 'Coordinated Universal Time' },
+    { regex: /\bGMT\b/g, replacement: 'Greenwich Mean Time' },
+    { regex: /\bEST\b(?!\w)/g, replacement: 'Eastern Standard Time' },
+    { regex: /\bEDT\b(?!\w)/g, replacement: 'Eastern Daylight Time' },
+    { regex: /\bCST\b(?!\w)/g, replacement: 'Central Standard Time' },
+    { regex: /\bCDT\b(?!\w)/g, replacement: 'Central Daylight Time' },
+    { regex: /\bMST\b(?!\w)/g, replacement: 'Mountain Standard Time' },
+    { regex: /\bMDT\b(?!\w)/g, replacement: 'Mountain Daylight Time' },
+    { regex: /\bPST\b(?!\w)/g, replacement: 'Pacific Standard Time' },
+    { regex: /\bPDT\b(?!\w)/g, replacement: 'Pacific Daylight Time' },
+    { regex: /\bAKST\b(?!\w)/g, replacement: 'Alaska Standard Time' },
+    { regex: /\bAKDT\b(?!\w)/g, replacement: 'Alaska Daylight Time' },
+    { regex: /\bHST\b(?!\w)/g, replacement: 'Hawaii Standard Time' },
+    { regex: /\bHDT\b(?!\w)/g, replacement: 'Hawaii Daylight Time' },
+    { regex: /\bmph\b(?!\w)/g, replacement: 'miles per hour' },
+    { regex: /\bkm\/h\b(?!\w)/g, replacement: 'kilometers per hour' },
+    { regex: /\bkmh\b(?!\w)/g, replacement: 'kilometers per hour' },
+    { regex: /\bkt\b(?!\w)/g, replacement: 'knots' },
+    { regex: /\bNE\b(?!\w)/g, replacement: 'northeast' },
+    { regex: /\bNW\b(?!\w)/g, replacement: 'northwest' },
+    { regex: /\bSE\b(?!\w)/g, replacement: 'southeast' },
+    { regex: /\bSW\b(?!\w)/g, replacement: 'southwest' },
+    { regex: /\bNM\b(?!\w)/g, replacement: 'nautical miles' },
+    { regex: /\bdeg\b(?!\w)/g, replacement: 'degrees' },
+    { regex: /\btstm\b(?!\w)/g, replacement: 'thunderstorm' },
+    { regex: /\bmm\b(?!\w)/g, replacement: 'millimeters' },
+    { regex: /\bcm\b(?!\w)/g, replacement: 'centimeters' },
+    { regex: /\bin.\b(?!\w)/g, replacement: 'inches' },
+    { regex: /\bft\b(?!\w)/g, replacement: 'feet' },
+    { regex: /\bmi\b(?!\w)/g, replacement: 'miles' },
+    { regex: /\bhr\b(?!\w)/g, replacement: 'hour' },
+    { regex: /\bhourly\b(?!\w)/g, replacement: 'per hour' },
+    { regex: /\bkg\b(?!\w)/g, replacement: 'kilograms' },
+    { regex: /\bg\/kg\b(?!\w)/g, replacement: 'grams per kilogram' },
+    { regex: /\bmb\b(?!\w)/g, replacement: 'millibars' },
+    { regex: /\bhPa\b(?!\w)/g, replacement: 'hectopascals' },
+    { regex: /\bPa\b(?!\w)/g, replacement: 'pascals' },
+    { regex: /\bKPa\b(?!\w)/g, replacement: 'kilopascals' },
+    { regex: /\bC\/hr\b(?!\w)/g, replacement: 'degrees Celsius per hour' },
+    { regex: /\bF\/hr\b(?!\w)/g, replacement: 'degrees Fahrenheit per hour' },
+    { regex: /\bC\/min\b(?!\w)/g, replacement: 'degrees Celsius per minute' },
+    { regex: /\bF\/min\b(?!\w)/g, replacement: 'degrees Fahrenheit per minute' },
+    { regex: /\bC\b(?!\w)/g, replacement: 'degrees Celsius' },
+    { regex: /\bF\b(?!\w)/g, replacement: 'degrees Fahrenheit' },
+];
+    

package/src/@parsers/@events/api.ts

@@ -0,0 +1,146 @@
+/*
+                                            _               _     __   __
+         /\  | |                           | |             (_)    \ \ / /
+        /  \ | |_ _ __ ___   ___  ___ _ __ | |__   ___ _ __ _  ___ \ V / 
+       / /\ \| __| "_ ` _ \ / _ \/ __| "_ \| "_ \ / _ \ "__| |/ __| > <  
+      / ____ \ |_| | | | | | (_) \__ \ |_) | | | |  __/ |  | | (__ / . \ 
+     /_/    \_\__|_| |_| |_|\___/|___/ .__/|_| |_|\___|_|  |_|\___/_/ \_\
+                                     | |                                 
+                                     |_|                                                                                                                
+    
+    Written by: KiyoWx (k3yomi)                
+*/
+
+import * as types from '../../types';
+import * as loader from '../../bootstrap';
+import EventParser from '../events';
+import TextParser from '../text';
+
+export class APIAlerts {
+    
+    /**
+     * @function getTracking
+     * @description
+     *   Generates a unique tracking identifier for a CAP alert based on extracted XML values.
+     *   If VTEC information is available, it constructs the tracking ID from the VTEC components.
+     *   Otherwise, it uses the WMO identifier along with TTAI and CCCC attributes.
+     *
+     * @private
+     * @static
+     * @param {Record<string, string>} extracted 
+     * @returns {string} 
+     */
+     private static getTracking(extracted: Record<string, string>): string {
+        if (extracted.pVtec) {
+            const vtecValue = Array.isArray(extracted.pVtec) 
+                ? extracted.pVtec[0] : extracted.pVtec;
+            const splitPVTEC = vtecValue.split('.');
+            return `${splitPVTEC[2]}-${splitPVTEC[3]}-${splitPVTEC[4]}-${splitPVTEC[5]}`;
+        }
+        const wmoMatch = extracted.wmoidentifier?.match(/([A-Z]{4}\d{2})\s+([A-Z]{4})/);
+        const station = wmoMatch?.[2] ?? 'N/A';
+        if (extracted.featureId) {
+            const idMatch = extracted.featureId.match(/([a-f0-9]+)\.(\d+)\.(\d+)$/);
+            return `${station}-${idMatch?.[1] ?? 'N/A'}`;
+        }
+        const id = wmoMatch?.[1] ?? 'N/A';
+        return `${station}-${id}`;
+     }
+
+    /**
+     * @function getICAO
+     * @description
+     *    Extracts the sender's ICAO code and corresponding name from a VTEC string.    
+     *
+     * @private
+     * @static
+     * @param {string} pVtec 
+     * @returns {{ icao: any; name: any; }} 
+     */
+    private static getICAO(pVtec: string): { icao: any; name: any; } {
+        const icao = pVtec ? pVtec.split(`.`)[2] : null;
+        const name = loader.definitions.ICAO?.[icao] ?? null;
+        return { icao, name };
+    }
+    
+    /**
+     * @function event
+     * @description
+     *   Processes validated API alert messages, extracting relevant information and compiling it into structured event objects.
+     *
+     * @public
+     * @static
+     * @async
+     * @param {types.StanzaCompiled} validated 
+     * @returns {*} 
+     */
+    public static async event(validated: types.StanzaCompiled): Promise<void> {
+        let processed = [] as unknown[];
+        const messages = Object.values(JSON.parse(validated.message).features) as types.EventCompiled[];
+        for (let feature of messages) {
+            const tick = performance.now();
+            const getPVTEC = feature?.properties?.parameters?.VTEC?.[0] ?? null;
+            const getWmo = feature?.properties?.parameters?.WMOidentifier?.[0] ?? null;
+            const getUgc = feature?.properties?.geocode?.UGC ?? null;
+            const getHeadline = feature?.properties?.parameters?.NWSheadline?.[0] ?? "";
+            const getDescription = `${getHeadline} ${feature?.properties?.description ?? ``}`
+            const getAWIP = feature?.properties?.parameters?.AWIPSidentifier?.[0] ?? null;
+            const getHeader = EventParser.getHeader({ ...{ getAwip: {prefix: getAWIP?.slice(0, -3) }},} as types.StanzaAttributes);
+            const getSource = TextParser.textProductToString(getDescription, `SOURCE...`, [`.`]) ?? null;
+            const getOffice = this.getICAO(getPVTEC ?? ``);
+            processed.push({
+                type: "Feature",
+                properties: {
+                    locations: feature?.properties?.areaDesc ?? null,
+                    event: feature?.properties?.event ?? null,
+                    issued: feature?.properties?.sent ? new Date(feature?.properties?.sent).toISOString() : null,
+                    expires: feature?.properties?.expires ? new Date(feature?.properties?.expires).toISOString() : null,
+                    parent: feature?.properties?.event ?? null,
+                    action_type: feature?.properties?.messageType ?? null,
+                    description: feature?.properties?.description ?? null,
+                    instruction: feature?.properties?.instruction ?? null,
+                    sender_name: getOffice.name ?? null,
+                    sender_icao: getOffice.icao ?? null,
+                    attributes: validated.attributes,
+                    geocode: {
+                        UGC: feature?.properties?.geocode?.UGC ?? [], 
+                        generated: feature?.geometry?.coordinates.length > 0 ? Buffer.from(JSON.stringify([feature?.geometry?.coordinates[0]])).toString('base64') : null,
+                    },
+                    raw: {},
+                    parameters: {
+                        wmo: feature?.properties?.parameters?.WMOidentifier?.[0] ?? getWmo ?? null,
+                        source: getSource,
+                        max_hail_size: feature?.properties?.parameters?.maxHailSize ?? null,
+                        max_wind_gust: feature?.properties?.parameters?.maxWindGust ?? null,
+                        damage_threat: feature?.properties?.parameters?.thunderstormDamageThreat?.[0] ?? null,
+                        tornado_detection: feature?.properties?.parameters?.tornadoDetection?.[0] ?? null,
+                        flood_detection: feature?.properties?.parameters?.floodDetection?.[0] ?? null,
+                        discussion_tornado_intensity: null, 
+                        discussion_wind_intensity: null,
+                        discussion_hail_intensity: null,
+                    },
+                    details: {
+                        performance: performance.now() - tick,
+                        source: `api-parser`,
+                        tracking: this.getTracking({ 
+                            pVtec: getPVTEC, 
+                            wmoidentifier: getWmo, 
+                            featureId: feature?.id, 
+                            ugc: getUgc ? getUgc.join(`,`) : null 
+                        }),
+                        header: getHeader,
+                        pvtec: getPVTEC ?? null,
+                        history: [{
+                            description: feature?.properties?.description ?? null,
+                            action: feature?.properties?.messageType ?? null,
+                            time: feature?.properties?.sent ? new Date(feature?.properties?.sent).toISOString() : null
+                        }],
+                    },
+                },
+            })
+        }
+        EventParser.validateEvents(processed);
+    }
+}
+
+export default APIAlerts;

package/src/@parsers/@events/cap.ts

@@ -0,0 +1,123 @@
+/*
+                                            _               _     __   __
+         /\  | |                           | |             (_)    \ \ / /
+        /  \ | |_ _ __ ___   ___  ___ _ __ | |__   ___ _ __ _  ___ \ V / 
+       / /\ \| __| "_ ` _ \ / _ \/ __| "_ \| "_ \ / _ \ "__| |/ __| > <  
+      / ____ \ |_| | | | | | (_) \__ \ |_) | | | |  __/ |  | | (__ / . \ 
+     /_/    \_\__|_| |_| |_|\___/|___/ .__/|_| |_|\___|_|  |_|\___/_/ \_\
+                                     | |                                 
+                                     |_|                                                                                                                
+    
+    Written by: KiyoWx (k3yomi)                
+*/
+
+import * as types from '../../types';
+import * as loader from '../../bootstrap';
+import EventParser from '../events';
+import TextParser from '../text';
+
+export class CapAlerts {
+    
+    /**
+     * @function getTracking
+     * @description
+     *   Generates a unique tracking identifier for a CAP alert based on extracted XML values.
+     *   If VTEC information is available, it constructs the tracking ID from the VTEC components.
+     *   Otherwise, it uses the WMO identifier along with TTAI and CCCC attributes.
+     *
+     * @private
+     * @static
+     * @param {Record<string, string>} extracted 
+     * @returns {string} 
+     */
+    private static getTracking(extracted: Record<string, string>, metadata: types.StanzaAttributes): string {
+        return extracted.vtec ? (() => {
+            const vtecValue = Array.isArray(extracted.vtec) ? extracted.vtec[0] : extracted.vtec;
+            const splitPVTEC = vtecValue.split('.');
+            return `${splitPVTEC[2]}-${splitPVTEC[3]}-${splitPVTEC[4]}-${splitPVTEC[5]}`;
+        })() : `${extracted.wmoidentifier.substring(extracted.wmoidentifier.length - 4)}-${metadata.attributes.ttaaii}-${metadata.attributes.id.slice(-4)}`;
+    }
+
+    /**
+     * @function event
+     * @description
+     *    Processes validated CAP alert messages, extracting relevant information and compiling it into structured event objects.   
+     *
+     * @public
+     * @static
+     * @async
+     * @param {types.StanzaCompiled} validated 
+     * @returns {*} 
+     */
+    public static async event(validated: types.StanzaCompiled): Promise<void> {
+      let processed = [] as unknown[];
+      const messages = validated?.message?.split(/(?=\$\$)/g)?.map(msg => msg.trim())?.filter(msg => msg && msg !== "$$");
+      if (!messages || messages.length == 0) { return }
+      for (let i = 0; i < messages.length; i++) {
+          const tick = performance.now();
+          let message = messages[i]
+          const attributes = validated as types.StanzaAttributes;
+            message = message.substring(message.indexOf(`<?xml version="1.0"`), message.lastIndexOf(`>`) + 1);
+            const parser = new loader.packages.xml2js.Parser({ explicitArray: false, mergeAttrs: true, trim: true })
+            const parsed = await parser.parseStringPromise(message);
+            if (parsed == null || parsed.alert == null) continue;
+            const extracted = TextParser.getXmlValues(parsed, [
+                `vtec`, `wmoidentifier`, `ugc`, `areadesc`, 
+                `expires`, `sent`, `msgtype`, `description`,
+                `event`, `sendername`, `tornadodetection`, `polygon`,
+                `maxHailSize`, `maxWindGust`, `thunderstormdamagethreat`,
+                `tornadodamagethreat`, `waterspoutdetection`, `flooddetection`,
+            ]);
+            const getHeader = EventParser.getHeader({ ...validated.attributes,} as types.StanzaAttributes);
+            const getSource = TextParser.textProductToString(extracted.description, `SOURCE...`, [`.`]) ?? null;
+            processed.push({
+                type: "Feature",
+                properties: {
+                    locations: extracted.areadesc ?? null,
+                    event: extracted.event ?? null,
+                    issued: extracted.sent ? new Date(extracted.sent).toISOString() : null,
+                    expires: extracted.expires ? new Date(extracted.expires).toISOString() : null,
+                    parent: extracted.event ?? null,
+                    action_type: extracted.msgtype ?? null,
+                    description: extracted.description ?? null,
+                    instruction: null,
+                    sender_name: extracted.sendername ?? null,
+                    sender_icao: extracted.wmoidentifier ? extracted.wmoidentifier.substring(extracted.wmoidentifier.length - 4) : null,
+                    attributes: attributes,
+                    geocode: {
+                        UGC: extracted.ugc ? (Array.isArray(extracted.ugc) ? extracted.ugc : [extracted.ugc]) : [],
+                        generated: extracted?.polygon?.length > 0 ? Buffer.from(JSON.stringify([extracted.polygon.split(' ').map((coord: string) => {
+                            const [lat, lon] = coord.split(',').map(Number);
+                            return [lon, lat];
+                        })])).toString('base64') : null,
+                    },
+                    raw: {attributes},
+                    parameters: {
+                        wmo: extracted.wmoidentifier ?? null,
+                        source: getSource,
+                        max_hail_size: extracted.maxHailSize ?? null,
+                        max_wind_gust: extracted.maxWindGust ?? null,
+                        damage_threat: extracted.thunderstormdamagethreat ?? null,
+                        tornado_detection: extracted.tornadodetection ?? extracted.waterspoutdetection ?? null,
+                        flood_detection: extracted.flooddetection ?? null,
+                        discussion_tornado_intensity: null,
+                        discussion_wind_intensity: null,
+                        discussion_hail_intensity: null,
+                    },
+                    details: {
+                        performance: performance.now() - tick,
+                        source: `cap-parser`,
+                        tracking: this.getTracking(extracted, attributes),
+                        header: getHeader,
+                        pvtec: extracted.vtec ?? null,
+                        hvtec: null,
+                        history: [{ description: extracted.description ?? null, issued: extracted.sent ? new Date(extracted.sent).toISOString() : null, type: extracted.msgtype ?? null }],
+                    },
+                },
+            })
+        }
+        EventParser.validateEvents(processed);
+    }
+}
+
+export default CapAlerts;