@parseo/appraisals 1.0.0

package/dist/form-1004mc/parse-sales.d.ts

@@ -0,0 +1,6 @@
+import type { TextLine } from "@parseo/shared";
+import type { SalesComparisonSection, ReconciliationSection, CostApproachSection } from "./types.js";
+export declare function parseSalesComparisonSection(lines: TextLine[], compStartNum?: number): SalesComparisonSection;
+export declare function parseReconciliationSection(lines: TextLine[]): ReconciliationSection;
+export declare function parseCostApproachSection(lines: TextLine[]): CostApproachSection;
+//# sourceMappingURL=parse-sales.d.ts.map

package/dist/form-1004mc/parse-sales.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parse-sales.d.ts","sourceRoot":"","sources":["../../src/form-1004mc/parse-sales.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,QAAQ,EAAe,MAAM,gBAAgB,CAAC;AAC5D,OAAO,KAAK,EACV,sBAAsB,EAEtB,qBAAqB,EACrB,mBAAmB,EACpB,MAAM,YAAY,CAAC;AAoOpB,wBAAgB,2BAA2B,CACzC,KAAK,EAAE,QAAQ,EAAE,EACjB,YAAY,GAAE,MAAU,GACvB,sBAAsB,CA6HxB;AAID,wBAAgB,0BAA0B,CAAC,KAAK,EAAE,QAAQ,EAAE,GAAG,qBAAqB,CA2EnF;AAID,wBAAgB,wBAAwB,CAAC,KAAK,EAAE,QAAQ,EAAE,GAAG,mBAAmB,CAoF/E"}

package/dist/form-1004mc/parse-sales.js

