tallyd 0.0.0-stage → 0.1.0

package/dist/statement/dates.js

@@ -0,0 +1,204 @@
+/**
+ * Reading the date column.
+ *
+ * `03/04/2026` is the third of April in London and the fourth of March in New
+ * York, and a bank export rarely says which it means. Guessing per row is the
+ * worst option: it produces a statement where some rows are right and some are
+ * silently six weeks out.
+ *
+ * So the format is decided once for the whole column. A single value with a
+ * component above 12 settles it for every other row. Where the column is
+ * genuinely ambiguous — every day-of-month is 12 or under — the caller is told
+ * so and can insist on a format rather than accept a coin flip.
+ */
+import { date as toCalendarDate, daysInMonth } from "../ledger/date.js";
+export const DATE_FORMATS = [
+    "YYYY-MM-DD",
+    "YYYY/MM/DD",
+    "DD/MM/YYYY",
+    "MM/DD/YYYY",
+    "DD-MM-YYYY",
+    "MM-DD-YYYY",
+    "DD.MM.YYYY",
+    "DD-MMM-YYYY",
+    "MMM DD, YYYY",
+];
+export class DateParseError extends Error {
+    input;
+    format;
+    constructor(input, format) {
+        super(format === null
+            ? `Cannot read ${JSON.stringify(input)} as a date`
+            : `Cannot read ${JSON.stringify(input)} as ${format}`);
+        this.input = input;
+        this.format = format;
+        this.name = "DateParseError";
+    }
+}
+const MONTH_NAMES = {
+    jan: 1,
+    feb: 2,
+    mar: 3,
+    apr: 4,
+    may: 5,
+    jun: 6,
+    jul: 7,
+    aug: 8,
+    sep: 9,
+    sept: 9,
+    oct: 10,
+    nov: 11,
+    dec: 12,
+};
+function pad(value, width) {
+    return String(value).padStart(width, "0");
+}
+/** Expand a two-digit year with the usual 1970 pivot. */
+function expandYear(year) {
+    if (year >= 100)
+        return year;
+    return year < 70 ? 2000 + year : 1900 + year;
+}
+function componentsFor(input, format) {
+    const text = input.trim();
+    if (format === "DD-MMM-YYYY") {
+        const m = /^(\d{1,2})[-\s]([A-Za-z]{3,4})[-\s](\d{2,4})$/.exec(text);
+        if (m === null)
+            return null;
+        const month = MONTH_NAMES[m[2].toLowerCase()];
+        if (month === undefined)
+            return null;
+        return { year: expandYear(Number(m[3])), month, day: Number(m[1]) };
+    }
+    if (format === "MMM DD, YYYY") {
+        const m = /^([A-Za-z]{3,4})\.?\s+(\d{1,2}),?\s+(\d{2,4})$/.exec(text);
+        if (m === null)
+            return null;
+        const month = MONTH_NAMES[m[1].toLowerCase()];
+        if (month === undefined)
+            return null;
+        return { year: expandYear(Number(m[3])), month, day: Number(m[2]) };
+    }
+    const separator = format.includes("/") ? "/" : format.includes(".") ? "." : "-";
+    const parts = text.split(separator);
+    if (parts.length !== 3)
+        return null;
+    if (parts.some((p) => !/^\d{1,4}$/.test(p.trim())))
+        return null;
+    const [a, b, c] = parts.map((p) => Number(p.trim()));
+    switch (format) {
+        case "YYYY-MM-DD":
+        case "YYYY/MM/DD":
+            return { year: a, month: b, day: c };
+        case "DD/MM/YYYY":
+        case "DD-MM-YYYY":
+        case "DD.MM.YYYY":
+            return { year: expandYear(c), month: b, day: a };
+        case "MM/DD/YYYY":
+        case "MM-DD-YYYY":
+            return { year: expandYear(c), month: a, day: b };
+        default:
+            return null;
+    }
+}
+function isRealDate(c) {
+    if (c.year < 1000 || c.year > 9999)
+        return false;
+    if (c.month < 1 || c.month > 12)
+        return false;
+    if (c.day < 1 || c.day > daysInMonth(c.year, c.month))
+        return false;
+    return true;
+}
+/** Parse one value in a known format. */
+export function parseDateIn(input, format) {
+    const components = componentsFor(input, format);
+    if (components === null || !isRealDate(components)) {
+        throw new DateParseError(input, format);
+    }
+    return toCalendarDate(`${pad(components.year, 4)}-${pad(components.month, 2)}-${pad(components.day, 2)}`);
+}
+export function canParseIn(input, format) {
+    const components = componentsFor(input, format);
+    return components !== null && isRealDate(components);
+}
+/**
+ * Share of a column a format must read to be considered at all. Below this it
+ * is the wrong format rather than the right one with bad rows in it.
+ */
+const MINIMUM_COVERAGE = 0.8;
+/**
+ * Work out which format a column of dates is in.
+ *
+ * A format survives only if it reads *every* sample. Where both DD/MM and
+ * MM/DD survive, the column contains no value with a component above 12 and
+ * the order is genuinely undecidable from the data alone.
+ */
+export function detectDateFormat(samples, options = {}) {
+    const usable = samples.map((s) => s.trim()).filter((s) => s !== "");
+    if (usable.length === 0) {
+        return {
+            format: options.prefer ?? "YYYY-MM-DD",
+            candidates: [],
+            confident: false,
+            unparsed: [],
+        };
+    }
+    // A format need not read *every* sample: one impossible value like 31/02
+    // should not disqualify the format the other four hundred rows are in. But
+    // it must read a strong majority, or it is simply the wrong format.
+    const coverage = DATE_FORMATS.map((format) => ({
+        format,
+        read: usable.filter((sample) => canParseIn(sample, format)).length,
+    }));
+    const best = Math.max(...coverage.map((c) => c.read));
+    const threshold = Math.max(1, Math.ceil(usable.length * MINIMUM_COVERAGE));
+    const candidates = best >= threshold
+        ? coverage.filter((c) => c.read === best).map((c) => c.format)
+        : [];
+    if (candidates.length === 0) {
+        return {
+            format: options.prefer ?? "YYYY-MM-DD",
+            candidates: [],
+            confident: false,
+            unparsed: usable.filter((s) => !DATE_FORMATS.some((f) => canParseIn(s, f))),
+        };
+    }
+    const unreadable = usable.filter((s) => !candidates.some((f) => canParseIn(s, f)));
+    // Prefer the caller's format when it is still viable — this is how a user
+    // resolves an ambiguous column.
+    const preferred = options.prefer;
+    if (preferred !== undefined && candidates.includes(preferred)) {
+        return { format: preferred, candidates, confident: true, unparsed: unreadable };
+    }
+    // Day-first and month-first both surviving means the data cannot tell them
+    // apart; the ordering of DATE_FORMATS then decides, and confidence is false.
+    const dayFirst = candidates.filter((f) => f.startsWith("DD"));
+    const monthFirst = candidates.filter((f) => f.startsWith("MM"));
+    const ambiguous = dayFirst.length > 0 && monthFirst.length > 0;
+    return {
+        format: candidates[0],
+        candidates,
+        confident: !ambiguous,
+        unparsed: unreadable,
+    };
+}
+/** Parse a column, detecting the format from the column itself. */
+export function parseDateColumn(values, options = {}) {
+    const detection = detectDateFormat(values, options);
+    const dates = values.map((value) => {
+        if (value.trim() === "")
+            return null;
+        try {
+            return parseDateIn(value, detection.format);
+        }
+        catch {
+            return null;
+        }
+    });
+    return { dates, detection };
+}
+/** True when a string parses as a date in any supported format. */
+export function looksLikeDate(input) {
+    return DATE_FORMATS.some((format) => canParseIn(input, format));
+}

