@sie-js/vkp 1.0.6 → 2.0.1

package/dist/src/lexer.d.ts

@@ -0,0 +1,2 @@
+export type VkpTokenType = 'WHITESPACE' | 'PRAGMA' | 'COMMENT' | 'OFFSET' | 'ADDRESS' | 'NUMBER' | 'DATA' | 'PLACEHOLDER' | 'STRING' | 'COMMA' | 'LINE_ESCAPE' | 'MULTILINE_COMMENT' | 'UNFINISHED_COMMENT' | 'TRAILING_COMMENT_END' | 'NEWLINE' | 'ERROR';
+export declare const VkpLexer: import("moo").Lexer;

package/dist/src/lexer.js

@@ -0,0 +1,23 @@
+import moo from "moo";
+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 VkpLexer = moo.compile({
+    WHITESPACE: { match: /[ \t]+/, lineBreaks: false },
+    PRAGMA: { match: /#pragma[ \t\w]+/, lineBreaks: false },
+    COMMENT: { match: /(?:\/\/|;|#).*?$/, lineBreaks: false },
+    OFFSET: { match: /[+-](?:0[xX])?[a-fA-F0-9]+/, lineBreaks: false },
+    ADDRESS: { match: /(?:0[xX])?[a-fA-F0-9]+:/, lineBreaks: false },
+    NUMBER: { match: [/0x[a-fA-F0-9]+(?:\b|$)/, /0n[10]+(?:\b|$)/, /0i[+-]?[0-9]+(?!\w)/], lineBreaks: false },
+    DATA: { match: /[a-fA-F0-9]+\b/, lineBreaks: false },
+    PLACEHOLDER: { match: RE_PLACEHOLDERS, lineBreaks: false },
+    STRING: { match: /"(?:\\[^]|[^"\\])*?"|'(?:\\[^]|[^"\\])*?'/, lineBreaks: true },
+    COMMA: { match: /,/, lineBreaks: false },
+    LINE_ESCAPE: { match: /\\(?:\r\n|\n)/, lineBreaks: true },
+    MULTILINE_COMMENT: { match: /\/\*[^]*?\*\//, lineBreaks: true },
+    UNFINISHED_COMMENT: { match: /\/\*[^]*$/, lineBreaks: true },
+    TRAILING_COMMENT_END: { match: /\*\//, lineBreaks: false },
+    NEWLINE: { match: /\r\n|\n/, lineBreaks: true },
+    ERROR: { match: /.+?$/, lineBreaks: false },
+});

package/dist/src/parser.d.ts

@@ -0,0 +1,37 @@
+import { VkpLocation, VkpParseError } from "./VkpParseError.js";
+export type VkpPragmaName = 'warn_no_old_on_apply' | 'warn_if_new_exist_on_apply' | 'warn_if_old_exist_on_undo' | 'undo' | 'old_equal_ff';
+export type VkpPragmaAction = 'enable' | 'disable';
+export interface VkpPragma {
+    name: VkpPragmaName;
+    action: VkpPragmaAction;
+}
+export interface VkpPragmaNode {
+    pragma: VkpPragma;
+    comment: string;
+}
+export interface VkpOffsetNode {
+    text: string;
+    offset: number;
+    comment: string;
+}
+export interface VkpPatchData {
+    loc: VkpLocation;
+    buffer: Buffer;
+    placeholders: number;
+}
+export interface VkpPatchDataNode {
+    address: number;
+    comment: string;
+    old?: VkpPatchData;
+    new: VkpPatchData;
+}
+export interface VkpParserOptions {
+    onPragma?: (value: VkpPragmaNode, loc: VkpLocation) => void;
+    onPatchData?: (data: VkpPatchDataNode, loc: VkpLocation) => void;
+    onOffset?: (value: VkpOffsetNode, loc: VkpLocation) => void;
+    onComments?: (comments: string[], loc: VkpLocation) => void;
+    onWarning?: (warning: VkpParseError) => void;
+    onError?: (error: VkpParseError, loc?: VkpLocation) => void;
+}
+declare function vkpRawParser(text: string, options?: VkpParserOptions): void;
+export { vkpRawParser };

package/dist/src/parser.js

@@ -0,0 +1,510 @@
+import iconv from "iconv-lite";
+import { VkpLexer } 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() {
+    // Really nothing!
+}
+function vkpRawParser(text, options = {}) {
+    const validOptions = {
+        onPragma: noop,
+        onPatchData: noop,
+        onOffset: noop,
+        onComments: noop,
+        onWarning: noop,
+        onError: noop,
+        ...options
+    };
+    state = {
+        token: undefined,
+        prevToken: undefined,
+        warnings: [],
+        onPragma: validOptions.onPragma,
+        onPatchData: validOptions.onPatchData,
+        onOffset: validOptions.onOffset,
+        onComments: validOptions.onComments,
+        onWarning: validOptions.onWarning,
+        onError: validOptions.onError,
+    };
+    VkpLexer.reset(text);
+    let token;
+    while ((token = peekToken())) {
+        try {
+            if (token.type == 'ADDRESS') {
+                const loc = getLocation();
+                state.onPatchData(parsePatchRecord(), loc);
+            }
+            else if (token.type == 'PRAGMA') {
+                const loc = getLocation();
+                state.onPragma(parsePatchPragma(), loc);
+            }
+            else if (token.type == 'OFFSET') {
+                const loc = getLocation();
+                state.onOffset(parsePatchOffsetCorrector(), loc);
+            }
+            else if (token.type == 'NEWLINE' || token.type == 'WHITESPACE') {
+                nextToken();
+            }
+            else if (token.type == 'COMMENT' || token.type == 'MULTILINE_COMMENT' || token.type == 'UNFINISHED_COMMENT') {
+                const loc = getLocation();
+                state.onComments(parseComments(), loc);
+            }
+            else if (token.type == 'TRAILING_COMMENT_END') {
+                state.onWarning(new VkpParseError(`Trailing multiline comment end`, getLocation()));
+                nextToken();
+            }
+            else {
+                throw new VkpParseError("Syntax error", getLocation());
+            }
+        }
+        catch (e) {
+            if (!(e instanceof VkpParseError))
+                throw e;
+            const loc = getLocation();
+            let token;
+            while ((token = nextToken())) {
+                if (token.type == 'NEWLINE')
+                    break;
+            }
+            state.onError(e, loc);
+        }
+    }
+    state = undefined;
+}
+function parseComments() {
+    const comments = [];
+    let token;
+    while ((token = peekToken())) {
+        if (token.type == 'NEWLINE') {
+            nextToken();
+            break;
+        }
+        else if (token.type == 'WHITESPACE') {
+            nextToken();
+        }
+        else if (token.type == 'COMMENT' || token.type == 'MULTILINE_COMMENT' || token.type == 'UNFINISHED_COMMENT') {
+            if (token.type == 'UNFINISHED_COMMENT')
+                state.onWarning(new VkpParseError(`Unfinished multiline comment`, getLocation()));
+            comments.push(parseCommentValue(token.value));
+            nextToken();
+        }
+        else {
+            break;
+        }
+    }
+    return comments;
+}
+function parsePatchPragma() {
+    const pragma = parsePragmaValue(peekToken().value);
+    nextToken();
+    const comment = parseCommentsAfterExpr();
+    return { pragma, comment };
+}
+function parsePatchOffsetCorrector() {
+    const text = peekToken().value;
+    const offset = parseOffsetValue(text);
+    nextToken();
+    const comment = parseCommentsAfterExpr();
+    return { text, offset, comment };
+}
+function parsePatchRecord() {
+    const address = parsePatchRecordAddress();
+    const data = [];
+    for (let i = 0; i < 2; i++) {
+        if (!parsePatchRecordSeparator())
+            break;
+        const loc = getLocation();
+        const [buffer, placeholders] = parsePatchData();
+        data.push({ loc, buffer: mergeBuffers(buffer), placeholders });
+    }
+    if (!data.length)
+        throw new VkpParseError(`Empty patch data record!`, getLocation());
+    const comment = parseCommentsAfterExpr();
+    return {
+        address,
+        comment,
+        old: data.length == 2 ? data[0] : undefined,
+        new: data.length == 2 ? data[1] : data[0],
+    };
+}
+function mergeBuffers(buffers) {
+    return buffers.length > 1 ? Buffer.concat(buffers) : buffers[0];
+}
+function parsePatchRecordAddress() {
+    const value = parseAddressValue(peekToken().value);
+    nextToken();
+    return value;
+}
+function parsePatchData() {
+    const data = [];
+    let token;
+    let placeholders = 0;
+    while ((token = peekToken())) {
+        if (token.type == 'COMMA') {
+            nextToken();
+        }
+        else if (token.type == 'DATA') {
+            data.push(parseHexDataValue(peekToken().value));
+            nextToken();
+        }
+        else if (token.type == 'PLACEHOLDER') {
+            data.push(parsePlaceholderValue(peekToken().value));
+            nextToken();
+            placeholders++;
+        }
+        else if (token.type == 'NUMBER') {
+            data.push(parseAnyNumberValue(peekToken().value));
+            nextToken();
+        }
+        else if (token.type == 'STRING') {
+            data.push(parseStringValue(peekToken().value));
+            nextToken();
+        }
+        else if (token.type == 'LINE_ESCAPE') {
+            nextToken();
+        }
+        else if (token.type == 'WHITESPACE' || token.type == 'NEWLINE') {
+            break;
+        }
+        else if (token.type == 'COMMENT' || token.type == 'MULTILINE_COMMENT' || token.type == 'UNFINISHED_COMMENT') {
+            if (prevToken().type == '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 == 'NEWLINE') {
+            return false;
+        }
+        else if (token.type == 'DATA' || token.type == 'PLACEHOLDER' || token.type == 'NUMBER' || token.type == 'STRING') {
+            return true;
+        }
+        else if (token.type == 'COMMENT' || token.type == 'MULTILINE_COMMENT' || token.type == 'UNFINISHED_COMMENT') {
+            return false;
+        }
+        else if (token.type == 'WHITESPACE' || token.type == 'LINE_ESCAPE') {
+            nextToken();
+        }
+        else {
+            throw new VkpParseError("Syntax error", getLocation());
+        }
+    }
+    return false;
+}
+function parseCommentsAfterExpr() {
+    const comments = [];
+    let token;
+    while ((token = peekToken())) {
+        if (token.type == 'NEWLINE') {
+            nextToken();
+            break;
+        }
+        else if (token.type == 'WHITESPACE') {
+            nextToken();
+        }
+        else if (token.type == 'COMMENT' || token.type == 'MULTILINE_COMMENT' || token.type == 'UNFINISHED_COMMENT') {
+            if (token.type == 'UNFINISHED_COMMENT')
+                state.onWarning(new VkpParseError(`Unfinished multiline comment`, getLocation()));
+            comments.push(parseCommentValue(token.value));
+            nextToken();
+        }
+        else {
+            throw new VkpParseError("Syntax error", getLocation());
+        }
+    }
+    return comments.join(" ");
+}
+function nextToken() {
+    state.prevToken = state.token;
+    const token = state.token ? state.token : VkpLexer.next();
+    state.token = VkpLexer.next();
+    return token;
+}
+function peekToken() {
+    if (state.token == null)
+        state.token = VkpLexer.next();
+    return state.token;
+}
+function prevToken() {
+    return state.prevToken;
+}
+/**
+ * VkpToken value parsers
+ * */
+function parseCommentValue(v) {
+    if (v.startsWith(';')) {
+        return v.substring(1);
+    }
+    else if (v.startsWith('#')) {
+        return v.substring(1);
+    }
+    else if (v.startsWith('//')) {
+        return v.substring(2);
+    }
+    else if (v.startsWith('/*')) {
+        return v.slice(2, -2);
+    }
+    throw new VkpParseError(`Invalid comment type`, getLocation());
+}
+function parseAnyNumberValue(v) {
+    let m;
+    const tmpBuffer = Buffer.allocUnsafe(8);
+    if ((m = v.match(/^0i([+-]\d+)$/i))) { // dec signed
+        const num = m[1];
+        for (const d of SINT_PARSER_DATA) {
+            if ((num.length - 1) <= d[0]) {
+                const parsedNum = BigInt(num);
+                if (parsedNum < -BigInt(d[1]) || parsedNum > BigInt(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
+        const num = m[1];
+        for (const d of UINT_PARSER_DATA) {
+            if (num.length <= d[0]) {
+                const 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(Number(parsedNum), 0);
+                    return tmpBuffer.subarray(0, d[2] / 8);
+                }
+                else {
+                    tmpBuffer.writeBigUInt64LE(BigInt(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 \\/\\/.`);
+    }
+    const text = value.slice(1, -1);
+    const parts = [];
+    let tmp = "";
+    const 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.`);
+        }
+    */
+    const breakpoint = () => {
+        if (tmp.length) {
+            parts.push(tmp);
+            tmp = "";
+        }
+    };
+    const getStrLocation = (i) => {
+        const loc = getLocation();
+        loc.column += i;
+        return loc;
+    };
+    for (let i = 0; i < text.length; i++) {
+        const 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") {
+                const hex = text.substring(i + 1, i + 1 + 2);
+                if (hex.length == 2) {
+                    breakpoint();
+                    const 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") {
+                const hex = text.substring(i + 1, i + 1 + 4);
+                if (hex.length == 4) {
+                    breakpoint();
+                    const 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 octalLen = 1;
+                for (let j = 1; j < 3; j++) {
+                    if (!text.charAt(i + j).match(/[0-7]/))
+                        break;
+                    octalLen++;
+                }
+                const oct = parseInt(text.substring(i, i + octalLen), 8);
+                if (oct > 0xFF)
+                    throw new VkpParseError(`Unknown escape sequence (\\${text.substring(i, i + octalLen)})`, getStrLocation(i));
+                breakpoint();
+                if (unicode) {
+                    parts.push(Buffer.from([oct, 0x00]));
+                }
+                else {
+                    parts.push(Buffer.from([oct]));
+                }
+                i += octalLen - 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 };

package/package.json

@@ -1,26 +1,35 @@
 {
-	"name": "@sie-js/vkp",
-	"version": "1.0.6",
-	"description": "Parser and utils for the .VKP files format which is used in the V-Klay.",
-	"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",
-		"rtf-parser": "^1.3.3"
-	},
-	"devDependencies": {
-		"glob": "^10.3.12",
-		"jest": "^29.7.0"
-	},
-	"repository": {
-		"url": "git+https://github.com/siemens-mobile-hacks/node-sie-vkp.git"
-	}
-}
+  "name": "@sie-js/vkp",
+  "version": "2.0.1",
+  "description": "Parser and utils for the .VKP files format which is used in the V-Klay.",
+  "main": "dist/src/index.js",
+  "types": "dist/src/index.d.ts",
+  "type": "module",
+  "files": [
+    "./dist/src/*"
+  ],
+  "author": "kirill.zhumarin@gmail.com",
+  "license": "MIT",
+  "dependencies": {
+    "iconv-lite": "^0.6.3",
+    "moo": "^0.5.2",
+    "rtf-parser": "^1.3.3",
+    "sprintf-js": "^1.1.3"
+  },
+  "devDependencies": {
+    "@types/jest": "^29.5.14",
+    "@types/node": "^22.14.1",
+    "@types/sprintf-js": "^1.1.4",
+    "glob": "^10.3.12",
+    "vitest": "^3.1.1"
+  },
+  "repository": {
+    "url": "git+https://github.com/siemens-mobile-hacks/node-sie-vkp.git"
+  },
+  "scripts": {
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "build": "tsc",
+    "dev": "tsc --watch"
+  }
+}

package/.editorconfig

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

package/.github/dependabot.yml

@@ -1,11 +0,0 @@
-# To get started with Dependabot version updates, you'll need to specify which
-# package ecosystems to update and where the package manifests are located.
-# Please see the documentation for all configuration options:
-# https://docs.github.com/code-security/dependabot/dependabot-version-updates/configuration-options-for-the-dependabot.yml-file
-
-version: 2
-updates:
-  - package-ecosystem: "npm" # See documentation for possible values
-    directory: "/" # Location of package manifests
-    schedule:
-      interval: "weekly"

package/.github/workflows/ci.yml

@@ -1,18 +0,0 @@
-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 }}