@zebbedaja/er-save-parser 0.1.2 → 0.1.4

package/dist/index.d.mts

@@ -2,6 +2,7 @@
 type LogLevel = 'debug' | 'info' | 'warn' | 'error' | 'none';
 interface ParseOptions {
   logLevel?: LogLevel;
+  includeEventFlagUInt8Array?: boolean;
 }
 interface Save {
   magicBytes?: string;
@@ -79,6 +80,7 @@ interface Slot {
   notAloneFlag?: number;
   inGameCountdownTimer?: number;
   eventFlags?: EventFlag[];
+  eventFlagUint8Array?: Uint8Array;
 }
 interface Character {
   unk0x0?: number;
@@ -141,6 +143,12 @@ interface EventFlag {
   location?: string;
   state?: boolean;
 }
+interface BitDifference {
+  offset: number;
+  bitIndex: number;
+  oldBit: 0 | 1;
+  newBit: 0 | 1;
+}
 //#endregion
 //#region src/parser.d.ts
 /**
@@ -149,8 +157,93 @@ interface EventFlag {
  * @param buffer - The ArrayBuffer containing the save file data
  * @param options - Optional configuration for parsing
  * @param options.logLevel - Log level threshold: 'debug', 'info', 'warn', 'error', or 'none'. Defaults to 'error'
+ * @param options.includeEventFlagUInt8Array - Includes the raw event flag array data
  * @returns A Save object containing parsed slot and profile data
  */
 declare function parse(buffer: ArrayBuffer, options?: ParseOptions): Save;
 //#endregion
-export { type Character, type EventFlag, type LogLevel, type ParseOptions, type ProfileSummary, type Save, type Settings, type Slot, parse };
+//#region src/util.d.ts
+/**
+ * Compare two ArrayBuffers for byte-by-byte equality.
+ *
+ * @param buf1 - The first ArrayBuffer to compare
+ * @param buf2 - The second ArrayBuffer to compare
+ * @returns True if both buffers have identical byte content
+ */
+declare function arrayBuffersEqual(buf1: ArrayBuffer, buf2: ArrayBuffer): boolean;
+/**
+ * Convert a string into an array of byte values.
+ *
+ * @param string - The string to convert
+ * @returns An array of ASCII/Unicode byte values for each character
+ */
+declare function stringToBytes(string: string): number[];
+/**
+ * Convert an ArrayBuffer to a lowercase hexadecimal string.
+ *
+ * @param buffer - The ArrayBuffer to convert
+ * @returns A lowercase hexadecimal string representation of the buffer
+ */
+declare function toHexString(buffer: ArrayBuffer): string;
+/**
+ * Remove all null ('\x00') characters from a string.
+ *
+ * @param text - The string to clean
+ * @returns The input string with all null ('\x00') characters removed
+ */
+declare const trim: (text: string) => string;
+/**
+ * Parse a string of delimiter-separated "key,value" pairs into a Map.
+ *
+ * @param text - A string of delimiter-separated pairs, one per line
+ * @param delimiter - The character separating key and value (default: ",")
+ * @returns A Map with numeric keys and values parsed from the input
+ */
+declare const parseToMap: (text: string, delimiter?: string) => Map<number, number>;
+/**
+ * Returns tha Bst Map as a Map
+ *
+ * @returns Bst Map as Map
+ */
+declare const getBstMap: () => Map<number, number>;
+/**
+ * Determine whether a specific event flag is set.
+ *
+ * @param bstMap - A map of block IDs to their binary offsets
+ * @param eventFlags - The raw event_flags byte array from the save data
+ * @param eventId - The event ID to check
+ * @returns True if the event flag is set (active), false otherwise
+ */
+declare const getEventFlagState: (bstMap: Map<number, number>, eventFlags: Uint8Array, eventId: number) => boolean;
+/**
+ * Determine the event ID from a byte position and bit index.
+ *
+ * @param bstMap - A map of block IDs to their binary offsets
+ * @param bytePos - The byte position in the event_flags array
+ * @param bitIndex - The bit index within the byte (0-7)
+ * @returns The event ID corresponding to the given position
+ */
+declare const getEventIdFromPosition: (bstMap: Map<number, number>, bytePos: number, bitIndex: number) => number;
+/**
+ * Compares two Uint8Arrays and returns all bit-level differences.
+ *
+ * Arrays of different lengths are supported — missing bytes in the shorter
+ * array are treated as `0`.
+ *
+ * @param a - The original Uint8Array.
+ * @param b - The Uint8Array to compare against.
+ * @returns An array of {@link BitDifference} objects, one per differing bit.
+ *
+ * @example
+ * const a = new Uint8Array([0b00001111, 0b11110000]);
+ * const b = new Uint8Array([0b00001111, 0b10110001]);
+ *
+ * const diffs = compareUint8Arrays(a, b);
+ * // [
+ * //   { offset: 1, bitIndex: 0, oldBit: 0, newBit: 1 },
+ * //   { offset: 1, bitIndex: 6, oldBit: 1, newBit: 0 },
+ * // ]
+ */
+declare const compareUint8Arrays: (a: Uint8Array, b: Uint8Array) => BitDifference[];
+//#endregion
+export { type BitDifference, type Character, type EventFlag, type LogLevel, type ParseOptions, type ProfileSummary, type Save, type Settings, type Slot, arrayBuffersEqual, compareUint8Arrays, getBstMap, getEventFlagState, getEventIdFromPosition, parse, parseToMap, stringToBytes, toHexString, trim };