package/dist/statement/duplicates.d.ts

@@ -0,0 +1,51 @@
+/**
+ * Duplicate detection on import.
+ *
+ * The naive rule — same date, same amount, same description means duplicate —
+ * is wrong, and wrong in a way that loses money. Two £2.85 coffees from the
+ * same shop on the same day are two transactions, not one imported twice.
+ *
+ * So the rule here is about *counts*, not existence: a batch that contains a
+ * fingerprint three times is fine if the account already has none of it, and
+ * is a duplicate only for the excess over what is already known. Everything is
+ * flagged for review rather than dropped, because only the account holder can
+ * say whether they bought two coffees.
+ */
+import type { StatementLine } from "./line.js";
+export type DuplicateKind = 
+/** Same fingerprint as an earlier line in this same import. */
+"within-batch"
+/** Same fingerprint as a line already imported previously. */
+ | "already-imported";
+export interface DuplicateFlag {
+    readonly line: StatementLine;
+    readonly kind: DuplicateKind;
+    /** Which occurrence this is, 1-based, counting prior sightings. */
+    readonly occurrence: number;
+    readonly reason: string;
+    /** Lines that share the fingerprint. */
+    readonly conflictsWith: readonly StatementLine[];
+}
+export interface DuplicateReport {
+    readonly unique: readonly StatementLine[];
+    readonly flagged: readonly DuplicateFlag[];
+}
+/**
+ * Compare a batch against itself and against lines already held.
+ *
+ * `existing` is the set already imported; its counts are what a new line has
+ * to exceed before it is considered a repeat.
+ */
+export declare function findDuplicates(batch: readonly StatementLine[], existing?: readonly StatementLine[]): DuplicateReport;
+/**
+ * A softer signal: lines that are suspiciously similar without being identical
+ * — same amount and description within a few days. Re-submitted payments and
+ * accidental double-imports of overlapping date ranges look like this.
+ */
+export declare function findNearDuplicates(lines: readonly StatementLine[], options?: {
+    windowDays?: number;
+}): readonly {
+    a: StatementLine;
+    b: StatementLine;
+    daysApart: number;
+}[];

