@sie-js/vkp 1.0.0

package/.editorconfig

@@ -0,0 +1,6 @@
+root = true
+
+[*]
+indent_style = tab
+indent_size = 4
+charset = utf-8

package/.github/workflows/ci.yml

@@ -0,0 +1,18 @@
+name: Publish Package to npmjs
+on:
+  release:
+    types: [published]
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-node@v4
+        with:
+          node-version: '20.x'
+          registry-url: 'https://registry.npmjs.org'
+      - run: npm ci
+      - run: npm test
+      - run: npm publish --access public
+        env:
+          NODE_AUTH_TOKEN: ${{ secrets.NPM_TOKEN }}

package/.prettierrc.json

@@ -0,0 +1,21 @@
+{
+	"arrowParens": "always",
+	"bracketSameLine": false,
+	"bracketSpacing": true,
+	"semi": true,
+	"experimentalTernaries": false,
+	"singleQuote": false,
+	"jsxSingleQuote": false,
+	"quoteProps": "as-needed",
+	"trailingComma": "none",
+	"singleAttributePerLine": false,
+	"htmlWhitespaceSensitivity": "css",
+	"vueIndentScriptAndStyle": false,
+	"proseWrap": "preserve",
+	"insertPragma": false,
+	"printWidth": 200,
+	"requirePragma": false,
+	"tabWidth": 4,
+	"useTabs": true,
+	"embeddedLanguageFormatting": "auto"
+}

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Kirill Zhumarin <kirill.zhumarin@gmail.com>
+
+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,44 @@
+[![NPM Version](https://img.shields.io/npm/v/%40sie-js%2Fvkp)](https://www.npmjs.com/package/@sie-js/vkp)
+
+# SUMMARY
+
+Parser and utils for the `.VKP` files format which is used in the V-Klay.
+
+# INSTALL
+```bash
+npm i @sie-js/vkp
+```
+
+# USAGE
+
+```js
+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'));
+
+// Parse patch
+let vkp = vkpParse(patchText);
+console.dir(vkp, { depth: null });
+
+if (vkp.warnings.length || vkp.errors.length) {
+    for (let warn of vkp.warnings) {
+        console.log(`Warning: ${warn.message}`);
+        console.log("```");
+        console.log(warn.codeFrame(patchText));
+        console.log("```");
+        console.log("");
+    }
+
+    for (let err of vkp.errors) {
+        console.log(`Error: ${err.message}`);
+        console.log("```");
+        console.log(err.codeFrame(patchText));
+        console.log("```");
+        console.log("");
+    }
+
+    console.log("");
+}
+```

package/jest.config.js

@@ -0,0 +1,4 @@
+const config = {
+	transform: {},
+};
+export default config;

package/package.json

@@ -0,0 +1,22 @@
+{
+	"name": "@sie-js/vkp",
+	"version": "1.0.0",
+	"description": "",
+	"main": "src/index.js",
+	"type": "module",
+	"scripts": {
+		"test": "NODE_OPTIONS=--experimental-vm-modules jest",
+		"gen-parser": "nearleyc src/vkp.ne -o src/grammar.js && prettier -w src/grammar.js",
+		"pub": "npm publish --access public"
+	},
+	"author": "",
+	"license": "MIT",
+	"dependencies": {
+		"iconv-lite": "^0.6.3",
+		"moo": "^0.5.2"
+	},
+	"devDependencies": {
+		"glob": "^10.3.12",
+		"jest": "^29.7.0"
+	}
+}

package/src/VkpParseError.js

@@ -0,0 +1,68 @@
+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;
+	}
+
+	codeFrame(text) {
+		return codeFrame(text, this.loc.line, this.loc.column);
+	}
+};
+
+export function codeFrame(text, lineNum, colNum) {
+	let lines = text.split(/\r\n|\n/);
+	let maxLineNumLen = lines.length.toString().length + 1;
+	let out = "";
+	let n = 1;
+	for (let line of lines) {
+		if (Math.abs(n - lineNum) > 3) {
+			n++;
+			continue;
+		}
+		out += `${n == lineNum ? '>' : ' '}${n.toString().padStart(maxLineNumLen, ' ')} | ${tab2spaces(line)}\n`;
+		if (n == lineNum) {
+			out += ` ${" ".repeat(maxLineNumLen, ' ')} | ${str2spaces(line.substr(0, colNum - 1))}^\n`;
+		}
+		n++;
+	}
+	return out;
+}
+
+export function getLocByOffset(text, offset) {
+	let line = 0;
+	let column = 1;
+	for (let i = 0; i < text.length; i++) {
+		let c = text.charAt(i);
+		if (c == "\n" || (c == "\r" && text.charAt(i + 1) == "\n")) {
+			column = 1;
+			line++;
+		}
+		if (i == offset)
+			return { line, column };
+	}
+	return { line, column: 1 };
+}
+
+function str2spaces(line) {
+	return tab2spaces(line).replace(/./g, ' ');
+}
+
+function tab2spaces(line) {
+	let newStr = "";
+	let virtualSymbols = 0;
+	for (let i = 0; i < line.length; i++) {
+		let c = line.charAt(i);
+		if (c == "\t") {
+			let spacesCnt = 4 - virtualSymbols % 4;
+			newStr += " ".repeat(spacesCnt);
+			virtualSymbols += spacesCnt;
+		} else {
+			virtualSymbols++;
+			newStr += c;
+		}
+	}
+	return newStr;
+}

package/src/index.js

@@ -0,0 +1,127 @@
+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,
+};
+
+function vkpParse(text, options) {
+	options = {
+		allowEmptyOldData:	false,
+		allowPlaceholders:	false,
+		...options
+	};
+
+	let vkp = {
+		ast: null,
+		valid: false,
+		writes: [],
+		warnings: [],
+		errors: [],
+	};
+
+	let pragmas = {...DEFAULT_PRAGMAS};
+	let pragma2loc = {};
+	let offsetCorrector;
+
+	vkpRawParser(text, {
+		onPragma(value, loc) {
+			if (value.pragma.action == "enable") {
+				if (pragmas[value.pragma.name]) {
+					vkp.warnings.push(new VkpParseError(`Useless "#pragma ${value.pragma.action} ${value.pragma.name}" has no effect`, loc, `You can safely remove this line.`));
+				} else {
+					pragmas[value.pragma.name] = true;
+					pragma2loc[value.pragma.name] = loc;
+				}
+			} else if (value.pragma.action == "disable") {
+				if (!pragmas[value.pragma.name]) {
+					vkp.warnings.push(new VkpParseError(`Useless "#pragma ${value.pragma.action} ${value.pragma.name}" has no effect`, loc, `You can safely remove this line.`));
+				} else {
+					pragma2loc[value.pragma.name] = loc;
+					pragmas[value.pragma.name] = false;
+				}
+			}
+		},
+		onPatchData(data, loc) {
+			let oldData = data.old ? data.old.buffer : null;
+			let newData = data.new.buffer;
+
+			if (data.new.placeholders > 0) {
+				if (!options.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 (!options.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);
+		}
+	});
+
+	let unsinishedPragmas = [];
+	for (let k in pragmas) {
+		if (pragmas[k] !== DEFAULT_PRAGMAS[k]) {
+			let cancel = pragmas[k] ? `#pragma disable ${k}` : `#pragma enable ${k}`;
+			vkp.warnings.push(new VkpParseError(`Uncanceled pragma "${k}"`, pragma2loc[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;
+}
+
+function vkpDetectContent(text) {
+	let trimmedText = text.replace(/\/\*.*?\*\//gs, '').replace(/(\/\/|;|#).*?$/mg, '');
+	if (trimmedText.match(/^\s*(0x[a-f0-9]+|[a-f0-9]+)\s*:[^\\/]/mi))
+		return "PATCH";
+	if (!trimmedText.trim().length)
+		return "EMPTY";
+	if (text.match(/;!к патчу прикреплён файл, https?:\/\//i))
+		return "DOWNLOAD_STUB";
+	return "UNKNOWN";
+}
+
+// CP1251 -> UTF-8 + CRLF -> LF
+function vkpNormalize(text) {
+	return iconv.decode(text, 'windows-1251').replace(/(\r\n|\n|\r)/g, "\n");
+}
+
+// UTF-8 -> CP1251 + LF -> CRLF
+function vkpCanonicalize(text) {
+	return iconv.encode(text.replace(/(\r\n|\n|\r)/g, "\r\n"), 'windows-1251');
+}
+
+export { vkpParse, vkpRawParser, vkpNormalize, vkpCanonicalize, vkpDetectContent };

package/src/index.test.js

@@ -0,0 +1,403 @@
+import { vkpParse } from './index.js';
+
+test('warn: useless pragma', () => {
+	let 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', () => {
+	let 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', () => {
+	let 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', () => {
+	let 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', () => {
+	let 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', () => { // thanks Viktor89
+	let 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', () => {
+	let 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', () => {
+	let 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', () => {
+	let 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', () => {
+	let 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', () => {
+	let 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', () => {
+	let 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', () => {
+	let 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', () => {
+	let 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', () => {
+	let 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', () => {
+	let 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', () => {
+	let 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', () => {
+	let 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', () => {
+	let 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', () => {
+	let 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', () => {
+	let 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', () => {
+	let 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', () => {
+	let 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');
+});

package/src/lexer.js

@@ -0,0 +1,46 @@
+import moo from 'moo';
+import iconv from 'iconv-lite';
+import { VkpParseError } from './VkpParseError.js';
+
+const RE_PLACEHOLDERS = [
+	/(?:0x)?(?:[a-fA-F0-9]*(?:XX|xx|YY|yy|ZZ|zz|HH|hh|nn|NN|Nn|MS|ML|\?\?)[a-fA-F0-9]*)+(?!\w)/,
+	/(?:0i[+-]?)(?:[0-9]*(?:[xyz?]+)[0-9]*)+(?!\w)/
+];
+
+export const TOKEN = {
+	WHITESPACE:				1,
+	PRAGMA:					2,
+	COMMENT:				3,
+	OFFSET:					4,
+	ADDRESS:				5,
+	NUMBER:					6,
+	DATA:					7,
+	PLACEHOLDER:			8,
+	STRING:					9,
+	COMMA:					10,
+	LINE_ESCAPE:			11,
+	MULTILINE_COMMENT:		12,
+	UNFINISHED_COMMENT:		13,
+	TRAILING_COMMENT_END:	14,
+	NEWLINE:				15,
+	ERROR:					16,
+};
+
+export const LEXER = moo.compile([
+	{ type: TOKEN.WHITESPACE,				match: /[ \t]+/, lineBreaks: false },
+	{ type: TOKEN.PRAGMA,					match: /#pragma[ \t\w]+/, lineBreaks: false },
+	{ type: TOKEN.COMMENT,					match: /(?:\/\/|;|#).*?$/, lineBreaks: false },
+	{ type: TOKEN.OFFSET,					match: /[+-](?:0[xX])?[a-fA-F0-9]+/, lineBreaks: false },
+	{ type: TOKEN.ADDRESS,					match: /(?:0[xX])?[a-fA-F0-9]+:/, lineBreaks: false },
+	{ type: TOKEN.NUMBER,					match: [/0x[a-fA-F0-9]+(?:\b|$)/, /0n[10]+(?:\b|$)/, /0i[+-]?[0-9]+(?!\w)/], lineBreaks: false },
+	{ type: TOKEN.DATA,						match: /[a-fA-F0-9]+\b/, lineBreaks: false },
+	{ type: TOKEN.PLACEHOLDER,				match: RE_PLACEHOLDERS, lineBreaks: false },
+	{ type: TOKEN.STRING,					match: /(?:"(?:\\[^]|[^"\\])*?"|'(?:\\[^]|[^"\\])*?')/, lineBreaks: true },
+	{ type: TOKEN.COMMA,					match: /,/, lineBreaks: false },
+	{ type: TOKEN.LINE_ESCAPE,				match: /\\(?:\r\n|\n)/, lineBreaks: true },
+	{ type: TOKEN.MULTILINE_COMMENT,		match: /\/\*[^]*?\*\//, lineBreaks: true },
+	{ type: TOKEN.UNFINISHED_COMMENT,		match: /\/\*[^]*$/, lineBreaks: true },
+	{ type: TOKEN.TRAILING_COMMENT_END,		match: /\*\//, lineBreaks: false },
+	{ type: TOKEN.NEWLINE,					match: /(?:\r\n|\n)/, lineBreaks: true },
+	{ type: TOKEN.ERROR,					match: /.+?$/, lineBreaks: false },
+]);

package/src/parser.js

@@ -0,0 +1,497 @@
+import iconv from 'iconv-lite';
+import { LEXER, TOKEN } from './lexer.js';
+import { VkpParseError } from './VkpParseError.js';
+
+const UINT_PARSER_DATA = [
+	[3,		0xFF,					8], // 1b
+	[5,		0xFFFF,					16], // 2b
+	[8,		0xFFFFFF,				24], // 3b
+	[10,	0xFFFFFFFF,				32], // 4b
+	[13,	0xFFFFFFFFFF,			40], // 5b
+	[15,	0xFFFFFFFFFFFF,			48], // 6b
+	[17,	0xFFFFFFFFFFFFFFn,		56], // 7b
+	[20,	0xFFFFFFFFFFFFFFFFn,	64], // 8b
+];
+
+const SINT_PARSER_DATA = [
+	[3,		0x7F,					8], // 1b
+	[5,		0x7FFF,					16], // 2b
+	[8,		0x7FFFFF,				24], // 3b
+	[10,	0x7FFFFFFF,				32], // 4b
+	[13,	0x7FFFFFFFFF,			40], // 5b
+	[15,	0x7FFFFFFFFFFF,			48], // 6b
+	[17,	0x7FFFFFFFFFFFFFn,		56], // 7b
+	[20,	0x7FFFFFFFFFFFFFFFn,	64], // 8b
+];
+
+const STR_ESCAPE_TABLE = {
+	"a":	"\x07",
+	"b":	"\b",
+	"t":	"\t",
+	"r":	"\r",
+	"n":	"\n",
+	"v":	"\v",
+	"f":	"\f",
+	"e":	"\x1B",
+	"\\":	"\\",
+	"/":	"/",
+	"*":	"*",
+	"\"":	"\"",
+	"'":	"'",
+	"`":	"`",
+	" ":	" ",
+};
+
+let state;
+
+function noop() {
+
+}
+
+function vkpRawParser(text, options = {}) {
+	options = {
+		onPragma: noop,
+		onPatchData: noop,
+		onOffset: noop,
+		onComments: noop,
+		onWarning: noop,
+		onError: noop,
+		...options
+	};
+
+	state = {
+		token:			null,
+		prevToken:		null,
+		warnings:		[],
+		onPragma:		options.onPragma,
+		onPatchData:	options.onPatchData,
+		onOffset:		options.onOffset,
+		onComments:		options.onComments,
+		onWarning:		options.onWarning,
+		onError:		options.onError,
+	};
+
+	LEXER.reset(text);
+
+	let token;
+	while ((token = peekToken())) {
+		try {
+			if (token.type == TOKEN.ADDRESS) {
+				let loc = getLocation();
+				state.onPatchData(parsePatchRecord(), loc);
+			} else if (token.type == TOKEN.PRAGMA) {
+				let loc = getLocation();
+				state.onPragma(parsePatchPragma(), loc);
+			} else if (token.type == TOKEN.OFFSET) {
+				let loc = getLocation();
+				state.onOffset(parsePatchOffsetCorrector(), loc);
+			} else if (token.type == TOKEN.NEWLINE || token.type == TOKEN.WHITESPACE) {
+				nextToken();
+			} else if (token.type == TOKEN.COMMENT || token.type == TOKEN.MULTILINE_COMMENT || token.type == TOKEN.UNFINISHED_COMMENT) {
+				let loc = getLocation();
+				state.onComments(parseComments(), loc);
+			} else if (token.type == TOKEN.TRAILING_COMMENT_END) {
+				state.onWarning(new VkpParseError(`Trailing multiline comment end`, getLocation()));
+				nextToken();
+			} else {
+				throw new VkpParseError("Syntax error", getLocation());
+			}
+		} catch (e) {
+			let loc = getLocation();
+			let token;
+			while ((token = nextToken())) {
+				if (token.type == TOKEN.NEWLINE)
+					break;
+			}
+			state.onError(e, loc);
+		}
+	}
+
+	state = null;
+}
+
+function parseComments() {
+	let comments = [];
+	let token;
+	while ((token = peekToken())) {
+		if (token.type == TOKEN.NEWLINE) {
+			nextToken();
+			break;
+		} else if (token.type == TOKEN.WHITESPACE) {
+			nextToken();
+		} else if (token.type == TOKEN.COMMENT || token.type == TOKEN.MULTILINE_COMMENT || token.type == TOKEN.UNFINISHED_COMMENT) {
+			if (token.type == TOKEN.UNFINISHED_COMMENT)
+				state.onWarning(new VkpParseError(`Unfinished multiline comment`, getLocation()));
+			comments.push(nextToken());
+		} else {
+			break;
+		}
+	}
+	return comments;
+}
+
+function parsePatchPragma() {
+	let pragma = parsePragmaValue(peekToken().value);
+	nextToken();
+	let comments = parseCommentsAfterExpr();
+	return { pragma, comments };
+}
+
+function parsePatchOffsetCorrector() {
+	let text = peekToken().value;
+	let offset = parseOffsetValue(text);
+	nextToken();
+	let comments = parseCommentsAfterExpr();
+	return { text, offset, comments };
+}
+
+function parsePatchRecord() {
+	let address = parsePatchRecordAddress();
+
+	let data = [];
+	for (let i = 0; i < 2; i++) {
+		if (!parsePatchRecordSeparator())
+			break;
+		let loc = getLocation();
+		let [buffer, placeholders] = parsePatchData();
+		data.push({ loc, buffer: mergeBuffers(buffer), placeholders });
+	}
+
+	if (!data.length)
+		throw new VkpParseError(`Empty patch data record!`, getLocation());
+
+	let comments = parseCommentsAfterExpr();
+	return {
+		address,
+		comments,
+		old:	data.length == 2 ? data[0] : null,
+		new:	data.length == 2 ? data[1] : data[0],
+	};
+}
+
+function mergeBuffers(buffers) {
+	return buffers.length > 1 ? Buffer.concat(buffers) : buffers[0];
+}
+
+function parsePatchRecordAddress() {
+	let value = parseAddressValue(peekToken().value);
+	nextToken();
+	return value;
+}
+
+function parsePatchData() {
+	let data = [];
+	let token;
+	let placeholders = 0;
+	while ((token = peekToken())) {
+		if (token.type == TOKEN.COMMA) {
+			nextToken();
+		} else if (token.type == TOKEN.DATA) {
+			data.push(parseHexDataValue(peekToken().value));
+			nextToken();
+		} else if (token.type == TOKEN.PLACEHOLDER) {
+			data.push(parsePlaceholderValue(peekToken().value));
+			nextToken();
+			placeholders++;
+		} else if (token.type == TOKEN.NUMBER) {
+			data.push(parseAnyNumberValue(peekToken().value));
+			nextToken();
+		} else if (token.type == TOKEN.STRING) {
+			data.push(parseStringValue(peekToken().value));
+			nextToken();
+		} else if (token.type == TOKEN.LINE_ESCAPE) {
+			nextToken();
+		} else if (token.type == TOKEN.WHITESPACE || token.type == TOKEN.NEWLINE) {
+			break;
+		} else if (token.type == TOKEN.COMMENT || token.type == TOKEN.MULTILINE_COMMENT || token.type == TOKEN.UNFINISHED_COMMENT) {
+			if (prevToken().type == TOKEN.NUMBER)
+				throw new VkpParseError(`No whitespace between number and comment`, getLocation());
+			break;
+		} else {
+			throw new VkpParseError("Syntax error", getLocation());
+		}
+	}
+	return [data, placeholders];
+}
+
+function parsePatchRecordSeparator() {
+	let token;
+	while ((token = peekToken())) {
+		if (token.type == TOKEN.NEWLINE) {
+			return false;
+		} else if (token.type == TOKEN.DATA || token.type == TOKEN.PLACEHOLDER || token.type == TOKEN.NUMBER || token.type == TOKEN.STRING) {
+			return true;
+		} else if (token.type == TOKEN.COMMENT || token.type == TOKEN.MULTILINE_COMMENT || token.type == TOKEN.UNFINISHED_COMMENT) {
+			return false;
+		} else if (token.type == TOKEN.WHITESPACE || token.type == TOKEN.LINE_ESCAPE) {
+			nextToken();
+		} else {
+			throw new VkpParseError("Syntax error", getLocation());
+		}
+	}
+	return false;
+}
+
+function parseCommentsAfterExpr() {
+	let comments = [];
+	let token;
+	while ((token = peekToken())) {
+		if (token.type == TOKEN.NEWLINE) {
+			nextToken();
+			break;
+		} else if (token.type == TOKEN.WHITESPACE) {
+			nextToken();
+		} else if (token.type == TOKEN.COMMENT || token.type == TOKEN.MULTILINE_COMMENT || token.type == TOKEN.UNFINISHED_COMMENT) {
+			if (token.type == TOKEN.UNFINISHED_COMMENT)
+				state.onWarning(new VkpParseError(`Unfinished multiline comment`, getLocation()));
+			comments.push(nextToken());
+		} else {
+			throw new VkpParseError("Syntax error", getLocation());
+		}
+	}
+	return comments;
+}
+
+function nextToken() {
+	state.prevToken = state.token;
+	let token = state.token ? state.token : LEXER.next();
+	state.token = LEXER.next();
+	return token;
+}
+
+function peekToken() {
+	if (state.token == null)
+		state.token = LEXER.next();
+	return state.token;
+}
+
+function prevToken() {
+	return state.prevToken;
+}
+
+/**
+ * Token value parsers
+ * */
+function parseAnyNumberValue(v) {
+	let m;
+	let tmpBuffer = Buffer.allocUnsafe(8);
+
+	if ((m = v.match(/^0i([+-]\d+)$/i))) { // dec signed
+		let num = m[1];
+		for (let d of SINT_PARSER_DATA) {
+			if ((num.length - 1) <= d[0]) {
+				let parsedNum = BigInt(num);
+				if (parsedNum < -d[1] || parsedNum > d[1])
+					throw new VkpParseError(`Number ${v} exceeds allowed range -${d[1].toString(10)} ... +${d[1].toString(10)}`, getLocation());
+				if ((num.length - 1) < d[0] && d[0] > 3) {
+					throw new VkpParseError(`The wrong number of digits in integer (${v})`, getLocation(),
+						"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.");
+				}
+				tmpBuffer.writeBigUInt64LE(BigInt.asUintN(d[2], parsedNum), 0);
+				return tmpBuffer.subarray(0, d[2] / 8);
+			}
+		}
+	} else if ((m = v.match(/^0i(\d+)$/i))) { // dec unsigned
+		let num = m[1];
+		for (let d of UINT_PARSER_DATA) {
+			if (num.length <= d[0]) {
+				let parsedNum = d[2] <= 32 ? parseInt(num, 10) : BigInt(num);
+				if (parsedNum < 0 || parsedNum > d[1])
+					throw new VkpParseError(`Number ${v} exceeds allowed range 0 ... ${d[1].toString(10)}`, getLocation());
+				if (num.length < d[0] && d[0] > 3) {
+					throw new VkpParseError(`The wrong number of digits in integer (${v})`, getLocation(),
+						"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.");
+				}
+				if (d[2] <= 32) {
+					tmpBuffer.writeUInt32LE(parsedNum, 0);
+					return tmpBuffer.subarray(0, d[2] / 8);
+				} else {
+					tmpBuffer.writeBigUInt64LE(parsedNum, 0);
+					return tmpBuffer.subarray(0, d[2] / 8);
+				}
+			}
+		}
+	} else if ((m = v.match(/^0x([a-f0-9]+)$/i))) { // hex unsigned
+		let hexnum = m[1];
+		if (hexnum.length % 2)
+			hexnum = "0" + hexnum;
+		if (hexnum.length > 8)
+			throw new VkpParseError(`Number ${v} exceeds allowed range 0x00000000 ... 0xFFFFFFFF`, getLocation());
+		let number = parseInt(`0x${hexnum}`, 16);
+		tmpBuffer.writeUInt32LE(number, 0);
+		return tmpBuffer.subarray(0, Math.ceil(hexnum.length / 2));
+	} else if ((m = v.match(/^0n([10]+)$/i))) { // binary unsigned
+		if (m[1].length > 32)
+			throw new VkpParseError(`Number ${v} exceeds allowed range 0n0 ... 0n11111111111111111111111111111111`, getLocation());
+		let number = parseInt(m[1], 2);
+		tmpBuffer.writeUInt32LE(number, 0);
+		return tmpBuffer.subarray(0, Math.ceil(m[1].length / 8));
+	}
+
+	throw new VkpParseError(`Invalid number: ${v}`, getLocation());
+}
+
+function parsePlaceholderValue(value) {
+	let m;
+	if ((m = value.match(/^(0i|0x|0n)(.*?)$/i))) {
+		return parseAnyNumberValue(m[1] + m[2].replace(/[^0-9a-f]/gi, '0'));
+	} else {
+		return parseHexDataValue(value.replace(/[^0-9a-f]/gi, '0'));
+	}
+}
+
+function parseStringValue(value) {
+	let m;
+	if ((m = value.match(/(\/\*|\*\/|\/\/)/))) {
+		throw new VkpParseError(`Unescaped ${m[1]} is not allowed in string: ${value}`, getLocation(),
+			`Escape these ambiguous characters like this: \\/* or \\/\\/.`);
+	}
+
+	let text = value.slice(1, -1);
+
+	let offset = 0;
+	let parts = [];
+	let tmp = "";
+	let unicode = (value.charAt(0) == "'");
+	let escape = false;
+
+/*
+	if (!unicode && value.match(/[^\u0000-\u007F]/)) {
+		throw new VkpParseError(`ASCII string with non-ASCII characters`, getLocation(),
+			`Please use only ASCII-safe characters from the range U+0000-U+007F or \\xNN escape sequences.`);
+	}
+*/
+
+	let breakpoint = () => {
+		if (tmp.length) {
+			parts.push(tmp);
+			tmp = "";
+		}
+	};
+
+	let getStrLocation = (i) => {
+		let loc = getLocation();
+		loc.column += i;
+		return loc;
+	};
+
+	for (let i = 0; i < text.length; i++) {
+		let c = text.charAt(i);
+		if (escape) {
+			if (c == "\r") {
+				if (text.charAt(i + 1) == "\n")
+					i++;
+			} else if (c == "\n") {
+				// Ignore
+			} else if (c == "x") {
+				let hex = text.substr(i + 1, 2);
+				if (hex.length == 2) {
+					breakpoint();
+					let hexnum = parseInt(`0x${hex}`);
+					if (unicode) {
+						parts.push(Buffer.from([ hexnum, 0x00 ]));
+					} else {
+						if (hexnum >= 0x7F && !unicode)
+							throw new VkpParseError(`Bad escape sequence (\\x${hex})`, getStrLocation(i), `Allowed range: \\x00-\\x7F.`);
+						parts.push(Buffer.from([ hexnum ]));
+					}
+					i += 2;
+				} else {
+					throw new VkpParseError(`Unknown escape sequence (\\x${hex})`, getStrLocation(i));
+				}
+			} else if (c == "u") {
+				let hex = text.substr(i + 1, 4);
+				if (hex.length == 4) {
+					breakpoint();
+					let hexnum = parseInt(`0x${hex}`);
+					if (unicode) {
+						parts.push(Buffer.from([ hexnum & 0xFF, (hexnum >> 8) & 0xFF ]));
+					} else {
+						throw new VkpParseError(`Unknown escape sequence (\\u${hex})`, getStrLocation(i));
+					}
+					i += 4;
+				} else {
+					throw new VkpParseError(`Unknown escape sequence (\\u${hex})`, getStrLocation(i));
+				}
+			} else if (c.match(/[0-7]/)) {
+				let ocatlLen = 1;
+				for (let j = 1; j < 3; j++) {
+					if (!text.charAt(i + j).match(/[0-7]/))
+						break;
+					ocatlLen++;
+				}
+
+				let oct = parseInt(text.substr(i, ocatlLen), 8);
+				if (oct > 0xFF)
+					throw new VkpParseError(`Unknown escape sequence (\\${text.substr(i, ocatlLen)})`, getStrLocation(i));
+
+				breakpoint();
+				if (unicode) {
+					parts.push(Buffer.from([ oct, 0x00 ]));
+				} else {
+					parts.push(Buffer.from([ oct ]));
+				}
+
+				i += ocatlLen - 1;
+			} else if ((c in STR_ESCAPE_TABLE)) {
+				tmp += STR_ESCAPE_TABLE[c];
+			} else {
+				throw new VkpParseError(`Unknown escape sequence (\\${c})`, getStrLocation(i));
+			}
+			escape = false;
+		} else {
+			if (c == '\\') {
+				escape = true;
+			} else {
+				tmp += c;
+			}
+		}
+	}
+
+	breakpoint();
+
+	if (unicode) {
+		return Buffer.concat(parts.map((p) => typeof p === "string" ? iconv.encode(p, 'utf-16', { addBOM: false }) : p));
+	} else {
+		return Buffer.concat(parts.map((p) => typeof p === "string" ? iconv.encode(p, 'windows-1251') : p));
+	}
+}
+
+function parseOffsetValue(v) {
+	let result = parseInt(v.replace(/^([+-])(0x)?/i, '$10x'), 16);
+	if (isNaN(result))
+		throw new VkpParseError(`Invalid offset: ${v}`, getLocation());
+	if (result > 0xFFFFFFFF)
+		throw new VkpParseError(`Offset ${v} exceeds allowed range 00000000 ... FFFFFFFF`, getLocation());
+	return result;
+}
+
+function parseAddressValue(v) {
+	let result = parseInt(v.replace(/^(0x)?(.*?):$/i, '0x$2'), 16);
+	if (isNaN(result))
+		throw new VkpParseError(`Invalid address: ${v}`, getLocation());
+	if (result > 0xFFFFFFFF)
+		throw new VkpParseError(`Address ${v} exceeds allowed range 00000000 ... FFFFFFFF`, getLocation());
+	return result;
+}
+
+function parseHexDataValue(v) {
+	if (v.length % 2 != 0)
+		throw new VkpParseError(`Hex data (${v}) must be even length`, getLocation());
+	return Buffer.from(v, "hex");
+}
+
+function parsePragmaValue(v) {
+	let m;
+	if (!(m = v.trim().match(/^#pragma\s+(enable|disable)\s+(warn_no_old_on_apply|warn_if_new_exist_on_apply|warn_if_old_exist_on_undo|undo|old_equal_ff)$/)))
+		throw new VkpParseError(`Invalid PRAGMA: ${v}`, getLocation());
+	return { name: m[2], action: m[1] };
+}
+
+function getLocation() {
+	return state.token ? { line: state.token.line, column: state.token.col } : { line: 1, column: 1 };
+}
+
+export { vkpRawParser };