modwright 0.1.0

package/dist/surfaces/baldursgate3/index/parsers/loca.js

@@ -0,0 +1,41 @@
+import { decodeEntities, parseProlog, parseTagClose, parseTagOpen, peekTagName, skipTrivia, stripBom, xmlError, } from "./xmlutil.js";
+const CLOSE_CONTENT = "</content>";
+export function parseLoca(text, file = "<loca>") {
+    const s = { text: stripBom(text), pos: 0, file };
+    parseProlog(s);
+    skipTrivia(s);
+    const open = parseTagOpen(s);
+    if (open.name !== "contentList") {
+        throw xmlError(s, `expected root <contentList> element, found <${open.name}>`);
+    }
+    const entries = [];
+    if (!open.selfClosing) {
+        for (;;) {
+            skipTrivia(s);
+            if (s.text.startsWith("</", s.pos))
+                break;
+            if (s.pos >= s.text.length)
+                throw xmlError(s, "unexpected end of file inside <contentList>");
+            const peek = peekTagName(s);
+            if (peek !== "content") {
+                throw xmlError(s, `unexpected <${peek}> inside <contentList>; expected <content>`);
+            }
+            const contentOpen = parseTagOpen(s);
+            const handle = contentOpen.attrs.contentuid;
+            if (handle === undefined)
+                throw xmlError(s, "<content> is missing its 'contentuid'");
+            const version = Number.parseInt(contentOpen.attrs.version ?? "0", 10) || 0;
+            let raw = "";
+            if (!contentOpen.selfClosing) {
+                const end = s.text.indexOf(CLOSE_CONTENT, s.pos);
+                if (end === -1)
+                    throw xmlError(s, `unterminated <content contentuid="${handle}">`);
+                raw = s.text.slice(s.pos, end);
+                s.pos = end + CLOSE_CONTENT.length;
+            }
+            entries.push({ handle, version, text: decodeEntities(raw) });
+        }
+        parseTagClose(s, "contentList");
+    }
+    return entries;
+}

package/dist/surfaces/baldursgate3/index/parsers/lsx.js