package/dist/statement/duplicates.js

@@ -0,0 +1,101 @@
+/**
+ * Duplicate detection on import.
+ *
+ * The naive rule — same date, same amount, same description means duplicate —
+ * is wrong, and wrong in a way that loses money. Two £2.85 coffees from the
+ * same shop on the same day are two transactions, not one imported twice.
+ *
+ * So the rule here is about *counts*, not existence: a batch that contains a
+ * fingerprint three times is fine if the account already has none of it, and
+ * is a duplicate only for the excess over what is already known. Everything is
+ * flagged for review rather than dropped, because only the account holder can
+ * say whether they bought two coffees.
+ */
+import { daysBetween } from "../ledger/date.js";
+/**
+ * Compare a batch against itself and against lines already held.
+ *
+ * `existing` is the set already imported; its counts are what a new line has
+ * to exceed before it is considered a repeat.
+ */
+export function findDuplicates(batch, existing = []) {
+    const existingByFingerprint = new Map();
+    for (const line of existing) {
+        const bucket = existingByFingerprint.get(line.fingerprint);
+        if (bucket === undefined)
+            existingByFingerprint.set(line.fingerprint, [line]);
+        else
+            bucket.push(line);
+    }
+    const seenInBatch = new Map();
+    const unique = [];
+    const flagged = [];
+    for (const line of batch) {
+        const priorInBatch = seenInBatch.get(line.fingerprint) ?? [];
+        const priorExisting = existingByFingerprint.get(line.fingerprint) ?? [];
+        if (priorExisting.length > 0 && priorInBatch.length === 0) {
+            flagged.push({
+                line,
+                kind: "already-imported",
+                occurrence: priorExisting.length + 1,
+                reason: `A line with the same date, amount and description was already imported ` +
+                    `(${priorExisting.length} time${priorExisting.length === 1 ? "" : "s"})`,
+                conflictsWith: Object.freeze([...priorExisting]),
+            });
+        }
+        else if (priorInBatch.length > 0) {
+            flagged.push({
+                line,
+                kind: "within-batch",
+                occurrence: priorInBatch.length + priorExisting.length + 1,
+                reason: `Row ${line.sourceRow} repeats row ${priorInBatch[0].sourceRow} ` +
+                    `— same date, amount and description`,
+                conflictsWith: Object.freeze([...priorInBatch, ...priorExisting]),
+            });
+        }
+        else {
+            unique.push(line);
+        }
+        seenInBatch.set(line.fingerprint, [...priorInBatch, line]);
+    }
+    return Object.freeze({
+        unique: Object.freeze(unique),
+        flagged: Object.freeze(flagged),
+    });
+}
+/**
+ * A softer signal: lines that are suspiciously similar without being identical
+ * — same amount and description within a few days. Re-submitted payments and
+ * accidental double-imports of overlapping date ranges look like this.
+ */
+export function findNearDuplicates(lines, options = {}) {
+    const window = options.windowDays ?? 3;
+    const out = [];
+    const byKey = new Map();
+    for (const line of lines) {
+        const key = `${line.amount.currency.code}|${line.amount.minorUnits}|${line.normalisedDescription}`;
+        const bucket = byKey.get(key);
+        if (bucket === undefined)
+            byKey.set(key, [line]);
+        else
+            bucket.push(line);
+    }
+    for (const bucket of byKey.values()) {
+        if (bucket.length < 2)
+            continue;
+        const sorted = [...bucket].sort((a, b) => (a.date < b.date ? -1 : a.date > b.date ? 1 : 0));
+        for (let i = 0; i < sorted.length - 1; i++) {
+            for (let j = i + 1; j < sorted.length; j++) {
+                const a = sorted[i];
+                const b = sorted[j];
+                const daysApart = Math.abs(daysBetween(a.date, b.date));
+                if (daysApart === 0)
+                    continue; // exact duplicates are the other function's job
+                if (daysApart > window)
+                    break;
+                out.push({ a, b, daysApart });
+            }
+        }
+    }
+    return Object.freeze(out);
+}

