@insightsentry/mcp 1.4.1 → 1.4.3

package/dist/history.js

@@ -0,0 +1,625 @@
+import { mkdir, readdir, readFile, unlink, writeFile } from "node:fs/promises";
+import path from "node:path";
+const HISTORY_PATH = "/v3/symbols/{symbol}/history";
+const SERIES_PATH = "/v3/symbols/{symbol}/series";
+const CONTRACTS_PATH = "/v3/symbols/{symbol}/contracts";
+const DEFAULT_CONCURRENCY = 5;
+const MAX_CONCURRENCY = 10;
+const DEFAULT_CONTRACT_LOOKBACK_MONTHS = 6;
+const HISTORY_BAR_TYPES = ["second", "minute", "hour"];
+const SERIES_BAR_TYPES = ["day", "week", "month"];
+export async function planHistoryRequests(options, deps) {
+    validateOptions(options);
+    if (isContinuousFrontMonth(options.symbol) && isArchiveBarType(options.bar_type)) {
+        return planFuturesHistoryRequests(options, deps.request);
+    }
+    return {
+        mode: "regular",
+        requests: planRequestsForSymbol(options, options.symbol),
+    };
+}
+export async function downloadHistory(options, deps) {
+    const format = options.format ?? "csv";
+    const concurrency = normalizeConcurrency(options.concurrency);
+    const shouldMergeCsv = options.merge ?? true;
+    const plan = await planHistoryRequests(options, deps);
+    const mergeCsvFilesByRequestIndex = new Map();
+    const createdCsvFiles = new Set();
+    const result = {
+        mode: plan.mode,
+        total: plan.requests.length,
+        completed: 0,
+        skipped: 0,
+        failed: 0,
+        concurrency,
+        output_dir: path.resolve(options.output_dir),
+        files: [],
+        errors: [],
+    };
+    let nextIndex = 0;
+    async function worker() {
+        while (nextIndex < plan.requests.length) {
+            const requestIndex = nextIndex;
+            const request = plan.requests[requestIndex];
+            nextIndex += 1;
+            const savedFiles = [];
+            const startDate = String(request.params.start_date ?? `${options.from}_${options.to}`);
+            const symbol = String(request.params.symbol);
+            try {
+                const existingTargetFiles = !options.overwrite
+                    ? await findExistingTargetFiles(request.outputBasePath, format)
+                    : null;
+                if (existingTargetFiles) {
+                    mergeCsvFilesByRequestIndex.set(requestIndex, existingTargetFiles.filter((target) => target.endsWith(".csv")));
+                    result.skipped += 1;
+                    result.completed += 1;
+                    deps.onProgress?.({
+                        completed: result.completed,
+                        total: result.total,
+                        status: "skipped",
+                        symbol,
+                        start_date: startDate,
+                        files: existingTargetFiles,
+                    });
+                    continue;
+                }
+                const response = filterResponseForRequest(await deps.request("GET", request.method === "series" ? SERIES_PATH : HISTORY_PATH, request.params), options, request);
+                const message = response?.message ?? response?.error;
+                if (message && !Array.isArray(response?.series)) {
+                    result.skipped += 1;
+                    result.completed += 1;
+                    deps.onProgress?.({
+                        completed: result.completed,
+                        total: result.total,
+                        status: "skipped",
+                        symbol,
+                        start_date: startDate,
+                        files: [],
+                        error: String(message),
+                    });
+                    continue;
+                }
+                const outputBasePath = outputBasePathForResponse(request, response);
+                const targetFiles = outputFilesForFormat(outputBasePath, format);
+                if (!options.overwrite && (await allFilesExist(targetFiles))) {
+                    mergeCsvFilesByRequestIndex.set(requestIndex, targetFiles.filter((target) => target.endsWith(".csv")));
+                    result.skipped += 1;
+                    result.completed += 1;
+                    deps.onProgress?.({
+                        completed: result.completed,
+                        total: result.total,
+                        status: "skipped",
+                        symbol,
+                        start_date: startDate,
+                        files: targetFiles,
+                    });
+                    continue;
+                }
+                for (const filePath of targetFiles) {
+                    await mkdir(path.dirname(filePath), { recursive: true });
+                    if (filePath.endsWith(".csv")) {
+                        await writeFile(filePath, responseToCsv(response), "utf8");
+                    }
+                    else {
+                        await writeFile(filePath, `${JSON.stringify(response, null, 2)}\n`, "utf8");
+                    }
+                    savedFiles.push(filePath);
+                    result.files.push(filePath);
+                    if (filePath.endsWith(".csv")) {
+                        const csvFiles = mergeCsvFilesByRequestIndex.get(requestIndex) ?? [];
+                        csvFiles.push(filePath);
+                        mergeCsvFilesByRequestIndex.set(requestIndex, csvFiles);
+                        createdCsvFiles.add(filePath);
+                    }
+                }
+                result.completed += 1;
+                deps.onProgress?.({
+                    completed: result.completed,
+                    total: result.total,
+                    status: "saved",
+                    symbol,
+                    start_date: startDate,
+                    files: savedFiles,
+                });
+            }
+            catch (error) {
+                const message = error?.message ?? String(error);
+                result.failed += 1;
+                result.completed += 1;
+                result.errors.push({ symbol, start_date: startDate, message });
+                deps.onProgress?.({
+                    completed: result.completed,
+                    total: result.total,
+                    status: "failed",
+                    symbol,
+                    start_date: startDate,
+                    files: savedFiles,
+                    error: message,
+                });
+            }
+        }
+    }
+    await Promise.all(Array.from({ length: Math.min(concurrency, plan.requests.length) }, () => worker()));
+    if (shouldMergeCsv && (format === "csv" || format === "both")) {
+        const orderedCsvFiles = plan.requests.flatMap((_request, index) => mergeCsvFilesByRequestIndex.get(index) ?? []);
+        if (orderedCsvFiles.length > 0) {
+            const mergedFile = mergedCsvPath(options, path.basename(path.dirname(orderedCsvFiles[0])));
+            await mergeCsvFiles(orderedCsvFiles, mergedFile);
+            result.merged_file = mergedFile;
+            result.files.push(mergedFile);
+            if (!options.keep_chunks) {
+                const removableCsvFiles = orderedCsvFiles.filter((filePath) => createdCsvFiles.has(filePath));
+                await removeChunkFiles(removableCsvFiles);
+                result.files = result.files.filter((filePath) => !removableCsvFiles.includes(filePath));
+            }
+        }
+    }
+    return result;
+}
+export function responseToCsv(response) {
+    const series = Array.isArray(response?.series) ? response.series : [];
+    if (series.length === 0)
+        return "";
+    const metadataHeaders = response?.code && response?.bar_type ? ["code", "bar_type"] : [];
+    const metadataValues = metadataHeaders.map((key) => response[key]);
+    if (Array.isArray(response?.series_keys) && Array.isArray(series[0])) {
+        const headers = [...metadataHeaders, ...response.series_keys.map(String)];
+        const rows = series.map((row) => [...metadataValues, ...row]);
+        return serializeCsvRows(headers, rows);
+    }
+    const preferred = ["code", "bar_type", "time", "open", "high", "low", "close", "volume", "type"];
+    const keys = new Set();
+    for (const row of series) {
+        if (row && typeof row === "object" && !Array.isArray(row)) {
+            for (const key of Object.keys(row))
+                keys.add(key);
+        }
+    }
+    for (const key of metadataHeaders)
+        keys.add(key);
+    const headers = [...preferred.filter((key) => keys.delete(key)), ...Array.from(keys).sort()];
+    const rows = series.map((row) => headers.map((key) => (key in row ? row[key] : response?.[key])));
+    return serializeCsvRows(headers, rows);
+}
+function planRequestsForSymbol(options, symbol, outputSymbol = symbol) {
+    if (isSeriesBarType(options.bar_type)) {
+        const rangeStart = parseDay(options.from, "start");
+        const rangeEnd = parseDay(options.to, "end");
+        if (compareDays(rangeStart, rangeEnd) > 0)
+            throw new Error("from must be before or equal to to");
+        const rangeLabel = `${formatDay(rangeStart)}_${formatDay(rangeEnd)}`;
+        return [
+            {
+                method: "series",
+                params: {
+                    symbol,
+                    bar_type: options.bar_type,
+                    dp: 30000,
+                    ...optionalSeriesParams(options),
+                },
+                outputBasePath: path.join(path.resolve(options.output_dir), sanitizePathPart(outputSymbol), timeframeLabel(options.bar_type, options.bar_interval), rangeLabel),
+            },
+        ];
+    }
+    const startDates = iterStartDates(options.from, options.to, options.bar_type);
+    return startDates.map((startDate) => ({
+        method: "history",
+        params: {
+            symbol,
+            bar_type: options.bar_type,
+            start_date: startDate,
+            ...optionalHistoryParams(options),
+        },
+        outputBasePath: path.join(path.resolve(options.output_dir), sanitizePathPart(outputSymbol), timeframeLabel(options.bar_type, options.bar_interval), startDate),
+    }));
+}
+async function planFuturesHistoryRequests(options, request) {
+    const schedule = await fetchContractSchedule(options.symbol, request);
+    const range = monthRangeFor(options.from, options.to);
+    const lookback = options.contract_lookback_months ?? DEFAULT_CONTRACT_LOOKBACK_MONTHS;
+    const requests = [];
+    for (let year = range.start.year; year <= range.end.year + 1; year += 1) {
+        for (const monthCode of schedule.monthCodes) {
+            const settlementMonth = schedule.settlementMonths.get(monthCode);
+            if (!settlementMonth)
+                continue;
+            const settlement = { year, month: settlementMonth };
+            const coverageStart = addMonths(settlement, -lookback + 1);
+            for (const month of iterMonths(coverageStart, settlement)) {
+                if (compareMonths(month, range.start) < 0 || compareMonths(month, range.end) > 0) {
+                    continue;
+                }
+                const symbol = `${schedule.fullBaseCode}${monthCode}${year}`;
+                const startDate = formatMonth(month);
+                for (const archiveDate of expandArchiveStartDates(startDate, options.bar_type)) {
+                    requests.push({
+                        method: "history",
+                        params: {
+                            symbol,
+                            bar_type: options.bar_type,
+                            start_date: archiveDate,
+                            ...optionalHistoryParams(options),
+                        },
+                        outputBasePath: path.join(path.resolve(options.output_dir), sanitizePathPart(schedule.fullBaseCode), sanitizePathPart(symbol), timeframeLabel(options.bar_type, options.bar_interval), archiveDate),
+                    });
+                }
+            }
+        }
+    }
+    return { mode: "futures", requests };
+}
+async function fetchContractSchedule(symbol, request) {
+    const response = await request("GET", CONTRACTS_PATH, { symbol });
+    const inferredBase = continuousToBaseSymbol(symbol);
+    const rawBase = String(response?.base_code || inferredBase);
+    const fullBaseCode = rawBase.includes(":") ? rawBase : `${symbol.split(":", 1)[0]}:${rawBase}`;
+    const rootBase = fullBaseCode.includes(":")
+        ? (fullBaseCode.split(":").at(-1) ?? fullBaseCode)
+        : fullBaseCode;
+    const settlementMonths = new Map();
+    for (const contract of response?.contracts ?? []) {
+        const code = String(contract?.code ?? "");
+        const settlementDate = String(contract?.settlement_date ?? "");
+        const monthCode = extractMonthCode(code, fullBaseCode, rootBase);
+        const month = parseSettlementMonth(settlementDate);
+        if (!monthCode || !month)
+            continue;
+        const existing = settlementMonths.get(monthCode);
+        if (existing !== undefined && existing !== month) {
+            throw new Error(`Contract month ${monthCode} maps to both ${existing} and ${month}`);
+        }
+        settlementMonths.set(monthCode, month);
+    }
+    if (settlementMonths.size === 0) {
+        throw new Error(`No contract schedule returned for ${symbol}`);
+    }
+    const monthCodes = Array.from(settlementMonths.entries())
+        .sort((a, b) => a[1] - b[1])
+        .map(([monthCode]) => monthCode);
+    return { fullBaseCode, monthCodes, settlementMonths };
+}
+function optionalHistoryParams(options) {
+    const params = {};
+    for (const key of ["bar_interval", "extended", "dadj", "badj", "settlement"]) {
+        if (options[key] !== undefined)
+            params[key] = options[key];
+    }
+    return params;
+}
+function optionalSeriesParams(options) {
+    return optionalHistoryParams(options);
+}
+function validateOptions(options) {
+    if (!options.symbol)
+        throw new Error("symbol is required");
+    if (!options.from)
+        throw new Error("from is required");
+    if (!options.to)
+        throw new Error("to is required");
+    if (!options.output_dir)
+        throw new Error("output_dir is required");
+    if (![...HISTORY_BAR_TYPES, ...SERIES_BAR_TYPES].includes(options.bar_type)) {
+        throw new Error("bar_type must be second, minute, hour, day, week, or month");
+    }
+    normalizeConcurrency(options.concurrency);
+    if (options.format && !["json", "csv", "both"].includes(options.format)) {
+        throw new Error("format must be json, csv, or both");
+    }
+    if (options.bar_interval !== undefined &&
+        (!Number.isInteger(options.bar_interval) ||
+            options.bar_interval < 1 ||
+            options.bar_interval > 1440)) {
+        throw new Error("bar_interval must be an integer between 1 and 1440");
+    }
+    if (options.contract_lookback_months !== undefined &&
+        (!Number.isInteger(options.contract_lookback_months) || options.contract_lookback_months < 1)) {
+        throw new Error("contract_lookback_months must be a positive integer");
+    }
+}
+function normalizeConcurrency(value) {
+    const concurrency = value ?? DEFAULT_CONCURRENCY;
+    if (!Number.isInteger(concurrency) || concurrency < 1 || concurrency > MAX_CONCURRENCY) {
+        throw new Error(`concurrency must be an integer between 1 and ${MAX_CONCURRENCY}`);
+    }
+    return concurrency;
+}
+function isContinuousFrontMonth(symbol) {
+    return symbol.endsWith("1!") || symbol.endsWith("2!");
+}
+function isArchiveBarType(barType) {
+    return HISTORY_BAR_TYPES.includes(barType);
+}
+function isSeriesBarType(barType) {
+    return SERIES_BAR_TYPES.includes(barType);
+}
+function continuousToBaseSymbol(symbol) {
+    return symbol.endsWith("1!") || symbol.endsWith("2!") ? symbol.slice(0, -2) : symbol;
+}
+function iterStartDates(from, to, barType) {
+    if (barType === "second") {
+        const start = parseDay(from, "start");
+        const end = parseDay(to, "end");
+        if (compareDays(start, end) > 0)
+            throw new Error("from must be before or equal to to");
+        return Array.from(iterDays(start, end), formatDay);
+    }
+    const { start, end } = monthRangeFor(from, to);
+    if (compareMonths(start, end) > 0)
+        throw new Error("from must be before or equal to to");
+    return Array.from(iterMonths(start, end), formatMonth);
+}
+function monthRangeFor(from, to) {
+    return { start: parseMonth(from), end: parseMonth(to) };
+}
+function expandArchiveStartDates(month, barType) {
+    if (barType !== "second")
+        return [month];
+    const start = parseDay(month, "start");
+    const end = parseDay(month, "end");
+    return Array.from(iterDays(start, end), formatDay);
+}
+function parseMonth(value) {
+    const match = /^(?<year>\d{4})-(?<month>\d{2})(?:-(?<day>\d{2}))?$/.exec(value);
+    if (!match?.groups)
+        throw new Error(`Invalid date "${value}". Use YYYY-MM or YYYY-MM-DD.`);
+    const year = Number(match.groups.year);
+    const month = Number(match.groups.month);
+    if (month < 1 || month > 12)
+        throw new Error(`Invalid month in "${value}"`);
+    if (match.groups.day !== undefined) {
+        const day = Number(match.groups.day);
+        if (day < 1 || day > daysInMonth(year, month)) {
+            throw new Error(`Invalid day in "${value}"`);
+        }
+    }
+    return { year, month };
+}
+function parseDay(value, bound) {
+    const monthOnly = /^(?<year>\d{4})-(?<month>\d{2})$/.exec(value);
+    if (monthOnly?.groups) {
+        const year = Number(monthOnly.groups.year);
+        const month = Number(monthOnly.groups.month);
+        if (month < 1 || month > 12)
+            throw new Error(`Invalid month in "${value}"`);
+        const day = bound === "start" ? 1 : daysInMonth(year, month);
+        return { year, month, day };
+    }
+    const match = /^(?<year>\d{4})-(?<month>\d{2})-(?<day>\d{2})$/.exec(value);
+    if (!match?.groups)
+        throw new Error(`Invalid date "${value}". Use YYYY-MM-DD.`);
+    const year = Number(match.groups.year);
+    const month = Number(match.groups.month);
+    const day = Number(match.groups.day);
+    if (month < 1 || month > 12 || day < 1 || day > daysInMonth(year, month)) {
+        throw new Error(`Invalid day in "${value}"`);
+    }
+    return { year, month, day };
+}
+function* iterMonths(start, end) {
+    let current = start;
+    while (compareMonths(current, end) <= 0) {
+        yield current;
+        current = addMonths(current, 1);
+    }
+}
+function* iterDays(start, end) {
+    let current = start;
+    while (compareDays(current, end) <= 0) {
+        yield current;
+        current = addDays(current, 1);
+    }
+}
+function addMonths(value, months) {
+    const index = value.year * 12 + value.month - 1 + months;
+    return { year: Math.floor(index / 12), month: (index % 12) + 1 };
+}
+function addDays(value, days) {
+    const date = new Date(Date.UTC(value.year, value.month - 1, value.day + days));
+    return { year: date.getUTCFullYear(), month: date.getUTCMonth() + 1, day: date.getUTCDate() };
+}
+function compareMonths(a, b) {
+    return a.year === b.year ? a.month - b.month : a.year - b.year;
+}
+function compareDays(a, b) {
+    if (a.year !== b.year)
+        return a.year - b.year;
+    if (a.month !== b.month)
+        return a.month - b.month;
+    return a.day - b.day;
+}
+function formatMonth(value) {
+    return `${value.year}-${String(value.month).padStart(2, "0")}`;
+}
+function formatDay(value) {
+    return `${formatMonth(value)}-${String(value.day).padStart(2, "0")}`;
+}
+function daysInMonth(year, month) {
+    return new Date(Date.UTC(year, month, 0)).getUTCDate();
+}
+function timeframeLabel(barType, interval = 1) {
+    const suffix = { second: "s", minute: "m", hour: "h", day: "D", week: "W", month: "M" }[barType];
+    return `${interval}${suffix}`;
+}
+function filterResponseForRequest(response, options, request) {
+    if (request.method !== "series" || !Array.isArray(response?.series))
+        return response;
+    const start = dayBoundaryUnixSeconds(parseDay(options.from, "start"), "start");
+    const end = dayBoundaryUnixSeconds(parseDay(options.to, "end"), "end");
+    return {
+        ...response,
+        series: response.series.filter((row) => {
+            const time = Array.isArray(row) ? row[0] : row?.time;
+            return typeof time === "number" && time >= start && time <= end;
+        }),
+    };
+}
+function dayBoundaryUnixSeconds(value, bound) {
+    const milliseconds = bound === "start"
+        ? Date.UTC(value.year, value.month - 1, value.day, 0, 0, 0, 0)
+        : Date.UTC(value.year, value.month - 1, value.day, 23, 59, 59, 999);
+    return Math.floor(milliseconds / 1000);
+}
+function sanitizePathPart(value) {
+    return value.replace(/[^A-Za-z0-9._!-]+/g, "_");
+}
+function outputFilesForFormat(outputBasePath, format) {
+    if (format === "both")
+        return [`${outputBasePath}.json`, `${outputBasePath}.csv`];
+    return [`${outputBasePath}.${format}`];
+}
+function outputBasePathForResponse(request, response) {
+    const responseBarType = typeof response?.bar_type === "string" && response.bar_type.trim()
+        ? sanitizePathPart(response.bar_type.trim())
+        : path.basename(path.dirname(request.outputBasePath));
+    return path.join(path.dirname(path.dirname(request.outputBasePath)), responseBarType, path.basename(request.outputBasePath));
+}
+function mergedCsvPath(options, barTypeLabel) {
+    return path.join(path.resolve(options.output_dir), sanitizePathPart(options.symbol), sanitizePathPart(barTypeLabel), "merged.csv");
+}
+async function mergeCsvFiles(files, outputPath) {
+    await mkdir(path.dirname(outputPath), { recursive: true });
+    const headers = [];
+    const headerSet = new Set();
+    const rowsByKey = new Map();
+    for (const file of files) {
+        const content = await readFile(file, "utf8");
+        if (!content.trim())
+            continue;
+        const lines = content.split(/\r?\n/).filter((line) => line.length > 0);
+        if (lines.length === 0)
+            continue;
+        const columns = parseCsvLine(lines[0]);
+        const codeIndex = columns.indexOf("code");
+        const barTypeIndex = columns.indexOf("bar_type");
+        const timeIndex = columns.indexOf("time");
+        if (codeIndex === -1 || barTypeIndex === -1 || timeIndex === -1) {
+            throw new Error("Merged CSV requires code, bar_type, and time columns for deduplication");
+        }
+        for (const column of columns) {
+            if (!headerSet.has(column)) {
+                headerSet.add(column);
+                headers.push(column);
+            }
+        }
+        for (const line of lines.slice(1)) {
+            const values = parseCsvLine(line);
+            const key = [codeIndex, barTypeIndex, timeIndex]
+                .map((index) => values[index] ?? "")
+                .join("\u0000");
+            const row = {};
+            for (let index = 0; index < columns.length; index += 1) {
+                row[columns[index]] = values[index] ?? "";
+            }
+            rowsByKey.set(key, row);
+        }
+    }
+    const rows = Array.from(rowsByKey.values()).map((row) => headers.map((header) => row[header] ?? ""));
+    const content = headers.length > 0 ? serializeCsvRows(headers, rows) : "";
+    await writeFile(outputPath, content, "utf8");
+}
+async function allFilesExist(files) {
+    for (const file of files) {
+        try {
+            await readFile(file);
+        }
+        catch {
+            return false;
+        }
+    }
+    return true;
+}
+async function findExistingTargetFiles(outputBasePath, format) {
+    const outputRoot = path.dirname(path.dirname(outputBasePath));
+    const outputName = path.basename(outputBasePath);
+    let entries;
+    try {
+        entries = await readdir(outputRoot, { withFileTypes: true });
+    }
+    catch (error) {
+        if (error?.code === "ENOENT")
+            return null;
+        throw error;
+    }
+    for (const entry of entries) {
+        if (!entry.isDirectory())
+            continue;
+        const candidateFiles = outputFilesForFormat(path.join(outputRoot, entry.name, outputName), format);
+        if (await allFilesExist(candidateFiles))
+            return candidateFiles;
+    }
+    return null;
+}
+async function removeChunkFiles(files) {
+    await Promise.all(files.map(async (file) => {
+        try {
+            await unlink(file);
+        }
+        catch (error) {
+            if (error?.code !== "ENOENT")
+                throw error;
+        }
+    }));
+}
+function serializeCsvRows(headers, rows) {
+    const lines = [headers.map(escapeCsvCell).join(",")];
+    for (const row of rows) {
+        lines.push(row.map(escapeCsvCell).join(","));
+    }
+    return `${lines.join("\n")}\n`;
+}
+function escapeCsvCell(value) {
+    if (value === undefined || value === null)
+        return "";
+    const text = typeof value === "object" ? JSON.stringify(value) : String(value);
+    if (/[",\n\r]/.test(text)) {
+        return `"${text.replace(/"/g, '""')}"`;
+    }
+    return text;
+}
+function parseCsvLine(line) {
+    const cells = [];
+    let current = "";
+    let inQuotes = false;
+    for (let index = 0; index < line.length; index += 1) {
+        const char = line[index];
+        if (char === '"') {
+            if (inQuotes && line[index + 1] === '"') {
+                current += '"';
+                index += 1;
+            }
+            else {
+                inQuotes = !inQuotes;
+            }
+            continue;
+        }
+        if (char === "," && !inQuotes) {
+            cells.push(current);
+            current = "";
+            continue;
+        }
+        current += char;
+    }
+    cells.push(current);
+    return cells;
+}
+function parseSettlementMonth(value) {
+    const match = /^\d{4}(?<month>\d{2})\d{2}$/.exec(value);
+    if (!match?.groups)
+        return null;
+    const month = Number(match.groups.month);
+    return month >= 1 && month <= 12 ? month : null;
+}
+function extractMonthCode(code, fullBaseCode, rootBase) {
+    const prefixes = [fullBaseCode, rootBase];
+    for (const prefix of prefixes) {
+        if (!code.startsWith(prefix))
+            continue;
+        const suffix = code.slice(prefix.length);
+        const match = /^(?<monthCode>[A-Z])\d{4}$/.exec(suffix);
+        if (match?.groups)
+            return match.groups.monthCode;
+    }
+    const fallback = /(?<monthCode>[A-Z])\d{4}$/.exec(code);
+    return fallback?.groups?.monthCode ?? null;
+}
+//# sourceMappingURL=history.js.map