modwright 0.1.0

package/dist/surfaces/valheim/logs.js

@@ -0,0 +1,197 @@
+const CHAINLOADER = "https://github.com/BepInEx/BepInEx/blob/v5-lts/BepInEx/Bootstrap/Chainloader.cs";
+const PRELOADER = "https://github.com/BepInEx/BepInEx/blob/v5-lts/BepInEx.Preloader/Preloader.cs";
+const PRE = String.raw `^\[(?<level>Fatal|Error|Warning|Message|Info|Debug)\s*:\s*(?<source>.+?)\] `;
+function re(body) {
+    return new RegExp(PRE + body);
+}
+export const SIGNATURES = [
+    {
+        id: "valheim.bepinex.version-banner",
+        game: "valheim",
+        sources: ["bepinex"],
+        severity: "info",
+        category: "version",
+        pattern: re(String.raw `BepInEx (?<version>\d[\w.\-]*) - (?<process>\S+)`),
+        explain: "BepInEx started and named its version and the process it attached to; the anchor for the run.",
+        seenIn: [PRELOADER],
+        extract: ["version", "process"],
+    },
+    {
+        id: "valheim.bepinex.unity-banner",
+        game: "valheim",
+        sources: ["bepinex"],
+        severity: "info",
+        category: "version",
+        pattern: re(String.raw `Running under Unity v(?<unity>[\w.]+)`),
+        explain: "The Unity engine version the game runs on; asset bundles and some plugins are bound to it.",
+        seenIn: [PRELOADER],
+        extract: ["unity"],
+    },
+    {
+        id: "valheim.bepinex.plugin-count",
+        game: "valheim",
+        sources: ["bepinex"],
+        severity: "info",
+        category: "load",
+        pattern: re(String.raw `(?<count>\d+) plugin\(s\) to load`),
+        explain: "How many plugins the chainloader found to load this run.",
+        seenIn: [CHAINLOADER],
+        extract: ["count"],
+    },
+    {
+        id: "valheim.bepinex.plugin-loaded",
+        game: "valheim",
+        sources: ["bepinex"],
+        severity: "info",
+        category: "load",
+        pattern: re(String.raw `Loading \[(?<plugin>.+?) (?<version>[\w.\-+]+)\]`),
+        explain: "One per plugin the chainloader loads, in dependency order; the roll-call of what is live.",
+        seenIn: [CHAINLOADER],
+        extract: ["plugin", "version"],
+    },
+    {
+        id: "valheim.bepinex.chainloader-complete",
+        game: "valheim",
+        sources: ["bepinex"],
+        severity: "info",
+        category: "success",
+        pattern: re(String.raw `Chainloader startup complete`),
+        explain: "Every plugin that was going to load has loaded. Unity exceptions from those plugins are not in this file by default; see Player.log.",
+        seenIn: [CHAINLOADER],
+    },
+    {
+        id: "valheim.bepinex.missing-dependency",
+        game: "valheim",
+        sources: ["bepinex"],
+        severity: "error",
+        category: "order",
+        pattern: re(String.raw `Could not load \[(?<plugin>.+?)\] because it has missing dependencies: (?<missing>.+)$`),
+        explain: "A plugin declared a hard dependency that is not installed; the plugin is skipped.",
+        hint: "Install the named dependency (its GUID is what is listed) or remove the plugin.",
+        seenIn: [CHAINLOADER],
+        extract: ["plugin", "missing"],
+    },
+    {
+        id: "valheim.bepinex.dependency-cascade",
+        game: "valheim",
+        sources: ["bepinex"],
+        severity: "warn",
+        category: "order",
+        pattern: re(String.raw `Skipping \[(?<plugin>.+?)\] because it has a dependency that was not loaded`),
+        explain: "A plugin was skipped because one it depends on failed earlier; fix the first failure and this one clears.",
+        seenIn: [CHAINLOADER],
+        extract: ["plugin"],
+    },
+    {
+        id: "valheim.bepinex.incompatible",
+        game: "valheim",
+        sources: ["bepinex"],
+        severity: "error",
+        category: "order",
+        pattern: re(String.raw `Could not load \[(?<plugin>.+?)\] because it is incompatible with: (?<with>.+)$`),
+        explain: "A plugin declared another as incompatible and both are installed; the declaring plugin is skipped.",
+        seenIn: [CHAINLOADER],
+        extract: ["plugin", "with"],
+    },
+    {
+        id: "valheim.bepinex.wrong-bepinex-version",
+        game: "valheim",
+        sources: ["bepinex"],
+        severity: "warn",
+        category: "version",
+        pattern: re(String.raw `Plugin \[(?<plugin>.+?)\] targets a wrong version of BepInEx \((?<targeted>[\w.]+)\) and might not work until you update`),
+        explain: "The plugin was built against a different BepInEx version; it still loads, and may or may not work.",
+        seenIn: [CHAINLOADER],
+        extract: ["plugin", "targeted"],
+    },
+    {
+        id: "valheim.bepinex.duplicate-guid",
+        game: "valheim",
+        sources: ["bepinex"],
+        severity: "warn",
+        category: "order",
+        pattern: re(String.raw `Skipping \[(?<plugin>.+?)\] because a newer version exists \((?<newer>.+?)\)`),
+        explain: "Two plugins share a GUID; the older one is dropped silently apart from this line. Real collisions here are on GUID, not on file path.",
+        seenIn: [CHAINLOADER],
+        extract: ["plugin", "newer"],
+    },
+    {
+        id: "valheim.bepinex.process-filtered",
+        game: "valheim",
+        sources: ["bepinex"],
+        severity: "info",
+        category: "load",
+        pattern: re(String.raw `Skipping \[(?<plugin>.+?)\] because of process filters \((?<filters>.+?)\)`),
+        explain: "The plugin declares it runs only in another process (the dedicated server, say) and was skipped on purpose.",
+        seenIn: [CHAINLOADER],
+        extract: ["plugin", "filters"],
+    },
+    {
+        id: "valheim.bepinex.plugin-load-error",
+        game: "valheim",
+        sources: ["bepinex"],
+        severity: "error",
+        category: "load",
+        pattern: re(String.raw `Error loading \[(?<plugin>.+?)\] :`),
+        explain: "The plugin threw while loading; the exception follows on the next lines. After a game update this is usually a missing method or type.",
+        seenIn: [CHAINLOADER],
+        extract: ["plugin"],
+    },
+    {
+        id: "valheim.bepinex.metadata-rejected",
+        game: "valheim",
+        sources: ["bepinex"],
+        severity: "warn",
+        category: "load",
+        pattern: re(String.raw `Skipping (?:over )?type \[(?<type>.+?)\] (?:as no metadata attribute is specified|because its (?<field>GUID|version|name))`),
+        explain: "A plugin class's [BepInPlugin] attribute is missing or malformed (an invalid GUID, version or name), so the class is not a plugin to BepInEx.",
+        seenIn: [CHAINLOADER],
+        extract: ["type", "field"],
+    },
+    {
+        id: "valheim.bepinex.fatal",
+        game: "valheim",
+        sources: ["bepinex"],
+        severity: "error",
+        category: "crash",
+        pattern: re(String.raw `Error occurred starting the game`),
+        explain: "The chainloader itself failed; nothing loaded.",
+        seenIn: [CHAINLOADER],
+    },
+    {
+        id: "valheim.harmony.target-not-found",
+        game: "valheim",
+        sources: ["bepinex"],
+        severity: "warn",
+        category: "resource",
+        pattern: re(String.raw `AccessTools\.\w+: Could not find (?<kind>method|field|property|type) (?<target>.+)$`),
+        explain: "A plugin's patch reached for a game member that no longer exists, usually after a game update; the plugin's patch silently does nothing.",
+        hint: "The plugin needs an update for the current game version.",
+        seenIn: ["HarmonyX AccessTools"],
+        extract: ["kind", "target"],
+        systemImpact: false,
+    },
+    {
+        id: "valheim.harmony.undefined-target-method",
+        game: "valheim",
+        sources: ["bepinex"],
+        severity: "error",
+        category: "resource",
+        pattern: re(String.raw `(?:[\w.]*Exception: )?Undefined target method for patch method (?<patch>.+)$`),
+        explain: "A Harmony patch declares a target the game no longer has; the patch is not applied and the plugin's feature is missing.",
+        hint: "The plugin needs an update for the current game version.",
+        seenIn: ["HarmonyX PatchClassProcessor"],
+        extract: ["patch"],
+        systemImpact: false,
+    },
+    {
+        id: "valheim.harmony.unpatchall",
+        game: "valheim",
+        sources: ["bepinex"],
+        severity: "warn",
+        category: "script",
+        pattern: re(String.raw `UnpatchAll has been called`),
+        explain: "A plugin called Harmony's UnpatchAll without an id, which removes every plugin's patches, not just its own.",
+        seenIn: ["HarmonyX"],
+    },
+];