package/dist/statement/import.d.ts

@@ -0,0 +1,52 @@
+/**
+ * The CSV import pipeline.
+ *
+ * One malformed row must not lose the other four hundred. Every row is
+ * attempted independently and failures are collected as data, so the caller
+ * gets the lines that worked plus a precise account of what did not and why.
+ * An import that half-succeeds and says so is worth far more than one that
+ * throws on row 137.
+ */
+import type { Currency } from "../money/currency.js";
+import { type ParseAmountOptions } from "./amount.js";
+import { type ColumnMapping, type ColumnRole } from "./columns.js";
+import { type Delimiter } from "./csv.js";
+import { type DateFormat } from "./dates.js";
+import { type DuplicateFlag } from "./duplicates.js";
+import { type StatementLine } from "./line.js";
+export interface RowError {
+    /** Zero-based index within the data rows, excluding the header. */
+    readonly row: number;
+    readonly reason: string;
+    readonly cells: readonly string[];
+}
+export interface ImportOptions {
+    currency?: Currency | string;
+    delimiter?: Delimiter;
+    dateFormat?: DateFormat;
+    decimal?: "dot" | "comma";
+    /** Force a column assignment when inference gets it wrong. */
+    columns?: Partial<Record<Exclude<ColumnRole, "unknown">, number>>;
+    /** Lines already imported, for duplicate detection. */
+    existing?: readonly StatementLine[];
+    /** Prefix for generated line ids. */
+    idPrefix?: string;
+    /** Accept amounts with more precision than the currency holds. */
+    rounding?: ParseAmountOptions["rounding"];
+}
+export interface ImportResult {
+    readonly lines: readonly StatementLine[];
+    readonly duplicates: readonly DuplicateFlag[];
+    readonly errors: readonly RowError[];
+    readonly warnings: readonly string[];
+    readonly mapping: ColumnMapping;
+    readonly delimiter: Delimiter;
+    readonly dateFormat: DateFormat;
+    readonly decimal: "dot" | "comma";
+    readonly currency: Currency;
+    readonly rowsRead: number;
+}
+/** Parse a bank CSV into statement lines. */
+export declare function importCsv(input: string, options?: ImportOptions): ImportResult;
+/** A one-line summary of how an import went, for the CLI and for logs. */
+export declare function describeImport(result: ImportResult): string;

