modwright 0.1.0

package/dist/surfaces/cyberpunk2077/index/parsers/tweak.js

@@ -0,0 +1,483 @@
+import { TweakParseError } from "../model.js";
+const TYPE_KEYWORDS = new Set([
+    "int",
+    "float",
+    "bool",
+    "string",
+    "CName",
+    "LocKey",
+    "ResRef",
+    "TweakDBID",
+    "Quaternion",
+    "EulerAngles",
+    "Vector2",
+    "Vector3",
+]);
+const TUPLE_TYPES = new Set(["Quaternion", "EulerAngles", "Vector2", "Vector3"]);
+function isIdentStart(ch) {
+    return /[A-Za-z_]/.test(ch);
+}
+function isIdentPart(ch) {
+    return /[A-Za-z0-9_]/.test(ch);
+}
+function isDigit(ch) {
+    return /[0-9]/.test(ch);
+}
+function tokenize(text, file) {
+    const tokens = [];
+    let i = 0;
+    let line = 1;
+    const n = text.length;
+    function advance(count = 1) {
+        for (let k = 0; k < count; k++) {
+            if (text[i] === "\n")
+                line++;
+            i++;
+        }
+    }
+    while (i < n) {
+        const ch = text[i];
+        if (ch === "\n" || ch === "\r" || ch === " " || ch === "\t") {
+            advance();
+            continue;
+        }
+        if (ch === "/" && text[i + 1] === "/") {
+            while (i < n && text[i] !== "\n")
+                i++;
+            continue;
+        }
+        if (ch === "/" && text[i + 1] === "*") {
+            const startLine = line;
+            advance(2);
+            let closed = false;
+            while (i < n) {
+                if (text[i] === "*" && text[i + 1] === "/") {
+                    advance(2);
+                    closed = true;
+                    break;
+                }
+                advance();
+            }
+            if (!closed)
+                throw new TweakParseError("unterminated block comment", file, startLine);
+            continue;
+        }
+        const startLine = line;
+        if (ch === '"') {
+            advance();
+            let value = "";
+            let closed = false;
+            while (i < n) {
+                const c = text[i];
+                if (c === "\\" && (text[i + 1] === '"' || text[i + 1] === "\\")) {
+                    value += text[i + 1];
+                    advance(2);
+                    continue;
+                }
+                if (c === '"') {
+                    advance();
+                    closed = true;
+                    break;
+                }
+                if (c === "\n")
+                    break;
+                value += c;
+                advance();
+            }
+            if (!closed)
+                throw new TweakParseError("unterminated string literal", file, startLine);
+            tokens.push({ type: "string", text: value, line: startLine });
+            continue;
+        }
+        if (isDigit(ch) ||
+            (ch === "." && isDigit(text[i + 1] ?? "")) ||
+            (ch === "-" && (isDigit(text[i + 1] ?? "") || (text[i + 1] === "." && isDigit(text[i + 2] ?? ""))))) {
+            let raw = "";
+            if (ch === "-") {
+                raw += "-";
+                advance();
+            }
+            while (i < n && isDigit(text[i])) {
+                raw += text[i];
+                advance();
+            }
+            if (text[i] === "." && (isDigit(text[i + 1] ?? "") || text[i + 1] === "f" || text[i + 1] === "F" || text[i + 1] === ";" || text[i + 1] === "," || text[i + 1] === ")" || text[i + 1] === "]" || text[i + 1] === " ")) {
+                raw += ".";
+                advance();
+                while (i < n && isDigit(text[i])) {
+                    raw += text[i];
+                    advance();
+                }
+            }
+            if (text[i] === "f" || text[i] === "F") {
+                raw += text[i];
+                advance();
+            }
+            tokens.push({ type: "number", text: raw, line: startLine });
+            continue;
+        }
+        if (isIdentStart(ch)) {
+            let raw = "";
+            while (i < n && isIdentPart(text[i])) {
+                raw += text[i];
+                advance();
+            }
+            while (text[i] === "." && isIdentStart(text[i + 1] ?? "")) {
+                raw += ".";
+                advance();
+                while (i < n && isIdentPart(text[i])) {
+                    raw += text[i];
+                    advance();
+                }
+            }
+            tokens.push({ type: "ident", text: raw, line: startLine });
+            continue;
+        }
+        switch (ch) {
+            case "{":
+                tokens.push({ type: "lbrace", text: ch, line: startLine });
+                advance();
+                continue;
+            case "}":
+                tokens.push({ type: "rbrace", text: ch, line: startLine });
+                advance();
+                continue;
+            case "[":
+                tokens.push({ type: "lbracket", text: ch, line: startLine });
+                advance();
+                continue;
+            case "]":
+                tokens.push({ type: "rbracket", text: ch, line: startLine });
+                advance();
+                continue;
+            case "(":
+                tokens.push({ type: "lparen", text: ch, line: startLine });
+                advance();
+                continue;
+            case ")":
+                tokens.push({ type: "rparen", text: ch, line: startLine });
+                advance();
+                continue;
+            case ":":
+                tokens.push({ type: "colon", text: ch, line: startLine });
+                advance();
+                continue;
+            case ";":
+                tokens.push({ type: "semi", text: ch, line: startLine });
+                advance();
+                continue;
+            case ",":
+                tokens.push({ type: "comma", text: ch, line: startLine });
+                advance();
+                continue;
+            case "<":
+                tokens.push({ type: "lt", text: ch, line: startLine });
+                advance();
+                continue;
+            case ">":
+                tokens.push({ type: "gt", text: ch, line: startLine });
+                advance();
+                continue;
+            case "=":
+                advance();
+                tokens.push({ type: "eq", text: "=", line: startLine });
+                continue;
+            case "+":
+                if (text[i + 1] === "=") {
+                    advance(2);
+                    tokens.push({ type: "pluseq", text: "+=", line: startLine });
+                    continue;
+                }
+                throw new TweakParseError(`unexpected character '${ch}'`, file, startLine);
+            case "-":
+                if (text[i + 1] === "=") {
+                    advance(2);
+                    tokens.push({ type: "minuseq", text: "-=", line: startLine });
+                    continue;
+                }
+                throw new TweakParseError(`unexpected character '${ch}'`, file, startLine);
+            default:
+                throw new TweakParseError(`unexpected character '${ch}'`, file, startLine);
+        }
+    }
+    tokens.push({ type: "eof", text: "", line: line });
+    return tokens;
+}
+class Parser {
+    tokens;
+    file;
+    pos = 0;
+    pkg = "";
+    inlineCounters = new Map();
+    inlineRoot;
+    declaredNames = new Set();
+    records = [];
+    constructor(tokens, file) {
+        this.tokens = tokens;
+        this.file = file;
+    }
+    peek(offset = 0) {
+        return this.tokens[Math.min(this.pos + offset, this.tokens.length - 1)];
+    }
+    next() {
+        const t = this.tokens[this.pos];
+        if (this.pos < this.tokens.length - 1)
+            this.pos++;
+        return t;
+    }
+    expect(type, what) {
+        const t = this.peek();
+        if (t.type !== type) {
+            throw new TweakParseError(`expected ${what}, found '${t.text || t.type}'`, this.file, t.line);
+        }
+        return this.next();
+    }
+    qualify(name) {
+        if (name.includes(".") || !this.pkg)
+            return name;
+        return `${this.pkg}.${name}`;
+    }
+    parse() {
+        if (this.peek().type === "ident" && this.peek().text === "package") {
+            this.next();
+            const name = this.expect("ident", "package name");
+            this.pkg = name.text;
+        }
+        while (this.peek().type === "ident" && this.peek().text === "using") {
+            this.next();
+            this.expect("ident", "using target");
+            while (this.peek().type === "comma") {
+                this.next();
+                this.expect("ident", "using target");
+            }
+        }
+        while (this.peek().type !== "eof") {
+            if (this.skipTagGroup())
+                continue;
+            const t = this.peek();
+            if (t.type === "ident" && (TYPE_KEYWORDS.has(t.text) || (t.text === "fk" && this.peek(1).type === "lt"))) {
+                const owner = this.pkg || "Global";
+                this.packageFlats.push(this.parseMember(owner));
+                continue;
+            }
+            this.parseBlock();
+        }
+        if (this.packageFlats.length > 0) {
+            const owner = this.pkg || "Global";
+            this.records.push({ name: owner, flats: this.packageFlats, file: this.file, line: 1 });
+            this.declaredNames.add(owner);
+        }
+    }
+    skipTagGroup() {
+        if (this.peek().type === "lbracket" && this.peek(1).type === "ident" && this.peek(2).type === "rbracket") {
+            this.next();
+            this.next();
+            this.next();
+            return true;
+        }
+        return false;
+    }
+    packageFlats = [];
+    parseBlock() {
+        const nameTok = this.expect("ident", "record or group name");
+        const line = nameTok.line;
+        let base;
+        let type;
+        if (this.peek().type === "colon") {
+            this.next();
+            const targetTok = this.expect("ident", "base record or type name");
+            if (targetTok.text.includes(".")) {
+                base = targetTok.text;
+            }
+            else {
+                const qualified = this.qualify(targetTok.text);
+                if (this.declaredNames.has(qualified))
+                    base = qualified;
+                else
+                    type = targetTok.text;
+            }
+        }
+        this.expect("lbrace", "'{'");
+        const owner = this.qualify(nameTok.text);
+        const flats = this.parseMembers(owner);
+        this.expect("rbrace", "'}'");
+        this.records.push({ name: owner, base, type, flats, file: this.file, line });
+        this.declaredNames.add(owner);
+    }
+    nextInlineName(owner) {
+        const count = this.inlineCounters.get(owner) ?? 0;
+        this.inlineCounters.set(owner, count + 1);
+        return `${owner}_inline${count}`;
+    }
+    parseMembers(owner) {
+        const flats = [];
+        while (this.peek().type !== "rbrace") {
+            if (this.skipTagGroup())
+                continue;
+            flats.push(this.parseMember(owner));
+        }
+        return flats;
+    }
+    parseMember(owner) {
+        {
+            const first = this.peek();
+            if (first.type !== "ident") {
+                throw new TweakParseError(`expected a flat name or type, found '${first.text || first.type}'`, this.file, first.line);
+            }
+            let typeToken;
+            if (TYPE_KEYWORDS.has(first.text)) {
+                typeToken = this.next().text;
+            }
+            else if (first.text === "fk" && this.peek(1).type === "lt") {
+                this.next();
+                this.next();
+                const inner = this.expect("ident", "fk<Type> target");
+                this.expect("gt", "'>'");
+                typeToken = `fk<${inner.text}>`;
+            }
+            if (typeToken && this.peek().type === "lbracket" && this.peek(1).type === "rbracket") {
+                this.next();
+                this.next();
+                typeToken = `${typeToken}[]`;
+            }
+            const nameTok = this.expect("ident", "flat name");
+            const opTok = this.peek();
+            let op;
+            if (opTok.type === "eq") {
+                op = "set";
+                this.next();
+            }
+            else if (opTok.type === "pluseq") {
+                op = "append";
+                this.next();
+            }
+            else if (opTok.type === "minuseq") {
+                op = "remove";
+                this.next();
+            }
+            else {
+                throw new TweakParseError(`expected '=', '+=' or '-=', found '${opTok.text || opTok.type}'`, this.file, opTok.line);
+            }
+            const { value, kind } = typeToken
+                ? this.parseTypedValue(typeToken, owner)
+                : this.parseUntypedValue(owner);
+            this.expect("semi", "';'");
+            return { name: nameTok.text, value, kind: typeToken ?? kind, op };
+        }
+    }
+    parseTypedValue(typeToken, owner) {
+        const base = typeToken.replace(/\[\]$/, "");
+        const isArray = typeToken.endsWith("[]");
+        if (isArray) {
+            this.expect("lbracket", "'['");
+            const items = [];
+            while (this.peek().type !== "rbracket") {
+                items.push(this.parseTypedScalar(base, owner));
+                if (this.peek().type === "comma")
+                    this.next();
+                else
+                    break;
+            }
+            this.expect("rbracket", "']'");
+            return { value: items, kind: typeToken };
+        }
+        return { value: this.parseTypedScalar(base, owner), kind: typeToken };
+    }
+    parseTypedScalar(base, owner) {
+        if (TUPLE_TYPES.has(base))
+            return this.parseTuple();
+        if (base === "int")
+            return parseInt(this.expect("number", "integer literal").text, 10);
+        if (base === "float")
+            return parseFloat(this.expect("number", "float literal").text);
+        if (base === "bool")
+            return this.parseBool();
+        if (this.peek().type === "lbrace")
+            return this.parseInlineRecord(owner);
+        return this.expect("string", `${base} string literal`).text;
+    }
+    parseBool() {
+        const t = this.peek();
+        if (t.type === "ident" && (t.text === "true" || t.text === "false")) {
+            this.next();
+            return t.text === "true";
+        }
+        throw new TweakParseError(`expected 'true' or 'false', found '${t.text || t.type}'`, this.file, t.line);
+    }
+    parseTuple() {
+        this.expect("lparen", "'('");
+        const nums = [];
+        while (this.peek().type !== "rparen") {
+            const numTok = this.expect("number", "number in tuple");
+            nums.push(parseFloat(numTok.text));
+            if (this.peek().type === "comma")
+                this.next();
+            else
+                break;
+        }
+        this.expect("rparen", "')'");
+        return nums;
+    }
+    parseUntypedValue(owner) {
+        const t = this.peek();
+        switch (t.type) {
+            case "number": {
+                this.next();
+                const isFloat = t.text.includes(".") || /[fF]$/.test(t.text);
+                return { value: isFloat ? parseFloat(t.text) : parseInt(t.text, 10), kind: isFloat ? "number" : "number" };
+            }
+            case "string":
+                this.next();
+                return { value: t.text, kind: "string" };
+            case "ident":
+                if (t.text === "true" || t.text === "false") {
+                    this.next();
+                    return { value: t.text === "true", kind: "bool" };
+                }
+                throw new TweakParseError(`unexpected identifier '${t.text}' as a value`, this.file, t.line);
+            case "lparen":
+                return { value: this.parseTuple(), kind: "tuple" };
+            case "lbracket": {
+                this.next();
+                const items = [];
+                while (this.peek().type !== "rbracket") {
+                    items.push(this.parseUntypedValue(owner).value);
+                    if (this.peek().type === "comma")
+                        this.next();
+                    else
+                        break;
+                }
+                this.expect("rbracket", "']'");
+                return { value: items, kind: "array" };
+            }
+            case "lbrace":
+                return { value: this.parseInlineRecord(owner), kind: "record" };
+            default:
+                throw new TweakParseError(`unexpected token '${t.text || t.type}' where a value was expected`, this.file, t.line);
+        }
+    }
+    parseInlineRecord(owner) {
+        const openTok = this.expect("lbrace", "'{'");
+        const outerRoot = this.inlineRoot;
+        const root = outerRoot ?? owner;
+        const name = this.nextInlineName(root);
+        this.inlineRoot = root;
+        const flats = this.parseMembers(name);
+        this.inlineRoot = outerRoot;
+        this.expect("rbrace", "'}'");
+        let type;
+        if (this.peek().type === "colon") {
+            this.next();
+            type = this.expect("ident", "inline record type").text;
+        }
+        this.records.push({ name, type, flats, file: this.file, line: openTok.line });
+        this.declaredNames.add(name);
+        return name;
+    }
+}
+export function parseTweakFile(text, file) {
+    const tokens = tokenize(text, file);
+    const parser = new Parser(tokens, file);
+    parser.parse();
+    return parser.records;
+}