package/dist/surfaces/valheim/packaging.js

@@ -0,0 +1,131 @@
+import { promises as fs } from "node:fs";
+import { parse as parseToml } from "smol-toml";
+export const MANIFEST_NAME_RE = /^[A-Za-z0-9_]{1,128}$/;
+export const MANIFEST_VERSION_RE = /^\d+\.\d+\.\d+$/;
+export const DEPENDENCY_STRING_RE = /^([A-Za-z0-9_]+)-([A-Za-z0-9_]+)-(\d+\.\d+\.\d+)$/;
+export const MANIFEST_DESCRIPTION_MAX = 250;
+export const PACKAGE_ROOT_FILES = ["manifest.json", "icon.png", "README.md"];
+export const PACKAGE_OPTIONAL_ROOT_FILES = ["CHANGELOG.md"];
+export const ICON_SIZE = 256;
+export const PACKAGE_ROUTES = ["plugins", "core", "patchers", "monomod", "config", "SlimVML"];
+export function parseDependencyString(s) {
+    const m = DEPENDENCY_STRING_RE.exec(s);
+    return m ? { team: m[1], name: m[2], version: m[3] } : undefined;
+}
+export function parseThunderstoreManifest(text) {
+    const raw = JSON.parse(text.replace(/^/, ""));
+    if (!raw || typeof raw !== "object" || Array.isArray(raw))
+        throw new Error("manifest.json is not a JSON object");
+    const record = raw;
+    const problems = [];
+    const manifest = { raw: record };
+    if (typeof record.name !== "string")
+        problems.push({ field: "name", message: "name is missing or not a string" });
+    else {
+        manifest.name = record.name;
+        if (!MANIFEST_NAME_RE.test(record.name))
+            problems.push({ field: "name", message: `name "${record.name}" must be 1-128 characters of a-z A-Z 0-9 _ with no spaces` });
+    }
+    if (typeof record.description !== "string")
+        problems.push({ field: "description", message: "description is missing or not a string" });
+    else {
+        manifest.description = record.description;
+        if (record.description.length > MANIFEST_DESCRIPTION_MAX)
+            problems.push({ field: "description", message: `description is ${record.description.length} characters; the limit is ${MANIFEST_DESCRIPTION_MAX}` });
+    }
+    if (typeof record.version_number !== "string")
+        problems.push({ field: "version_number", message: "version_number is missing or not a string" });
+    else {
+        manifest.versionNumber = record.version_number;
+        if (!MANIFEST_VERSION_RE.test(record.version_number))
+            problems.push({ field: "version_number", message: `version_number "${record.version_number}" must be three integers Major.Minor.Patch with no suffix` });
+    }
+    if (!("website_url" in record))
+        problems.push({ field: "website_url", message: "website_url is absent; it is optional in meaning but must be present, an empty string if there is none" });
+    else if (typeof record.website_url !== "string")
+        problems.push({ field: "website_url", message: "website_url is not a string" });
+    else
+        manifest.websiteUrl = record.website_url;
+    if (!Array.isArray(record.dependencies))
+        problems.push({ field: "dependencies", message: "dependencies is missing or not a list (an empty list is fine)" });
+    else {
+        const deps = [];
+        record.dependencies.forEach((d, i) => {
+            if (typeof d !== "string") {
+                problems.push({ field: `dependencies[${i}]`, message: "a dependency must be a string" });
+                return;
+            }
+            deps.push(d);
+            if (!parseDependencyString(d))
+                problems.push({ field: `dependencies[${i}]`, message: `"${d}" is not {team}-{package}-{Major.Minor.Patch}` });
+        });
+        manifest.dependencies = deps;
+    }
+    return { manifest, problems };
+}
+const PNG_SIGNATURE = [0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a];
+export async function readPngDimensions(file) {
+    const handle = await fs.open(file, "r");
+    try {
+        const buf = new Uint8Array(24);
+        const { bytesRead } = await handle.read(buf, 0, 24, 0);
+        if (bytesRead < 24)
+            return undefined;
+        if (PNG_SIGNATURE.some((b, i) => buf[i] !== b))
+            return undefined;
+        if (String.fromCharCode(buf[12], buf[13], buf[14], buf[15]) !== "IHDR")
+            return undefined;
+        const view = new DataView(buf.buffer);
+        return { width: view.getUint32(16, false), height: view.getUint32(20, false) };
+    }
+    finally {
+        await handle.close();
+    }
+}
+export function routeOf(relativePath) {
+    const segments = relativePath.split(/[\\/]+/).filter((s) => s.length > 0);
+    if (segments.length < 2)
+        return undefined;
+    const prefixed = segments[0].toLowerCase() === "bepinex";
+    const candidate = prefixed ? segments[1] : segments[0];
+    if (prefixed && segments.length < 3)
+        return undefined;
+    const route = PACKAGE_ROUTES.find((r) => r.toLowerCase() === candidate.toLowerCase());
+    return route ? { route, prefixed } : undefined;
+}
+export function checkThunderstoreToml(text) {
+    const out = { dependencies: {}, problems: [] };
+    let doc;
+    try {
+        doc = parseToml(text);
+    }
+    catch (err) {
+        out.problems.push(`not valid TOML: ${err.message.split("\n")[0]}`);
+        return out;
+    }
+    const pkg = doc.package;
+    if (!pkg || typeof pkg !== "object" || Array.isArray(pkg)) {
+        out.problems.push("no [package] table");
+        return out;
+    }
+    const deps = pkg.dependencies;
+    if (deps === undefined)
+        return out;
+    if (Array.isArray(deps)) {
+        out.problems.push("[package] dependencies is a list; thunderstore.toml wants a [package.dependencies] table of \"Team-Name\" = \"version\" (the list form is manifest.json's shape)");
+        return out;
+    }
+    if (typeof deps !== "object") {
+        out.problems.push("[package.dependencies] is not a table");
+        return out;
+    }
+    for (const [key, value] of Object.entries(deps)) {
+        if (!/^[A-Za-z0-9_]+-[A-Za-z0-9_]+$/.test(key))
+            out.problems.push(`dependency key "${key}" is not Team-Name`);
+        if (typeof value !== "string" || !MANIFEST_VERSION_RE.test(value))
+            out.problems.push(`dependency "${key}" has version ${JSON.stringify(value)}, not Major.Minor.Patch`);
+        else
+            out.dependencies[key] = value;
+    }
+    return out;
+}