package/dist/statement/import.js

@@ -0,0 +1,172 @@
+/**
+ * The CSV import pipeline.
+ *
+ * One malformed row must not lose the other four hundred. Every row is
+ * attempted independently and failures are collected as data, so the caller
+ * gets the lines that worked plus a precise account of what did not and why.
+ * An import that half-succeeds and says so is worth far more than one that
+ * throws on row 137.
+ */
+import { Money } from "../money/money.js";
+import { currency as lookupCurrency } from "../money/currency.js";
+import { combineDebitCredit, detectDecimalConvention, parseAmount, } from "./amount.js";
+import { inferColumns } from "./columns.js";
+import { readTable } from "./csv.js";
+import { detectDateFormat, parseDateIn } from "./dates.js";
+import { findDuplicates } from "./duplicates.js";
+import { statementLine } from "./line.js";
+function columnValue(row, index) {
+    if (index === null)
+        return "";
+    return row[index] ?? "";
+}
+/** Parse a bank CSV into statement lines. */
+export function importCsv(input, options = {}) {
+    const table = readTable(input, options.delimiter === undefined ? {} : { delimiter: options.delimiter });
+    const mapping = inferColumns(table.header, table.rows, options.columns ?? {});
+    const warnings = [...mapping.warnings];
+    const errors = [];
+    const currency = typeof options.currency === "string"
+        ? lookupCurrency(options.currency)
+        : (options.currency ?? lookupCurrency("GBP"));
+    // Decide the date format and decimal convention from whole columns before
+    // touching any individual row.
+    const dateSamples = table.rows.map((r) => columnValue(r, mapping.date)).filter((v) => v !== "");
+    const dateDetection = detectDateFormat(dateSamples, options.dateFormat === undefined ? {} : { prefer: options.dateFormat });
+    if (!dateDetection.confident && dateSamples.length > 0) {
+        if (dateDetection.candidates.length > 1) {
+            warnings.push(`Date column is ambiguous between ${dateDetection.candidates.join(" and ")}; ` +
+                `reading it as ${dateDetection.format}. Pass dateFormat to be sure.`);
+        }
+        else if (dateDetection.candidates.length === 0) {
+            warnings.push(`No date format reads every value in the date column` +
+                (dateDetection.unparsed.length > 0
+                    ? ` (for example ${JSON.stringify(dateDetection.unparsed[0])})`
+                    : ""));
+        }
+    }
+    const amountColumns = [mapping.amount, mapping.debit, mapping.credit].filter((i) => i !== null);
+    const amountSamples = table.rows.flatMap((r) => amountColumns.map((i) => r[i] ?? "").filter((v) => v.trim() !== ""));
+    const decimalDetection = detectDecimalConvention(amountSamples);
+    const decimal = options.decimal ?? decimalDetection.convention;
+    if (options.decimal === undefined && !decimalDetection.confident && amountSamples.length > 0) {
+        warnings.push(`Could not tell whether amounts use '.' or ',' as the decimal separator; ` +
+            `assuming '${decimal === "dot" ? "." : ","}'.`);
+    }
+    const amountOptions = {
+        convention: decimal,
+        ...(options.rounding === undefined ? {} : { rounding: options.rounding }),
+    };
+    const prefix = options.idPrefix ?? "SL";
+    const parsed = [];
+    table.rows.forEach((row, index) => {
+        const rawDate = columnValue(row, mapping.date).trim();
+        if (rawDate === "") {
+            errors.push({ row: index, reason: "no date", cells: [...row] });
+            return;
+        }
+        let when;
+        try {
+            when = parseDateIn(rawDate, dateDetection.format);
+        }
+        catch {
+            errors.push({
+                row: index,
+                reason: `date ${JSON.stringify(rawDate)} is not ${dateDetection.format}`,
+                cells: [...row],
+            });
+            return;
+        }
+        let amount;
+        try {
+            if (mapping.amount !== null) {
+                const rawAmount = columnValue(row, mapping.amount).trim();
+                if (rawAmount === "")
+                    throw new Error("amount cell is empty");
+                amount = parseAmount(rawAmount, currency, amountOptions);
+            }
+            else if (mapping.debit !== null && mapping.credit !== null) {
+                amount = combineDebitCredit(columnValue(row, mapping.debit), columnValue(row, mapping.credit), currency, amountOptions);
+            }
+            else {
+                throw new Error("no amount, debit or credit column");
+            }
+        }
+        catch (error) {
+            errors.push({
+                row: index,
+                reason: error instanceof Error ? error.message : String(error),
+                cells: [...row],
+            });
+            return;
+        }
+        let balance;
+        if (mapping.balance !== null) {
+            const rawBalance = columnValue(row, mapping.balance).trim();
+            if (rawBalance !== "") {
+                try {
+                    balance = parseAmount(rawBalance, currency, amountOptions);
+                }
+                catch {
+                    // A bad balance is not worth losing the transaction over; it is
+                    // informational, and its absence is noted rather than fatal.
+                    warnings.push(`Row ${index}: could not read the balance ${JSON.stringify(rawBalance)}`);
+                }
+            }
+        }
+        let valueDate;
+        if (mapping.valueDate !== null) {
+            const rawValueDate = columnValue(row, mapping.valueDate).trim();
+            if (rawValueDate !== "") {
+                try {
+                    valueDate = parseDateIn(rawValueDate, dateDetection.format);
+                }
+                catch {
+                    warnings.push(`Row ${index}: could not read the value date`);
+                }
+            }
+        }
+        const raw = {};
+        table.header.forEach((name, i) => {
+            if (name !== "")
+                raw[name] = row[i] ?? "";
+        });
+        const description = columnValue(row, mapping.description).trim();
+        const reference = columnValue(row, mapping.reference).trim();
+        const type = columnValue(row, mapping.type).trim();
+        parsed.push(statementLine({
+            id: `${prefix}-${String(index + 1).padStart(4, "0")}`,
+            date: when,
+            ...(valueDate === undefined ? {} : { valueDate }),
+            description,
+            amount,
+            ...(balance === undefined ? {} : { balance }),
+            ...(reference === "" ? {} : { reference }),
+            ...(type === "" ? {} : { type }),
+            sourceRow: index,
+            raw,
+        }));
+    });
+    const { unique, flagged } = findDuplicates(parsed, options.existing ?? []);
+    return Object.freeze({
+        lines: Object.freeze(unique),
+        duplicates: Object.freeze(flagged),
+        errors: Object.freeze(errors),
+        warnings: Object.freeze(warnings),
+        mapping,
+        delimiter: table.delimiter,
+        dateFormat: dateDetection.format,
+        decimal,
+        currency,
+        rowsRead: table.rows.length,
+    });
+}
+/** A one-line summary of how an import went, for the CLI and for logs. */
+export function describeImport(result) {
+    const parts = [
+        `${result.lines.length} line${result.lines.length === 1 ? "" : "s"}`,
+        `${result.duplicates.length} duplicate${result.duplicates.length === 1 ? "" : "s"}`,
+        `${result.errors.length} error${result.errors.length === 1 ? "" : "s"}`,
+    ];
+    return `${parts.join(", ")} from ${result.rowsRead} rows (${result.dateFormat}, '${result.decimal === "dot" ? "." : ","}' decimal, ${result.currency.code})`;
+}