package/dist/surfaces/cyberpunk2077/index/parsers/tweakxl-yaml.js

@@ -0,0 +1,183 @@
+import * as YAML from "yaml";
+import { TweakParseError } from "../model.js";
+function toIR(node) {
+    if (node === null || node === undefined)
+        return { kind: "scalar", value: null };
+    if (YAML.isScalar(node))
+        return { kind: "scalar", value: node.value ?? null, tag: node.tag };
+    if (YAML.isSeq(node))
+        return { kind: "seq", tag: node.tag, items: node.items.map(toIR) };
+    if (YAML.isMap(node)) {
+        return {
+            kind: "map",
+            tag: node.tag,
+            entries: node.items.map((pair) => ({
+                key: String(YAML.isScalar(pair.key) ? pair.key.value : pair.key),
+                value: toIR(pair.value),
+            })),
+        };
+    }
+    return { kind: "scalar", value: node };
+}
+const OP_TAGS = {
+    "!append": "append",
+    "!append-once": "append",
+    "!append-from": "append",
+    "!prepend": "append",
+    "!prepend-once": "append",
+    "!prepend-from": "append",
+    "!remove": "remove",
+};
+function tagToOp(tag) {
+    return tag ? OP_TAGS[tag] : undefined;
+}
+function hasBaseOrType(node) {
+    return node.kind === "map" && node.entries.some((e) => e.key === "$base" || e.key === "$type");
+}
+const VAR_RE = /\$\(([^)]+)\)/g;
+function substituteText(text, bindings) {
+    return text.replace(VAR_RE, (whole, name) => (name in bindings ? bindings[name] : whole));
+}
+function substituteIR(node, bindings) {
+    if (node.kind === "scalar") {
+        return typeof node.value === "string" ? { ...node, value: substituteText(node.value, bindings) } : node;
+    }
+    if (node.kind === "seq")
+        return { ...node, items: node.items.map((i) => substituteIR(i, bindings)) };
+    return { ...node, entries: node.entries.map((e) => ({ key: e.key, value: substituteIR(e.value, bindings) })) };
+}
+function inferScalarKind(value) {
+    if (typeof value === "number")
+        return "number";
+    if (typeof value === "boolean")
+        return "bool";
+    if (value === null)
+        return "null";
+    return "string";
+}
+function nextInlineName(ctx, owner) {
+    const n = ctx.inlineCounters.get(owner) ?? 0;
+    ctx.inlineCounters.set(owner, n + 1);
+    return `${owner}_inline${n}`;
+}
+function resolveValue(node, owner, line, ctx) {
+    if (node.kind === "scalar")
+        return node.value;
+    if (node.kind === "seq")
+        return node.items.map((item) => resolveValue(item, owner, line, ctx));
+    if (hasBaseOrType(node)) {
+        const name = nextInlineName(ctx, owner);
+        buildRecord(name, node, line, ctx);
+        return name;
+    }
+    const obj = {};
+    for (const entry of node.entries)
+        obj[entry.key] = resolveValue(entry.value, owner, line, ctx);
+    return obj;
+}
+function buildFlatsForEntry(key, value, owner, line, ctx) {
+    if (value.kind === "seq") {
+        const wholeOp = tagToOp(value.tag);
+        if (wholeOp) {
+            return [
+                {
+                    name: key,
+                    value: value.items.map((item) => resolveValue(item, owner, line, ctx)),
+                    kind: "array",
+                    op: wholeOp,
+                },
+            ];
+        }
+        const order = [];
+        const groups = new Map();
+        for (const item of value.items) {
+            const op = tagToOp(item.tag) ?? "set";
+            if (!groups.has(op)) {
+                groups.set(op, []);
+                order.push(op);
+            }
+            groups.get(op).push(resolveValue(item, owner, line, ctx));
+        }
+        return order.map((op) => ({ name: key, value: groups.get(op), kind: "array", op }));
+    }
+    if (value.kind === "map") {
+        const isRecord = hasBaseOrType(value);
+        const resolved = resolveValue(value, owner, line, ctx);
+        return [{ name: key, value: resolved, kind: isRecord ? "record" : "struct", op: tagToOp(value.tag) ?? "set" }];
+    }
+    return [{ name: key, value: value.value, kind: inferScalarKind(value.value), op: tagToOp(value.tag) ?? "set" }];
+}
+function buildRecord(name, ir, line, ctx) {
+    if (ir.kind !== "map") {
+        ctx.records.push({ name, flats: [], file: ctx.file, line });
+        return;
+    }
+    let base;
+    let type;
+    const flats = [];
+    for (const { key, value } of ir.entries) {
+        if (key === "$base") {
+            base = String(resolveValue(value, name, line, ctx));
+            continue;
+        }
+        if (key === "$type") {
+            type = String(resolveValue(value, name, line, ctx));
+            continue;
+        }
+        if (key === "$instances")
+            continue;
+        flats.push(...buildFlatsForEntry(key, value, name, line, ctx));
+    }
+    ctx.records.push({ name, base, type, flats, file: ctx.file, line });
+}
+function extractBindings(node, file, line) {
+    if (node.kind !== "map") {
+        throw new TweakParseError("each $instances entry must be a mapping of variable names to values", file, line);
+    }
+    const bindings = {};
+    for (const { key, value } of node.entries) {
+        bindings[key] = value.kind === "scalar" && value.value !== null ? String(value.value) : "";
+    }
+    return bindings;
+}
+export function parseTweakXLYaml(text, file) {
+    const lineCounter = new YAML.LineCounter();
+    const doc = YAML.parseDocument(text, { lineCounter });
+    if (doc.errors.length > 0) {
+        const first = doc.errors[0];
+        const line = first.pos ? lineCounter.linePos(first.pos[0]).line : 1;
+        throw new TweakParseError(first.message, file, line);
+    }
+    const root = doc.contents;
+    if (!root || !YAML.isMap(root))
+        return [];
+    const ctx = { file, records: [], inlineCounters: new Map() };
+    for (const pair of root.items) {
+        if (!YAML.isScalar(pair.key))
+            continue;
+        const rawName = String(pair.key.value);
+        const line = pair.key.range ? lineCounter.linePos(pair.key.range[0]).line : 1;
+        const bodyIR = toIR(pair.value);
+        if (bodyIR.kind !== "map") {
+            const dot = rawName.lastIndexOf(".");
+            const owner = dot === -1 ? rawName : rawName.slice(0, dot);
+            const flatName = dot === -1 ? rawName : rawName.slice(dot + 1);
+            const flats = buildFlatsForEntry(flatName, bodyIR, owner, line, ctx);
+            ctx.records.push({ name: owner, flats, file, line });
+            continue;
+        }
+        const instancesEntry = bodyIR.entries.find((e) => e.key === "$instances");
+        if (instancesEntry && instancesEntry.value.kind === "seq" && bodyIR.kind === "map") {
+            const withoutInstances = { ...bodyIR, entries: bodyIR.entries.filter((e) => e.key !== "$instances") };
+            for (const instanceNode of instancesEntry.value.items) {
+                const bindings = extractBindings(instanceNode, file, line);
+                const expandedName = substituteText(rawName, bindings);
+                const substituted = substituteIR(withoutInstances, bindings);
+                buildRecord(expandedName, substituted, line, ctx);
+            }
+            continue;
+        }
+        buildRecord(rawName, bodyIR, line, ctx);
+    }
+    return ctx.records;
+}