package/dist/surfaces/valheim/plugins.js

@@ -0,0 +1,270 @@
+export const BEPINPLUGIN_GUID_RE = /^[a-zA-Z0-9._-]+$/;
+export const SYSTEM_VERSION_RE = /^\d+\.\d+(?:\.\d+){0,2}$/;
+export const SEMVER_RE = /^\d+\.\d+\.\d+(?:-[0-9A-Za-z.-]+)?(?:\+[0-9A-Za-z.-]+)?$/;
+export const COMPATIBILITY_LEVELS = ["NotEnforced", "VersionCheckOnly", "EveryoneMustHaveMod", "ClientMustHaveMod", "ServerMustHaveMod"];
+export const VERSION_STRICTNESS = ["None", "Major", "Minor", "Patch"];
+function stripComments(text) {
+    const out = text.split("");
+    const blank = (from, to) => {
+        for (let i = from; i < to; i++)
+            if (out[i] !== "\n")
+                out[i] = " ";
+    };
+    const skipQuoted = (start, quote) => {
+        let i = start + 1;
+        while (i < text.length && text[i] !== "\n") {
+            if (text[i] === "\\" && text[i + 1] !== "\n")
+                i += 2;
+            else if (text[i] === quote)
+                return i + 1;
+            else
+                i++;
+        }
+        return i;
+    };
+    const skipVerbatim = (start) => {
+        let i = start + 1;
+        while (i < text.length) {
+            if (text[i] !== '"')
+                i++;
+            else if (text[i + 1] === '"')
+                i += 2;
+            else
+                return i + 1;
+        }
+        return i;
+    };
+    let i = 0;
+    while (i < text.length) {
+        const c = text[i];
+        const next = text[i + 1];
+        if (c === "/" && next === "/") {
+            const eol = text.indexOf("\n", i);
+            const end = eol < 0 ? text.length : eol;
+            blank(i, end);
+            i = end;
+        }
+        else if (c === "/" && next === "*") {
+            const close = text.indexOf("*/", i + 2);
+            const end = close < 0 ? text.length : close + 2;
+            blank(i, end);
+            i = end;
+        }
+        else if (c === '"')
+            i = text[i - 1] === "@" ? skipVerbatim(i) : skipQuoted(i, '"');
+        else if (c === "'")
+            i = skipQuoted(i, "'");
+        else
+            i++;
+    }
+    return out.join("");
+}
+function lineAt(text, index) {
+    let line = 1;
+    for (let i = 0; i < index && i < text.length; i++)
+        if (text.charCodeAt(i) === 10)
+            line++;
+    return line;
+}
+function constants(text) {
+    const out = new Map();
+    const re = /\bconst\s+string\s+([A-Za-z_][A-Za-z0-9_]*)\s*=\s*"([^"\n]*)"\s*;/g;
+    let m;
+    while ((m = re.exec(text)))
+        out.set(m[1], m[2]);
+    return out;
+}
+function splitArgs(args) {
+    const out = [];
+    let depth = 0;
+    let inString = false;
+    let current = "";
+    for (let i = 0; i < args.length; i++) {
+        const c = args[i];
+        if (inString) {
+            current += c;
+            if (c === "\\") {
+                current += args[i + 1] ?? "";
+                i++;
+            }
+            else if (c === '"')
+                inString = false;
+            continue;
+        }
+        if (c === '"') {
+            inString = true;
+            current += c;
+        }
+        else if (c === "(") {
+            depth++;
+            current += c;
+        }
+        else if (c === ")") {
+            depth--;
+            current += c;
+        }
+        else if (c === "," && depth === 0) {
+            out.push(current.trim());
+            current = "";
+        }
+        else
+            current += c;
+    }
+    if (current.trim().length > 0)
+        out.push(current.trim());
+    return out;
+}
+function resolveString(expr, consts) {
+    const literal = /^@?"([^"\n]*)"$/.exec(expr);
+    if (literal)
+        return literal[1];
+    const ident = /^(?:[A-Za-z_][A-Za-z0-9_]*\.)*([A-Za-z_][A-Za-z0-9_]*)$/.exec(expr);
+    if (ident && consts.has(ident[1]))
+        return consts.get(ident[1]);
+    return undefined;
+}
+function attributes(text, name) {
+    const out = [];
+    const re = new RegExp(`\\[\\s*(?:[A-Za-z_][A-Za-z0-9_]*\\.)*${name}(?:Attribute)?\\s*(?:\\(([^\\]]*?)\\))?\\s*\\]`, "g");
+    let m;
+    while ((m = re.exec(text)))
+        out.push({ args: m[1] ?? "", index: m.index });
+    return out;
+}
+export function scanPluginSource(source) {
+    const text = stripComments(source);
+    const consts = constants(text);
+    const scan = {
+        plugins: [],
+        dependencies: [],
+        baseUnityPluginClasses: [],
+        unpatchAllWithoutId: [],
+        patchAllParameterless: [],
+        networkCompatibility: [],
+        bepInProcesses: [],
+    };
+    for (const a of attributes(text, "BepInPlugin")) {
+        const args = splitArgs(a.args);
+        const entry = { line: lineAt(text, a.index), unresolved: [] };
+        const [guid, name, version] = args;
+        const take = (expr) => {
+            if (expr === undefined)
+                return undefined;
+            const v = resolveString(expr, consts);
+            if (v === undefined)
+                entry.unresolved.push(expr);
+            return v;
+        };
+        const g = take(guid);
+        if (g !== undefined)
+            entry.guid = g;
+        const n = take(name);
+        if (n !== undefined)
+            entry.name = n;
+        const v = take(version);
+        if (v !== undefined)
+            entry.version = v;
+        scan.plugins.push(entry);
+    }
+    for (const a of attributes(text, "BepInDependency")) {
+        const args = splitArgs(a.args);
+        const entry = { line: lineAt(text, a.index), unresolved: [] };
+        const guid = args[0] !== undefined ? resolveString(args[0], consts) : undefined;
+        if (guid !== undefined)
+            entry.guid = guid;
+        else if (args[0] !== undefined)
+            entry.unresolved.push(args[0]);
+        if (args.length === 1)
+            entry.kind = "hard";
+        else if (args[1] !== undefined) {
+            const second = args[1];
+            if (/SoftDependency\b/.test(second))
+                entry.kind = "soft";
+            else if (/HardDependency\b/.test(second))
+                entry.kind = "hard";
+            else {
+                const min = resolveString(second, consts);
+                if (min !== undefined) {
+                    entry.kind = "hard";
+                    entry.minimumVersion = min;
+                }
+                else
+                    entry.unresolved.push(second);
+            }
+        }
+        scan.dependencies.push(entry);
+    }
+    const classRe = /\bclass\s+([A-Za-z_][A-Za-z0-9_]*)\s*(?:<[^>]*>)?\s*:\s*([^{]+)\{/g;
+    let m;
+    while ((m = classRe.exec(text))) {
+        const bases = m[2].split(",").map((b) => b.trim().replace(/^(?:[A-Za-z_][A-Za-z0-9_]*\.)*/, ""));
+        if (bases.includes("BaseUnityPlugin"))
+            scan.baseUnityPluginClasses.push({ name: m[1], line: lineAt(text, m.index) });
+    }
+    const unpatchRe = /\.UnpatchAll\s*\(\s*(null)?\s*\)/g;
+    while ((m = unpatchRe.exec(text)))
+        scan.unpatchAllWithoutId.push({ line: lineAt(text, m.index) });
+    const patchAllRe = /\.PatchAll\s*\(\s*\)/g;
+    while ((m = patchAllRe.exec(text)))
+        scan.patchAllParameterless.push({ line: lineAt(text, m.index) });
+    for (const a of attributes(text, "NetworkCompatibility")) {
+        const args = splitArgs(a.args);
+        const entry = { line: lineAt(text, a.index) };
+        const level = args[0]?.match(/(?:CompatibilityLevel\.)?([A-Za-z]+)$/)?.[1];
+        if (level)
+            entry.level = level;
+        const strictness = args[1]?.match(/(?:VersionStrictness\.)?([A-Za-z]+)$/)?.[1];
+        if (strictness)
+            entry.strictness = strictness;
+        scan.networkCompatibility.push(entry);
+    }
+    for (const a of attributes(text, "BepInProcess")) {
+        const args = splitArgs(a.args);
+        const name = args[0] !== undefined ? resolveString(args[0], consts) : undefined;
+        scan.bepInProcesses.push({ line: lineAt(text, a.index), ...(name !== undefined ? { name } : {}) });
+    }
+    return scan;
+}
+export function packageNameMatchesGuid(packageName, guid) {
+    const norm = (s) => s.toLowerCase().replace(/[_-]/g, "");
+    const p = norm(packageName);
+    if (p.length === 0)
+        return false;
+    const g = guid.toLowerCase();
+    if (norm(g) === p)
+        return true;
+    return g.split(".").some((segment) => norm(segment) === p);
+}
+export function scanCfg(text) {
+    const scan = { sections: [], entries: [], malformed: [], duplicates: [] };
+    let section = "";
+    const seen = new Map();
+    text.split(/\r?\n/).forEach((raw, i) => {
+        const line = i + 1;
+        const trimmed = raw.trim();
+        if (trimmed.length === 0 || trimmed.startsWith("#"))
+            return;
+        const sec = /^\[(.+)\]$/.exec(trimmed);
+        if (sec) {
+            section = sec[1].trim();
+            scan.sections.push({ name: section, line });
+            return;
+        }
+        const kv = /^([^=\s][^=]*?)\s*=\s*(.*)$/.exec(trimmed);
+        if (!kv) {
+            scan.malformed.push({ line, text: trimmed });
+            return;
+        }
+        const key = kv[1];
+        scan.entries.push({ section, key, value: kv[2], line });
+        const id = `${section}\u0000${key}`;
+        seen.set(id, [...(seen.get(id) ?? []), line]);
+    });
+    for (const [id, lines] of seen) {
+        if (lines.length < 2)
+            continue;
+        const [section, key] = id.split("\u0000");
+        scan.duplicates.push({ section, key, lines });
+    }
+    return scan;
+}