package/dist/statement/index.d.ts

@@ -0,0 +1,20 @@
+export { type Delimiter, DELIMITERS, CsvParseError, stripBom, parseCsv, sniffDelimiter, readTable, type CsvTable, } from "./csv.js";
+export { type DecimalConvention, type ParseAmountOptions, AmountParseError, detectDecimalConvention, normaliseAmount, parseAmount, combineDebitCredit, looksLikeAmount, } from "./amount.js";
+export { type DateFormat, type DateFormatDetection, DATE_FORMATS, DateParseError, parseDateIn, canParseIn, detectDateFormat, parseDateColumn, looksLikeDate, } from "./dates.js";
+export { type ColumnRole, type ColumnAssignment, type ColumnMapping, inferColumns, } from "./columns.js";
+export { type StatementLine, type StatementLineInput, statementLine, normaliseDescription, hashString, fingerprintOf, isMoneyIn, isMoneyOut, } from "./line.js";
+export { type DuplicateKind, type DuplicateFlag, type DuplicateReport, findDuplicates, findNearDuplicates, } from "./duplicates.js";
+export { type ImportOptions, type ImportResult, type RowError, importCsv, describeImport, } from "./import.js";
+export { type OfxAccount, type OfxImportOptions, type OfxImportResult, importOfx, parseOfxDate, extractTransactionBlocks, looksLikeOfx, } from "./ofx.js";
+import { type ImportOptions, type ImportResult } from "./import.js";
+import type { StatementLine } from "./line.js";
+/**
+ * Import a statement without being told which format it is in. Bank downloads
+ * arrive as whatever the bank felt like that day.
+ */
+export declare function importStatement(input: string, options?: ImportOptions): {
+    lines: readonly StatementLine[];
+    warnings: readonly string[];
+    errors: ImportResult["errors"];
+    format: "csv" | "ofx";
+};

