@sie-js/vkp 1.0.6 → 2.0.0

package/README.md

@@ -16,14 +16,14 @@ import fs from 'fs';
 import { vkpNormalize, vkpParse } from '@sie-js/vkp';
 
 // Convert from windows-1251 to UTF-8 + replace CRLF to LF
-let patchText = vkpNormalize(fs.readFileSync('../patches/patches/E71v45/10732-ElfPack-18_03_2024-v3_2_2.vkp'));
+const patchText = vkpNormalize(fs.readFileSync('../patches/patches/E71v45/10732-ElfPack-18_03_2024-v3_2_2.vkp'));
 
 // Parse patch
-let vkp = vkpParse(patchText);
+const vkp = vkpParse(patchText);
 console.dir(vkp, { depth: null });
 
 if (vkp.warnings.length || vkp.errors.length) {
-    for (let warn of vkp.warnings) {
+    for (const warn of vkp.warnings) {
         console.log(`Warning: ${warn.message}`);
         console.log("```");
         console.log(warn.codeFrame(patchText));
@@ -31,7 +31,7 @@ if (vkp.warnings.length || vkp.errors.length) {
         console.log("");
     }
 
-    for (let err of vkp.errors) {
+    for (const err of vkp.errors) {
         console.log(`Error: ${err.message}`);
         console.log("```");
         console.log(err.codeFrame(patchText));

package/dist/src/VkpParseError.d.ts

@@ -0,0 +1,12 @@
+export interface VkpLocation {
+    line: number;
+    column: number;
+}
+export declare class VkpParseError extends Error {
+    loc: VkpLocation;
+    hint?: string;
+    constructor(message: string, loc: VkpLocation, hint?: string);
+    codeFrame(text: string): string;
+}
+export declare function codeFrame(text: string, lineNum: number, colNum: number): string;
+export declare function getLocByOffset(text: string, offset: number): VkpLocation;

package/dist/src/VkpParseError.js

@@ -0,0 +1,65 @@
+export class VkpParseError extends Error {
+    loc;
+    hint;
+    constructor(message, loc, hint) {
+        super(`${message} at line ${loc.line} col ${loc.column}${hint ? "\n" + hint : ""}`);
+        this.name = "VkpParseError";
+        this.loc = loc;
+        this.hint = hint;
+    }
+    codeFrame(text) {
+        return codeFrame(text, this.loc.line, this.loc.column);
+    }
+}
+export function codeFrame(text, lineNum, colNum) {
+    const lines = text.split(/\r\n|\n/);
+    const maxLineNumLen = lines.length.toString().length + 1;
+    let out = "";
+    let n = 1;
+    for (const line of lines) {
+        if (Math.abs(n - lineNum) > 3) {
+            n++;
+            continue;
+        }
+        out += `${n == lineNum ? '>' : ' '}${n.toString().padStart(maxLineNumLen, ' ')} | ${tabToSpaces(line)}\n`;
+        if (n == lineNum) {
+            out += ` ${" ".repeat(maxLineNumLen)} | ${strToSpaces(line.substring(0, colNum - 1))}^\n`;
+        }
+        n++;
+    }
+    return out;
+}
+export function getLocByOffset(text, offset) {
+    let line = 1;
+    let column = 1;
+    for (let i = 0; i < text.length; i++) {
+        const c = text.charAt(i);
+        if (c == "\n") {
+            column = 1;
+            line++;
+        }
+        if (i == offset)
+            return { line, column };
+    }
+    return { line, column: 1 };
+}
+function strToSpaces(line) {
+    return tabToSpaces(line).replace(/./g, ' ');
+}
+function tabToSpaces(line) {
+    let newStr = "";
+    let virtualSymbols = 0;
+    for (let i = 0; i < line.length; i++) {
+        const c = line.charAt(i);
+        if (c == "\t") {
+            const spacesCnt = 4 - virtualSymbols % 4;
+            newStr += " ".repeat(spacesCnt);
+            virtualSymbols += spacesCnt;
+        }
+        else {
+            virtualSymbols++;
+            newStr += c;
+        }
+    }
+    return newStr;
+}

package/dist/src/index.d.ts

@@ -0,0 +1,33 @@
+import { VkpPragmaName } from "./parser.js";
+import { VkpLocation, VkpParseError } from "./VkpParseError.js";
+export type VkpContentType = "RTF" | "PATCH" | "DOWNLOAD_STUB" | "EMPTY" | "UNKNOWN";
+export interface VkpWrite {
+    addr: number;
+    size: number;
+    old?: Buffer;
+    new: Buffer;
+    loc: VkpLocation;
+    pragmas: Record<VkpPragmaName, boolean>;
+}
+export interface VkpParseResult {
+    valid: boolean;
+    writes: VkpWrite[];
+    warnings: VkpParseError[];
+    errors: VkpParseError[];
+}
+export interface VkpParseOptions {
+    allowEmptyOldData?: boolean;
+    allowPlaceholders?: boolean;
+}
+export interface VkpOffsetCorrector {
+    value: number;
+    text: string;
+    loc: VkpLocation;
+}
+export declare function vkpParse(text: string, options?: VkpParseOptions): VkpParseResult;
+export declare function vkpDetectContent(text: string): VkpContentType;
+export declare function vkpNormalizeWithRTF(text: Buffer): Promise<string>;
+export declare function vkpNormalize(text: Buffer): string;
+export declare function vkpCanonicalize(text: string): Buffer;
+export * from "./parser.js";
+export * from "./VkpParseError.js";

package/dist/src/index.js

@@ -0,0 +1,156 @@
+import iconv from "iconv-lite";
+import { vkpRawParser } from "./parser.js";
+import { VkpParseError } from "./VkpParseError.js";
+const DEFAULT_PRAGMAS = {
+    warn_no_old_on_apply: true,
+    warn_if_new_exist_on_apply: true,
+    warn_if_old_exist_on_undo: true,
+    undo: true,
+    old_equal_ff: false,
+};
+export function vkpParse(text, options) {
+    const validOptions = {
+        allowEmptyOldData: false,
+        allowPlaceholders: false,
+        ...options
+    };
+    const vkp = {
+        valid: false,
+        writes: [],
+        warnings: [],
+        errors: [],
+    };
+    const pragmas = { ...DEFAULT_PRAGMAS };
+    const pragmaToLocation = {};
+    let offsetCorrector;
+    vkpRawParser(text, {
+        onPragma(value, loc) {
+            const pragmaName = value.pragma.name;
+            if (value.pragma.action == "enable") {
+                if (pragmas[pragmaName]) {
+                    vkp.warnings.push(new VkpParseError(`Useless "#pragma ${value.pragma.action} ${pragmaName}" has no effect`, loc, `You can safely remove this line.`));
+                }
+                else {
+                    pragmas[pragmaName] = true;
+                    pragmaToLocation[pragmaName] = loc;
+                }
+            }
+            else if (value.pragma.action == "disable") {
+                if (!pragmas[pragmaName]) {
+                    vkp.warnings.push(new VkpParseError(`Useless "#pragma ${value.pragma.action} ${pragmaName}" has no effect`, loc, `You can safely remove this line.`));
+                }
+                else {
+                    pragmaToLocation[pragmaName] = loc;
+                    pragmas[pragmaName] = false;
+                }
+            }
+        },
+        onPatchData(data, loc) {
+            let oldData = data.old ? data.old.buffer : undefined;
+            const newData = data.new.buffer;
+            if (data.new.placeholders > 0) {
+                if (!validOptions.allowPlaceholders)
+                    vkp.errors.push(new VkpParseError(`Found placeholder instead of real patch data`, data.new.loc));
+            }
+            if (pragmas.old_equal_ff && !oldData)
+                oldData = Buffer.alloc(newData.length).fill(0xFF);
+            if (oldData && oldData.length < newData.length) {
+                vkp.errors.push(new VkpParseError(`Old data (${oldData.length} bytes) is less than new data (${newData.length} bytes)`, data.old.loc));
+            }
+            if (pragmas.warn_no_old_on_apply && !oldData) {
+                if (!validOptions.allowEmptyOldData) {
+                    vkp.warnings.push(new VkpParseError(`Old data is not specified`, data.new.loc, `Undo operation is impossible!`));
+                }
+            }
+            vkp.writes.push({
+                addr: (offsetCorrector ? offsetCorrector.value : 0) + data.address,
+                size: newData.length,
+                old: oldData,
+                new: newData,
+                loc,
+                pragmas: { ...pragmas }
+            });
+        },
+        onOffset(value, loc) {
+            offsetCorrector = { value: value.offset, text: value.text, loc };
+        },
+        onWarning(e) {
+            vkp.warnings.push(e);
+        },
+        onError(e) {
+            vkp.errors.push(e);
+        }
+    });
+    for (const k of Object.keys(pragmas)) {
+        if (pragmas[k] !== DEFAULT_PRAGMAS[k]) {
+            const cancel = pragmas[k] ? `#pragma disable ${k}` : `#pragma enable ${k}`;
+            vkp.warnings.push(new VkpParseError(`Uncanceled pragma "${k}"`, pragmaToLocation[k], `Please put "${cancel}" at the end of the patch.`));
+        }
+    }
+    if (offsetCorrector && offsetCorrector.value != 0) {
+        vkp.warnings.push(new VkpParseError(`Uncanceled offset ${offsetCorrector.text}`, offsetCorrector.loc, `Please put "+0" at the end of the patch.`));
+    }
+    vkp.valid = (vkp.errors.length == 0);
+    return vkp;
+}
+export function vkpDetectContent(text) {
+    if (text.indexOf('{\\rtf1') >= 0)
+        return "RTF";
+    const trimmedText = text.replace(/\/\*.*?\*\//gs, '').replace(/(\/\/|;|#).*?$/mg, '');
+    if (trimmedText.match(/^\s*(0x[a-f0-9]+|[a-f0-9]+)\s*:[^\\/]/mi))
+        return "PATCH";
+    if (text.match(/;!(к патчу прикреплён файл|There is a file attached to this patch), https?:\/\//i))
+        return "DOWNLOAD_STUB";
+    if (!trimmedText.trim().length)
+        return "EMPTY";
+    return "UNKNOWN";
+}
+// CP1251 -> UTF-8 + CRLF -> LF (with RTF support)
+export async function vkpNormalizeWithRTF(text) {
+    if (!Buffer.isBuffer(text))
+        throw new Error(`Patch text is not Buffer!`);
+    const { default: RTFParser } = await import('rtf-parser');
+    if (text.indexOf('{\\rtf1') >= 0) {
+        // Strip RTF images
+        while (true) {
+            const pictureIndex = text.indexOf('{\\pict');
+            if (pictureIndex >= 0) {
+                const pictureEndIndex = text.indexOf('}', pictureIndex);
+                if (pictureIndex >= 0) {
+                    text = Buffer.concat([text.subarray(0, pictureIndex), text.subarray(pictureEndIndex + 1)]);
+                    continue;
+                }
+            }
+            break;
+        }
+        const textStr = text.toString('utf-8').replace(/{\\pict.*?}/gsi, ''); // remove pictures
+        const parsed = await new Promise((resolve, reject) => {
+            RTFParser.string(textStr, (err, doc) => {
+                if (err) {
+                    reject(err);
+                }
+                else {
+                    resolve(doc);
+                }
+            });
+        });
+        const lines = [];
+        for (const p of parsed.content) {
+            lines.push(p.content.map((s) => s.value).join(''));
+        }
+        return lines.join('\n');
+    }
+    return iconv.decode(text, 'windows-1251').replace(/(\r\n|\n|\r)/g, "\n");
+}
+// CP1251 -> UTF-8 + CRLF -> LF
+export function vkpNormalize(text) {
+    if (!Buffer.isBuffer(text))
+        throw new Error(`Patch text is not Buffer!`);
+    return iconv.decode(text, 'windows-1251').replace(/(\r\n|\n|\r)/g, "\n");
+}
+// UTF-8 -> CP1251 + LF -> CRLF
+export function vkpCanonicalize(text) {
+    return iconv.encode(text.replace(/(\r\n|\n|\r)/g, "\r\n"), 'windows-1251');
+}
+export * from "./parser.js";
+export * from "./VkpParseError.js";

package/dist/src/index.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/src/index.test.js

@@ -0,0 +1,381 @@
+import { test, expect } from "vitest";
+import { vkpParse } from "./index.js";
+test('warn: useless pragma', () => {
+    const vkp = vkpParse(`#pragma enable warn_no_old_on_apply`);
+    expect(vkp.valid).toBe(true);
+    expect(vkp.warnings.length).toBe(1);
+    expect(vkp.warnings[0]).toHaveProperty("message", "Useless \"#pragma enable warn_no_old_on_apply\" has no effect at line 1 col 1\nYou can safely remove this line.");
+});
+test('warn: uncanceled pragma', () => {
+    const vkp = vkpParse(`#pragma disable warn_no_old_on_apply`);
+    expect(vkp.valid).toBe(true);
+    expect(vkp.warnings.length).toBe(1);
+    expect(vkp.warnings[0]).toHaveProperty("message", "Uncanceled pragma \"warn_no_old_on_apply\" at line 1 col 1\nPlease put \"#pragma enable warn_no_old_on_apply\" at the end of the patch.");
+});
+test('warn: uncanceled offset', () => {
+    const vkp = vkpParse(`+123`);
+    expect(vkp.valid).toBe(true);
+    expect(vkp.warnings.length).toBe(1);
+    expect(vkp.warnings[0]).toHaveProperty("message", "Uncanceled offset +123 at line 1 col 1\nPlease put \"+0\" at the end of the patch.");
+});
+test('warn: bad comments', () => {
+    const vkp = vkpParse(`
+		*/
+		/* comment...
+	`);
+    expect(vkp.valid).toBe(true);
+    expect(vkp.warnings.length).toBe(2);
+    expect(vkp.warnings[0]).toHaveProperty("message", "Trailing multiline comment end at line 2 col 3");
+    expect(vkp.warnings[1]).toHaveProperty("message", "Unfinished multiline comment at line 3 col 3");
+});
+test('warn: no old data', () => {
+    const vkp = vkpParse(`
+		AA: BB
+	`);
+    expect(vkp.valid).toBe(true);
+    expect(vkp.warnings.length).toBe(1);
+    expect(vkp.warnings[0]).toHaveProperty("message", "Old data is not specified at line 2 col 7\nUndo operation is impossible!");
+});
+test('error: space after number', () => {
+    const vkp = vkpParse(`
+		AAAA: BB 0i123; comment
+		AAAA: BB 0x12; comment
+		AAAA: BB CC; comment
+	`);
+    expect(vkp.valid).toBe(false);
+    expect(vkp.warnings.length).toBe(0);
+    expect(vkp.errors.length).toBe(2);
+    expect(vkp.errors[0]).toHaveProperty("message", "No whitespace between number and comment at line 2 col 17");
+    expect(vkp.errors[1]).toHaveProperty("message", "No whitespace between number and comment at line 3 col 16");
+});
+test('error: placeholder', () => {
+    const vkp = vkpParse(`AAAA: BB XX`);
+    expect(vkp.valid).toBe(false);
+    expect(vkp.warnings.length).toBe(0);
+    expect(vkp.errors.length).toBe(1);
+    expect(vkp.errors[0]).toHaveProperty("message", "Found placeholder instead of real patch data at line 1 col 10");
+});
+test('error: invalid hex data', () => {
+    const vkp = vkpParse(`AAAA: BB B`);
+    expect(vkp.valid).toBe(false);
+    expect(vkp.warnings.length).toBe(0);
+    expect(vkp.errors.length).toBe(1);
+    expect(vkp.errors[0]).toHaveProperty("message", "Hex data (B) must be even length at line 1 col 10");
+});
+test('error: old data is less than new data', () => {
+    const vkp = vkpParse(`AAAA: BB BBCC`);
+    expect(vkp.valid).toBe(false);
+    expect(vkp.warnings.length).toBe(0);
+    expect(vkp.errors.length).toBe(1);
+    expect(vkp.errors[0]).toHaveProperty("message", "Old data (1 bytes) is less than new data (2 bytes) at line 1 col 7");
+});
+test('error: comment tokens in string', () => {
+    const vkp = vkpParse(`
+		AAAA: AABBCCDDEE "//"
+		AAAA: AABBCCDDEE "/*"
+		AAAA: AABBCCDDEE "\\/\\/"
+		AAAA: AABBCCDDEE "\\/\\*"
+	`);
+    expect(vkp.valid).toBe(false);
+    expect(vkp.warnings.length).toBe(0);
+    expect(vkp.errors.length).toBe(2);
+    expect(vkp.errors[0]).toHaveProperty("message", "Unescaped // is not allowed in string: \"//\" at line 2 col 20\nEscape these ambiguous characters like this: \\/* or \\/\\/.");
+    expect(vkp.errors[1]).toHaveProperty("message", "Unescaped /* is not allowed in string: \"/*\" at line 3 col 20\nEscape these ambiguous characters like this: \\/* or \\/\\/.");
+});
+test('error: number ranges', () => {
+    const vkp = vkpParse(`
+		AAAA: AABBCCDDEE 0i0,0i999
+		AAAA: AABBCCDDEE 0i0,0i99999
+		AAAA: AABBCCDDEE 0i0,0i99999999
+		AAAA: AABBCCDDEE 0i0,0i9999999999
+		AAAA: AABBCCDDEE 0i0,0i9999999999999
+		AAAA: AABBCCDDEE 0i0,0i999999999999999
+		AAAA: AABBCCDDEE 0i0,0i99999999999999999
+		AAAA: AABBCCDDEE 0i0,0i99999999999999999999
+
+		AAAA: AABBCCDDEE 0i0,0i-999
+		AAAA: AABBCCDDEE 0i0,0i-99999
+		AAAA: AABBCCDDEE 0i0,0i-99999999
+		AAAA: AABBCCDDEE 0i0,0i-9999999999
+		AAAA: AABBCCDDEE 0i0,0i-9999999999999
+		AAAA: AABBCCDDEE 0i0,0i-999999999999999
+		AAAA: AABBCCDDEE 0i0,0i-99999999999999999
+		AAAA: AABBCCDDEE 0i0,0i-99999999999999999999
+	`);
+    expect(vkp.valid).toBe(false);
+    expect(vkp.warnings.length).toBe(0);
+    expect(vkp.errors.length).toBe(16);
+    expect(vkp.errors[0]).toHaveProperty("message", "Number 0i999 exceeds allowed range 0 ... 255 at line 2 col 24");
+    expect(vkp.errors[1]).toHaveProperty("message", "Number 0i99999 exceeds allowed range 0 ... 65535 at line 3 col 24");
+    expect(vkp.errors[2]).toHaveProperty("message", "Number 0i99999999 exceeds allowed range 0 ... 16777215 at line 4 col 24");
+    expect(vkp.errors[3]).toHaveProperty("message", "Number 0i9999999999 exceeds allowed range 0 ... 4294967295 at line 5 col 24");
+    expect(vkp.errors[4]).toHaveProperty("message", "Number 0i9999999999999 exceeds allowed range 0 ... 1099511627775 at line 6 col 24");
+    expect(vkp.errors[5]).toHaveProperty("message", "Number 0i999999999999999 exceeds allowed range 0 ... 281474976710655 at line 7 col 24");
+    expect(vkp.errors[6]).toHaveProperty("message", "Number 0i99999999999999999 exceeds allowed range 0 ... 72057594037927935 at line 8 col 24");
+    expect(vkp.errors[7]).toHaveProperty("message", "Number 0i99999999999999999999 exceeds allowed range 0 ... 18446744073709551615 at line 9 col 24");
+    expect(vkp.errors[8]).toHaveProperty("message", "Number 0i-999 exceeds allowed range -127 ... +127 at line 11 col 24");
+    expect(vkp.errors[9]).toHaveProperty("message", "Number 0i-99999 exceeds allowed range -32767 ... +32767 at line 12 col 24");
+    expect(vkp.errors[10]).toHaveProperty("message", "Number 0i-99999999 exceeds allowed range -8388607 ... +8388607 at line 13 col 24");
+    expect(vkp.errors[11]).toHaveProperty("message", "Number 0i-9999999999 exceeds allowed range -2147483647 ... +2147483647 at line 14 col 24");
+    expect(vkp.errors[12]).toHaveProperty("message", "Number 0i-9999999999999 exceeds allowed range -549755813887 ... +549755813887 at line 15 col 24");
+    expect(vkp.errors[13]).toHaveProperty("message", "Number 0i-999999999999999 exceeds allowed range -140737488355327 ... +140737488355327 at line 16 col 24");
+    expect(vkp.errors[14]).toHaveProperty("message", "Number 0i-99999999999999999 exceeds allowed range -36028797018963967 ... +36028797018963967 at line 17 col 24");
+    expect(vkp.errors[15]).toHaveProperty("message", "Number 0i-99999999999999999999 exceeds allowed range -9223372036854775807 ... +9223372036854775807 at line 18 col 24");
+});
+test('error: bad numbers', () => {
+    const vkp = vkpParse(`
+		AAAA: AABBCCDDEE 0i0,0n1234
+		AAAA: AABBCCDDEE 0i0,0n111111111111111111111111111111111
+	`);
+    expect(vkp.valid).toBe(false);
+    expect(vkp.warnings.length).toBe(0);
+    expect(vkp.errors.length).toBe(2);
+    expect(vkp.errors[0]).toHaveProperty("message", "Syntax error at line 2 col 24");
+    expect(vkp.errors[1]).toHaveProperty("message", "Number 0n111111111111111111111111111111111 exceeds allowed range 0n0 ... 0n11111111111111111111111111111111 at line 3 col 24");
+});
+test('error: bad decimal numbers', () => {
+    const vkp = vkpParse(`
+		00000000: FF,FF,FF 0i+000,0i+00,0i+0
+		00000000: FFFF 0i+0000
+		00000000: FFFFFF 0i+0000000
+		00000000: FFFFFFFF 0i+000000000
+		00000000: FFFFFFFFFF 0i+000000000000
+		00000000: FFFFFFFFFFFF 0i+00000000000000
+		00000000: FFFFFFFFFFFFFF 0i+0000000000000000
+		00000000: FFFFFFFFFFFFFFFF 0i+0000000000000000000
+	`);
+    expect(vkp.valid).toBe(false);
+    expect(vkp.warnings.length).toBe(0);
+    expect(vkp.errors.length).toBe(7);
+    const hint = "Must be: 3 (for BYTE), 5 (for WORD), 8 (for 3 BYTES), 10 (for DWORD), 13 (for 5 BYTES), 15 (for 6 BYTES),  17 (for 7 BYTES), " +
+        "20 (for 8 BYTES).Use leading zeroes to match the number of digits.";
+    expect(vkp.errors[0]).toHaveProperty("message", "The wrong number of digits in integer (0i+0000) at line 3 col 18\n" + hint);
+    expect(vkp.errors[1]).toHaveProperty("message", "The wrong number of digits in integer (0i+0000000) at line 4 col 20\n" + hint);
+    expect(vkp.errors[2]).toHaveProperty("message", "The wrong number of digits in integer (0i+000000000) at line 5 col 22\n" + hint);
+    expect(vkp.errors[3]).toHaveProperty("message", "The wrong number of digits in integer (0i+000000000000) at line 6 col 24\n" + hint);
+    expect(vkp.errors[4]).toHaveProperty("message", "The wrong number of digits in integer (0i+00000000000000) at line 7 col 26\n" + hint);
+    expect(vkp.errors[5]).toHaveProperty("message", "The wrong number of digits in integer (0i+0000000000000000) at line 8 col 28\n" + hint);
+    expect(vkp.errors[6]).toHaveProperty("message", "The wrong number of digits in integer (0i+0000000000000000000) at line 9 col 30\n" + hint);
+});
+test('error: bad address & offset', () => {
+    const vkp = vkpParse(`
+		+AAAAAAAAA
+		AAAAAAAAA: AA BB
+	`);
+    expect(vkp.valid).toBe(false);
+    expect(vkp.warnings.length).toBe(0);
+    expect(vkp.errors.length).toBe(2);
+    expect(vkp.errors[0]).toHaveProperty("message", "Offset +AAAAAAAAA exceeds allowed range 00000000 ... FFFFFFFF at line 2 col 3");
+    expect(vkp.errors[1]).toHaveProperty("message", "Address AAAAAAAAA: exceeds allowed range 00000000 ... FFFFFFFF at line 3 col 3");
+});
+test('error: bad string', () => {
+    const vkp = vkpParse(`
+		AAAAAAAA: FFFFFFFFFFFFFFFF "\\xAA"
+		AAAAAAAA: FFFFFFFFFFFFFFFF "\\u1234"
+		AAAAAAAA: FFFFFFFFFFFFFFFF "\\777"
+		AAAAAAAA: FFFFFFFFFFFFFFFF "\\jam"
+	`);
+    expect(vkp.valid).toBe(false);
+    expect(vkp.warnings.length).toBe(0);
+    expect(vkp.errors.length).toBe(4);
+    expect(vkp.errors[0]).toHaveProperty("message", "Bad escape sequence (\\xAA) at line 2 col 31\nAllowed range: \\x00-\\x7F.");
+    expect(vkp.errors[1]).toHaveProperty("message", "Unknown escape sequence (\\u1234) at line 3 col 31");
+    expect(vkp.errors[2]).toHaveProperty("message", "Unknown escape sequence (\\777) at line 4 col 31");
+    expect(vkp.errors[3]).toHaveProperty("message", "Unknown escape sequence (\\j) at line 5 col 31");
+});
+test('data: valid address & offset', () => {
+    const vkp = vkpParse(`
+		-123450
+		A8123456: AA BB
+		+0
+	`);
+    expect(vkp.valid).toBe(true);
+    expect(vkp.warnings.length).toBe(0);
+    expect(vkp.errors.length).toBe(0);
+    expect(vkp.writes.length).toBe(1);
+    expect(vkp.writes[0].addr).toBe(0xA8000006);
+});
+test('data: HEX bytes', () => {
+    const vkp = vkpParse(`00000000: FFFFFFFFFFFFFFFF DEAD926E,DE,AD,92,6E`);
+    expect(vkp.valid).toBe(true);
+    expect(vkp.warnings.length).toBe(0);
+    expect(vkp.errors.length).toBe(0);
+    expect(vkp.writes.length).toBe(1);
+    expect(vkp.writes[0].new.toString('hex')).toBe('dead926edead926e');
+});
+test('data: HEX numbers', () => {
+    const vkp = vkpParse(`00000000: FFFFFFFFFFFFFFFFFFFFFFFF 0xDEAD926E,0xDEAD,0x92,0x6E,0x1,0x2,0x123`);
+    expect(vkp.valid).toBe(true);
+    expect(vkp.warnings.length).toBe(0);
+    expect(vkp.errors.length).toBe(0);
+    expect(vkp.writes.length).toBe(1);
+    expect(vkp.writes[0].new.toString('hex')).toBe('6e92addeadde926e01022301');
+});
+test('data: binary numbers', () => {
+    const vkp = vkpParse(`00000000: FFFFFFFFFFFFFFFFFFFFFF 0n11011110101011011011111011101111,0n11011110,0n1101111010101101,0n100100011010001010110`);
+    expect(vkp.valid).toBe(true);
+    expect(vkp.warnings.length).toBe(0);
+    expect(vkp.errors.length).toBe(0);
+    expect(vkp.writes.length).toBe(1);
+    expect(vkp.writes[0].new.toString('hex')).toBe('efbeaddedeadde563412');
+});
+test('data: unsigned decimal numbers', () => {
+    const vkp = vkpParse(`
+		00000000: FF 0i18
+		00000000: FFFF 0i04660
+		00000000: FFFFFF 0i01193046
+		00000000: FFFFFFFF 0i0305419896
+		00000000: FFFFFFFFFF 0i0078187493530
+		00000000: FFFFFFFFFFFF 0i020015998343868
+		00000000: FFFFFFFFFFFFFF 0i05124095576030430
+		00000000: FFFFFFFFFFFFFFFF 0i01311768467463790320
+	`);
+    expect(vkp.valid).toBe(true);
+    expect(vkp.warnings.length).toBe(0);
+    expect(vkp.errors.length).toBe(0);
+    expect(vkp.writes.length).toBe(8);
+    expect(vkp.writes[0].new.toString('hex')).toBe('12');
+    expect(vkp.writes[1].new.toString('hex')).toBe('3412');
+    expect(vkp.writes[2].new.toString('hex')).toBe('563412');
+    expect(vkp.writes[3].new.toString('hex')).toBe('78563412');
+    expect(vkp.writes[4].new.toString('hex')).toBe('9a78563412');
+    expect(vkp.writes[5].new.toString('hex')).toBe('bc9a78563412');
+    expect(vkp.writes[6].new.toString('hex')).toBe('debc9a78563412');
+    expect(vkp.writes[7].new.toString('hex')).toBe('f0debc9a78563412');
+});
+test('data: positive decimal numbers', () => {
+    const vkp = vkpParse(`
+		; middle value
+		00000000: FF 0i+18
+		00000000: FFFF 0i+04660
+		00000000: FFFFFF 0i+01193046
+		00000000: FFFFFFFF 0i+0305419896
+		00000000: FFFFFFFFFF 0i+0078187493530
+		00000000: FFFFFFFFFFFF 0i+020015998343868
+		00000000: FFFFFFFFFFFFFF 0i+05124095576030430
+		00000000: FFFFFFFFFFFFFFFF 0i+01311768467463790320
+
+		; max value
+		00000000: FF 0i+127
+		00000000: FFFF 0i+32767
+		00000000: FFFFFF 0i+08388607
+		00000000: FFFFFFFF 0i+2147483647
+		00000000: FFFFFFFFFF 0i+0549755813887
+		00000000: FFFFFFFFFFFF 0i+140737488355327
+		00000000: FFFFFFFFFFFFFF 0i+36028797018963967
+		00000000: FFFFFFFFFFFFFFFF 0i+09223372036854775807
+
+		; min value
+		00000000: FF 0i+000
+		00000000: FFFF 0i+00000
+		00000000: FFFFFF 0i+00000000
+		00000000: FFFFFFFF 0i+0000000000
+		00000000: FFFFFFFFFF 0i+0000000000000
+		00000000: FFFFFFFFFFFF 0i+000000000000000
+		00000000: FFFFFFFFFFFFFF 0i+00000000000000000
+		00000000: FFFFFFFFFFFFFFFF 0i+00000000000000000000
+	`);
+    expect(vkp.valid).toBe(true);
+    expect(vkp.warnings.length).toBe(0);
+    expect(vkp.errors.length).toBe(0);
+    expect(vkp.writes.length).toBe(24);
+    expect(vkp.writes[0].new.toString('hex')).toBe('12');
+    expect(vkp.writes[1].new.toString('hex')).toBe('3412');
+    expect(vkp.writes[2].new.toString('hex')).toBe('563412');
+    expect(vkp.writes[3].new.toString('hex')).toBe('78563412');
+    expect(vkp.writes[4].new.toString('hex')).toBe('9a78563412');
+    expect(vkp.writes[5].new.toString('hex')).toBe('bc9a78563412');
+    expect(vkp.writes[6].new.toString('hex')).toBe('debc9a78563412');
+    expect(vkp.writes[7].new.toString('hex')).toBe('f0debc9a78563412');
+    expect(vkp.writes[8].new.toString('hex')).toBe('7f');
+    expect(vkp.writes[9].new.toString('hex')).toBe('ff7f');
+    expect(vkp.writes[10].new.toString('hex')).toBe('ffff7f');
+    expect(vkp.writes[11].new.toString('hex')).toBe('ffffff7f');
+    expect(vkp.writes[12].new.toString('hex')).toBe('ffffffff7f');
+    expect(vkp.writes[13].new.toString('hex')).toBe('ffffffffff7f');
+    expect(vkp.writes[14].new.toString('hex')).toBe('ffffffffffff7f');
+    expect(vkp.writes[15].new.toString('hex')).toBe('ffffffffffffff7f');
+    expect(vkp.writes[16].new.toString('hex')).toBe('00');
+    expect(vkp.writes[17].new.toString('hex')).toBe('0000');
+    expect(vkp.writes[18].new.toString('hex')).toBe('000000');
+    expect(vkp.writes[19].new.toString('hex')).toBe('00000000');
+    expect(vkp.writes[20].new.toString('hex')).toBe('0000000000');
+    expect(vkp.writes[21].new.toString('hex')).toBe('000000000000');
+    expect(vkp.writes[22].new.toString('hex')).toBe('00000000000000');
+    expect(vkp.writes[23].new.toString('hex')).toBe('0000000000000000');
+});
+test('data: negative decimal numbers', () => {
+    const vkp = vkpParse(`
+		; middle value
+		00000000: FF 0i-18
+		00000000: FFFF 0i-04660
+		00000000: FFFFFF 0i-01193046
+		00000000: FFFFFFFF 0i-0305419896
+		00000000: FFFFFFFFFF 0i-0078187493530
+		00000000: FFFFFFFFFFFF 0i-020015998343868
+		00000000: FFFFFFFFFFFFFF 0i-05124095576030430
+		00000000: FFFFFFFFFFFFFFFF 0i-01311768467463790320
+
+		; min value
+		00000000: FF 0i-127
+		00000000: FFFF 0i-32767
+		00000000: FFFFFF 0i-08388607
+		00000000: FFFFFFFF 0i-2147483647
+		00000000: FFFFFFFFFF 0i-0549755813887
+		00000000: FFFFFFFFFFFF 0i-140737488355327
+		00000000: FFFFFFFFFFFFFF 0i-36028797018963967
+		00000000: FFFFFFFFFFFFFFFF 0i-09223372036854775807
+
+		; max value
+		00000000: FF 0i-001
+		00000000: FFFF 0i-00001
+		00000000: FFFFFF 0i-00000001
+		00000000: FFFFFFFF 0i-0000000001
+		00000000: FFFFFFFFFF 0i-0000000000001
+		00000000: FFFFFFFFFFFF 0i-000000000000001
+		00000000: FFFFFFFFFFFFFF 0i-00000000000000001
+		00000000: FFFFFFFFFFFFFFFF 0i-00000000000000000001
+	`);
+    expect(vkp.valid).toBe(true);
+    expect(vkp.warnings.length).toBe(0);
+    expect(vkp.errors.length).toBe(0);
+    expect(vkp.writes.length).toBe(24);
+    expect(vkp.writes[0].new.toString('hex')).toBe('ee');
+    expect(vkp.writes[1].new.toString('hex')).toBe('cced');
+    expect(vkp.writes[2].new.toString('hex')).toBe('aacbed');
+    expect(vkp.writes[3].new.toString('hex')).toBe('88a9cbed');
+    expect(vkp.writes[4].new.toString('hex')).toBe('6687a9cbed');
+    expect(vkp.writes[5].new.toString('hex')).toBe('446587a9cbed');
+    expect(vkp.writes[6].new.toString('hex')).toBe('22436587a9cbed');
+    expect(vkp.writes[7].new.toString('hex')).toBe('1021436587a9cbed');
+    expect(vkp.writes[8].new.toString('hex')).toBe('81');
+    expect(vkp.writes[9].new.toString('hex')).toBe('0180');
+    expect(vkp.writes[10].new.toString('hex')).toBe('010080');
+    expect(vkp.writes[11].new.toString('hex')).toBe('01000080');
+    expect(vkp.writes[12].new.toString('hex')).toBe('0100000080');
+    expect(vkp.writes[13].new.toString('hex')).toBe('010000000080');
+    expect(vkp.writes[14].new.toString('hex')).toBe('01000000000080');
+    expect(vkp.writes[15].new.toString('hex')).toBe('0100000000000080');
+    expect(vkp.writes[16].new.toString('hex')).toBe('ff');
+    expect(vkp.writes[17].new.toString('hex')).toBe('ffff');
+    expect(vkp.writes[18].new.toString('hex')).toBe('ffffff');
+    expect(vkp.writes[19].new.toString('hex')).toBe('ffffffff');
+    expect(vkp.writes[20].new.toString('hex')).toBe('ffffffffff');
+    expect(vkp.writes[21].new.toString('hex')).toBe('ffffffffffff');
+    expect(vkp.writes[22].new.toString('hex')).toBe('ffffffffffffff');
+    expect(vkp.writes[23].new.toString('hex')).toBe('ffffffffffffffff');
+});
+test('data: string', () => {
+    const vkp = vkpParse(`
+00000000: FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF "ололо\\
+\\0\\177\\100test\\x50\\x20\\a\\b\\t\\r\\n\\v\\f\\e\\\\\\/"
+00000000: FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF 'ололо\\
+\\0\\177\\100\\uABCDtest\\xAB\\xCD\\a\\b\\t\\r\\n\\v\\f\\e\\\\\\/'
+	`);
+    expect(vkp.valid).toBe(true);
+    expect(vkp.warnings.length).toBe(0);
+    expect(vkp.errors.length).toBe(0);
+    expect(vkp.writes.length).toBe(2);
+    expect(vkp.writes[0].new.toString('hex')).toBe('eeebeeebee007f407465737450200708090d0a0b0c1b5c2f');
+    expect(vkp.writes[1].new.toString('hex')).toBe('3e043b043e043b043e0400007f004000cdab7400650073007400ab00cd000700080009000d000a000b000c001b005c002f00');
+});