@@ -0,0 +1,137 @@
+import { parseProlog, parseTagClose, parseTagOpen, peekTagName, skipTrivia, stripBom, xmlError, } from "./xmlutil.js";
+function parseAttribute(s) {
+    const open = parseTagOpen(s);
+    if (open.name !== "attribute") {
+        throw xmlError(s, `expected <attribute>, found <${open.name}>`);
+    }
+    if (!open.selfClosing) {
+        throw xmlError(s, "<attribute> must be self-closing (\"<attribute .../>\")");
+    }
+    const id = open.attrs.id;
+    if (id === undefined)
+        throw xmlError(s, "<attribute> is missing its 'id'");
+    const type = open.attrs.type;
+    if (type === undefined)
+        throw xmlError(s, `<attribute id="${id}"> is missing its 'type'`);
+    const attribute = { id, type, value: open.attrs.value ?? "" };
+    if (open.attrs.handle !== undefined)
+        attribute.handle = open.attrs.handle;
+    if (open.attrs.version !== undefined)
+        attribute.version = open.attrs.version;
+    return attribute;
+}
+function parseChildren(s) {
+    const open = parseTagOpen(s);
+    if (open.name !== "children")
+        throw xmlError(s, `expected <children>, found <${open.name}>`);
+    const nodes = [];
+    if (!open.selfClosing) {
+        for (;;) {
+            skipTrivia(s);
+            if (s.text.startsWith("</", s.pos))
+                break;
+            if (s.pos >= s.text.length)
+                throw xmlError(s, "unexpected end of file inside <children>");
+            const peek = peekTagName(s);
+            if (peek !== "node") {
+                throw xmlError(s, `unexpected <${peek}> inside <children>; only <node> is allowed here`);
+            }
+            nodes.push(parseNode(s));
+        }
+        parseTagClose(s, "children");
+    }
+    return nodes;
+}
+function parseNode(s) {
+    const open = parseTagOpen(s);
+    if (open.name !== "node")
+        throw xmlError(s, `expected <node>, found <${open.name}>`);
+    const id = open.attrs.id;
+    if (id === undefined)
+        throw xmlError(s, "<node> is missing its 'id'");
+    const attributes = {};
+    const children = [];
+    if (!open.selfClosing) {
+        for (;;) {
+            skipTrivia(s);
+            if (s.text.startsWith("</", s.pos))
+                break;
+            if (s.pos >= s.text.length)
+                throw xmlError(s, `unexpected end of file inside <node id="${id}">`);
+            const peek = peekTagName(s);
+            if (peek === "attribute") {
+                const { id: attributeId, ...attribute } = parseAttribute(s);
+                attributes[attributeId] = attribute;
+            }
+            else if (peek === "children") {
+                children.push(...parseChildren(s));
+            }
+            else {
+                throw xmlError(s, `unexpected <${peek}> inside <node id="${id}">; expected <attribute> or <children>`);
+            }
+        }
+        parseTagClose(s, "node");
+    }
+    return { id, attributes, children };
+}
+function parseRegion(s) {
+    const open = parseTagOpen(s);
+    if (open.name !== "region")
+        throw xmlError(s, `expected <region>, found <${open.name}>`);
+    const id = open.attrs.id;
+    if (id === undefined)
+        throw xmlError(s, "<region> is missing its 'id'");
+    if (open.selfClosing)
+        throw xmlError(s, `<region id="${id}"> has no content (expected a root <node>)`);
+    skipTrivia(s);
+    const root = parseNode(s);
+    parseTagClose(s, "region");
+    return { id, root };
+}
+function parseVersion(s) {
+    const open = parseTagOpen(s);
+    if (open.name !== "version")
+        throw xmlError(s, `expected <version>, found <${open.name}>`);
+    if (!open.selfClosing)
+        parseTagClose(s, "version");
+}
+export function parseLsx(text, file = "<lsx>") {
+    const s = { text: stripBom(text), pos: 0, file };
+    parseProlog(s);
+    skipTrivia(s);
+    const saveOpen = parseTagOpen(s);
+    if (saveOpen.name !== "save")
+        throw xmlError(s, `expected root <save> element, found <${saveOpen.name}>`);
+    const regions = [];
+    if (!saveOpen.selfClosing) {
+        skipTrivia(s);
+        if (s.text[s.pos] === "<" && peekTagName(s) === "version") {
+            parseVersion(s);
+        }
+        for (;;) {
+            skipTrivia(s);
+            if (s.text.startsWith("</", s.pos))
+                break;
+            if (s.pos >= s.text.length)
+                throw xmlError(s, "unexpected end of file inside <save>");
+            const peek = peekTagName(s);
+            if (peek !== "region")
+                throw xmlError(s, `unexpected <${peek}> inside <save>; expected <region>`);
+            regions.push(parseRegion(s));
+        }
+        parseTagClose(s, "save");
+    }
+    skipTrivia(s);
+    if (s.pos < s.text.length)
+        throw xmlError(s, "unexpected content after </save>");
+    return { regions };
+}
+export function walkLsxNodes(root, visit) {
+    const recurse = (node, ancestors) => {
+        const breadcrumb = [...ancestors, node.id].join("/");
+        visit(node, breadcrumb);
+        for (const child of node.children)
+            recurse(child, [...ancestors, node.id]);
+    };
+    recurse(root, []);
+}

package/dist/surfaces/baldursgate3/index/parsers/stats.js

@@ -0,0 +1,45 @@
+const NEW_ENTRY = /^new entry "([^"]*)"$/;
+const TYPE_LINE = /^type "([^"]*)"$/;
+const USING_LINE = /^using "([^"]*)"$/;
+const DATA_LINE = /^data "([^"]*)" "(.*)"$/;
+function stripBom(text) {
+    return text.charCodeAt(0) === 0xfeff ? text.slice(1) : text;
+}
+export function parseStats(text, file) {
+    const normalized = stripBom(text).replace(/\r\n/g, "\n").replace(/\r/g, "\n");
+    const lines = normalized.split("\n");
+    const entries = [];
+    let current;
+    for (let i = 0; i < lines.length; i++) {
+        const line = (lines[i] ?? "").trim();
+        if (line.length === 0 || line.startsWith("//"))
+            continue;
+        const newEntry = NEW_ENTRY.exec(line);
+        if (newEntry) {
+            if (current)
+                entries.push(current);
+            current = { name: newEntry[1] ?? "", type: "", fields: {}, file, line: i + 1 };
+            continue;
+        }
+        if (!current)
+            continue;
+        const type = TYPE_LINE.exec(line);
+        if (type) {
+            current.type = type[1] ?? "";
+            continue;
+        }
+        const using = USING_LINE.exec(line);
+        if (using) {
+            current.using = using[1] ?? "";
+            continue;
+        }
+        const data = DATA_LINE.exec(line);
+        if (data) {
+            current.fields[data[1] ?? ""] = data[2] ?? "";
+            continue;
+        }
+    }
+    if (current)
+        entries.push(current);
+    return entries;
+}