package/dist/statement/index.js

@@ -0,0 +1,32 @@
+export { DELIMITERS, CsvParseError, stripBom, parseCsv, sniffDelimiter, readTable, } from "./csv.js";
+export { AmountParseError, detectDecimalConvention, normaliseAmount, parseAmount, combineDebitCredit, looksLikeAmount, } from "./amount.js";
+export { DATE_FORMATS, DateParseError, parseDateIn, canParseIn, detectDateFormat, parseDateColumn, looksLikeDate, } from "./dates.js";
+export { inferColumns, } from "./columns.js";
+export { statementLine, normaliseDescription, hashString, fingerprintOf, isMoneyIn, isMoneyOut, } from "./line.js";
+export { findDuplicates, findNearDuplicates, } from "./duplicates.js";
+export { importCsv, describeImport, } from "./import.js";
+export { importOfx, parseOfxDate, extractTransactionBlocks, looksLikeOfx, } from "./ofx.js";
+import { importCsv } from "./import.js";
+import { importOfx, looksLikeOfx } from "./ofx.js";
+/**
+ * Import a statement without being told which format it is in. Bank downloads
+ * arrive as whatever the bank felt like that day.
+ */
+export function importStatement(input, options = {}) {
+    if (looksLikeOfx(input)) {
+        const result = importOfx(input, options.currency === undefined ? {} : { currency: options.currency });
+        return {
+            lines: result.lines,
+            warnings: result.warnings,
+            errors: result.errors,
+            format: "ofx",
+        };
+    }
+    const result = importCsv(input, options);
+    return {
+        lines: result.lines,
+        warnings: result.warnings,
+        errors: result.errors,
+        format: "csv",
+    };
+}