cs2-log-parser 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2020 Negezor
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,100 @@
+# cs2-log-parser
+
+A simple 0-dependency library that parses logs from a CS2 server into JavaScript objects, originally based on this fork by [BLAST](https://github.com/blastorg) (available [here](https://github.com/blastorg/srcds-log-parser)), and the original library made by [negezor](https://github.com/negezor) (available [here](https://github.com/negezor/srcds)).
+These libraries however have not been updated in a while, which is the reason for making this one, which has been cleaned up & updated to the latest CS2 logging formats, with some new log parsers added.
+
+For a list of the logs this library supports look inside the [tests](/tests/) directory.
+
+## Install
+
+```bash
+npm i cs2-log-parser
+```
+
+## Usage
+
+### HTTP
+
+CS2 supports sending logs over HTTP POST requests by giving it an address using `logaddress_add_http`.  
+Here is a simple example using [tinyhttp](https://github.com/tinyhttp/tinyhttp) and [milliparsec](https://github.com/tinyhttp/milliparsec) on how we can handle these on our server:
+
+```js
+import { App } from "@tinyhttp/app";
+import { text } from "milliparsec";
+import { StatusCodes } from "http-status-codes";
+import parse from "cs2-log-parser";
+
+const app = new App();
+
+app.post("/cs2_logs", text(), (req, res) => {
+
+	const logLines = req.body.split("\n");
+
+	for (const logLine of logLines) {
+
+		const event = parse(logLine, { format: "http" });
+
+		if (event === null) {
+			continue;
+		}
+
+		console.log(event);
+		
+	}
+
+	res.sendStatus(StatusCodes.OK);
+
+});
+
+app.listen(3000);
+```
+
+### Log file
+
+CS2 can write logs to a text file by setting `sv_logfile 1`, saved in a directory specified by `sv_logsdir` (defaults to `logs` inside the `game/csgo` folder).  
+Here is a simple example on how we can read these using Node's built-in `fs` & `path` modules:
+
+```js
+import fs from "fs";
+import path from "path";
+import parse from "cs2-log-parser";
+
+const logFilePath = path.join(
+  "C:",
+  "Program Files (x86)",
+  "Steam",
+  "steamapps",
+  "common",
+  "Counter-Strike Global Offensive",
+  "game",
+  "csgo",
+  "logs",
+  "2025_10_08_214757.log"
+);
+
+const logFileData = fs.readFileSync(logFilePath, "utf-8");
+
+const logLines = logFileData.split("\n");
+
+for (const logLine of logLines) {
+
+    // Log file lines begin with "L" & contain whitespace, we clean them up here
+    const cleanLogLine = logLine.slice(1).trim();
+
+    const event = parse(cleanLogLine, { format: "file" });
+
+    if (!event) {
+        continue;
+    }
+
+    console.log(event);
+    
+}
+```
+
+## Note
+
+Some logs require additional ConVars to be set on the server in order to get logged, specifically:
+
+- `attacked` needs `mp_logdetail` set to either `1` (to log enemy attacks), `2` (to log team attacks) or `3` (to log both).
+- `picked_up` needs `mp_logdetail_items` set to `true` (or `1`). 

package/lib/assertions.d.ts

@@ -0,0 +1,3 @@
+import type { Vector, ConnectionState } from './models.js';
+export declare function assertValidVector(vectorArray: number[]): asserts vectorArray is Vector;
+export declare function assertValidConnectionState(state?: string): asserts state is ConnectionState;

package/lib/assertions.js

@@ -0,0 +1,13 @@
+export function assertValidVector(vectorArray) {
+    if (vectorArray.some((n) => isNaN(n))) {
+        throw new Error('Vector contains invalid number(s)');
+    }
+    if (vectorArray.length !== 3) {
+        throw new Error(`Vector must have 3 numbers, got ${vectorArray.length}`);
+    }
+}
+export function assertValidConnectionState(state) {
+    if (state !== 'connected' && state !== 'entered' && state !== 'disconnected') {
+        throw new Error(`Received unknown connection state, got ${state}`);
+    }
+}

package/lib/helpers.d.ts

@@ -0,0 +1 @@
+export declare function convertSteamIdTo64Dec(steamId: string): string;

package/lib/helpers.js

@@ -0,0 +1,18 @@
+export function convertSteamIdTo64Dec(steamId) {
+    // old steam id format: STEAM_1:0:12345
+    if (steamId.includes('STEAM')) {
+        const steamIdSplit = steamId.split(':');
+        let commId = parseInt(steamIdSplit[2]) * 2;
+        if (steamIdSplit[1] === '1') {
+            commId += 1;
+        }
+        const newCommId = BigInt(commId) + BigInt(76561197960265728);
+        return newCommId.toString();
+    }
+    // new steam id format: [U:1:230970467]
+    const cleanedSteamId = steamId.replaceAll(/\[|\]/g, '');
+    const uSteamIdSplit = cleanedSteamId.split(':');
+    const commId = BigInt(uSteamIdSplit[2]) + BigInt(76561197960265728);
+    return commId.toString();
+}
+;

package/lib/index.d.ts

@@ -0,0 +1,2 @@
+export { AssistedEvent, AttackedEvent, BlindedEvent, ConnectionEvent, EntityTriggeredEvent, KilledByBombEvent, KilledEvent, LeftBuyzoneEvent, PickedUpEvent, PurchasedEvent, RconEvent, SayEvent, ScoredEvent, SuicideEvent, SwitchedTeamEvent, TeamTriggeredEvent, ThrewEvent } from './parsers/index.js';
+export { Event, ParseOptions, defaultParsers, parse as default } from './parser.js';

package/lib/index.js

@@ -0,0 +1 @@
+export { defaultParsers, parse as default } from './parser.js';

package/lib/models.d.ts

@@ -0,0 +1,80 @@
+export declare const baseEntityRe: RegExp;
+export declare const basePlayerRe: RegExp;
+export declare const vectorRe: RegExp;
+export declare const entityRe: RegExp;
+export declare enum Team {
+    Unassigned = 0,
+    Spectators = 1,
+    Terrorists = 2,
+    CounterTerrorists = 3,
+    Unknown = 999
+}
+export declare const teamMapping: Record<string, Team>;
+export type EntityID = number;
+export type KillModifier = 'attackerblind' | 'attackerinair' | 'headshot' | 'penetrated' | 'throughsmoke' | 'noscope';
+export type SuicideMethod = 'world' | 'hegrenade' | 'inferno';
+export type ConnectionState = 'connected' | 'entered' | 'disconnected';
+export type HitGroup = 'generic' | 'head' | 'chest' | 'stomach' | 'left_arm' | 'right_arm' | 'left_leg' | 'right_leg';
+export type SayTo = 'all' | 'team';
+export type LogTimestampFormat = 'file' | 'http';
+export type Entity = WorldEntity | ConsoleEntity | ChickenEntity | PlayerEntity | BotEntity | MultiplayerPhysicsPropEntity | DynamicPropEntity;
+export type Vector = [number, number, number];
+export interface BaseEvent<T, P> {
+    name: T;
+    payload: P;
+    receivedAt: Date;
+}
+export interface BaseParser<T extends BaseEvent<string, unknown>> {
+    name: T['name'];
+    patterns: RegExp[];
+    parse(groups: Record<string, string>): T['payload'];
+}
+interface BaseEntity {
+    type: string;
+}
+interface IdentifiedEntity extends BaseEntity {
+    id: EntityID;
+}
+interface PositionedEntity extends IdentifiedEntity {
+    position?: Vector;
+}
+export interface MultiplayerPhysicsPropEntity extends PositionedEntity {
+    type: 'prop_physics_multiplayer';
+}
+export interface DynamicPropEntity extends PositionedEntity {
+    type: 'prop_dynamic';
+}
+export interface WorldEntity extends BaseEntity {
+    type: 'world';
+}
+export interface ConsoleEntity extends BaseEntity {
+    type: 'console';
+}
+export interface ChickenEntity extends PositionedEntity {
+    type: 'chicken';
+    id: EntityID;
+}
+export interface BasePlayerEntity extends PositionedEntity {
+    id: EntityID;
+    name: string;
+    position?: Vector;
+    team: Team;
+}
+export interface PlayerEntity extends BasePlayerEntity {
+    type: 'player';
+    steamId3: string;
+    steamId64: string;
+}
+export interface BotEntity extends BasePlayerEntity {
+    type: 'bot';
+}
+export declare function parseTeam(rawTeam: string): Team;
+export declare function parseKillModifiers(rawModifiers?: string): KillModifier[];
+export declare function parseConnectionState(rawState?: string): ConnectionState;
+export declare function parseHitGroup(rawHitGroup: string): HitGroup;
+export declare function parseEquipmentList(rawEquipmentList: string): string[];
+export declare function parseEntity(rawEntity: string): Entity;
+export declare function parseVector(rawVector?: string): Vector;
+export declare function concatPattern(literals: TemplateStringsArray, ...placeholders: (string | RegExp)[]): RegExp;
+export declare function defineParser<T extends BaseEvent<string, unknown>>(parser: BaseParser<T>): BaseParser<T>;
+export {};

package/lib/models.js

@@ -0,0 +1,133 @@
+import { assertValidConnectionState, assertValidVector } from './assertions.js';
+import { convertSteamIdTo64Dec } from './helpers.js';
+// ----------------------------
+// Regular expressions
+// ----------------------------
+const baseWorldRe = /World/;
+export const baseEntityRe = /"(?<entityType>chicken|prop_physics_multiplayer|prop_dynamic)<(?<entityId>\d+)>"/;
+export const basePlayerRe = /"(?<name>.+)<(?<entityId>\d*)><(?<steamId>(?:\[U:[01]:\d+\]|STEAM_[0-5]:[01]:\d+|BOT|Console))>(?:<(?<team>[^>]*)>)?"/;
+export const vectorRe = /\[?[-.\d]+ [-.\d]+ [-.\d]+\]?/;
+export const entityRe = /".+<\d*><(?:\[U:[01]:\d+\]|STEAM_[0-5]:[01]:\d+|BOT|Console)>(?:<[^>]*>)?"|"chicken<\d+>"|World/;
+// ----------------------------
+// Enums
+// ----------------------------
+export var Team;
+(function (Team) {
+    Team[Team["Unassigned"] = 0] = "Unassigned";
+    Team[Team["Spectators"] = 1] = "Spectators";
+    Team[Team["Terrorists"] = 2] = "Terrorists";
+    Team[Team["CounterTerrorists"] = 3] = "CounterTerrorists";
+    Team[Team["Unknown"] = 999] = "Unknown";
+})(Team || (Team = {}));
+// ----------------------------
+// Mappings
+// ----------------------------
+export const teamMapping = {
+    Unassigned: Team.Unassigned,
+    Spectator: Team.Spectators,
+    TERRORIST: Team.Terrorists,
+    CT: Team.CounterTerrorists
+};
+// ----------------------------
+// Base parsers
+// ----------------------------
+export function parseTeam(rawTeam) {
+    const mappedTeam = teamMapping[rawTeam] ?? Team.Unknown;
+    return mappedTeam;
+}
+export function parseKillModifiers(rawModifiers) {
+    const modifiersArr = rawModifiers?.split(' ') ?? [];
+    return modifiersArr;
+}
+export function parseConnectionState(rawState) {
+    assertValidConnectionState(rawState);
+    return rawState;
+}
+export function parseHitGroup(rawHitGroup) {
+    // We don't want spaces in our values, and CS2 returns hitgroups with spaces:
+    // ("left leg", "right arm" etc), so we join them with underscores here
+    const formattedHitGroup = rawHitGroup.split(' ').join('_');
+    return formattedHitGroup;
+}
+export function parseEquipmentList(rawEquipmentList) {
+    const equipmentStr = rawEquipmentList.replaceAll('[', '').replaceAll(']', '').trim();
+    let equipment;
+    if (equipmentStr.length > 0) {
+        equipment = equipmentStr.split(' ');
+    }
+    else {
+        equipment = [];
+    }
+    return equipment;
+}
+export function parseEntity(rawEntity) {
+    // Test for "world" entity
+    if (baseWorldRe.test(rawEntity)) {
+        return {
+            type: 'world',
+        };
+    }
+    // Test for base entities (chicken, prop_dynamic & prop_physics_multiplayer)
+    if (baseEntityRe.test(rawEntity)) {
+        const baseEntityMatch = rawEntity.match(baseEntityRe);
+        const entityType = baseEntityMatch[1];
+        const entityId = Number(baseEntityMatch[2]);
+        if (entityType === 'chicken' || entityType === 'prop_dynamic' || entityType === 'prop_physics_multiplayer') {
+            return {
+                type: entityType,
+                id: entityId
+            };
+        }
+        else {
+            throw new Error(`Unknown base entity type "${rawEntity}"`);
+        }
+    }
+    if (basePlayerRe.test(rawEntity)) {
+        const { entityId: rawEntityId, steamId, name, team: rawTeam } = rawEntity.match(basePlayerRe).groups;
+        // Test for "Console" entity
+        if (steamId === 'Console') {
+            return {
+                type: 'console',
+            };
+        }
+        const entityId = Number(rawEntityId);
+        const team = parseTeam(rawTeam);
+        // Test for BOT entity
+        if (steamId === 'BOT') {
+            return {
+                type: 'bot',
+                id: entityId,
+                name,
+                team,
+            };
+        }
+        return {
+            type: 'player',
+            id: entityId,
+            steamId3: steamId,
+            steamId64: convertSteamIdTo64Dec(steamId),
+            name,
+            team,
+        };
+    }
+    throw new Error(`Failed to parse entity "${rawEntity}"`);
+}
+export function parseVector(rawVector) {
+    const vectorStrings = rawVector?.split(' ') ?? [];
+    const vectorNumbers = vectorStrings.map(Number);
+    assertValidVector(vectorNumbers);
+    return vectorNumbers;
+}
+export function concatPattern(literals, ...placeholders) {
+    let result = '';
+    for (let i = 0; i < placeholders.length; i += 1) {
+        result += literals[i];
+        const { [i]: placeholder } = placeholders;
+        result += placeholder instanceof RegExp ? placeholder.source : placeholder;
+    }
+    result += literals[literals.length - 1];
+    return new RegExp(result);
+}
+export function defineParser(parser) {
+    return parser;
+}

package/lib/parser.d.ts

@@ -0,0 +1,9 @@
+import type { LogTimestampFormat, BaseParser } from './models.js';
+import type { AssistedEvent, AttackedEvent, BlindedEvent, ConnectionEvent, EntityTriggeredEvent, KilledByBombEvent, KilledEvent, LeftBuyzoneEvent, PickedUpEvent, PurchasedEvent, RconEvent, SayEvent, ScoredEvent, SuicideEvent, SwitchedTeamEvent, TeamTriggeredEvent, ThrewEvent } from './parsers/index.js';
+export type Event = AssistedEvent | AttackedEvent | BlindedEvent | ConnectionEvent | EntityTriggeredEvent | KilledByBombEvent | KilledEvent | LeftBuyzoneEvent | PickedUpEvent | PurchasedEvent | RconEvent | SayEvent | ScoredEvent | SuicideEvent | SwitchedTeamEvent | TeamTriggeredEvent | ThrewEvent;
+export declare const defaultParsers: (BaseParser<AssistedEvent> | BaseParser<AttackedEvent> | BaseParser<BlindedEvent> | BaseParser<ConnectionEvent> | BaseParser<EntityTriggeredEvent> | BaseParser<KilledByBombEvent> | BaseParser<KilledEvent> | BaseParser<LeftBuyzoneEvent> | BaseParser<PickedUpEvent> | BaseParser<PurchasedEvent> | BaseParser<RconEvent> | BaseParser<SayEvent> | BaseParser<ScoredEvent> | BaseParser<SuicideEvent> | BaseParser<SwitchedTeamEvent> | BaseParser<TeamTriggeredEvent> | BaseParser<ThrewEvent>)[];
+export interface ParseOptions {
+    parsers?: BaseParser<Event>[];
+    format?: LogTimestampFormat;
+}
+export declare function parse(rawLog: string, parseOptions?: ParseOptions): Event | null;

package/lib/parser.js

@@ -0,0 +1,74 @@
+import { assistedParser, attackedParser, blindedParser, connectionParser, entityTriggeredParser, killedByBombParser, killedParser, leftBuyzoneParser, pickedUpParser, purchasedParser, rconParser, sayParser, scoredParser, suicideParser, switchedTeamParser, teamTriggeredParser, threwParser } from './parsers/index.js';
+export const defaultParsers = [
+    assistedParser,
+    attackedParser,
+    blindedParser,
+    connectionParser,
+    entityTriggeredParser,
+    killedByBombParser,
+    killedParser,
+    leftBuyzoneParser,
+    pickedUpParser,
+    purchasedParser,
+    rconParser,
+    sayParser,
+    scoredParser,
+    suicideParser,
+    switchedTeamParser,
+    teamTriggeredParser,
+    threwParser
+];
+// mm/dd/yyyy
+const { length: LENGTH_OF_DATE_FILE } = '01/01/1970 - 00:00:00: ';
+const { length: LENGTH_OF_DATE_HTTP } = '01/01/1970 - 00:00:00.000 - ';
+function parseTimestamp(timestamp) {
+    const [dateStr, timeStr] = timestamp.split(' - ');
+    const [month, day, year] = dateStr.split('/');
+    const [hours, minutes, seconds] = timeStr.split(':');
+    // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date#date_time_string_format
+    const dateTimeStringFormat = `${year}-${month}-${day}T${hours}:${minutes}:${seconds}Z`;
+    const date = new Date(dateTimeStringFormat);
+    return date;
+}
+export function parse(rawLog, parseOptions) {
+    if (parseOptions === undefined) {
+        parseOptions = {
+            parsers: defaultParsers,
+            format: 'file'
+        };
+    }
+    if (parseOptions.parsers === undefined) {
+        parseOptions.parsers = defaultParsers;
+    }
+    if (parseOptions.format === undefined) {
+        parseOptions.format = 'file';
+    }
+    let log;
+    let timestamp;
+    if (parseOptions.format === 'file') {
+        timestamp = rawLog.substring(0, LENGTH_OF_DATE_FILE - 2);
+        log = rawLog.substring(LENGTH_OF_DATE_FILE);
+    }
+    else if (parseOptions.format === 'http') {
+        timestamp = rawLog.substring(0, LENGTH_OF_DATE_HTTP - 3);
+        log = rawLog.substring(LENGTH_OF_DATE_HTTP);
+    }
+    else {
+        throw new Error('Invalid CS2 log date format specified.');
+    }
+    for (const parser of parseOptions.parsers) {
+        const pattern = parser.patterns.find((pattern) => pattern.test(log));
+        if (pattern === undefined) {
+            continue;
+        }
+        const groups = log.match(pattern).groups;
+        const receivedAt = parseTimestamp(timestamp);
+        const payload = parser.parse(groups);
+        return {
+            name: parser.name,
+            receivedAt: receivedAt,
+            payload
+        };
+    }
+    return null;
+}

package/lib/parsers/assisted.d.ts

@@ -0,0 +1,8 @@
+import type { BaseEvent, Entity } from '../models.js';
+export interface AssistedEventPayload {
+    assistant: Entity;
+    victim: Entity;
+    flashAssist: boolean;
+}
+export type AssistedEvent = BaseEvent<'assisted', AssistedEventPayload>;
+export declare const assistedParser: import("../models.js").BaseParser<AssistedEvent>;

package/lib/parsers/assisted.js

@@ -0,0 +1,15 @@
+import { defineParser, concatPattern, entityRe, parseEntity } from '../models.js';
+;
+export const assistedParser = defineParser({
+    name: 'assisted',
+    patterns: [
+        concatPattern `^(?<assistant>${entityRe}) (?<assistType>assisted|flash-assisted) killing (?<victim>${entityRe})$`
+    ],
+    parse({ assistant, victim, assistType }) {
+        return {
+            assistant: parseEntity(assistant),
+            victim: parseEntity(victim),
+            flashAssist: assistType === 'flash-assisted'
+        };
+    },
+});

package/lib/parsers/attacked.d.ts

@@ -0,0 +1,13 @@
+import type { BaseEvent, Entity, HitGroup } from '../models.js';
+export interface AttackedEventPayload {
+    attacker: Entity;
+    victim: Entity;
+    weapon: string;
+    damage: number;
+    damageArmor: number;
+    remainingHealth: number;
+    remainingArmor: number;
+    hitGroup: HitGroup;
+}
+export type AttackedEvent = BaseEvent<'attacked', AttackedEventPayload>;
+export declare const attackedParser: import("../models.js").BaseParser<AttackedEvent>;

package/lib/parsers/attacked.js

@@ -0,0 +1,25 @@
+import { defineParser, concatPattern, entityRe, vectorRe, parseEntity, parseVector, parseHitGroup } from '../models.js';
+export const attackedParser = defineParser({
+    name: 'attacked',
+    patterns: [
+        concatPattern `^(?<attacker>${entityRe}) \\[(?<attackerPos>${vectorRe})\\] attacked (?<victim>${entityRe}) \\[(?<victimPos>${vectorRe})\\] with "(?<weapon>[^"]+)" \\(damage "(?<damageAmount>[^"]+)"\\) \\(damage_armor "(?<damageArmorAmount>[^"]+)"\\) \\(health "(?<remainingHealth>[^"]+)"\\) \\(armor "(?<remainingArmor>[^"]+)"\\) \\(hitgroup "(?<hitGroup>[^"]+)"\\)$`,
+    ],
+    parse: ({ attacker, attackerPos, victim, victimPos, weapon, damageAmount, damageArmorAmount, remainingHealth, remainingArmor, hitGroup }) => {
+        return {
+            attacker: {
+                ...parseEntity(attacker),
+                position: parseVector(attackerPos)
+            },
+            victim: {
+                ...parseEntity(victim),
+                position: parseVector(victimPos)
+            },
+            damage: Number(damageAmount),
+            damageArmor: Number(damageArmorAmount),
+            remainingHealth: Number(remainingHealth),
+            remainingArmor: Number(remainingArmor),
+            hitGroup: parseHitGroup(hitGroup),
+            weapon
+        };
+    }
+});

package/lib/parsers/blinded.d.ts

@@ -0,0 +1,9 @@
+import type { BaseEvent, Entity } from '../models.js';
+export interface BlindedEventPayload {
+    attacker: Entity;
+    victim: Entity;
+    blindDuration: number;
+    flashbangIndex: number;
+}
+export type BlindedEvent = BaseEvent<'blinded', BlindedEventPayload>;
+export declare const blindedParser: import("../models.js").BaseParser<BlindedEvent>;

package/lib/parsers/blinded.js

@@ -0,0 +1,15 @@
+import { concatPattern, defineParser, entityRe, parseEntity } from '../models.js';
+export const blindedParser = defineParser({
+    name: 'blinded',
+    patterns: [
+        concatPattern `^(?<victim>${entityRe}) blinded for (?<blindDuration>[^"]+) by (?<attacker>${entityRe}) from flashbang entindex (?<entIndex>[^"]+)$`
+    ],
+    parse: ({ attacker, victim, blindDuration, entIndex }) => {
+        return {
+            attacker: parseEntity(attacker),
+            victim: parseEntity(victim),
+            blindDuration: Number(blindDuration),
+            flashbangIndex: Number(entIndex)
+        };
+    }
+});

package/lib/parsers/connection.d.ts

@@ -0,0 +1,20 @@
+import type { ConnectionState, BaseEvent, Entity } from '../models.js';
+interface BaseConnectionEvent {
+    state: ConnectionState;
+    client: Entity;
+}
+interface ConnectedEvent extends BaseConnectionEvent {
+    state: 'connected';
+    address: string;
+}
+interface EnteredEvent extends BaseConnectionEvent {
+    state: 'entered';
+}
+interface DisconnectedEvent extends BaseConnectionEvent {
+    state: 'disconnected';
+    reason: string;
+}
+export type ConnectionEventPayload = ConnectedEvent | EnteredEvent | DisconnectedEvent;
+export type ConnectionEvent = BaseEvent<'connection', ConnectionEventPayload>;
+export declare const connectionParser: import("../models.js").BaseParser<ConnectionEvent>;
+export {};

package/lib/parsers/connection.js

@@ -0,0 +1,34 @@
+import { defineParser, concatPattern, entityRe, parseEntity, parseConnectionState } from '../models.js';
+const basePattern = concatPattern `^(?<client>${entityRe})`;
+export const connectionParser = defineParser({
+    name: 'connection',
+    patterns: [
+        concatPattern `${basePattern} (?<state>entered) the game$`,
+        concatPattern `${basePattern} (?<state>connected), address "(?<address>[^"]*)"$`,
+        concatPattern `${basePattern} (?<state>disconnected) \\(reason "(?<reason>[^"]*)"\\)$`,
+    ],
+    parse: ({ client: rawClient, state: rawState, address, reason }) => {
+        const state = parseConnectionState(rawState);
+        const client = parseEntity(rawClient);
+        if (state === 'connected') {
+            return {
+                state,
+                client,
+                address
+            };
+        }
+        else if (state === 'entered') {
+            return {
+                state,
+                client
+            };
+        }
+        else {
+            return {
+                state,
+                client,
+                reason
+            };
+        }
+    }
+});

package/lib/parsers/entity-triggered.d.ts

@@ -0,0 +1,10 @@
+import type { Entity, BaseEvent } from '../models.js';
+type EntityTriggeredSubEvent = 'game_commencing' | 'warmup_start' | 'warmup_end' | 'match_start' | 'round_start' | 'round_end' | 'begin_bomb_defuse_with_kit' | 'begin_bomb_defuse_without_kit' | 'defused_the_bomb' | 'planted_the_bomb' | 'got_the_bomb' | 'dropped_the_bomb' | 'touched_a_hostage' | 'rescued_a_hostage';
+export interface EntityTriggeredEventPayload {
+    entity: Entity;
+    event: EntityTriggeredSubEvent;
+    value: string | null;
+}
+export type EntityTriggeredEvent = BaseEvent<'entity_triggered', EntityTriggeredEventPayload>;
+export declare const entityTriggeredParser: import("../models.js").BaseParser<EntityTriggeredEvent>;
+export {};

package/lib/parsers/entity-triggered.js

@@ -0,0 +1,17 @@
+import { defineParser, concatPattern, entityRe, parseEntity } from '../models.js';
+export const entityTriggeredParser = defineParser({
+    name: 'entity_triggered',
+    patterns: [
+        // concatPattern`^(?<entity>${entityRe}) triggered "(?<event>[^"]+)"(?: \\(value "(?<value>[^"]+)"\\))?$`,
+        concatPattern `^(?<entity>${entityRe}) triggered "(?<event>[^"]+)"$`,
+        concatPattern `^(?<entity>${entityRe}) triggered "(?<event>[^"]+)" on "(?<value>[^"]+)"$`,
+        concatPattern `^(?<entity>${entityRe}) triggered "(?<event>[^"]+)" at bombsite (?<value>[^"]+)$`
+    ],
+    parse: ({ entity, event, value }) => {
+        return {
+            entity: parseEntity(entity),
+            event: event.toLowerCase(),
+            value: value ?? null
+        };
+    }
+});

package/lib/parsers/index.d.ts

@@ -0,0 +1,17 @@
+export * from './assisted.js';
+export * from './attacked.js';
+export * from './blinded.js';
+export * from './connection.js';
+export * from './entity-triggered.js';
+export * from './killed-by-bomb.js';
+export * from './killed.js';
+export * from './left-buyzone.js';
+export * from './picked-up.js';
+export * from './purchased.js';
+export * from './rcon.js';
+export * from './say.js';
+export * from './scored.js';
+export * from './suicide.js';
+export * from './switched-team.js';
+export * from './team-triggered.js';
+export * from './threw.js';

package/lib/parsers/index.js

@@ -0,0 +1,17 @@
+export * from './assisted.js';
+export * from './attacked.js';
+export * from './blinded.js';
+export * from './connection.js';
+export * from './entity-triggered.js';
+export * from './killed-by-bomb.js';
+export * from './killed.js';
+export * from './left-buyzone.js';
+export * from './picked-up.js';
+export * from './purchased.js';
+export * from './rcon.js';
+export * from './say.js';
+export * from './scored.js';
+export * from './suicide.js';
+export * from './switched-team.js';
+export * from './team-triggered.js';
+export * from './threw.js';

package/lib/parsers/killed-by-bomb.d.ts

@@ -0,0 +1,4 @@
+import type { BaseEvent, Entity } from '../models.js';
+export type KilledByBombEventPayload = Entity;
+export type KilledByBombEvent = BaseEvent<'killed_by_bomb', KilledByBombEventPayload>;
+export declare const killedByBombParser: import("../models.js").BaseParser<KilledByBombEvent>;

package/lib/parsers/killed-by-bomb.js

@@ -0,0 +1,13 @@
+import { defineParser, concatPattern, entityRe, vectorRe, parseEntity, parseVector } from '../models.js';
+export const killedByBombParser = defineParser({
+    name: 'killed_by_bomb',
+    patterns: [
+        concatPattern `^(?<victim>${entityRe}) \\[(?<victimPos>${vectorRe})\\] was killed by the bomb.$`
+    ],
+    parse: ({ victim, victimPos }) => {
+        return {
+            ...parseEntity(victim),
+            position: parseVector(victimPos)
+        };
+    }
+});

package/lib/parsers/killed.d.ts

@@ -0,0 +1,9 @@
+import type { BaseEvent, Entity, KillModifier } from '../models.js';
+export interface KilledEventPayload {
+    attacker: Entity;
+    victim: Entity;
+    weapon: string;
+    modifiers: KillModifier[];
+}
+export type KilledEvent = BaseEvent<'killed', KilledEventPayload>;
+export declare const killedParser: import("../models.js").BaseParser<KilledEvent>;

package/lib/parsers/killed.js

@@ -0,0 +1,22 @@
+import { defineParser, concatPattern, entityRe, vectorRe, parseEntity, parseVector, parseKillModifiers, baseEntityRe } from '../models.js';
+export const killedParser = defineParser({
+    name: 'killed',
+    patterns: [
+        concatPattern `^(?<attacker>${entityRe}) \\[(?<attackerPos>${vectorRe})\\] killed (?<victim>${entityRe}) \\[(?<victimPos>${vectorRe})\\] with "(?<weapon>[^"]+)"(?: \\((?<modifiers>[^\\)]+)\\))?$`,
+        concatPattern `^(?<attacker>${entityRe}) \\[(?<attackerPos>${vectorRe})\\] killed other (?<victim>${baseEntityRe}) \\[(?<victimPos>${vectorRe})\\] with "(?<weapon>[^"]+)"(?: \\((?<modifiers>[^\\)]+)\\))?$`,
+    ],
+    parse: ({ attacker, attackerPos, victim, victimPos, weapon, modifiers }) => {
+        return {
+            attacker: {
+                ...parseEntity(attacker),
+                position: parseVector(attackerPos)
+            },
+            victim: {
+                ...parseEntity(victim),
+                position: parseVector(victimPos)
+            },
+            modifiers: parseKillModifiers(modifiers),
+            weapon
+        };
+    }
+});

package/lib/parsers/left-buyzone.d.ts

@@ -0,0 +1,7 @@
+import type { BaseEvent, Entity } from '../models.js';
+export interface LeftBuyzoneEventPayload {
+    player: Entity;
+    equipment: string[];
+}
+export type LeftBuyzoneEvent = BaseEvent<'left_buyzone', LeftBuyzoneEventPayload>;
+export declare const leftBuyzoneParser: import("../models.js").BaseParser<LeftBuyzoneEvent>;

package/lib/parsers/left-buyzone.js

@@ -0,0 +1,13 @@
+import { concatPattern, defineParser, entityRe, parseEntity, parseEquipmentList } from '../models.js';
+export const leftBuyzoneParser = defineParser({
+    name: 'left_buyzone',
+    patterns: [
+        concatPattern `^(?<player>${entityRe}) left buyzone with (?<equipment>\\[.*\\])$`
+    ],
+    parse: ({ player, equipment }) => {
+        return {
+            player: parseEntity(player),
+            equipment: parseEquipmentList(equipment)
+        };
+    }
+});

package/lib/parsers/picked-up.d.ts

@@ -0,0 +1,7 @@
+import type { BaseEvent, Entity } from '../models.js';
+export interface PickedUpEventPayload {
+    player: Entity;
+    weapon: string;
+}
+export type PickedUpEvent = BaseEvent<'picked_up', PickedUpEventPayload>;
+export declare const pickedUpParser: import("../models.js").BaseParser<PickedUpEvent>;

package/lib/parsers/picked-up.js

@@ -0,0 +1,13 @@
+import { defineParser, concatPattern, entityRe, parseEntity } from '../models.js';
+export const pickedUpParser = defineParser({
+    name: 'picked_up',
+    patterns: [
+        concatPattern `^(?<player>${entityRe}) picked up "(?<weapon>[^"]+)"$`
+    ],
+    parse: ({ player, weapon }) => {
+        return {
+            player: parseEntity(player),
+            weapon
+        };
+    }
+});

package/lib/parsers/purchased.d.ts

@@ -0,0 +1,7 @@
+import type { BaseEvent, Entity } from '../models.js';
+export interface PurchasedEventPayload {
+    player: Entity;
+    weapon: string;
+}
+export type PurchasedEvent = BaseEvent<'purchased', PurchasedEventPayload>;
+export declare const purchasedParser: import("../models.js").BaseParser<PurchasedEvent>;

package/lib/parsers/purchased.js

@@ -0,0 +1,13 @@
+import { defineParser, concatPattern, entityRe, parseEntity } from '../models.js';
+export const purchasedParser = defineParser({
+    name: 'purchased',
+    patterns: [
+        concatPattern `^(?<player>${entityRe}) purchased "(?<weapon>[^"]+)"$`
+    ],
+    parse: ({ player, weapon }) => {
+        return {
+            player: parseEntity(player),
+            weapon
+        };
+    }
+});

package/lib/parsers/rcon.d.ts

@@ -0,0 +1,7 @@
+import type { BaseEvent } from '../models.js';
+export interface RconEventPayload {
+    address: string;
+    command: string;
+}
+export type RconEvent = BaseEvent<'rcon', RconEventPayload>;
+export declare const rconParser: import("../models.js").BaseParser<RconEvent>;

package/lib/parsers/rcon.js

@@ -0,0 +1,13 @@
+import { defineParser, concatPattern } from '../models.js';
+export const rconParser = defineParser({
+    name: 'rcon',
+    patterns: [
+        concatPattern `^rcon from "(?<address>.+)": command "(?<command>.+)"$`,
+    ],
+    parse: ({ address, command }) => {
+        return {
+            address,
+            command
+        };
+    }
+});

package/lib/parsers/say.d.ts

@@ -0,0 +1,8 @@
+import type { BaseEvent, Entity, SayTo } from '../models.js';
+export interface SayEventPayload {
+    player: Entity;
+    to: SayTo;
+    message: string;
+}
+export type SayEvent = BaseEvent<'say', SayEventPayload>;
+export declare const sayParser: import("../models.js").BaseParser<SayEvent>;

package/lib/parsers/say.js

@@ -0,0 +1,14 @@
+import { defineParser, concatPattern, entityRe, parseEntity } from '../models.js';
+export const sayParser = defineParser({
+    name: 'say',
+    patterns: [
+        concatPattern `^(?<player>${entityRe}) (?<to>say|say_team) "(?<message>.+)"$`
+    ],
+    parse: ({ player, to, message }) => {
+        return {
+            player: parseEntity(player),
+            to: to === 'say_team' ? 'team' : 'all',
+            message
+        };
+    }
+});

package/lib/parsers/scored.d.ts

@@ -0,0 +1,8 @@
+import type { BaseEvent, Team } from '../models.js';
+export interface ScoredEventPayload {
+    team: Team;
+    score: number;
+    playerCount: number;
+}
+export type ScoredEvent = BaseEvent<'scored', ScoredEventPayload>;
+export declare const scoredParser: import("../models.js").BaseParser<ScoredEvent>;

package/lib/parsers/scored.js

@@ -0,0 +1,14 @@
+import { defineParser, parseTeam, concatPattern } from '../models.js';
+export const scoredParser = defineParser({
+    name: 'scored',
+    patterns: [
+        concatPattern `^Team "(?<team>[^"]+)" scored "(?<score>[^"]+)" with "(?<playerCount>[^"]+)" players$`
+    ],
+    parse: ({ team, score, playerCount }) => {
+        return {
+            team: parseTeam(team),
+            score: Number(score),
+            playerCount: Number(playerCount)
+        };
+    }
+});

package/lib/parsers/suicide.d.ts

@@ -0,0 +1,7 @@
+import type { Entity, SuicideMethod, BaseEvent } from '../models.js';
+export interface SuicideEventPayload {
+    player: Entity;
+    method: SuicideMethod;
+}
+export type SuicideEvent = BaseEvent<'suicide', SuicideEventPayload>;
+export declare const suicideParser: import("../models.js").BaseParser<SuicideEvent>;

package/lib/parsers/suicide.js

@@ -0,0 +1,16 @@
+import { defineParser, concatPattern, entityRe, vectorRe, parseEntity, parseVector } from '../models.js';
+export const suicideParser = defineParser({
+    name: 'suicide',
+    patterns: [
+        concatPattern `^(?<player>${entityRe}) \\[(?<playerPos>${vectorRe})\\] committed suicide with "(?<how>.+)"$`,
+    ],
+    parse: ({ player, playerPos, how }) => {
+        return {
+            player: {
+                ...parseEntity(player),
+                position: parseVector(playerPos),
+            },
+            method: how
+        };
+    }
+});

package/lib/parsers/switched-team.d.ts

@@ -0,0 +1,8 @@
+import type { Entity, Team, BaseEvent } from '../models.js';
+export interface SwitchedTeamEventPayload {
+    player: Entity;
+    fromTeam: Team;
+    toTeam: Team;
+}
+export type SwitchedTeamEvent = BaseEvent<'switched_team', SwitchedTeamEventPayload>;
+export declare const switchedTeamParser: import("../models.js").BaseParser<SwitchedTeamEvent>;

package/lib/parsers/switched-team.js

@@ -0,0 +1,14 @@
+import { defineParser, concatPattern, entityRe, parseEntity, parseTeam } from '../models.js';
+export const switchedTeamParser = defineParser({
+    name: 'switched_team',
+    patterns: [
+        concatPattern `^(?<player>${entityRe}) switched from team <(?<fromTeam>[^>]+)> to <(?<toTeam>[^>]+)>$`
+    ],
+    parse: ({ player, fromTeam, toTeam }) => {
+        return {
+            player: parseEntity(player),
+            fromTeam: parseTeam(fromTeam),
+            toTeam: parseTeam(toTeam)
+        };
+    }
+});

package/lib/parsers/team-triggered.d.ts

@@ -0,0 +1,11 @@
+import type { Team, BaseEvent } from '../models.js';
+type TeamTriggeredSubEvent = 'sfui_notice_terrorists_win' | 'sfui_notice_cts_win' | 'sfui_notice_target_bombed' | 'sfui_notice_target_saved' | 'sfui_notice_bomb_defused' | 'sfui_notice_hostages_not_rescued' | 'sfui_notice_all_hostages_rescued';
+export interface TeamTriggeredEventPayload {
+    team: Team;
+    event: TeamTriggeredSubEvent;
+    tScore: number;
+    ctScore: number;
+}
+export type TeamTriggeredEvent = BaseEvent<'team_triggered', TeamTriggeredEventPayload>;
+export declare const teamTriggeredParser: import("../models.js").BaseParser<TeamTriggeredEvent>;
+export {};

package/lib/parsers/team-triggered.js

@@ -0,0 +1,15 @@
+import { parseTeam, defineParser, concatPattern } from '../models.js';
+export const teamTriggeredParser = defineParser({
+    name: 'team_triggered',
+    patterns: [
+        concatPattern `^Team "(?<team>[^"]+)" triggered "(?<event>[^"]+)" \\(CT "(?<ctScore>\\d+)"\\) \\(T "(?<tScore>\\d+)"\\)$`
+    ],
+    parse: ({ team, tScore, ctScore, event }) => {
+        return {
+            team: parseTeam(team),
+            tScore: Number(tScore),
+            ctScore: Number(ctScore),
+            event: event.toLowerCase()
+        };
+    }
+});

package/lib/parsers/threw.d.ts

@@ -0,0 +1,9 @@
+import type { Entity, BaseEvent, Vector } from '../models.js';
+export interface ThrewEventPayload {
+    player: Entity;
+    grenade: string;
+    position: Vector;
+    entIndex: number | null;
+}
+export type ThrewEvent = BaseEvent<'threw', ThrewEventPayload>;
+export declare const threwParser: import("../models.js").BaseParser<ThrewEvent>;

package/lib/parsers/threw.js

@@ -0,0 +1,16 @@
+import { concatPattern, defineParser, entityRe, vectorRe, parseEntity, parseVector } from '../models.js';
+export const threwParser = defineParser({
+    name: 'threw',
+    patterns: [
+        concatPattern `^(?<player>${entityRe}) threw (?<grenade>.+) \\[(?<position>${vectorRe})\\]$`,
+        concatPattern `^(?<player>${entityRe}) threw (?<grenade>.+) \\[(?<position>${vectorRe})\\] flashbang entindex (?<entIndex>.+)\\)$`
+    ],
+    parse: ({ player, grenade, position, entIndex }) => {
+        return {
+            player: parseEntity(player),
+            position: parseVector(position),
+            entIndex: Number(entIndex) || null,
+            grenade
+        };
+    }
+});

package/package.json

@@ -0,0 +1,43 @@
+{
+	"name": "cs2-log-parser",
+	"version": "1.0.0",
+	"description": "Parses CS2 logs into JavaScript objects.",
+	"license": "MIT",
+	"author": "GekasD",
+	"keywords": [
+		"cs2",
+		"source2",
+		"log",
+		"parser",
+		"counter-strike",
+		"counter-strike-2"
+	],
+	"homepage": "https://github.com/GekasD/cs2-log-parser",
+	"type": "module",
+	"main": "lib/index.js",
+	"files": [
+		"lib/**/*"
+	],
+	"engines": {
+		"node": ">=22.0.0"
+	},
+	"scripts": {
+		"build": "npm run clean && npm run lint && npm run transpile",
+		"clean": "rimraf lib",
+		"lint": "eslint --fix",
+		"transpile": "tsc",
+		"test": "node --import tsx --test tests/*.test.ts",
+		"prepare": "npm run build"
+	},
+	"devDependencies": {
+		"@eslint/eslintrc": "^3.3.1",
+		"@eslint/js": "^9.37.0",
+		"@types/node": "^24.6.2",
+		"@typescript-eslint/eslint-plugin": "^8.46.0",
+		"@typescript-eslint/parser": "^8.46.0",
+		"eslint": "^9.37.0",
+		"rimraf": "^6.0.1",
+		"tsx": "^4.20.6",
+		"typescript": "^5.9.2"
+	}
+}