package/dist/surfaces/baldursgate3/index/parsers/treasuretable.js

@@ -0,0 +1,57 @@
+const NEW_TREASURETABLE = /^new treasuretable "([^"]*)"$/;
+const CAN_MERGE = /^CanMerge\s+(\S+)$/;
+const NEW_SUBTABLE = /^new subtable "([^"]*)"$/;
+const OBJECT_CATEGORY = /^object category\s+"([^"]*)"\s*,\s*(.*)$/;
+function stripBom(text) {
+    return text.charCodeAt(0) === 0xfeff ? text.slice(1) : text;
+}
+export function parseTreasureTable(text, file) {
+    const normalized = stripBom(text).replace(/\r\n/g, "\n").replace(/\r/g, "\n");
+    const lines = normalized.split("\n");
+    const entries = [];
+    let currentTable;
+    let canMerge = false;
+    let subtableIndex = -1;
+    let subtableChance = "";
+    for (let i = 0; i < lines.length; i++) {
+        const line = (lines[i] ?? "").trim();
+        if (line.length === 0 || line.startsWith("//"))
+            continue;
+        const table = NEW_TREASURETABLE.exec(line);
+        if (table) {
+            currentTable = table[1] ?? "";
+            canMerge = false;
+            subtableIndex = -1;
+            subtableChance = "";
+            continue;
+        }
+        if (!currentTable)
+            continue;
+        const merge = CAN_MERGE.exec(line);
+        if (merge) {
+            canMerge = merge[1] !== "0";
+            continue;
+        }
+        const subtable = NEW_SUBTABLE.exec(line);
+        if (subtable) {
+            subtableIndex++;
+            subtableChance = subtable[1] ?? "";
+            continue;
+        }
+        const obj = OBJECT_CATEGORY.exec(line);
+        if (obj) {
+            entries.push({
+                treasuretable: currentTable,
+                canMerge,
+                subtableIndex,
+                subtableChance,
+                category: obj[1] ?? "",
+                args: (obj[2] ?? "").trim(),
+                file,
+                line: i + 1,
+            });
+            continue;
+        }
+    }
+    return entries;
+}

package/dist/surfaces/baldursgate3/index/parsers/xmlutil.js