@@ -0,0 +1,505 @@
+import { toBBox } from "@parseo/shared";
+// ── Utilities ─────────────────────────────────────────────────────────────
+function parseNum(raw) {
+    if (!raw)
+        return null;
+    const cleaned = raw.replace(/[$,%]/g, "").replace(/,/g, "").trim();
+    if (!cleaned || /^n\/?a$/i.test(cleaned))
+        return null;
+    const n = Number(cleaned);
+    return Number.isNaN(n) ? null : n;
+}
+function parseCurrency(raw) {
+    const match = raw.match(/\$?\s*([\d,]+(?:\.\d+)?)/);
+    return match ? parseNum(match[1]) : null;
+}
+// Column x-boundaries for Form 1004 sales comparison grid
+// Subject ~131, Comp1 ~197, Comp2 ~328, Comp3 ~459
+// Adjustment columns follow each comp description
+const SUBJECT_X = { min: 120, max: 195 };
+const COMP_COLS = [
+    { desc: { min: 195, max: 295 }, adj: { min: 295, max: 325 } }, // Comp 1
+    { desc: { min: 325, max: 430 }, adj: { min: 430, max: 457 } }, // Comp 2
+    { desc: { min: 457, max: 560 }, adj: { min: 560, max: 600 } }, // Comp 3
+];
+function segInRange(line, min, max) {
+    const segs = line.segments.filter((s) => s.x >= min && s.x < max);
+    return segs.map((s) => s.text.trim()).join(" ").trim();
+}
+function segWithBBox(line, min, max) {
+    const seg = line.segments.find((s) => s.x >= min && s.x < max);
+    return { text: seg ? seg.text.trim() : "", seg: seg ?? null };
+}
+function findLine(lines, pattern) {
+    return lines.find((l) => pattern.test(l.fullText));
+}
+// ── Parse comparable from a column ────────────────────────────────────────
+function parseComparable(lines, compNum, col) {
+    const bb = {};
+    const prefix = `comp${compNum}`;
+    function getDesc(line) {
+        return line ? segInRange(line, col.desc.min, col.adj.min) : "";
+    }
+    function getAdj(line) {
+        if (!line)
+            return null;
+        const text = segInRange(line, col.adj.min, col.adj.min + 60);
+        return parseNum(text);
+    }
+    function getDescWithBB(line, key) {
+        if (!line)
+            return "";
+        const r = segWithBBox(line, col.desc.min, col.adj.min);
+        if (r.seg)
+            bb[`${prefix}_${key}`] = toBBox(r.seg, line);
+        return r.text;
+    }
+    const addrLine = findLine(lines, /^Address/i);
+    const address = getDescWithBB(addrLine, "address");
+    // City is on the next line after address
+    const addrIdx = addrLine ? lines.indexOf(addrLine) : -1;
+    const cityLine = addrIdx >= 0 ? lines[addrIdx + 1] : undefined;
+    const cityVal = cityLine ? segInRange(cityLine, col.desc.min, col.adj.min) : "";
+    const proxLine = findLine(lines, /^Proximity to Subject/i);
+    const proximityToSubject = getDescWithBB(proxLine, "proximity");
+    const priceLine = findLine(lines, /^Sale Price\b/i);
+    let salePrice = null;
+    if (priceLine) {
+        // Price segments have $ and number in separate segments
+        const priceText = segInRange(priceLine, col.desc.min - 30, col.adj.min);
+        salePrice = parseCurrency(priceText);
+        const pSeg = segWithBBox(priceLine, col.desc.min, col.adj.min);
+        if (pSeg.seg)
+            bb[`${prefix}_salePrice`] = toBBox(pSeg.seg, priceLine);
+    }
+    const ppsLine = findLine(lines, /^Sale Price\/Gross Liv/i);
+    let salePricePerSqft = null;
+    if (ppsLine) {
+        const txt = segInRange(ppsLine, col.desc.min - 30, col.adj.min);
+        const m = txt.match(/([\d,.]+)\s*sq\.?\s*ft/i);
+        if (m)
+            salePricePerSqft = parseNum(m[1]);
+    }
+    const dsLine = findLine(lines, /^Data Source\(s\)/i);
+    const dataSources = getDescWithBB(dsLine, "dataSources");
+    const vsLine = findLine(lines, /^Verification Source/i);
+    const verificationSources = getDesc(vsLine);
+    const sfLine = findLine(lines, /^Sales or Financing/i);
+    const salesOrFinancing = getDesc(sfLine);
+    const concLine = findLine(lines, /^Concessions/i);
+    const concessions = getDesc(concLine);
+    const dateLine = findLine(lines, /^Date of Sale\/Time/i);
+    const dateOfSaleTime = getDescWithBB(dateLine, "dateOfSale");
+    const locLine = findLine(lines, /^Location\b/i);
+    const location = getDesc(locLine);
+    const feeLine = findLine(lines, /^Leasehold\/Fee Simple/i);
+    const leaseholdFeeSimple = getDesc(feeLine);
+    const siteLine = findLine(lines, /^Site\b/i);
+    const site = getDesc(siteLine);
+    const siteAdjustment = getAdj(siteLine);
+    const viewLine = findLine(lines, /^View\b/i);
+    const viewVal = getDesc(viewLine);
+    const viewAdjustment = getAdj(viewLine);
+    const styleLine = findLine(lines, /^Design \(Style\)/i);
+    const designStyle = getDesc(styleLine);
+    const qualLine = findLine(lines, /^Quality of Construction/i);
+    const qualityOfConstruction = getDesc(qualLine);
+    const ageLine = findLine(lines, /^Actual Age\b/i);
+    const actualAge = parseNum(getDesc(ageLine));
+    const ageAdjustment = getAdj(ageLine);
+    const condLine = findLine(lines, /^Condition\b/i);
+    const condition = getDescWithBB(condLine, "condition");
+    // Room count line
+    const rcLine = findLine(lines, /^Room Count/i);
+    let roomCountTotal = null, roomCountBedrooms = null, roomCountBaths = null, roomCountAdjustment = null;
+    if (rcLine) {
+        const text = segInRange(rcLine, col.desc.min, col.adj.min);
+        const parts = text.split(/\s+/).map((s) => parseNum(s)).filter((n) => n !== null);
+        if (parts.length >= 3) {
+            roomCountTotal = parts[0];
+            roomCountBedrooms = parts[1];
+            roomCountBaths = parts[2];
+        }
+        roomCountAdjustment = getAdj(rcLine);
+    }
+    const glaLine = findLine(lines, /^Gross Living Area/i);
+    let grossLivingArea = null, grossLivingAreaAdjustment = null;
+    if (glaLine) {
+        const text = segInRange(glaLine, col.desc.min - 30, col.adj.min);
+        const m = text.match(/([\d,]+)\s*sq/i);
+        if (m)
+            grossLivingArea = parseNum(m[1]);
+        grossLivingAreaAdjustment = getAdj(glaLine);
+        const glaSeg = segWithBBox(glaLine, col.desc.min, col.adj.min);
+        if (glaSeg.seg)
+            bb[`${prefix}_gla`] = toBBox(glaSeg.seg, glaLine);
+    }
+    const bfLine = findLine(lines, /^Basement & Finished/i);
+    const basementFinished = getDesc(bfLine);
+    const fuLine = findLine(lines, /^Functional Utility/i);
+    const functionalUtility = getDesc(fuLine);
+    const hcLine = findLine(lines, /^Heating\/Cooling/i);
+    const heatingCooling = getDesc(hcLine);
+    const eeLine = findLine(lines, /^Energy Efficient/i);
+    const energyEfficientItems = getDesc(eeLine);
+    const gcLine = findLine(lines, /^Garage\/Carport/i);
+    const garageCarport = getDesc(gcLine);
+    const garageCarportAdjustment = getAdj(gcLine);
+    const ppLine = findLine(lines, /^Porch\/Patio\/Deck/i);
+    const porchPatioDeck = getDesc(ppLine);
+    const poolLine = findLine(lines, /^POOL\b/i);
+    const poolVal = getDesc(poolLine);
+    const poolAdjustment = getAdj(poolLine);
+    const olpLine = findLine(lines, /^ORIGINAL LIST PRICE/i);
+    const originalListPrice = getDesc(olpLine);
+    // Net/Gross adjustment
+    const netLine = findLine(lines, /^Net Adjustment \(Total\)/i);
+    let netAdjustmentTotal = null;
+    if (netLine) {
+        const text = segInRange(netLine, col.adj.min - 10, col.adj.min + 60);
+        netAdjustmentTotal = parseNum(text);
+    }
+    const adjPriceLine = findLine(lines, /^Adjusted Sale Price/i);
+    let netAdjustmentPercent = null;
+    if (adjPriceLine) {
+        const text = segInRange(adjPriceLine, col.desc.min, col.adj.min + 20);
+        const pctMatch = text.match(/([\d.]+)\s*%/);
+        if (pctMatch)
+            netAdjustmentPercent = parseNum(pctMatch[1]);
+    }
+    const grossLine = findLine(lines, /^of Comparables/i);
+    let grossAdjustmentPercent = null, adjustedSalePrice = null;
+    if (grossLine) {
+        const text = segInRange(grossLine, col.desc.min, col.adj.min + 60);
+        const pctMatch = text.match(/([\d.]+)\s*%/);
+        if (pctMatch)
+            grossAdjustmentPercent = parseNum(pctMatch[1]);
+        const priceMatch = text.match(/\$\s*([\d,]+)/);
+        if (priceMatch)
+            adjustedSalePrice = parseNum(priceMatch[1]);
+    }
+    return {
+        number: compNum,
+        address: address + (cityVal ? `, ${cityVal}` : ""),
+        proximityToSubject, salePrice, salePricePerSqft, dataSources, verificationSources,
+        salesOrFinancing, concessions, dateOfSaleTime, location, leaseholdFeeSimple,
+        site, siteAdjustment, view: viewVal, viewAdjustment, designStyle, qualityOfConstruction,
+        actualAge, ageAdjustment, condition,
+        roomCountTotal, roomCountBedrooms, roomCountBaths, roomCountAdjustment,
+        grossLivingArea, grossLivingAreaAdjustment, basementFinished, functionalUtility,
+        heatingCooling, energyEfficientItems, garageCarport, garageCarportAdjustment,
+        porchPatioDeck, pool: poolVal, poolAdjustment, originalListPrice,
+        netAdjustmentTotal, netAdjustmentPercent, grossAdjustmentPercent, adjustedSalePrice,
+        boundingBoxes: bb,
+    };
+}
+// ── Sales Comparison ──────────────────────────────────────────────────────
+export function parseSalesComparisonSection(lines, compStartNum = 1) {
+    const bb = {};
+    // Active listings / comparable sales ranges
+    const alLine = findLine(lines, /comparable properties currently offered/i);
+    let activeListingsLow = null, activeListingsHigh = null;
+    if (alLine) {
+        const m = alLine.fullText.match(/\$\s*([\d,]+).*?to\s*\$\s*([\d,]+)/i);
+        if (m) {
+            activeListingsLow = parseNum(m[1]);
+            activeListingsHigh = parseNum(m[2]);
+        }
+    }
+    const csLine = findLine(lines, /comparable sales in the subject/i);
+    let comparableSalesLow = null, comparableSalesHigh = null;
+    if (csLine) {
+        const m = csLine.fullText.match(/\$\s*([\d,]+).*?to\s*\$\s*([\d,]+)/i);
+        if (m) {
+            comparableSalesLow = parseNum(m[1]);
+            comparableSalesHigh = parseNum(m[2]);
+        }
+    }
+    // Subject column
+    const subBB = {};
+    function getSubject(line) {
+        return line ? segInRange(line, SUBJECT_X.min, SUBJECT_X.max) : "";
+    }
+    function getSubjectWithBB(line, key) {
+        if (!line)
+            return "";
+        const r = segWithBBox(line, SUBJECT_X.min, SUBJECT_X.max);
+        if (r.seg)
+            subBB[key] = toBBox(r.seg, line);
+        return r.text;
+    }
+    const addrLine = findLine(lines, /^Address/i);
+    const subjAddress = getSubjectWithBB(addrLine, "address");
+    const priceLine = findLine(lines, /^Sale Price\b/i);
+    const subjPrice = priceLine ? parseCurrency(segInRange(priceLine, SUBJECT_X.min - 20, SUBJECT_X.max)) : null;
+    const ppsLine = findLine(lines, /^Sale Price\/Gross Liv/i);
+    let subjPPS = null;
+    if (ppsLine) {
+        const m = segInRange(ppsLine, SUBJECT_X.min, SUBJECT_X.max).match(/([\d,.]+)/);
+        if (m)
+            subjPPS = parseNum(m[1]);
+    }
+    const subject = {
+        address: subjAddress,
+        salePrice: subjPrice,
+        salePricePerSqft: subjPPS,
+        location: getSubject(findLine(lines, /^Location\b/i)),
+        leaseholdFeeSimple: getSubject(findLine(lines, /^Leasehold\/Fee/i)),
+        site: getSubject(findLine(lines, /^Site\b/i)),
+        view: getSubject(findLine(lines, /^View\b/i)),
+        designStyle: getSubject(findLine(lines, /^Design \(Style\)/i)),
+        qualityOfConstruction: getSubject(findLine(lines, /^Quality of Construction/i)),
+        actualAge: parseNum(getSubject(findLine(lines, /^Actual Age/i))),
+        condition: getSubjectWithBB(findLine(lines, /^Condition\b/i), "condition"),
+        roomCountTotal: null,
+        roomCountBedrooms: null,
+        roomCountBaths: null,
+        grossLivingArea: null,
+        basementFinished: getSubject(findLine(lines, /^Basement & Finished/i)),
+        functionalUtility: getSubject(findLine(lines, /^Functional Utility/i)),
+        heatingCooling: getSubject(findLine(lines, /^Heating\/Cooling/i)),
+        energyEfficientItems: getSubject(findLine(lines, /^Energy Efficient/i)),
+        garageCarport: getSubject(findLine(lines, /^Garage\/Carport/i)),
+        porchPatioDeck: getSubject(findLine(lines, /^Porch\/Patio/i)),
+        pool: getSubject(findLine(lines, /^POOL\b/i)),
+        originalListPrice: getSubject(findLine(lines, /^ORIGINAL LIST PRICE/i)),
+        boundingBoxes: subBB,
+    };
+    // Parse room count for subject
+    const rcLine = findLine(lines, /^Room Count/i);
+    if (rcLine) {
+        const text = segInRange(rcLine, SUBJECT_X.min, SUBJECT_X.max);
+        const parts = text.split(/\s+/).map((s) => parseNum(s)).filter((n) => n !== null);
+        if (parts.length >= 3) {
+            subject.roomCountTotal = parts[0];
+            subject.roomCountBedrooms = parts[1];
+            subject.roomCountBaths = parts[2];
+        }
+    }
+    const glaLine = findLine(lines, /^Gross Living Area/i);
+    if (glaLine) {
+        const m = segInRange(glaLine, SUBJECT_X.min, SUBJECT_X.max).match(/([\d,]+)/);
+        if (m)
+            subject.grossLivingArea = parseNum(m[1]);
+    }
+    // Parse 3 comparables
+    const comparables = [];
+    for (let i = 0; i < 3; i++) {
+        comparables.push(parseComparable(lines, compStartNum + i, COMP_COLS[i]));
+    }
+    // Prior sale analysis
+    const priorLine = findLine(lines, /Analysis of prior sale or transfer/i);
+    let priorSaleAnalysis = "";
+    if (priorLine) {
+        const idx = lines.indexOf(priorLine);
+        const parts = [];
+        const valueSeg = priorLine.segments.find((s) => s.x > 280);
+        if (valueSeg)
+            parts.push(valueSeg.text.trim());
+        for (let i = idx + 1; i < lines.length; i++) {
+            if (/^Summary of Sales|^Analysis\/Comments|^Indicated Value/i.test(lines[i].fullText))
+                break;
+            const t = lines[i].fullText.trim();
+            if (t && !/^AFFECT FINAL/.test(t) || /AFFECT FINAL/.test(t))
+                parts.push(t);
+        }
+        priorSaleAnalysis = parts.join(" ").trim();
+    }
+    // Summary
+    const sumLine = findLine(lines, /^Summary of Sales Comparison|^Analysis\/Comments/i);
+    let summaryOfSalesComparison = "";
+    if (sumLine) {
+        const idx = lines.indexOf(sumLine);
+        const parts = [];
+        const valueSeg = sumLine.segments.find((s) => s.x > 150);
+        if (valueSeg)
+            parts.push(valueSeg.text.trim());
+        for (let i = idx + 1; i < lines.length; i++) {
+            if (/^Indicated Value|^AS-IS APPRAISED/i.test(lines[i].fullText))
+                break;
+            const t = lines[i].fullText.trim();
+            if (t)
+                parts.push(t);
+        }
+        summaryOfSalesComparison = parts.join(" ").trim();
+        if (sumLine.segments[0])
+            bb.summaryOfSalesComparison = toBBox(sumLine.segments[0], sumLine);
+    }
+    return {
+        activeListingsLow, activeListingsHigh, comparableSalesLow, comparableSalesHigh,
+        subject, comparables, priorSaleAnalysis, summaryOfSalesComparison,
+        boundingBoxes: bb,
+    };
+}
+// ── Reconciliation ────────────────────────────────────────────────────────
+export function parseReconciliationSection(lines) {
+    const bb = {};
+    const indLine = findLine(lines, /^Indicated Value by Sales Comparison Approach\s*\$/i);
+    let indicatedValueBySalesComparison = null;
+    if (indLine) {
+        const seg = indLine.segments.find((s) => s.x > 150 && /^\d/.test(s.text.trim()));
+        if (seg) {
+            indicatedValueBySalesComparison = parseNum(seg.text);
+            bb.indicatedBySales = toBBox(seg, indLine);
+        }
+    }
+    const indAllLine = findLine(lines, /^Indicated Value by: Sales Comparison/i);
+    let indicatedValueByCostApproach = null, indicatedValueByIncomeApproach = null;
+    if (indAllLine) {
+        for (const seg of indAllLine.segments) {
+            if (/Cost Approach.*\$\s*([\d,]+)/i.test(seg.text)) {
+                const m = seg.text.match(/\$\s*([\d,]+)/);
+                if (m) {
+                    indicatedValueByCostApproach = parseNum(m[1]);
+                    bb.indicatedByCost = toBBox(seg, indAllLine);
+                }
+            }
+            if (/Income Approach.*\$\s*([\d,]+)/i.test(seg.text)) {
+                const m = seg.text.match(/\$\s*([\d,]+)/);
+                if (m)
+                    indicatedValueByIncomeApproach = parseNum(m[1]);
+            }
+        }
+        // Also get sales comparison from this line
+        if (!indicatedValueBySalesComparison) {
+            const salesSeg = indAllLine.segments.find((s) => s.x > 180 && s.x < 255 && /^\d/.test(s.text.trim()));
+            if (salesSeg)
+                indicatedValueBySalesComparison = parseNum(salesSeg.text);
+        }
+    }
+    // Reconciliation comments
+    const recLine = findLine(lines, /ALL WEIGHT GIVEN|reconciliation|weight.*given/i);
+    let reconciliationComments = "";
+    if (recLine) {
+        const idx = lines.indexOf(recLine);
+        const parts = [recLine.fullText.trim()];
+        for (let i = idx + 1; i < lines.length; i++) {
+            if (/^This appraisal is made|^Based on a complete/i.test(lines[i].fullText))
+                break;
+            const t = lines[i].fullText.trim();
+            if (t)
+                parts.push(t);
+        }
+        reconciliationComments = parts.join(" ").trim();
+        bb.reconciliationComments = toBBox(recLine.segments[0], recLine);
+    }
+    // Appraisal basis
+    const basisLine = findLine(lines, /This appraisal is made/i);
+    let appraisalBasis = "";
+    if (basisLine) {
+        const idx = lines.indexOf(basisLine);
+        const parts = [basisLine.fullText.trim()];
+        for (let i = idx + 1; i < lines.length; i++) {
+            if (/^Based on a complete|^\$/i.test(lines[i].fullText))
+                break;
+            parts.push(lines[i].fullText.trim());
+        }
+        appraisalBasis = parts.join(" ").trim();
+    }
+    // Final value and effective date
+    const valueLine = findLine(lines, /^\$\s*[\d,]+\s*,\s*as of/i);
+    let finalValue = null, effectiveDate = "";
+    if (valueLine) {
+        for (const seg of valueLine.segments) {
+            if (/^\d[\d,]*$/.test(seg.text.trim())) {
+                finalValue = parseNum(seg.text);
+                bb.finalValue = toBBox(seg, valueLine);
+            }
+            if (/^\d{2}\/\d{2}\/\d{4}$/.test(seg.text.trim())) {
+                effectiveDate = seg.text.trim();
+                bb.effectiveDate = toBBox(seg, valueLine);
+            }
+        }
+    }
+    return { indicatedValueBySalesComparison, indicatedValueByCostApproach, indicatedValueByIncomeApproach, reconciliationComments, appraisalBasis, finalValue, effectiveDate, boundingBoxes: bb };
+}
+// ── Cost Approach (Page 3) ────────────────────────────────────────────────
+export function parseCostApproachSection(lines) {
+    const bb = {};
+    function findCostVal(pattern) {
+        for (const l of lines) {
+            if (!pattern.test(l.fullText))
+                continue;
+            // Dollar value is usually at the far right (x > 500)
+            const valSeg = l.segments.filter((s) => s.x > 480);
+            for (const seg of valSeg) {
+                const n = parseNum(seg.text);
+                if (n !== null)
+                    return n;
+            }
+        }
+        return null;
+    }
+    const siteValueLine = findLine(lines, /support for the opinion of site value/i);
+    let siteValueSupport = "";
+    if (siteValueLine) {
+        const valueSeg = siteValueLine.segments.find((s) => s.x > 250);
+        if (valueSeg)
+            siteValueSupport = valueSeg.text.trim();
+        // Continue on next lines
+        const idx = lines.indexOf(siteValueLine);
+        const parts = siteValueSupport ? [siteValueSupport] : [];
+        for (let i = idx + 1; i < lines.length; i++) {
+            if (/^ESTIMATED|^OPINION OF SITE/i.test(lines[i].fullText))
+                break;
+            parts.push(lines[i].fullText.trim());
+        }
+        siteValueSupport = parts.join(" ").trim();
+    }
+    const siteValue = findCostVal(/OPINION OF SITE VALUE/i);
+    // Dwelling cost
+    const dwellingLine = findLine(lines, /^DWELLING/i);
+    let dwellingSqft = null, dwellingCostPerSqft = null, dwellingCost = null;
+    if (dwellingLine) {
+        const sqftMatch = dwellingLine.fullText.match(/([\d,]+)\s*Sq\.?\s*Ft/i);
+        if (sqftMatch)
+            dwellingSqft = parseNum(sqftMatch[1]);
+        const costMatch = dwellingLine.fullText.match(/@\s*\$?\s*([\d,.]+)/i) || dwellingLine.fullText.match(/(\d+\.?\d*)\s*=\s*\$/);
+        if (costMatch)
+            dwellingCostPerSqft = parseNum(costMatch[1]);
+        const valSegs = dwellingLine.segments.filter((s) => s.x > 480);
+        for (const seg of valSegs) {
+            const n = parseNum(seg.text);
+            if (n !== null) {
+                dwellingCost = n;
+                bb.dwellingCost = toBBox(seg, dwellingLine);
+            }
+        }
+    }
+    const amenitiesCost = findCostVal(/AMENITIES/i);
+    // Garage/Carport
+    const garageLine = findLine(lines, /^Garage\/Carport/i);
+    let garageCarportSqft = null, garageCarportCostPerSqft = null, garageCarportCost = null;
+    if (garageLine) {
+        const sqftMatch = garageLine.fullText.match(/([\d,]+)\s*Sq\.?\s*Ft/i);
+        if (sqftMatch)
+            garageCarportSqft = parseNum(sqftMatch[1]);
+        const costMatch = garageLine.fullText.match(/@\s*\$?\s*([\d,.]+)/i) || garageLine.fullText.match(/(\d+\.?\d*)\s*=\s*\$/);
+        if (costMatch)
+            garageCarportCostPerSqft = parseNum(costMatch[1]);
+        const valSegs = garageLine.segments.filter((s) => s.x > 480);
+        for (const seg of valSegs) {
+            const n = parseNum(seg.text);
+            if (n !== null)
+                garageCarportCost = n;
+        }
+    }
+    const totalCostNew = findCostVal(/Total Estimate of Cost-?New/i);
+    const depreciation = findCostVal(/^Depreciation\b/i);
+    const depreciatedCostOfImprovements = findCostVal(/Depreciated Cost of Improvements/i);
+    const asIsValueOfSiteImprovements = findCostVal(/As-?is.*Value of Site Improvements/i);
+    const indicatedValueByCostApproach = findCostVal(/INDICATED VALUE BY COST APPROACH/i);
+    const erlLine = findLine(lines, /Estimated Remaining Economic Life/i);
+    let estimatedRemainingEconomicLife = null;
+    if (erlLine) {
+        const m = erlLine.fullText.match(/(\d+)\s*Years/i);
+        if (m)
+            estimatedRemainingEconomicLife = parseNum(m[1]);
+    }
+    return {
+        siteValueSupport, siteValue, dwellingSqft, dwellingCostPerSqft, dwellingCost,
+        amenitiesCost, garageCarportSqft, garageCarportCostPerSqft, garageCarportCost,
+        totalCostNew, depreciation, depreciatedCostOfImprovements, asIsValueOfSiteImprovements,
+        indicatedValueByCostApproach, estimatedRemainingEconomicLife, boundingBoxes: bb,
+    };
+}

package/dist/form-1004mc/parser.d.ts

@@ -0,0 +1,5 @@
+import type { TextLine } from "@parseo/shared";
+import type { Form1004MCReport } from "./types.js";
+export declare function parseForm1004MC(buffer: Buffer): Promise<Form1004MCReport>;
+export declare function parseForm1004MCFromLines(lines: TextLine[], buffer: Buffer, pageOffset?: number): Promise<Form1004MCReport>;
+//# sourceMappingURL=parser.d.ts.map

package/dist/form-1004mc/parser.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parser.d.ts","sourceRoot":"","sources":["../../src/form-1004mc/parser.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,QAAQ,EAA4B,MAAM,gBAAgB,CAAC;AACzE,OAAO,KAAK,EACV,gBAAgB,EASjB,MAAM,YAAY,CAAC;AAKpB,wBAAsB,eAAe,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,gBAAgB,CAAC,CAG/E;AAED,wBAAsB,wBAAwB,CAC5C,KAAK,EAAE,QAAQ,EAAE,EACjB,MAAM,EAAE,MAAM,EACd,UAAU,GAAE,MAAU,GACrB,OAAO,CAAC,gBAAgB,CAAC,CAgJ3B"}