hledger-lsp 0.1.1 → 0.1.5

package/out/parser/ast.js

@@ -5,10 +5,16 @@ exports.inferCosts = inferCosts;
 exports.parseTransactionHeader = parseTransactionHeader;
 exports.parsePosting = parsePosting;
 exports.parseAmount = parseAmount;
-exports.extractAccounts = extractAccounts;
-exports.extractPayees = extractPayees;
-exports.extractCommodities = extractCommodities;
-exports.extractTagNames = extractTagNames;
+exports.parseFormat = parseFormat;
+exports.addAccount = addAccount;
+exports.addPayee = addPayee;
+exports.addCommodity = addCommodity;
+exports.addTag = addTag;
+exports.processAccountDirective = processAccountDirective;
+exports.processPayeeDirective = processPayeeDirective;
+exports.processCommodityDirective = processCommodityDirective;
+exports.processTagDirective = processTagDirective;
+exports.processTransaction = processTransaction;
 exports.parseDirective = parseDirective;
 const index_1 = require("../utils/index");
 /**
@@ -111,11 +117,13 @@ function inferCosts(transaction) {
     const firstCommodity = transaction.postings[0].amount.commodity || '';
     // Sum all amounts in the other commodity
     let otherCommodity = '';
+    let otherCommodityFormat;
     let otherSum = 0;
     for (const posting of transaction.postings) {
         const commodity = posting.amount.commodity || '';
         if (commodity !== firstCommodity) {
             otherCommodity = commodity;
+            otherCommodityFormat = posting.amount.format;
             otherSum += posting.amount.quantity;
         }
     }
@@ -123,7 +131,8 @@ function inferCosts(transaction) {
     // This makes the transaction balance when cost is used for balance calculation
     const costAmount = {
         quantity: -otherSum,
-        commodity: otherCommodity
+        commodity: otherCommodity,
+        format: otherCommodityFormat,
     };
     // Add inferred total cost to first posting
     transaction.postings[0].cost = {
@@ -131,60 +140,107 @@ function inferCosts(transaction) {
         amount: costAmount
     };
 }
-function parseTransactionHeader(line) {
-    const trimmed = line.trim();
-    const dateMatch = trimmed.match(/^(\d{4}[-/]\d{2}[-/]\d{2})/);
-    if (!dateMatch)
+function parseDate(line) {
+    const match = line.match(/^(\d{4}[-/]\d{2}[-/]\d{2})/);
+    if (!match)
         return null;
-    const date = dateMatch[1];
-    let rest = trimmed.substring(date.length).trim();
-    let effectiveDate;
-    const effectiveDateMatch = rest.match(/^=(\d{4}[-/]\d{2}[-/]\d{2})/);
-    if (effectiveDateMatch) {
-        effectiveDate = effectiveDateMatch[1];
-        rest = rest.substring(effectiveDateMatch[0].length).trim();
-    }
-    let status;
-    if (rest.startsWith('*')) {
-        status = 'cleared';
-        rest = rest.substring(1).trim();
-    }
-    else if (rest.startsWith('!')) {
-        status = 'pending';
-        rest = rest.substring(1).trim();
-    }
-    let code;
-    const codeMatch = rest.match(/^\(([^)]+)\)/);
-    if (codeMatch) {
-        code = codeMatch[1];
-        rest = rest.substring(codeMatch[0].length).trim();
+    return { date: match[1], rest: line.substring(match[1].length).trim() };
+}
+function parseEffectiveDate(line) {
+    const match = line.match(/^=(\d{4}[-/]\d{2}[-/]\d{2})/);
+    if (match) {
+        return { effectiveDate: match[1], rest: line.substring(match[0].length).trim() };
+    }
+    return { effectiveDate: undefined, rest: line };
+}
+function parseStatus(line) {
+    if (line.startsWith('*'))
+        return { status: 'cleared', rest: line.substring(1).trim() };
+    if (line.startsWith('!'))
+        return { status: 'pending', rest: line.substring(1).trim() };
+    return { status: undefined, rest: line };
+}
+function parseCode(line) {
+    const match = line.match(/^\(([^)]+)\)/);
+    if (match) {
+        return { code: match[1], rest: line.substring(match[0].length).trim() };
     }
+    return { code: undefined, rest: line };
+}
+function parseDescription(line) {
+    let description = line;
     let comment;
     let tags;
-    const commentMatch = rest.match(/^([^;]*);(.*)$/);
-    if (commentMatch) {
-        rest = commentMatch[1].trim();
-        comment = commentMatch[2].trim();
+    const match = line.match(/^([^;]*);(.*)$/);
+    if (match) {
+        description = match[1].trim();
+        comment = match[2].trim();
         const extracted = (0, index_1.extractTags)(comment);
         if (Object.keys(extracted).length > 0)
             tags = extracted;
     }
-    const description = rest.trim();
-    // Parse payee and note according to hledger spec:
-    // If description contains |, split into payee (left) and note (right)
-    // If no |, payee and note both equal description
-    let payee;
-    let note;
+    else {
+        description = line.trim();
+    }
+    return { description, comment, tags };
+}
+function parsePayeeAndNote(description) {
     const pipeIndex = description.indexOf('|');
     if (pipeIndex !== -1) {
-        payee = description.substring(0, pipeIndex).trim();
-        note = description.substring(pipeIndex + 1).trim();
+        return {
+            payee: description.substring(0, pipeIndex).trim(),
+            note: description.substring(pipeIndex + 1).trim()
+        };
     }
-    else {
-        payee = description;
-        note = description;
+    return { payee: description, note: description };
+}
+function parseTransactionHeader(line) {
+    const trimmed = line.trim();
+    const dateRes = parseDate(trimmed);
+    if (!dateRes)
+        return null;
+    let rest = dateRes.rest;
+    const effDateRes = parseEffectiveDate(rest);
+    rest = effDateRes.rest;
+    const statusRes = parseStatus(rest);
+    rest = statusRes.rest;
+    const codeRes = parseCode(rest);
+    rest = codeRes.rest;
+    const descRes = parseDescription(rest);
+    const { payee, note } = parsePayeeAndNote(descRes.description);
+    return {
+        date: dateRes.date,
+        effectiveDate: effDateRes.effectiveDate,
+        status: statusRes.status,
+        code: codeRes.code,
+        description: descRes.description,
+        payee,
+        note,
+        comment: descRes.comment,
+        tags: descRes.tags
+    };
+}
+function parseCost(text) {
+    // Check for @@ first (total price), then @ (unit price)
+    const totalCostMatch = text.match(/@@\s*(.+)$/);
+    const unitCostMatch = !totalCostMatch ? text.match(/@\s*(.+)$/) : null;
+    if (totalCostMatch) {
+        const amountPart = text.substring(0, totalCostMatch.index ?? 0).trim();
+        const costPart = totalCostMatch[1].trim();
+        const costAmount = parseAmount(costPart);
+        if (costAmount) {
+            return { amountPart, cost: { type: 'total', amount: costAmount } };
+        }
     }
-    return { date, effectiveDate, status, code, description, payee, note, comment, tags };
+    else if (unitCostMatch) {
+        const amountPart = text.substring(0, unitCostMatch.index ?? 0).trim();
+        const costPart = unitCostMatch[1].trim();
+        const costAmount = parseAmount(costPart);
+        if (costAmount) {
+            return { amountPart, cost: { type: 'unit', amount: costAmount } };
+        }
+    }
+    return { amountPart: text.trim() };
 }
 function parsePosting(line) {
     if (!(0, index_1.isPosting)(line))
@@ -221,365 +277,493 @@ function parsePosting(line) {
             posting.assertion = assertionAmount;
     }
     // Now parse amount and cost from beforeAssertion
-    // Check for @@ first (total price), then @ (unit price)
-    const totalCostMatch = beforeAssertion.match(/@@\s*(.+)$/);
-    const unitCostMatch = !totalCostMatch ? beforeAssertion.match(/@\s*(.+)$/) : null;
-    if (totalCostMatch) {
-        // Parse total cost: amount @@ totalCost
-        const amountPart = beforeAssertion.substring(0, totalCostMatch.index ?? 0).trim();
-        const costPart = totalCostMatch[1].trim();
-        const amount = parseAmount(amountPart);
-        if (amount)
-            posting.amount = amount;
-        const costAmount = parseAmount(costPart);
-        if (costAmount) {
-            posting.cost = { type: 'total', amount: costAmount };
+    const { amountPart, cost } = parseCost(beforeAssertion);
+    if (cost)
+        posting.cost = cost;
+    const amount = parseAmount(amountPart);
+    if (amount)
+        posting.amount = amount;
+    return posting;
+}
+/**
+ * Helper to detect decimal mark and thousands separator from a number string.
+ */
+function detectNumberFormat(numStr, defaultDecimalMark) {
+    let decimalMark = defaultDecimalMark;
+    if (!decimalMark) {
+        const lastDot = numStr.lastIndexOf('.');
+        const lastComma = numStr.lastIndexOf(',');
+        if (lastDot > -1 && lastComma > -1) {
+            decimalMark = lastDot > lastComma ? '.' : ',';
+        }
+        else if (lastDot > -1) {
+            // Check if it's a thousands separator
+            const parts = numStr.split('.');
+            if (parts.length > 2) {
+                decimalMark = null; // Multiple dots -> thousands separator
+            }
+            else {
+                decimalMark = '.';
+            }
+        }
+        else if (lastComma > -1) {
+            const parts = numStr.split(',');
+            if (parts.length > 2) {
+                decimalMark = null; // Multiple commas -> thousands separator
+            }
+            else {
+                decimalMark = ',';
+            }
+        }
+        else {
+            decimalMark = null;
         }
     }
-    else if (unitCostMatch) {
-        // Parse unit cost: amount @ unitCost
-        const amountPart = beforeAssertion.substring(0, unitCostMatch.index ?? 0).trim();
-        const costPart = unitCostMatch[1].trim();
-        const amount = parseAmount(amountPart);
-        if (amount)
-            posting.amount = amount;
-        const costAmount = parseAmount(costPart);
-        if (costAmount) {
-            posting.cost = { type: 'unit', amount: costAmount };
+    // Detect thousands separator
+    // It should be the other separator if present
+    // We need to look at the integer part only
+    let integerPart = numStr;
+    if (decimalMark) {
+        const lastIndex = numStr.lastIndexOf(decimalMark);
+        if (lastIndex >= 0) {
+            integerPart = numStr.substring(0, lastIndex);
+        }
+    }
+    const sepCounts = {};
+    for (let i = 0; i < integerPart.length; i++) {
+        const ch = integerPart[i];
+        if (ch < '0' || ch > '9')
+            sepCounts[ch] = (sepCounts[ch] || 0) + 1;
+    }
+    let thousandsSeparator = null;
+    const separators = Object.keys(sepCounts);
+    // If we have a decimal mark, the thousands separator must be different
+    // Filter out the decimal mark from potential separators just in case
+    const potentialSeparators = separators.filter(s => s !== decimalMark);
+    if (potentialSeparators.length === 1) {
+        thousandsSeparator = potentialSeparators[0];
+    }
+    else if (potentialSeparators.length > 1) {
+        let max = 0;
+        let pick = null;
+        for (const k of potentialSeparators) {
+            if (sepCounts[k] > max) {
+                max = sepCounts[k];
+                pick = k;
+            }
+        }
+        thousandsSeparator = pick;
+    }
+    return { decimalMark, thousandsSeparator };
+}
+/**
+ * Helper to parse number string given a decimal mark
+ */
+function parseNumberWithFormat(numStr, mark) {
+    if (!mark) {
+        // If no mark provided/detected, assume standard float parsing (remove all non-digits/dots/minus)
+        // But wait, if no mark, we need to decide what to do.
+        // If ambiguous (e.g. 1.000), hledger assumes decimal mark.
+        // So we should treat the last separator as decimal if it exists.
+        const lastDot = numStr.lastIndexOf('.');
+        const lastComma = numStr.lastIndexOf(',');
+        if (lastDot > -1 && lastComma > -1) {
+            mark = lastDot > lastComma ? '.' : ',';
+        }
+        else if (lastDot > -1) {
+            mark = '.';
+        }
+        else if (lastComma > -1) {
+            mark = ',';
+        }
+    }
+    let cleanStr = numStr;
+    if (mark) {
+        // Remove everything that is NOT the decimal mark, digit, or minus
+        // This effectively removes thousands separators
+        const regex = new RegExp(`[^0-9${mark === '.' ? '\\.' : ','}-]`, 'g');
+        cleanStr = numStr.replace(regex, '');
+        // Replace decimal mark with dot for JS parseFloat
+        if (mark === ',') {
+            cleanStr = cleanStr.replace(',', '.');
         }
     }
     else {
-        // No cost notation, just parse amount
-        const amount = parseAmount(beforeAssertion);
-        if (amount)
-            posting.amount = amount;
+        // No separators found, just parse
+        cleanStr = numStr.replace(/[^0-9.-]/g, '');
     }
-    return posting;
+    return parseFloat(cleanStr);
 }
-function parseAmount(amountStr) {
+function parseAmount(amountStr, decimalMark) {
     const trimmed = amountStr.trim();
     if (!trimmed)
         return null;
+    // Regex to split commodity and amount
+    // We need to be more permissive with the amount part to capture various formats
+    // Amount part can contain digits, commas, dots, spaces (maybe)
+    // But spaces are tricky. For now let's assume space separates commodity if symbol is on left/right
     const patterns = [
-        { pattern: /^-([^\d\s-]+)\s*(\d+(?:[,]\d{3})*(?:\.\d+)?)$/, handler: (m) => ({ quantity: -parseFloat(m[2].replace(/,/g, '')), commodity: m[1] }) },
-        { pattern: /^([^\d\s-]+)\s*([-]?\d+(?:[,]\d{3})*(?:\.\d+)?)$/, handler: (m) => ({ quantity: parseFloat(m[2].replace(/,/g, '')), commodity: m[1] }) },
-        { pattern: /^([-]?\d+(?:[,]\d{3})*(?:\.\d+)?)\s*([^\d\s]+)$/, handler: (m) => ({ quantity: parseFloat(m[1].replace(/,/g, '')), commodity: m[2] }) },
-        { pattern: /^([-]?\d+(?:[,]\d{3})*(?:\.\d+)?)$/, handler: (m) => ({ quantity: parseFloat(m[1].replace(/,/g, '')), commodity: '' }) }
+        {
+            // Symbol on left, negative
+            pattern: /^-([^\d\s-]+)\s*([-]?\d[\d.,\s]*)$/,
+            handler: (m) => {
+                const rawAmount = m[2];
+                const { decimalMark: mark } = detectNumberFormat(rawAmount, decimalMark);
+                return { quantity: -Math.abs(parseNumberWithFormat(rawAmount, mark || undefined)), commodity: m[1], rawAmount };
+            },
+            cleaner: (m, s) => s.replace(/^-/, '')
+        },
+        {
+            // Symbol on left
+            pattern: /^([^\d\s-]+)\s*([-]?\d[\d.,\s]*)$/,
+            handler: (m) => {
+                const rawAmount = m[2];
+                const { decimalMark: mark } = detectNumberFormat(rawAmount, decimalMark);
+                return { quantity: parseNumberWithFormat(rawAmount, mark || undefined), commodity: m[1], rawAmount };
+            },
+            cleaner: (m, s) => s.replace(m[2], m[2].replace('-', ''))
+        },
+        {
+            // Symbol on right
+            pattern: /^([-]?\d[\d.,\s]*)\s*([^\d\s]+)$/,
+            handler: (m) => {
+                const rawAmount = m[1];
+                const { decimalMark: mark } = detectNumberFormat(rawAmount, decimalMark);
+                return { quantity: parseNumberWithFormat(rawAmount, mark || undefined), commodity: m[2], rawAmount };
+            },
+            cleaner: (m, s) => s.replace(m[1], m[1].replace('-', ''))
+        },
+        {
+            // No symbol
+            pattern: /^([-]?\d[\d.,\s]*)$/,
+            handler: (m) => {
+                const rawAmount = m[1];
+                const { decimalMark: mark } = detectNumberFormat(rawAmount, decimalMark);
+                return { quantity: parseNumberWithFormat(rawAmount, mark || undefined), commodity: '', rawAmount };
+            },
+            cleaner: (m, s) => s.replace(m[1], m[1].replace('-', ''))
+        }
     ];
-    for (const { pattern, handler } of patterns) {
+    for (const { pattern, handler, cleaner } of patterns) {
         const match = trimmed.match(pattern);
         if (match) {
+            // Verify that the amount part looks valid (e.g. not just a dot)
+            // and doesn't contain internal spaces that look like commodity separators
+            // This is a heuristic.
             const res = handler(match);
             if (isNaN(res.quantity))
-                return null;
-            return { quantity: res.quantity, commodity: res.commodity };
+                continue;
+            const amount = { quantity: res.quantity, commodity: res.commodity };
+            let sampleForFormat = trimmed;
+            if (res.quantity < 0) {
+                sampleForFormat = cleaner(match, trimmed);
+            }
+            const parsedFormat = parseFormat(sampleForFormat);
+            if (parsedFormat && parsedFormat.format) {
+                amount.format = parsedFormat.format;
+            }
+            return amount;
         }
     }
     return null;
 }
-function extractAccounts(document, sourceUri) {
-    const text = document.getText();
-    const lines = text.split('\n');
-    const accountMap = new Map();
-    for (let i = 0; i < lines.length; i++) {
-        const line = lines[i];
-        if (line.trim().startsWith('account ')) {
-            const accountName = line.trim().substring(8).split(';')[0].trim();
-            if (accountName) {
-                const acc = { name: accountName, declared: true };
-                if (sourceUri !== undefined) {
-                    acc.sourceUri = sourceUri;
-                    acc.line = i;
-                }
-                accountMap.set(accountName, acc);
-            }
+function parseFormat(sample) {
+    if (!sample)
+        return null;
+    const s = sample.trim();
+    const stripQuotes = (s) => { const t = s.trim(); if (t.length >= 2 && t.startsWith('"') && t.endsWith('"'))
+        return t.substring(1, t.length - 1); return t; };
+    const firstDigit = s.search(/\d/);
+    if (firstDigit === -1) {
+        return { name: stripQuotes(s) };
+    }
+    const allowed = /[0-9.,\u00A0\s]/;
+    let start = firstDigit;
+    let end = start;
+    while (end < s.length && allowed.test(s[end]))
+        end++;
+    const leftRaw = s.substring(0, start).trim();
+    const numberRaw = s.substring(start, end).trim();
+    const rightRaw = s.substring(end).trim();
+    if (!numberRaw)
+        return null;
+    const { decimalMark, thousandsSeparator } = detectNumberFormat(numberRaw);
+    let decimalIndex = -1;
+    if (decimalMark) {
+        decimalIndex = numberRaw.lastIndexOf(decimalMark);
+    }
+    const fractionalPart = decimalIndex >= 0 ? numberRaw.substring(decimalIndex + 1) : '';
+    const precision = decimalIndex >= 0 ? (fractionalPart.length > 0 ? fractionalPart.length : 0) : null;
+    let rawSymbol = leftRaw || rightRaw || '';
+    rawSymbol = stripQuotes(rawSymbol);
+    const symbolOnLeft = Boolean(leftRaw);
+    let spaceBetween = false;
+    if (symbolOnLeft) {
+        const between = s.substring(0, firstDigit);
+        spaceBetween = /\s/.test(between.replace(stripQuotes(leftRaw), '')) || /\s/.test(leftRaw.slice(-1));
+    }
+    else {
+        const after = s.substring(end);
+        spaceBetween = /\s/.test(after.replace(stripQuotes(rightRaw), '')) || /\s/.test(s[end - 1]);
+    }
+    const format = { symbol: rawSymbol, symbolOnLeft, spaceBetween, decimalMark: decimalMark, thousandsSeparator: thousandsSeparator || null, precision };
+    let name = rawSymbol;
+    if (rightRaw) {
+        const candidate = stripQuotes(rightRaw);
+        if (/^[A-Za-z][A-Za-z0-9 _-]*$/.test(candidate) || (rightRaw.trim().startsWith('"') && rightRaw.trim().endsWith('"')))
+            name = candidate;
+    }
+    if (rawSymbol === '""')
+        name = '';
+    return { name, format };
+}
+/**
+ * Helper functions used by processCommodityDirective
+ */
+const stripQuotes = (s) => { const t = s.trim(); if (t.length >= 2 && t.startsWith('"') && t.endsWith('"'))
+    return t.substring(1, t.length - 1); return t; };
+function parseCommodityDirective(line) {
+    const directive = line.trim().substring(10).split(';')[0].trim();
+    if (!directive)
+        return null;
+    let parsed = null;
+    if (/\d/.test(directive))
+        parsed = parseFormat(directive);
+    if (parsed) {
+        return { name: parsed.name, format: parsed.format };
+    }
+    else {
+        return { name: stripQuotes(directive), format: undefined };
+    }
+}
+function parseFormatSubDirective(line) {
+    const trimmedNext = line.trim();
+    if (!trimmedNext.startsWith('format '))
+        return null;
+    const rest = trimmedNext.substring(7).trim();
+    const m = rest.match(/^(".*?"|\S+)\s+(.*)$/);
+    if (m) {
+        const formatSymbolRaw = m[1];
+        const samplePart = m[2];
+        const parsedFormat = parseFormat(samplePart) || parseFormat(`${samplePart} ${formatSymbolRaw}`);
+        if (parsedFormat && parsedFormat.format) {
+            const fs = stripQuotes(formatSymbolRaw);
+            return { name: fs, format: parsedFormat.format };
         }
-        if ((0, index_1.isPosting)(line)) {
-            const account = (0, index_1.extractAccountFromPosting)(line);
-            if (account && !accountMap.has(account)) {
-                const acc = { name: account, declared: false };
-                if (sourceUri !== undefined) {
-                    acc.sourceUri = sourceUri;
-                    acc.line = i;
-                }
-                accountMap.set(account, acc);
-            }
+    }
+    // If no match, try parsing rest directly as a format sample (e.g., "format $1,000.00")
+    const parsedDirect = parseFormat(rest);
+    if (parsedDirect && parsedDirect.format) {
+        return { name: parsedDirect.name, format: parsedDirect.format };
+    }
+    return null;
+}
+/**
+ * Helper functions for incremental parsing - adding items to Maps
+ */
+/**
+ * Add or update an account in the accounts map
+ * If account exists, mark as declared if it wasn't already
+ */
+function addAccount(accountMap, name, declared, sourceUri, line) {
+    const existing = accountMap.get(name);
+    if (existing) {
+        // If we're adding a declared version, update the existing entry
+        if (declared && !existing.declared) {
+            existing.declared = true;
+            if (sourceUri !== undefined)
+                existing.sourceUri = sourceUri;
+            if (line !== undefined)
+                existing.line = line;
         }
     }
-    return Array.from(accountMap.values()).sort((a, b) => a.name.localeCompare(b.name));
+    else {
+        const acc = { name, declared };
+        if (sourceUri !== undefined) {
+            acc.sourceUri = sourceUri;
+            acc.line = line;
+        }
+        accountMap.set(name, acc);
+    }
 }
-function extractPayees(document, sourceUri) {
-    const text = document.getText();
-    const lines = text.split('\n');
-    const payeeMap = new Map();
-    for (let i = 0; i < lines.length; i++) {
-        const line = lines[i];
-        if (line.trim().startsWith('payee ')) {
-            const payeeName = line.trim().substring(6).split(';')[0].trim();
-            if (payeeName) {
-                const p = { name: payeeName, declared: true };
-                if (sourceUri !== undefined) {
-                    p.sourceUri = sourceUri;
-                    p.line = i;
-                }
-                payeeMap.set(payeeName, p);
-            }
+/**
+ * Add or update a payee in the payees map
+ */
+function addPayee(payeeMap, name, declared, sourceUri, line) {
+    const existing = payeeMap.get(name);
+    if (existing) {
+        if (declared && !existing.declared) {
+            existing.declared = true;
+            if (sourceUri !== undefined)
+                existing.sourceUri = sourceUri;
+            if (line !== undefined)
+                existing.line = line;
         }
-        if ((0, index_1.isTransactionHeader)(line)) {
-            const header = parseTransactionHeader(line);
-            // Use payee field instead of description (handles | splitting)
-            if (header && header.payee && !payeeMap.has(header.payee)) {
-                const p = { name: header.payee, declared: false };
-                if (sourceUri !== undefined) {
-                    p.sourceUri = sourceUri;
-                    p.line = i;
-                }
-                payeeMap.set(header.payee, p);
-            }
+    }
+    else {
+        const p = { name, declared };
+        if (sourceUri !== undefined) {
+            p.sourceUri = sourceUri;
+            p.line = line;
         }
+        payeeMap.set(name, p);
     }
-    return Array.from(payeeMap.values()).sort((a, b) => a.name.localeCompare(b.name));
 }
-function extractCommodities(document, sourceUri) {
-    const text = document.getText();
-    const lines = text.split('\n');
-    const commodityMap = new Map();
-    const stripQuotes = (s) => { const t = s.trim(); if (t.length >= 2 && t.startsWith('"') && t.endsWith('"'))
-        return t.substring(1, t.length - 1); return t; };
-    const parseCommoditySample = (sample) => {
-        if (!sample)
-            return null;
-        const s = sample.trim();
-        const firstDigit = s.search(/\d/);
-        if (firstDigit === -1)
-            return null;
-        const allowed = /[0-9.,\u00A0\s]/;
-        let start = firstDigit;
-        let end = start;
-        while (end < s.length && allowed.test(s[end]))
-            end++;
-        const leftRaw = s.substring(0, start).trim();
-        const numberRaw = s.substring(start, end).trim();
-        const rightRaw = s.substring(end).trim();
-        if (!numberRaw)
-            return null;
-        const lastDot = numberRaw.lastIndexOf('.');
-        const lastComma = numberRaw.lastIndexOf(',');
-        let decimalMark;
-        let decimalIndex = -1;
-        if (lastDot === -1 && lastComma === -1)
-            decimalMark = undefined;
-        else if (lastDot > lastComma) {
-            decimalMark = '.';
-            decimalIndex = lastDot;
+/**
+ * Add or update a commodity in the commodities map
+ * When merging formats, prefer the one with higher precision or more detail
+ */
+function addCommodity(commodityMap, name, declared, format, sourceUri, line) {
+    const existing = commodityMap.get(name);
+    if (existing) {
+        if (declared) {
+            existing.declared = true;
+            if (format)
+                existing.format = format;
+            if (sourceUri !== undefined)
+                existing.sourceUri = sourceUri;
+            if (line !== undefined)
+                existing.line = line;
         }
-        else {
-            decimalMark = ',';
-            decimalIndex = lastComma;
-        }
-        const integerPart = decimalIndex >= 0 ? numberRaw.substring(0, decimalIndex) : numberRaw;
-        const fractionalPart = decimalIndex >= 0 ? numberRaw.substring(decimalIndex + 1) : '';
-        const precision = decimalIndex >= 0 ? (fractionalPart.length > 0 ? fractionalPart.length : 0) : null;
-        const sepCounts = {};
-        for (let i = 0; i < integerPart.length; i++) {
-            const ch = integerPart[i];
-            if (ch < '0' || ch > '9')
-                sepCounts[ch] = (sepCounts[ch] || 0) + 1;
-        }
-        let thousandsSeparator = null;
-        const separators = Object.keys(sepCounts);
-        if (separators.length === 1)
-            thousandsSeparator = separators[0];
-        else if (separators.length > 1) {
-            let max = 0;
-            let pick = null;
-            for (const k of separators) {
-                if (sepCounts[k] > max) {
-                    max = sepCounts[k];
-                    pick = k;
-                }
+        else if (format && !existing.declared) {
+            // For undeclared commodities, keep the format with better precision
+            const newPrecision = format.precision ?? null;
+            const existingPrecision = existing.format?.precision ?? null;
+            if (!existing.format || (newPrecision !== null && (existingPrecision === null || newPrecision > existingPrecision))) {
+                existing.format = format;
             }
-            thousandsSeparator = pick;
         }
-        let rawSymbol = leftRaw || rightRaw || '';
-        rawSymbol = stripQuotes(rawSymbol);
-        const symbolOnLeft = Boolean(leftRaw);
-        let spaceBetween = false;
-        if (symbolOnLeft) {
-            const between = s.substring(0, firstDigit);
-            spaceBetween = /\s/.test(between.replace(stripQuotes(leftRaw), '')) || /\s/.test(leftRaw.slice(-1));
+    }
+    else {
+        const c = { name, declared, format };
+        if (sourceUri !== undefined) {
+            c.sourceUri = sourceUri;
+            c.line = line;
         }
-        else {
-            const after = s.substring(end);
-            spaceBetween = /\s/.test(after.replace(stripQuotes(rightRaw), '')) || /\s/.test(s[end - 1]);
-        }
-        const format = { symbol: rawSymbol, symbolOnLeft, spaceBetween, decimalMark: decimalMark, thousandsSeparator: thousandsSeparator || null, precision };
-        let name = rawSymbol;
-        if (rightRaw) {
-            const candidate = stripQuotes(rightRaw);
-            if (/^[A-Za-z][A-Za-z0-9 _-]*$/.test(candidate) || (rightRaw.trim().startsWith('"') && rightRaw.trim().endsWith('"')))
-                name = candidate;
-        }
-        if (rawSymbol === '""')
-            name = '';
-        return { name, format };
-    };
-    for (let i = 0; i < lines.length; i++) {
-        const line = lines[i];
-        if (line.trim().startsWith('commodity ')) {
-            const directive = line.trim().substring(10).split(';')[0].trim();
-            if (!directive)
-                continue;
-            let parsed = null;
-            if (/\d/.test(directive))
-                parsed = parseCommoditySample(directive);
-            let commodityName;
-            let format;
-            if (parsed) {
-                commodityName = parsed.name;
-                format = parsed.format;
-            }
-            else {
-                commodityName = stripQuotes(directive);
-                format = undefined;
-            }
-            let look = i + 1;
-            while (look < lines.length) {
-                const next = lines[look];
-                if (!next.trim()) {
-                    look++;
-                    continue;
-                }
-                if (!/^\s+/.test(next))
-                    break;
-                const trimmedNext = next.trim();
-                if (trimmedNext.startsWith('format ')) {
-                    const rest = trimmedNext.substring(7).trim();
-                    const m = rest.match(/^(".*?"|\S+)\s+(.*)$/);
-                    if (m) {
-                        const formatSymbolRaw = m[1];
-                        const samplePart = m[2];
-                        const parsedFormat = parseCommoditySample(samplePart) || parseCommoditySample(`${samplePart} ${formatSymbolRaw}`);
-                        if (parsedFormat && parsedFormat.format) {
-                            format = parsedFormat.format;
-                            const fs = stripQuotes(formatSymbolRaw);
-                            if (fs && fs !== '' && (!commodityName || commodityName === '' || commodityName === fs))
-                                commodityName = fs;
-                        }
-                    }
-                }
-                look++;
-            }
-            const key = commodityName;
-            if (commodityMap.has(key)) {
-                const existing = commodityMap.get(key);
-                const merged = { ...existing, declared: existing.declared || true, format: existing.format || format };
-                if (sourceUri !== undefined) {
-                    merged.sourceUri = existing.sourceUri || sourceUri;
-                    merged.line = existing.line ?? i;
-                }
-                commodityMap.set(key, merged);
-            }
-            else {
-                const c = { name: commodityName, declared: true, format };
-                if (sourceUri !== undefined) {
-                    c.sourceUri = sourceUri;
-                    c.line = i;
-                }
-                commodityMap.set(key, c);
-            }
+        commodityMap.set(name, c);
+    }
+}
+/**
+ * Add or update a tag in the tags map
+ */
+function addTag(tagMap, name, declared, sourceUri, line) {
+    const existing = tagMap.get(name);
+    if (existing) {
+        if (declared && !existing.declared) {
+            existing.declared = true;
+            if (sourceUri !== undefined)
+                existing.sourceUri = sourceUri;
+            if (line !== undefined)
+                existing.line = line;
         }
-        if ((0, index_1.isPosting)(line)) {
-            const posting = parsePosting(line);
-            if (posting?.amount?.commodity && posting.amount.commodity !== '') {
-                const key = posting.amount.commodity;
-                if (!commodityMap.has(key)) {
-                    const c = { name: key, declared: false };
-                    if (sourceUri !== undefined) {
-                        c.sourceUri = sourceUri;
-                    }
-                    commodityMap.set(key, c);
-                }
-            }
-            // Also extract commodity from cost notation
-            if (posting?.cost?.amount?.commodity && posting.cost.amount.commodity !== '') {
-                const key = posting.cost.amount.commodity;
-                if (!commodityMap.has(key)) {
-                    const c = { name: key, declared: false };
-                    if (sourceUri !== undefined) {
-                        c.sourceUri = sourceUri;
-                    }
-                    commodityMap.set(key, c);
-                }
-            }
+    }
+    else {
+        const t = { name, declared };
+        if (sourceUri !== undefined) {
+            t.sourceUri = sourceUri;
+            t.line = line;
         }
+        tagMap.set(name, t);
     }
-    return Array.from(commodityMap.values()).sort((a, b) => a.name.localeCompare(b.name));
 }
-function extractTagNames(document, sourceUri) {
-    const text = document.getText();
-    const lines = text.split('\n');
-    const tagMap = new Map();
-    for (let i = 0; i < lines.length; i++) {
-        const line = lines[i];
-        if (line.trim().startsWith('tag ')) {
-            const tagName = line.trim().substring(4).split(';')[0].trim();
-            if (tagName) {
-                const t = { name: tagName, declared: true };
-                if (sourceUri !== undefined) {
-                    t.sourceUri = sourceUri;
-                    t.line = i;
-                }
-                tagMap.set(tagName, t);
-            }
+/**
+ * Process an account directive and add it to the accounts map
+ */
+function processAccountDirective(line, accountMap, sourceUri, lineNumber) {
+    const accountName = line.trim().substring(8).split(';')[0].trim();
+    if (accountName) {
+        addAccount(accountMap, accountName, true, sourceUri, lineNumber);
+    }
+}
+/**
+ * Process a payee directive and add it to the payees map
+ */
+function processPayeeDirective(line, payeeMap, sourceUri, lineNumber) {
+    const payeeName = line.trim().substring(6).split(';')[0].trim();
+    if (payeeName) {
+        addPayee(payeeMap, payeeName, true, sourceUri, lineNumber);
+    }
+}
+/**
+ * Process a commodity directive and add it to the commodities map
+ * Handles multi-line commodity directives with format subdirectives
+ */
+function processCommodityDirective(lines, startLine, commodityMap, sourceUri) {
+    const line = lines[startLine];
+    const parsed = parseCommodityDirective(line);
+    if (!parsed)
+        return startLine;
+    let commodityName = parsed.name;
+    let format = parsed.format;
+    // Check for format subdirective on following lines
+    let look = startLine + 1;
+    while (look < lines.length) {
+        const next = lines[look];
+        if (!next.trim()) {
+            look++;
+            continue;
         }
-        // Standalone or indented comment lines (transaction-level comments)
-        if ((0, index_1.isComment)(line)) {
-            const commentText = line.trim().substring(1);
-            const extracted = (0, index_1.extractTags)(commentText);
-            for (const k of Object.keys(extracted)) {
-                if (!tagMap.has(k)) {
-                    const t = { name: k, declared: false };
-                    if (sourceUri !== undefined) {
-                        t.sourceUri = sourceUri;
-                        t.line = i;
-                    }
-                    tagMap.set(k, t);
-                }
+        if (!/^\s+/.test(next))
+            break;
+        const subParsed = parseFormatSubDirective(next);
+        if (subParsed) {
+            if (subParsed.format)
+                format = subParsed.format;
+            if (subParsed.name && subParsed.name !== '' && (!commodityName || commodityName === '' || commodityName === subParsed.name)) {
+                commodityName = subParsed.name;
             }
         }
-        if ((0, index_1.isPosting)(line)) {
-            // Use parsePosting to extract tags from the posting's comment part only
-            const posting = parsePosting(line);
-            if (posting?.tags) {
-                for (const k of Object.keys(posting.tags)) {
-                    if (!tagMap.has(k)) {
-                        const t = { name: k, declared: false };
-                        if (sourceUri !== undefined) {
-                            t.sourceUri = sourceUri;
-                        }
-                        tagMap.set(k, t);
-                    }
-                }
-            }
+        look++;
+    }
+    addCommodity(commodityMap, commodityName, true, format, sourceUri, startLine);
+    // Return the last line we processed
+    return look - 1;
+}
+/**
+ * Process a tag directive and add it to the tags map
+ */
+function processTagDirective(line, tagMap, sourceUri, lineNumber) {
+    const tagName = line.trim().substring(4).split(';')[0].trim();
+    if (tagName) {
+        addTag(tagMap, tagName, true, sourceUri, lineNumber);
+    }
+}
+/**
+ * Extract accounts, commodities, tags from a transaction and add them to the maps
+ */
+function processTransaction(transaction, accountMap, commodityMap, tagMap, sourceUri) {
+    // Extract payee is handled separately since it's in the transaction header
+    // Extract accounts and commodities from postings
+    for (const posting of transaction.postings) {
+        // Add account
+        if (posting.account) {
+            addAccount(accountMap, posting.account, false, sourceUri);
         }
-        if ((0, index_1.isTransactionHeader)(line)) {
-            const m = line.match(/;(.+)$/);
-            if (m) {
-                const extracted = (0, index_1.extractTags)(m[1]);
-                for (const k of Object.keys(extracted)) {
-                    if (!tagMap.has(k)) {
-                        const t = { name: k, declared: false };
-                        if (sourceUri !== undefined) {
-                            t.sourceUri = sourceUri;
-                        }
-                        tagMap.set(k, t);
-                    }
-                }
+        // Add commodity from amount
+        if (posting.amount?.commodity && posting.amount.commodity !== '') {
+            addCommodity(commodityMap, posting.amount.commodity, false, undefined, sourceUri);
+        }
+        // Add commodity from cost
+        if (posting.cost?.amount?.commodity && posting.cost.amount.commodity !== '') {
+            addCommodity(commodityMap, posting.cost.amount.commodity, false, undefined, sourceUri);
+        }
+        // Add commodity from balance assertion
+        if (posting.assertion?.commodity && posting.assertion.commodity !== '') {
+            addCommodity(commodityMap, posting.assertion.commodity, false, undefined, sourceUri);
+        }
+        // Extract tags from posting comments
+        if (posting.tags) {
+            for (const tagName of Object.keys(posting.tags)) {
+                addTag(tagMap, tagName, false, sourceUri);
             }
         }
     }
-    return Array.from(tagMap.values()).sort((a, b) => a.name.localeCompare(b.name));
+    // Extract tags from transaction-level tags
+    if (transaction.tags) {
+        for (const tagName of Object.keys(transaction.tags)) {
+            addTag(tagMap, tagName, false, sourceUri);
+        }
+    }
 }
 function parseDirective(line) {
     const trimmed = line.trim();