@@ -0,0 +1,142 @@
+const NAME_RE = /^[A-Za-z_][\w.-]*/;
+const ENTITY_RE = /&(amp|lt|gt|quot|apos|#x[0-9a-fA-F]+|#\d+);/g;
+export function stripBom(text) {
+    return text.charCodeAt(0) === 0xfeff ? text.slice(1) : text;
+}
+export function lineAt(text, pos) {
+    let line = 1;
+    const upto = Math.min(pos, text.length);
+    for (let i = 0; i < upto; i++) {
+        if (text[i] === "\n")
+            line++;
+    }
+    return line;
+}
+export function xmlError(s, message) {
+    return new Error(`${s.file}:${lineAt(s.text, s.pos)}: ${message}`);
+}
+export function decodeEntities(raw) {
+    return raw.replace(ENTITY_RE, (whole, ent) => {
+        switch (ent) {
+            case "amp":
+                return "&";
+            case "lt":
+                return "<";
+            case "gt":
+                return ">";
+            case "quot":
+                return '"';
+            case "apos":
+                return "'";
+            default:
+                if (ent.startsWith("#x") || ent.startsWith("#X"))
+                    return String.fromCodePoint(parseInt(ent.slice(2), 16));
+                if (ent.startsWith("#"))
+                    return String.fromCodePoint(parseInt(ent.slice(1), 10));
+                return whole;
+        }
+    });
+}
+export function skipTrivia(s) {
+    for (;;) {
+        const c = s.text[s.pos];
+        if (c === " " || c === "\t" || c === "\n" || c === "\r") {
+            s.pos++;
+            continue;
+        }
+        if (s.text.startsWith("<!--", s.pos)) {
+            const end = s.text.indexOf("-->", s.pos + 4);
+            if (end === -1)
+                throw xmlError(s, "unterminated comment");
+            s.pos = end + 3;
+            continue;
+        }
+        break;
+    }
+}
+function skipInlineWs(s) {
+    while (s.pos < s.text.length && /\s/.test(s.text[s.pos]))
+        s.pos++;
+}
+export function parseProlog(s) {
+    skipTrivia(s);
+    if (s.text.startsWith("<?xml", s.pos)) {
+        const end = s.text.indexOf("?>", s.pos);
+        if (end === -1)
+            throw xmlError(s, "unterminated XML declaration");
+        s.pos = end + 2;
+    }
+}
+export function peekTagName(s) {
+    if (s.text[s.pos] !== "<")
+        throw xmlError(s, "expected '<'");
+    const m = NAME_RE.exec(s.text.slice(s.pos + 1));
+    if (!m)
+        throw xmlError(s, "malformed tag: expected an element name after '<'");
+    return m[0];
+}
+export function parseTagOpen(s) {
+    if (s.text[s.pos] !== "<")
+        throw xmlError(s, "expected '<'");
+    s.pos++;
+    const nameMatch = NAME_RE.exec(s.text.slice(s.pos));
+    if (!nameMatch)
+        throw xmlError(s, "expected an element name after '<'");
+    const name = nameMatch[0];
+    s.pos += name.length;
+    const attrs = {};
+    for (;;) {
+        skipInlineWs(s);
+        if (s.text.startsWith("/>", s.pos)) {
+            s.pos += 2;
+            return { name, attrs, selfClosing: true };
+        }
+        if (s.text[s.pos] === ">") {
+            s.pos++;
+            return { name, attrs, selfClosing: false };
+        }
+        if (s.pos >= s.text.length)
+            throw xmlError(s, `unterminated tag <${name}>`);
+        const attrNameMatch = NAME_RE.exec(s.text.slice(s.pos));
+        if (!attrNameMatch) {
+            throw xmlError(s, `malformed tag <${name}>: expected an attribute name, '/>' or '>'`);
+        }
+        const attrName = attrNameMatch[0];
+        s.pos += attrName.length;
+        skipInlineWs(s);
+        if (s.text[s.pos] !== "=")
+            throw xmlError(s, `attribute '${attrName}' on <${name}> is missing '='`);
+        s.pos++;
+        skipInlineWs(s);
+        if (s.text[s.pos] !== '"') {
+            throw xmlError(s, `attribute '${attrName}' on <${name}> must be double-quoted`);
+        }
+        s.pos++;
+        const valueStart = s.pos;
+        while (s.pos < s.text.length && s.text[s.pos] !== '"')
+            s.pos++;
+        if (s.text[s.pos] !== '"') {
+            throw xmlError(s, `unterminated value for attribute '${attrName}' on <${name}>`);
+        }
+        const raw = s.text.slice(valueStart, s.pos);
+        s.pos++;
+        attrs[attrName] = decodeEntities(raw);
+    }
+}
+export function parseTagClose(s, expectedName) {
+    skipTrivia(s);
+    if (!s.text.startsWith("</", s.pos)) {
+        throw xmlError(s, `expected closing tag </${expectedName}>`);
+    }
+    s.pos += 2;
+    const nameMatch = NAME_RE.exec(s.text.slice(s.pos));
+    const name = nameMatch?.[0];
+    if (name !== expectedName) {
+        throw xmlError(s, `expected </${expectedName}> but found </${name ?? "?"}>`);
+    }
+    s.pos += name.length;
+    skipInlineWs(s);
+    if (s.text[s.pos] !== ">")
+        throw xmlError(s, `malformed closing tag for '${expectedName}'`);
+    s.pos++;
+}