@fin.cx/opendata 4.7.0 → 4.9.0

package/dist_ts/financialstatements/parse.statement.d.ts

@@ -0,0 +1,8 @@
+import type { IHgbStatement } from './interfaces.js';
+/**
+ * Reads a statement under the HGB from the HTML or the PDF a register shows: the balance sheet
+ * (§ 266 HGB) and, where one is published, the income statement (§ 275 HGB). Everything it returns
+ * was printed and adds up; where the current year's balance sheet cannot be read with certainty it
+ * throws `unparseable` rather than guess. A PDF is read from its text layer only.
+ */
+export declare const parseStatementDocument: (bytesArg: Uint8Array, mediaTypeArg: string) => Promise<IHgbStatement>;

package/dist_ts/financialstatements/parse.statement.js

@@ -0,0 +1,25 @@
+import { FinancialStatementError } from './classes.financialstatementerror.js';
+import { maxStatementBytes } from './constants.js';
+import { decodeHtml } from './html.js';
+import { htmlLayout } from './layout.html.js';
+import { pdfLayout } from './layout.pdf.js';
+import { statementMediaTypeOf } from './mediatypes.js';
+import { readHgbStatement } from './parse.hgb.js';
+/**
+ * Reads a statement under the HGB from the HTML or the PDF a register shows: the balance sheet
+ * (§ 266 HGB) and, where one is published, the income statement (§ 275 HGB). Everything it returns
+ * was printed and adds up; where the current year's balance sheet cannot be read with certainty it
+ * throws `unparseable` rather than guess. A PDF is read from its text layer only.
+ */
+export const parseStatementDocument = async (bytesArg, mediaTypeArg) => {
+    const mediaType = statementMediaTypeOf(mediaTypeArg);
+    if (mediaType !== 'text/html' && mediaType !== 'application/xhtml+xml' && mediaType !== 'application/pdf') {
+        throw new FinancialStatementError('unsupported_media_type', `A statement in "${mediaTypeArg}" is not read here; HTML and PDF are.`);
+    }
+    if (bytesArg.byteLength > maxStatementBytes) {
+        throw new FinancialStatementError('too_large', `The document has ${bytesArg.byteLength} bytes, more than the ${maxStatementBytes} read here.`);
+    }
+    const blocks = mediaType === 'application/pdf' ? await pdfLayout(bytesArg) : htmlLayout(decodeHtml(bytesArg));
+    return readHgbStatement(blocks);
+};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicGFyc2Uuc3RhdGVtZW50LmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vdHMvZmluYW5jaWFsc3RhdGVtZW50cy9wYXJzZS5zdGF0ZW1lbnQudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLHVCQUF1QixFQUFFLE1BQU0sc0NBQXNDLENBQUM7QUFDL0UsT0FBTyxFQUFFLGlCQUFpQixFQUFFLE1BQU0sZ0JBQWdCLENBQUM7QUFDbkQsT0FBTyxFQUFFLFVBQVUsRUFBRSxNQUFNLFdBQVcsQ0FBQztBQUN2QyxPQUFPLEVBQUUsVUFBVSxFQUFFLE1BQU0sa0JBQWtCLENBQUM7QUFDOUMsT0FBTyxFQUFFLFNBQVMsRUFBRSxNQUFNLGlCQUFpQixDQUFDO0FBQzVDLE9BQU8sRUFBRSxvQkFBb0IsRUFBRSxNQUFNLGlCQUFpQixDQUFDO0FBQ3ZELE9BQU8sRUFBRSxnQkFBZ0IsRUFBRSxNQUFNLGdCQUFnQixDQUFDO0FBR2xEOzs7OztHQUtHO0FBQ0gsTUFBTSxDQUFDLE1BQU0sc0JBQXNCLEdBQUcsS0FBSyxFQUFFLFFBQW9CLEVBQUUsWUFBb0IsRUFBMEIsRUFBRTtJQUNqSCxNQUFNLFNBQVMsR0FBRyxvQkFBb0IsQ0FBQyxZQUFZLENBQUMsQ0FBQztJQUNyRCxJQUFJLFNBQVMsS0FBSyxXQUFXLElBQUksU0FBUyxLQUFLLHVCQUF1QixJQUFJLFNBQVMsS0FBSyxpQkFBaUIsRUFBRSxDQUFDO1FBQzFHLE1BQU0sSUFBSSx1QkFBdUIsQ0FBQyx3QkFBd0IsRUFBRSxtQkFBbUIsWUFBWSx1Q0FBdUMsQ0FBQyxDQUFDO0lBQ3RJLENBQUM7SUFDRCxJQUFJLFFBQVEsQ0FBQyxVQUFVLEdBQUcsaUJBQWlCLEVBQUUsQ0FBQztRQUM1QyxNQUFNLElBQUksdUJBQXVCLENBQUMsV0FBVyxFQUFFLG9CQUFvQixRQUFRLENBQUMsVUFBVSx5QkFBeUIsaUJBQWlCLGFBQWEsQ0FBQyxDQUFDO0lBQ2pKLENBQUM7SUFDRCxNQUFNLE1BQU0sR0FBRyxTQUFTLEtBQUssaUJBQWlCLENBQUMsQ0FBQyxDQUFDLE1BQU0sU0FBUyxDQUFDLFFBQVEsQ0FBQyxDQUFDLENBQUMsQ0FBQyxVQUFVLENBQUMsVUFBVSxDQUFDLFFBQVEsQ0FBQyxDQUFDLENBQUM7SUFDOUcsT0FBTyxnQkFBZ0IsQ0FBQyxNQUFNLENBQUMsQ0FBQztBQUNsQyxDQUFDLENBQUMifQ==

package/dist_ts/financialstatements/plugins.d.ts

@@ -0,0 +1,10 @@
+import * as path from 'node:path';
+import { createRequire } from 'node:module';
+export { path, createRequire, };
+import * as smartarchiveZip from '@push.rocks/smartarchive/web/zip';
+import * as smartxmlXpath from '@push.rocks/smartxml/xpath';
+export { smartarchiveZip, smartxmlXpath, };
+import * as parse5 from 'parse5';
+export { parse5, };
+/** PDF.js for Node.js (its legacy build), loaded when the first PDF is read */
+export declare const loadPdfjs: () => Promise<typeof import("pdfjs-dist/legacy/build/pdf.mjs")>;

package/dist_ts/financialstatements/plugins.js

@@ -0,0 +1,15 @@
+// This entry point stands alone: it imports nothing from the rest of the package and needs no storage.
+// node native scope
+import * as path from 'node:path';
+import { createRequire } from 'node:module';
+export { path, createRequire, };
+// @push.rocks scope
+import * as smartarchiveZip from '@push.rocks/smartarchive/web/zip';
+import * as smartxmlXpath from '@push.rocks/smartxml/xpath';
+export { smartarchiveZip, smartxmlXpath, };
+// third party scope
+import * as parse5 from 'parse5';
+export { parse5, };
+/** PDF.js for Node.js (its legacy build), loaded when the first PDF is read */
+export const loadPdfjs = () => import('pdfjs-dist/legacy/build/pdf.mjs');
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicGx1Z2lucy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3RzL2ZpbmFuY2lhbHN0YXRlbWVudHMvcGx1Z2lucy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSx1R0FBdUc7QUFFdkcsb0JBQW9CO0FBQ3BCLE9BQU8sS0FBSyxJQUFJLE1BQU0sV0FBVyxDQUFDO0FBQ2xDLE9BQU8sRUFBRSxhQUFhLEVBQUUsTUFBTSxhQUFhLENBQUM7QUFFNUMsT0FBTyxFQUNMLElBQUksRUFDSixhQUFhLEdBQ2QsQ0FBQTtBQUVELG9CQUFvQjtBQUNwQixPQUFPLEtBQUssZUFBZSxNQUFNLGtDQUFrQyxDQUFDO0FBQ3BFLE9BQU8sS0FBSyxhQUFhLE1BQU0sNEJBQTRCLENBQUM7QUFFNUQsT0FBTyxFQUNMLGVBQWUsRUFDZixhQUFhLEdBQ2QsQ0FBQTtBQUVELG9CQUFvQjtBQUNwQixPQUFPLEtBQUssTUFBTSxNQUFNLFFBQVEsQ0FBQztBQUVqQyxPQUFPLEVBQ0wsTUFBTSxHQUNQLENBQUE7QUFFRCwrRUFBK0U7QUFDL0UsTUFBTSxDQUFDLE1BQU0sU0FBUyxHQUFHLEdBQUcsRUFBRSxDQUFDLE1BQU0sQ0FBQyxpQ0FBaUMsQ0FBQyxDQUFDIn0=

package/dist_ts/financialstatements/read.d.ts

@@ -0,0 +1,10 @@
+import type { IFinancialStatement, IReadFinancialStatementOptions } from './interfaces.js';
+/**
+ * Keeps a published statement as a caller stores it: the filing as the caller states it, the
+ * document byte for byte with its SHA-256, and what could be read from it: an ESEF report by
+ * `parseEsefPackage` or `parseEsefReport`, any other HTML or PDF by `parseStatementDocument`. A
+ * document that cannot be read with certainty is kept with `parsed` null and `parseFailure` saying
+ * why. Throws `invalid_input`, `unsupported_media_type` and, for a document larger than
+ * `maxStatementBytes`, `too_large`, as nothing would be kept.
+ */
+export declare const readFinancialStatement: (optionsArg: IReadFinancialStatementOptions) => Promise<IFinancialStatement>;

package/dist_ts/financialstatements/read.js

@@ -0,0 +1,113 @@
+import { FinancialStatementError } from './classes.financialstatementerror.js';
+import { maxStatementBytes, unternehmensregisterNotice } from './constants.js';
+import { statementMediaTypeOf } from './mediatypes.js';
+import { parseEsefPackage, parseEsefReport } from './parse.esef.js';
+import { parseStatementDocument } from './parse.statement.js';
+const filingSources = ['unternehmensregister', 'bundesanzeiger', 'issuer', 'unknown'];
+const filingKinds = ['annual_accounts', 'consolidated_accounts', 'deposited_balance_sheet', 'annual_financial_report'];
+const sizeClasses = ['micro', 'small', 'medium', 'large'];
+const parseFailureCodes = new Set(['invalid_package', 'unreadable', 'no_text', 'unparseable', 'too_large']);
+/** the inline XBRL namespace, which marks an HTML document as an ESEF report */
+const inlineXbrlNamespace = 'http://www.xbrl.org/2013/inlineXBRL';
+const invalid = (messageArg) => {
+    throw new FinancialStatementError('invalid_input', messageArg);
+};
+const isIsoDate = (valueArg) => {
+    if (!/^\d{4}-\d{2}-\d{2}$/.test(valueArg)) {
+        return false;
+    }
+    const date = new Date(`${valueArg}T00:00:00Z`);
+    return !Number.isNaN(date.getTime()) && date.toISOString().slice(0, 10) === valueArg;
+};
+const filingOf = (inputArg) => {
+    if (!filingSources.includes(inputArg?.source)) {
+        invalid(`The filing's source "${inputArg?.source}" is not one of ${filingSources.join(', ')}.`);
+    }
+    if (!filingKinds.includes(inputArg.kind)) {
+        invalid(`The filing's kind "${inputArg.kind}" is not one of ${filingKinds.join(', ')}.`);
+    }
+    if (inputArg.sizeClass != null && !sizeClasses.includes(inputArg.sizeClass)) {
+        invalid(`The filing's size class "${inputArg.sizeClass}" is not one of ${sizeClasses.join(', ')}.`);
+    }
+    for (const field of ['fiscalYearStart', 'fiscalYearEnd', 'publishedOn']) {
+        const value = inputArg[field];
+        if (value != null && (typeof value !== 'string' || !isIsoDate(value))) {
+            invalid(`The filing's ${field} "${value}" is not an ISO date (YYYY-MM-DD).`);
+        }
+    }
+    if (inputArg.source === 'unternehmensregister' && inputArg.publishedOn == null) {
+        invalid('A filing from the Unternehmensregister needs publishedOn, the day it was posted or deposited, for its origin note.');
+    }
+    return {
+        source: inputArg.source,
+        kind: inputArg.kind,
+        companyName: inputArg.companyName ?? null,
+        registerReference: inputArg.registerReference ?? null,
+        lei: inputArg.lei ?? null,
+        fiscalYearStart: inputArg.fiscalYearStart ?? null,
+        fiscalYearEnd: inputArg.fiscalYearEnd ?? null,
+        publishedOn: inputArg.publishedOn ?? null,
+        title: inputArg.title ?? null,
+        sizeClass: inputArg.sizeClass ?? null,
+        documentId: inputArg.documentId ?? null,
+        sourceUrl: inputArg.sourceUrl ?? null,
+    };
+};
+const sha256Of = async (bytesArg) => {
+    const digest = new Uint8Array(await globalThis.crypto.subtle.digest('SHA-256', bytesArg));
+    return [...digest].map((byteArg) => byteArg.toString(16).padStart(2, '0')).join('');
+};
+/**
+ * Keeps a published statement as a caller stores it: the filing as the caller states it, the
+ * document byte for byte with its SHA-256, and what could be read from it: an ESEF report by
+ * `parseEsefPackage` or `parseEsefReport`, any other HTML or PDF by `parseStatementDocument`. A
+ * document that cannot be read with certainty is kept with `parsed` null and `parseFailure` saying
+ * why. Throws `invalid_input`, `unsupported_media_type` and, for a document larger than
+ * `maxStatementBytes`, `too_large`, as nothing would be kept.
+ */
+export const readFinancialStatement = async (optionsArg) => {
+    if (!(optionsArg?.bytes instanceof Uint8Array)) {
+        invalid('bytes must be a Uint8Array.');
+    }
+    const filing = filingOf(optionsArg.filing);
+    if (optionsArg.bytes.byteLength > maxStatementBytes) {
+        throw new FinancialStatementError('too_large', `The document has ${optionsArg.bytes.byteLength} bytes, more than the ${maxStatementBytes} read here.`);
+    }
+    const mediaType = statementMediaTypeOf(String(optionsArg.mediaType));
+    if (!mediaType) {
+        throw new FinancialStatementError('unsupported_media_type', `A statement in "${optionsArg.mediaType}" is not read here; HTML, PDF, XHTML and ZIP packages are.`);
+    }
+    const bytes = new Uint8Array(optionsArg.bytes);
+    const sha256 = await sha256Of(bytes);
+    let parsed = null;
+    let parseFailure = null;
+    try {
+        if (mediaType === 'application/zip') {
+            parsed = await parseEsefPackage(bytes);
+        }
+        else if (mediaType === 'application/xhtml+xml' ||
+            (mediaType === 'text/html' && new TextDecoder('windows-1252').decode(bytes.subarray(0, 65536)).includes(inlineXbrlNamespace))) {
+            parsed = parseEsefReport(bytes);
+        }
+        else {
+            parsed = await parseStatementDocument(bytes, mediaType);
+        }
+    }
+    catch (error) {
+        if (!(error instanceof FinancialStatementError) || !parseFailureCodes.has(error.code)) {
+            throw error;
+        }
+        parseFailure = { code: error.code, message: error.message };
+    }
+    return {
+        filing,
+        raw: { bytes, mediaType, sha256 },
+        parsed,
+        parseFailure,
+        obtainedAt: (optionsArg.now ?? Date.now)(),
+        notice: filing.source === 'unternehmensregister'
+            ? unternehmensregisterNotice(filing.publishedOn, filing.kind === 'deposited_balance_sheet')
+            : null,
+    };
+};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicmVhZC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3RzL2ZpbmFuY2lhbHN0YXRlbWVudHMvcmVhZC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsdUJBQXVCLEVBQUUsTUFBTSxzQ0FBc0MsQ0FBQztBQUMvRSxPQUFPLEVBQUUsaUJBQWlCLEVBQUUsMEJBQTBCLEVBQUUsTUFBTSxnQkFBZ0IsQ0FBQztBQUMvRSxPQUFPLEVBQUUsb0JBQW9CLEVBQUUsTUFBTSxpQkFBaUIsQ0FBQztBQUN2RCxPQUFPLEVBQUUsZ0JBQWdCLEVBQUUsZUFBZSxFQUFFLE1BQU0saUJBQWlCLENBQUM7QUFDcEUsT0FBTyxFQUFFLHNCQUFzQixFQUFFLE1BQU0sc0JBQXNCLENBQUM7QUFZOUQsTUFBTSxhQUFhLEdBQW9CLENBQUMsc0JBQXNCLEVBQUUsZ0JBQWdCLEVBQUUsUUFBUSxFQUFFLFNBQVMsQ0FBQyxDQUFDO0FBQ3ZHLE1BQU0sV0FBVyxHQUFrQixDQUFDLGlCQUFpQixFQUFFLHVCQUF1QixFQUFFLHlCQUF5QixFQUFFLHlCQUF5QixDQUFDLENBQUM7QUFDdEksTUFBTSxXQUFXLEdBQWlCLENBQUMsT0FBTyxFQUFFLE9BQU8sRUFBRSxRQUFRLEVBQUUsT0FBTyxDQUFDLENBQUM7QUFDeEUsTUFBTSxpQkFBaUIsR0FBRyxJQUFJLEdBQUcsQ0FBUyxDQUFDLGlCQUFpQixFQUFFLFlBQVksRUFBRSxTQUFTLEVBQUUsYUFBYSxFQUFFLFdBQVcsQ0FBQyxDQUFDLENBQUM7QUFFcEgsZ0ZBQWdGO0FBQ2hGLE1BQU0sbUJBQW1CLEdBQUcscUNBQXFDLENBQUM7QUFFbEUsTUFBTSxPQUFPLEdBQUcsQ0FBQyxVQUFrQixFQUFTLEVBQUU7SUFDNUMsTUFBTSxJQUFJLHVCQUF1QixDQUFDLGVBQWUsRUFBRSxVQUFVLENBQUMsQ0FBQztBQUNqRSxDQUFDLENBQUM7QUFFRixNQUFNLFNBQVMsR0FBRyxDQUFDLFFBQWdCLEVBQVcsRUFBRTtJQUM5QyxJQUFJLENBQUMscUJBQXFCLENBQUMsSUFBSSxDQUFDLFFBQVEsQ0FBQyxFQUFFLENBQUM7UUFDMUMsT0FBTyxLQUFLLENBQUM7SUFDZixDQUFDO0lBQ0QsTUFBTSxJQUFJLEdBQUcsSUFBSSxJQUFJLENBQUMsR0FBRyxRQUFRLFlBQVksQ0FBQyxDQUFDO0lBQy9DLE9BQU8sQ0FBQyxNQUFNLENBQUMsS0FBSyxDQUFDLElBQUksQ0FBQyxPQUFPLEVBQUUsQ0FBQyxJQUFJLElBQUksQ0FBQyxXQUFXLEVBQUUsQ0FBQyxLQUFLLENBQUMsQ0FBQyxFQUFFLEVBQUUsQ0FBQyxLQUFLLFFBQVEsQ0FBQztBQUN2RixDQUFDLENBQUM7QUFFRixNQUFNLFFBQVEsR0FBRyxDQUFDLFFBQWtELEVBQVcsRUFBRTtJQUMvRSxJQUFJLENBQUMsYUFBYSxDQUFDLFFBQVEsQ0FBQyxRQUFRLEVBQUUsTUFBTSxDQUFDLEVBQUUsQ0FBQztRQUM5QyxPQUFPLENBQUMsd0JBQXdCLFFBQVEsRUFBRSxNQUFNLG1CQUFtQixhQUFhLENBQUMsSUFBSSxDQUFDLElBQUksQ0FBQyxHQUFHLENBQUMsQ0FBQztJQUNsRyxDQUFDO0lBQ0QsSUFBSSxDQUFDLFdBQVcsQ0FBQyxRQUFRLENBQUMsUUFBUSxDQUFDLElBQUksQ0FBQyxFQUFFLENBQUM7UUFDekMsT0FBTyxDQUFDLHNCQUFzQixRQUFRLENBQUMsSUFBSSxtQkFBbUIsV0FBVyxDQUFDLElBQUksQ0FBQyxJQUFJLENBQUMsR0FBRyxDQUFDLENBQUM7SUFDM0YsQ0FBQztJQUNELElBQUksUUFBUSxDQUFDLFNBQVMsSUFBSSxJQUFJLElBQUksQ0FBQyxXQUFXLENBQUMsUUFBUSxDQUFDLFFBQVEsQ0FBQyxTQUFTLENBQUMsRUFBRSxDQUFDO1FBQzVFLE9BQU8sQ0FBQyw0QkFBNEIsUUFBUSxDQUFDLFNBQVMsbUJBQW1CLFdBQVcsQ0FBQyxJQUFJLENBQUMsSUFBSSxDQUFDLEdBQUcsQ0FBQyxDQUFDO0lBQ3RHLENBQUM7SUFDRCxLQUFLLE1BQU0sS0FBSyxJQUFJLENBQUMsaUJBQWlCLEVBQUUsZUFBZSxFQUFFLGFBQWEsQ0FBVSxFQUFFLENBQUM7UUFDakYsTUFBTSxLQUFLLEdBQUcsUUFBUSxDQUFDLEtBQUssQ0FBQyxDQUFDO1FBQzlCLElBQUksS0FBSyxJQUFJLElBQUksSUFBSSxDQUFDLE9BQU8sS0FBSyxLQUFLLFFBQVEsSUFBSSxDQUFDLFNBQVMsQ0FBQyxLQUFLLENBQUMsQ0FBQyxFQUFFLENBQUM7WUFDdEUsT0FBTyxDQUFDLGdCQUFnQixLQUFLLEtBQUssS0FBSyxvQ0FBb0MsQ0FBQyxDQUFDO1FBQy9FLENBQUM7SUFDSCxDQUFDO0lBQ0QsSUFBSSxRQUFRLENBQUMsTUFBTSxLQUFLLHNCQUFzQixJQUFJLFFBQVEsQ0FBQyxXQUFXLElBQUksSUFBSSxFQUFFLENBQUM7UUFDL0UsT0FBTyxDQUFDLG9IQUFvSCxDQUFDLENBQUM7SUFDaEksQ0FBQztJQUNELE9BQU87UUFDTCxNQUFNLEVBQUUsUUFBUSxDQUFDLE1BQU07UUFDdkIsSUFBSSxFQUFFLFFBQVEsQ0FBQyxJQUFJO1FBQ25CLFdBQVcsRUFBRSxRQUFRLENBQUMsV0FBVyxJQUFJLElBQUk7UUFDekMsaUJBQWlCLEVBQUUsUUFBUSxDQUFDLGlCQUFpQixJQUFJLElBQUk7UUFDckQsR0FBRyxFQUFFLFFBQVEsQ0FBQyxHQUFHLElBQUksSUFBSTtRQUN6QixlQUFlLEVBQUUsUUFBUSxDQUFDLGVBQWUsSUFBSSxJQUFJO1FBQ2pELGFBQWEsRUFBRSxRQUFRLENBQUMsYUFBYSxJQUFJLElBQUk7UUFDN0MsV0FBVyxFQUFFLFFBQVEsQ0FBQyxXQUFXLElBQUksSUFBSTtRQUN6QyxLQUFLLEVBQUUsUUFBUSxDQUFDLEtBQUssSUFBSSxJQUFJO1FBQzdCLFNBQVMsRUFBRSxRQUFRLENBQUMsU0FBUyxJQUFJLElBQUk7UUFDckMsVUFBVSxFQUFFLFFBQVEsQ0FBQyxVQUFVLElBQUksSUFBSTtRQUN2QyxTQUFTLEVBQUUsUUFBUSxDQUFDLFNBQVMsSUFBSSxJQUFJO0tBQ3RDLENBQUM7QUFDSixDQUFDLENBQUM7QUFFRixNQUFNLFFBQVEsR0FBRyxLQUFLLEVBQUUsUUFBaUMsRUFBbUIsRUFBRTtJQUM1RSxNQUFNLE1BQU0sR0FBRyxJQUFJLFVBQVUsQ0FBQyxNQUFNLFVBQVUsQ0FBQyxNQUFNLENBQUMsTUFBTSxDQUFDLE1BQU0sQ0FBQyxTQUFTLEVBQUUsUUFBUSxDQUFDLENBQUMsQ0FBQztJQUMxRixPQUFPLENBQUMsR0FBRyxNQUFNLENBQUMsQ0FBQyxHQUFHLENBQUMsQ0FBQyxPQUFPLEVBQUUsRUFBRSxDQUFDLE9BQU8sQ0FBQyxRQUFRLENBQUMsRUFBRSxDQUFDLENBQUMsUUFBUSxDQUFDLENBQUMsRUFBRSxHQUFHLENBQUMsQ0FBQyxDQUFDLElBQUksQ0FBQyxFQUFFLENBQUMsQ0FBQztBQUN0RixDQUFDLENBQUM7QUFFRjs7Ozs7OztHQU9HO0FBQ0gsTUFBTSxDQUFDLE1BQU0sc0JBQXNCLEdBQUcsS0FBSyxFQUFFLFVBQTBDLEVBQWdDLEVBQUU7SUFDdkgsSUFBSSxDQUFDLENBQUMsVUFBVSxFQUFFLEtBQUssWUFBWSxVQUFVLENBQUMsRUFBRSxDQUFDO1FBQy9DLE9BQU8sQ0FBQyw2QkFBNkIsQ0FBQyxDQUFDO0lBQ3pDLENBQUM7SUFDRCxNQUFNLE1BQU0sR0FBRyxRQUFRLENBQUMsVUFBVSxDQUFDLE1BQU0sQ0FBQyxDQUFDO0lBQzNDLElBQUksVUFBVSxDQUFDLEtBQUssQ0FBQyxVQUFVLEdBQUcsaUJBQWlCLEVBQUUsQ0FBQztRQUNwRCxNQUFNLElBQUksdUJBQXVCLENBQy9CLFdBQVcsRUFDWCxvQkFBb0IsVUFBVSxDQUFDLEtBQUssQ0FBQyxVQUFVLHlCQUF5QixpQkFBaUIsYUFBYSxDQUN2RyxDQUFDO0lBQ0osQ0FBQztJQUNELE1BQU0sU0FBUyxHQUFHLG9CQUFvQixDQUFDLE1BQU0sQ0FBQyxVQUFVLENBQUMsU0FBUyxDQUFDLENBQUMsQ0FBQztJQUNyRSxJQUFJLENBQUMsU0FBUyxFQUFFLENBQUM7UUFDZixNQUFNLElBQUksdUJBQXVCLENBQy9CLHdCQUF3QixFQUN4QixtQkFBbUIsVUFBVSxDQUFDLFNBQVMsNERBQTRELENBQ3BHLENBQUM7SUFDSixDQUFDO0lBQ0QsTUFBTSxLQUFLLEdBQUcsSUFBSSxVQUFVLENBQUMsVUFBVSxDQUFDLEtBQUssQ0FBQyxDQUFDO0lBQy9DLE1BQU0sTUFBTSxHQUFHLE1BQU0sUUFBUSxDQUFDLEtBQUssQ0FBQyxDQUFDO0lBQ3JDLElBQUksTUFBTSxHQUE0QixJQUFJLENBQUM7SUFDM0MsSUFBSSxZQUFZLEdBQWtDLElBQUksQ0FBQztJQUN2RCxJQUFJLENBQUM7UUFDSCxJQUFJLFNBQVMsS0FBSyxpQkFBaUIsRUFBRSxDQUFDO1lBQ3BDLE1BQU0sR0FBRyxNQUFNLGdCQUFnQixDQUFDLEtBQUssQ0FBQyxDQUFDO1FBQ3pDLENBQUM7YUFBTSxJQUNMLFNBQVMsS0FBSyx1QkFBdUI7WUFDckMsQ0FBQyxTQUFTLEtBQUssV0FBVyxJQUFJLElBQUksV0FBVyxDQUFDLGNBQWMsQ0FBQyxDQUFDLE1BQU0sQ0FBQyxLQUFLLENBQUMsUUFBUSxDQUFDLENBQUMsRUFBRSxLQUFLLENBQUMsQ0FBQyxDQUFDLFFBQVEsQ0FBQyxtQkFBbUIsQ0FBQyxDQUFDLEVBQzdILENBQUM7WUFDRCxNQUFNLEdBQUcsZUFBZSxDQUFDLEtBQUssQ0FBQyxDQUFDO1FBQ2xDLENBQUM7YUFBTSxDQUFDO1lBQ04sTUFBTSxHQUFHLE1BQU0sc0JBQXNCLENBQUMsS0FBSyxFQUFFLFNBQVMsQ0FBQyxDQUFDO1FBQzFELENBQUM7SUFDSCxDQUFDO0lBQUMsT0FBTyxLQUFLLEVBQUUsQ0FBQztRQUNmLElBQUksQ0FBQyxDQUFDLEtBQUssWUFBWSx1QkFBdUIsQ0FBQyxJQUFJLENBQUMsaUJBQWlCLENBQUMsR0FBRyxDQUFDLEtBQUssQ0FBQyxJQUFJLENBQUMsRUFBRSxDQUFDO1lBQ3RGLE1BQU0sS0FBSyxDQUFDO1FBQ2QsQ0FBQztRQUNELFlBQVksR0FBRyxFQUFFLElBQUksRUFBRSxLQUFLLENBQUMsSUFBc0MsRUFBRSxPQUFPLEVBQUUsS0FBSyxDQUFDLE9BQU8sRUFBRSxDQUFDO0lBQ2hHLENBQUM7SUFDRCxPQUFPO1FBQ0wsTUFBTTtRQUNOLEdBQUcsRUFBRSxFQUFFLEtBQUssRUFBRSxTQUFTLEVBQUUsTUFBTSxFQUFFO1FBQ2pDLE1BQU07UUFDTixZQUFZO1FBQ1osVUFBVSxFQUFFLENBQUMsVUFBVSxDQUFDLEdBQUcsSUFBSSxJQUFJLENBQUMsR0FBRyxDQUFDLEVBQUU7UUFDMUMsTUFBTSxFQUNKLE1BQU0sQ0FBQyxNQUFNLEtBQUssc0JBQXNCO1lBQ3RDLENBQUMsQ0FBQywwQkFBMEIsQ0FBQyxNQUFNLENBQUMsV0FBcUIsRUFBRSxNQUFNLENBQUMsSUFBSSxLQUFLLHlCQUF5QixDQUFDO1lBQ3JHLENBQUMsQ0FBQyxJQUFJO0tBQ1gsQ0FBQztBQUNKLENBQUMsQ0FBQyJ9

package/dist_ts/gleif/classes.gleifclient.d.ts

@@ -0,0 +1,26 @@
+import type { IGleifClientOptions, IGleifGoldenCopyFile, IGleifPublish, IGleifReadOptions, IGleifRecord, IGleifStreamOptions, TGleifDelta } from './interfaces.js';
+export declare const gleifGoldenCopyBaseUrl = "https://goldencopy.gleif.org/api/v2";
+export declare const gleifRestBaseUrl = "https://api.gleif.org/api/v1";
+export declare const gleifDeltaKinds: readonly TGleifDelta[];
+/** Official Golden Copy ZIP/CSV streams and JSON:API lookup; no files, cache or retries. */
+export declare class GleifClient {
+    private readonly options;
+    private readonly goldenCopyBaseUrl;
+    private readonly restBaseUrl;
+    private readonly timeoutMs;
+    constructor(options?: IGleifClientOptions);
+    /** Discovers the current full file and all four delta windows from the official v2 API. */
+    getLatestPublish(optionsArg?: {
+        signal?: AbortSignal;
+    }): Promise<IGleifPublish>;
+    /** Discovers once, then streams the selected full file or delta. */
+    streamRecords(optionsArg?: IGleifStreamOptions): AsyncGenerator<IGleifRecord>;
+    /** Streams a discovered descriptor. Breaking iteration cancels the response immediately. */
+    readGoldenCopy(fileArg: IGleifGoldenCopyFile, optionsArg?: IGleifReadOptions): AsyncGenerator<IGleifRecord>;
+    /** One LEI using the documented public JSON:API resource, mapped to the same record type. */
+    lookup(leiArg: string, optionsArg?: {
+        signal?: AbortSignal;
+    }): Promise<IGleifRecord>;
+    private getJson;
+    private requestBytes;
+}

package/dist_ts/gleif/classes.gleifclient.js

@@ -0,0 +1,214 @@
+import { GleifError } from './classes.gleiferror.js';
+import { parseCsvRows } from './csv.js';
+import { csvRecordMapper, parseGleifRestRecord } from './records.js';
+import { unzipCsv } from './stream.zip.js';
+export const gleifGoldenCopyBaseUrl = 'https://goldencopy.gleif.org/api/v2';
+export const gleifRestBaseUrl = 'https://api.gleif.org/api/v1';
+export const gleifDeltaKinds = ['IntraDay', 'LastDay', 'LastWeek', 'LastMonth'];
+const bad = (labelArg) => { throw new GleifError('unexpected_answer', `Invalid GLEIF publication ${labelArg}.`); };
+const object = (valueArg) => valueArg && typeof valueArg === 'object' && !Array.isArray(valueArg) ? valueArg : bad('object');
+const url = (valueArg) => {
+    if (typeof valueArg !== 'string')
+        throw new GleifError('invalid_input', 'Expected an HTTP(S) URL.');
+    let parsed;
+    try {
+        parsed = new URL(valueArg);
+    }
+    catch {
+        throw new GleifError('invalid_input', 'Expected an HTTP(S) URL.');
+    }
+    if (!['http:', 'https:'].includes(parsed.protocol) || parsed.username || parsed.password)
+        throw new GleifError('invalid_input', 'Expected an HTTP(S) URL without credentials.');
+    return valueArg;
+};
+const descriptor = (valueArg, kindArg) => {
+    const value = object(valueArg);
+    if (value.type !== 'lei2' || value.format !== 'csv' || value.cdf_version !== 'LEI_3.1' || value.delta_type !== kindArg)
+        bad('file type, format, CDF version or delta type');
+    if (!Number.isSafeInteger(value.record_count) || Number(value.record_count) < 0 || !Number.isSafeInteger(value.size) || Number(value.size) < 1)
+        bad('record count or size');
+    return { url: url(value.url), kind: kindArg, format: 'csv', cdfVersion: 'LEI_3.1', recordCount: value.record_count, size: value.size };
+};
+const checkFilters = (optionsArg) => {
+    if (optionsArg.country !== undefined && !/^[A-Z]{2}$/.test(optionsArg.country))
+        throw new GleifError('invalid_input', 'country must be an ISO alpha-2 code, e.g. DE.');
+    if (optionsArg.jurisdiction !== undefined && !/^[A-Z]{2}(?:-[A-Z0-9]{1,3})?$/.test(optionsArg.jurisdiction))
+        throw new GleifError('invalid_input', 'jurisdiction must be a country or subdivision code.');
+    if (optionsArg.maxRowChars !== undefined && (!Number.isSafeInteger(optionsArg.maxRowChars) || optionsArg.maxRowChars < 1))
+        throw new GleifError('invalid_input', 'maxRowChars must be a positive safe integer.');
+};
+const abortable = async (promiseArg, signalArg) => {
+    signalArg.throwIfAborted();
+    let abort;
+    const aborted = new Promise((_, rejectArg) => {
+        abort = () => rejectArg(signalArg.reason);
+        signalArg.addEventListener('abort', abort, { once: true });
+    });
+    try {
+        return await Promise.race([promiseArg, aborted]);
+    }
+    finally {
+        if (abort)
+            signalArg.removeEventListener('abort', abort);
+    }
+};
+/** Official Golden Copy ZIP/CSV streams and JSON:API lookup; no files, cache or retries. */
+export class GleifClient {
+    options;
+    goldenCopyBaseUrl;
+    restBaseUrl;
+    timeoutMs;
+    constructor(options = {}) {
+        this.options = options;
+        this.goldenCopyBaseUrl = url(options.goldenCopyBaseUrl ?? gleifGoldenCopyBaseUrl).replace(/\/$/, '');
+        this.restBaseUrl = url(options.restBaseUrl ?? gleifRestBaseUrl).replace(/\/$/, '');
+        this.timeoutMs = options.timeoutMs ?? 30 * 60 * 1000;
+        if (!Number.isSafeInteger(this.timeoutMs) || this.timeoutMs < 1 || this.timeoutMs > 2147483647)
+            throw new GleifError('invalid_input', 'timeoutMs must be a positive integer within the timer range.');
+    }
+    /** Discovers the current full file and all four delta windows from the official v2 API. */
+    async getLatestPublish(optionsArg = {}) {
+        const response = object(await this.getJson(`${this.goldenCopyBaseUrl}/golden-copies/publishes/latest`, optionsArg.signal));
+        const publish = object(response.data);
+        if (typeof publish.publish_date !== 'string' || !/^\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2}$/.test(publish.publish_date))
+            bad('date');
+        const level1 = object(publish.lei2);
+        const deltas = object(level1.delta_files);
+        const deltaFiles = Object.fromEntries(gleifDeltaKinds.map((kindArg) => [kindArg, descriptor(object(deltas[kindArg]).csv, kindArg)]));
+        return { publishDate: publish.publish_date, fullFile: descriptor(object(level1.full_file).csv, 'GoldenCopy'), deltaFiles };
+    }
+    /** Discovers once, then streams the selected full file or delta. */
+    async *streamRecords(optionsArg = {}) {
+        checkFilters(optionsArg);
+        const kind = optionsArg.kind ?? 'GoldenCopy';
+        if (kind !== 'GoldenCopy' && !gleifDeltaKinds.includes(kind))
+            throw new GleifError('invalid_input', 'Unknown Golden Copy file kind.');
+        const publish = await this.getLatestPublish(optionsArg);
+        yield* this.readGoldenCopy(kind === 'GoldenCopy' ? publish.fullFile : publish.deltaFiles[kind], optionsArg);
+    }
+    /** Streams a discovered descriptor. Breaking iteration cancels the response immediately. */
+    async *readGoldenCopy(fileArg, optionsArg = {}) {
+        checkFilters(optionsArg);
+        if (fileArg.format !== 'csv' || fileArg.cdfVersion !== 'LEI_3.1' || !['GoldenCopy', ...gleifDeltaKinds].includes(fileArg.kind) || !Number.isSafeInteger(fileArg.size) || fileArg.size < 1 || !Number.isSafeInteger(fileArg.recordCount) || fileArg.recordCount < 0) {
+            throw new GleifError('invalid_input', 'Expected a discovered LEI-CDF 3.1 ZIP/CSV descriptor.');
+        }
+        const uri = url(fileArg.url);
+        let compressedBytes = 0;
+        const response = this.requestBytes(uri, optionsArg.signal, 'application/zip');
+        async function* counted() {
+            for await (const chunk of response) {
+                compressedBytes += chunk.length;
+                yield chunk;
+            }
+        }
+        let mapper;
+        let records = 0;
+        for await (const row of parseCsvRows(unzipCsv(counted()), optionsArg.maxRowChars)) {
+            if (optionsArg.signal?.aborted)
+                throw new GleifError('aborted', 'GLEIF iteration was aborted.');
+            if (!mapper) {
+                mapper = csvRecordMapper(row);
+                continue;
+            }
+            const record = mapper(row);
+            records++;
+            if ((!optionsArg.country || record.legalAddress.country === optionsArg.country) && (!optionsArg.jurisdiction || record.jurisdiction === optionsArg.jurisdiction))
+                yield record;
+        }
+        if (!mapper)
+            throw new GleifError('invalid_csv', 'Golden Copy CSV has no header.');
+        if (compressedBytes !== fileArg.size || records !== fileArg.recordCount)
+            throw new GleifError('unexpected_answer', `Golden Copy totals differ from its descriptor: ${compressedBytes} bytes, ${records} records.`);
+    }
+    /** One LEI using the documented public JSON:API resource, mapped to the same record type. */
+    async lookup(leiArg, optionsArg = {}) {
+        if (!/^[A-Z0-9]{18}\d{2}$/.test(leiArg))
+            throw new GleifError('invalid_input', 'Expected a 20-character LEI.');
+        const record = parseGleifRestRecord(await this.getJson(`${this.restBaseUrl}/lei-records/${leiArg}`, optionsArg.signal));
+        if (record.lei !== leiArg)
+            throw new GleifError('unexpected_answer', 'GLEIF answered with a different LEI.');
+        return record;
+    }
+    async getJson(uriArg, signalArg) {
+        const decoder = new TextDecoder('utf-8', { fatal: true });
+        let text = '';
+        let bytes = 0;
+        try {
+            for await (const chunk of this.requestBytes(uriArg, signalArg, 'application/vnd.api+json, application/json')) {
+                bytes += chunk.length;
+                if (bytes > 2 * 1024 * 1024)
+                    throw new GleifError('record_limit', 'GLEIF metadata/lookup exceeds 2 MiB.');
+                text += decoder.decode(chunk, { stream: true });
+            }
+            return JSON.parse(text + decoder.decode());
+        }
+        catch (error) {
+            if (error instanceof GleifError)
+                throw error;
+            throw new GleifError('unexpected_answer', 'GLEIF did not answer with valid JSON.', undefined, { cause: error });
+        }
+    }
+    async *requestBytes(uriArg, signalArg, acceptArg) {
+        const controller = new AbortController();
+        const signal = signalArg ? AbortSignal.any([signalArg, controller.signal]) : controller.signal;
+        const timer = setTimeout(() => controller.abort(new Error('GLEIF request timed out.')), this.timeoutMs);
+        let reader;
+        let ended = false;
+        let failed = false;
+        try {
+            signal.throwIfAborted();
+            const headers = { Accept: acceptArg };
+            if (this.options.userAgent)
+                headers['User-Agent'] = this.options.userAgent;
+            const response = await abortable((this.options.fetch ?? globalThis.fetch)(uriArg, { headers, signal }), signal);
+            if (response.status !== 200) {
+                await response.body?.cancel();
+                throw new GleifError(response.status === 404 ? 'not_found' : 'http_error', `GLEIF answered HTTP ${response.status}.`, response.status);
+            }
+            if (!response.body)
+                throw new GleifError('unexpected_answer', 'GLEIF response has no body.');
+            reader = response.body.getReader();
+            while (true) {
+                const chunk = await abortable(reader.read(), signal);
+                if (chunk.done) {
+                    ended = true;
+                    break;
+                }
+                signal.throwIfAborted();
+                yield chunk.value;
+            }
+        }
+        catch (error) {
+            failed = true;
+            if (signal.aborted)
+                throw new GleifError(signalArg?.aborted ? 'aborted' : 'timeout', 'GLEIF request ended before completion.', undefined, { cause: error });
+            if (error instanceof GleifError)
+                throw error;
+            throw new GleifError('unreachable', 'Could not read the GLEIF response.', undefined, { cause: error });
+        }
+        finally {
+            clearTimeout(timer);
+            try {
+                if (reader) {
+                    try {
+                        if (!ended)
+                            await reader.cancel();
+                    }
+                    catch (error) {
+                        // An already failed/aborted reader rejects cancellation with its existing error.
+                        // Preserve the primary error; normal loop exit must still report cleanup failures.
+                        if (!failed && !signal.aborted)
+                            throw new GleifError('unreachable', 'Could not cancel the GLEIF response.', undefined, { cause: error });
+                    }
+                    finally {
+                        reader.releaseLock();
+                    }
+                }
+            }
+            finally {
+                controller.abort();
+            }
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"classes.gleifclient.js","sourceRoot":"","sources":["../../ts/gleif/classes.gleifclient.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,yBAAyB,CAAC;AACrD,OAAO,EAAE,YAAY,EAAE,MAAM,UAAU,CAAC;AACxC,OAAO,EAAE,eAAe,EAAE,oBAAoB,EAAE,MAAM,cAAc,CAAC;AACrE,OAAO,EAAE,QAAQ,EAAE,MAAM,iBAAiB,CAAC;AAG3C,MAAM,CAAC,MAAM,sBAAsB,GAAG,qCAAqC,CAAC;AAC5E,MAAM,CAAC,MAAM,gBAAgB,GAAG,8BAA8B,CAAC;AAC/D,MAAM,CAAC,MAAM,eAAe,GAA2B,CAAC,UAAU,EAAE,SAAS,EAAE,UAAU,EAAE,WAAW,CAAC,CAAC;AAExG,MAAM,GAAG,GAAG,CAAC,QAAgB,EAAS,EAAE,GAAG,MAAM,IAAI,UAAU,CAAC,mBAAmB,EAAE,6BAA6B,QAAQ,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC;AAClI,MAAM,MAAM,GAAG,CAAC,QAAiB,EAA2B,EAAE,CAC5D,QAAQ,IAAI,OAAO,QAAQ,KAAK,QAAQ,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC,QAAmC,CAAC,CAAC,CAAC,GAAG,CAAC,QAAQ,CAAC,CAAC;AAC7H,MAAM,GAAG,GAAG,CAAC,QAAiB,EAAU,EAAE;IACxC,IAAI,OAAO,QAAQ,KAAK,QAAQ;QAAE,MAAM,IAAI,UAAU,CAAC,eAAe,EAAE,0BAA0B,CAAC,CAAC;IACpG,IAAI,MAAW,CAAC;IAChB,IAAI,CAAC;QAAC,MAAM,GAAG,IAAI,GAAG,CAAC,QAAQ,CAAC,CAAC;IAAC,CAAC;IAAC,MAAM,CAAC;QAAC,MAAM,IAAI,UAAU,CAAC,eAAe,EAAE,0BAA0B,CAAC,CAAC;IAAC,CAAC;IAChH,IAAI,CAAC,CAAC,OAAO,EAAE,QAAQ,CAAC,CAAC,QAAQ,CAAC,MAAM,CAAC,QAAQ,CAAC,IAAI,MAAM,CAAC,QAAQ,IAAI,MAAM,CAAC,QAAQ;QAAE,MAAM,IAAI,UAAU,CAAC,eAAe,EAAE,8CAA8C,CAAC,CAAC;IAChL,OAAO,QAAQ,CAAC;AAClB,CAAC,CAAC;AACF,MAAM,UAAU,GAAG,CAAC,QAAiB,EAAE,OAAuB,EAAwB,EAAE;IACtF,MAAM,KAAK,GAAG,MAAM,CAAC,QAAQ,CAAC,CAAC;IAC/B,IAAI,KAAK,CAAC,IAAI,KAAK,MAAM,IAAI,KAAK,CAAC,MAAM,KAAK,KAAK,IAAI,KAAK,CAAC,WAAW,KAAK,SAAS,IAAI,KAAK,CAAC,UAAU,KAAK,OAAO;QAAE,GAAG,CAAC,8CAA8C,CAAC,CAAC;IAC5K,IAAI,CAAC,MAAM,CAAC,aAAa,CAAC,KAAK,CAAC,YAAY,CAAC,IAAI,MAAM,CAAC,KAAK,CAAC,YAAY,CAAC,GAAG,CAAC,IAAI,CAAC,MAAM,CAAC,aAAa,CAAC,KAAK,CAAC,IAAI,CAAC,IAAI,MAAM,CAAC,KAAK,CAAC,IAAI,CAAC,GAAG,CAAC;QAAE,GAAG,CAAC,sBAAsB,CAAC,CAAC;IAC5K,OAAO,EAAE,GAAG,EAAE,GAAG,CAAC,KAAK,CAAC,GAAG,CAAC,EAAE,IAAI,EAAE,OAAO,EAAE,MAAM,EAAE,KAAK,EAAE,UAAU,EAAE,SAAS,EAAE,WAAW,EAAE,KAAK,CAAC,YAAsB,EAAE,IAAI,EAAE,KAAK,CAAC,IAAc,EAAE,CAAC;AAC7J,CAAC,CAAC;AACF,MAAM,YAAY,GAAG,CAAC,UAA6B,EAAQ,EAAE;IAC3D,IAAI,UAAU,CAAC,OAAO,KAAK,SAAS,IAAI,CAAC,YAAY,CAAC,IAAI,CAAC,UAAU,CAAC,OAAO,CAAC;QAAE,MAAM,IAAI,UAAU,CAAC,eAAe,EAAE,+CAA+C,CAAC,CAAC;IACvK,IAAI,UAAU,CAAC,YAAY,KAAK,SAAS,IAAI,CAAC,+BAA+B,CAAC,IAAI,CAAC,UAAU,CAAC,YAAY,CAAC;QAAE,MAAM,IAAI,UAAU,CAAC,eAAe,EAAE,qDAAqD,CAAC,CAAC;IAC1M,IAAI,UAAU,CAAC,WAAW,KAAK,SAAS,IAAI,CAAC,CAAC,MAAM,CAAC,aAAa,CAAC,UAAU,CAAC,WAAW,CAAC,IAAI,UAAU,CAAC,WAAW,GAAG,CAAC,CAAC;QAAE,MAAM,IAAI,UAAU,CAAC,eAAe,EAAE,8CAA8C,CAAC,CAAC;AACnN,CAAC,CAAC;AAEF,MAAM,SAAS,GAAG,KAAK,EAAQ,UAAyB,EAAE,SAAsB,EAAiB,EAAE;IACjG,SAAS,CAAC,cAAc,EAAE,CAAC;IAC3B,IAAI,KAA+B,CAAC;IACpC,MAAM,OAAO,GAAG,IAAI,OAAO,CAAQ,CAAC,CAAC,EAAE,SAAS,EAAE,EAAE;QAClD,KAAK,GAAG,GAAG,EAAE,CAAC,SAAS,CAAC,SAAS,CAAC,MAAM,CAAC,CAAC;QAC1C,SAAS,CAAC,gBAAgB,CAAC,OAAO,EAAE,KAAK,EAAE,EAAE,IAAI,EAAE,IAAI,EAAE,CAAC,CAAC;IAC7D,CAAC,CAAC,CAAC;IACH,IAAI,CAAC;QAAC,OAAO,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC,UAAU,EAAE,OAAO,CAAC,CAAC,CAAC;IAAC,CAAC;YACjD,CAAC;QAAC,IAAI,KAAK;YAAE,SAAS,CAAC,mBAAmB,CAAC,OAAO,EAAE,KAAK,CAAC,CAAC;IAAC,CAAC;AACvE,CAAC,CAAC;AAEF,4FAA4F;AAC5F,MAAM,OAAO,WAAW;IAKO,OAAO;IAJnB,iBAAiB,CAAS;IAC1B,WAAW,CAAS;IACpB,SAAS,CAAS;IAEnC,YAA6B,OAAO,GAAwB,EAAE;uBAAjC,OAAO;QAClC,IAAI,CAAC,iBAAiB,GAAG,GAAG,CAAC,OAAO,CAAC,iBAAiB,IAAI,sBAAsB,CAAC,CAAC,OAAO,CAAC,KAAK,EAAE,EAAE,CAAC,CAAC;QACrG,IAAI,CAAC,WAAW,GAAG,GAAG,CAAC,OAAO,CAAC,WAAW,IAAI,gBAAgB,CAAC,CAAC,OAAO,CAAC,KAAK,EAAE,EAAE,CAAC,CAAC;QACnF,IAAI,CAAC,SAAS,GAAG,OAAO,CAAC,SAAS,IAAI,EAAE,GAAG,EAAE,GAAG,IAAI,CAAC;QACrD,IAAI,CAAC,MAAM,CAAC,aAAa,CAAC,IAAI,CAAC,SAAS,CAAC,IAAI,IAAI,CAAC,SAAS,GAAG,CAAC,IAAI,IAAI,CAAC,SAAS,GAAG,UAAU;YAAE,MAAM,IAAI,UAAU,CAAC,eAAe,EAAE,8DAA8D,CAAC,CAAC;IACxM,CAAC;IAED,2FAA2F;IACpF,KAAK,CAAC,gBAAgB,CAAC,UAAU,GAA6B,EAAE;QACrE,MAAM,QAAQ,GAAG,MAAM,CAAC,MAAM,IAAI,CAAC,OAAO,CAAC,GAAG,IAAI,CAAC,iBAAiB,iCAAiC,EAAE,UAAU,CAAC,MAAM,CAAC,CAAC,CAAC;QAC3H,MAAM,OAAO,GAAG,MAAM,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC;QACtC,IAAI,OAAO,OAAO,CAAC,YAAY,KAAK,QAAQ,IAAI,CAAC,uCAAuC,CAAC,IAAI,CAAC,OAAO,CAAC,YAAY,CAAC;YAAE,GAAG,CAAC,MAAM,CAAC,CAAC;QACjI,MAAM,MAAM,GAAG,MAAM,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC;QACpC,MAAM,MAAM,GAAG,MAAM,CAAC,MAAM,CAAC,WAAW,CAAC,CAAC;QAC1C,MAAM,UAAU,GAAG,MAAM,CAAC,WAAW,CAAC,eAAe,CAAC,GAAG,CAAC,CAAC,OAAO,EAAE,EAAE,CAAC,CAAC,OAAO,EAAE,UAAU,CAAC,MAAM,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC,CAAC,GAAG,EAAE,OAAO,CAAC,CAAC,CAAC,CAA8C,CAAC;QAClL,OAAO,EAAE,WAAW,EAAE,OAAO,CAAC,YAAsB,EAAE,QAAQ,EAAE,UAAU,CAAC,MAAM,CAAC,MAAM,CAAC,SAAS,CAAC,CAAC,GAAG,EAAE,YAAY,CAAC,EAAE,UAAU,EAAE,CAAC;IACvI,CAAC;IAED,oEAAoE;IAC7D,KAAK,CAAC,CAAC,aAAa,CAAC,UAAU,GAAwB,EAAE;QAC9D,YAAY,CAAC,UAAU,CAAC,CAAC;QACzB,MAAM,IAAI,GAAG,UAAU,CAAC,IAAI,IAAI,YAAY,CAAC;QAC7C,IAAI,IAAI,KAAK,YAAY,IAAI,CAAC,eAAe,CAAC,QAAQ,CAAC,IAAI,CAAC;YAAE,MAAM,IAAI,UAAU,CAAC,eAAe,EAAE,gCAAgC,CAAC,CAAC;QACtI,MAAM,OAAO,GAAG,MAAM,IAAI,CAAC,gBAAgB,CAAC,UAAU,CAAC,CAAC;QACxD,KAAK,CAAC,CAAC,IAAI,CAAC,cAAc,CAAC,IAAI,KAAK,YAAY,CAAC,CAAC,CAAC,OAAO,CAAC,QAAQ,CAAC,CAAC,CAAC,OAAO,CAAC,UAAU,CAAC,IAAI,CAAC,EAAE,UAAU,CAAC,CAAC;IAC9G,CAAC;IAED,4FAA4F;IACrF,KAAK,CAAC,CAAC,cAAc,CAAC,OAA6B,EAAE,UAAU,GAAsB,EAAE;QAC5F,YAAY,CAAC,UAAU,CAAC,CAAC;QACzB,IAAI,OAAO,CAAC,MAAM,KAAK,KAAK,IAAI,OAAO,CAAC,UAAU,KAAK,SAAS,IAAI,CAAC,CAAC,YAAY,EAAE,GAAG,eAAe,CAAC,CAAC,QAAQ,CAAC,OAAO,CAAC,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,aAAa,CAAC,OAAO,CAAC,IAAI,CAAC,IAAI,OAAO,CAAC,IAAI,GAAG,CAAC,IAAI,CAAC,MAAM,CAAC,aAAa,CAAC,OAAO,CAAC,WAAW,CAAC,IAAI,OAAO,CAAC,WAAW,GAAG,CAAC,EAAE,CAAC;YACnQ,MAAM,IAAI,UAAU,CAAC,eAAe,EAAE,uDAAuD,CAAC,CAAC;QACjG,CAAC;QACD,MAAM,GAAG,GAAG,GAAG,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC;QAC7B,IAAI,eAAe,GAAG,CAAC,CAAC;QACxB,MAAM,QAAQ,GAAG,IAAI,CAAC,YAAY,CAAC,GAAG,EAAE,UAAU,CAAC,MAAM,EAAE,iBAAiB,CAAC,CAAC;QAC9E,KAAK,SAAS,CAAC,CAAC,OAAO;YACrB,IAAI,KAAK,EAAE,MAAM,KAAK,IAAI,QAAQ,EAAE,CAAC;gBAAC,eAAe,IAAI,KAAK,CAAC,MAAM,CAAC;gBAAC,MAAM,KAAK,CAAC;YAAC,CAAC;QACvF,CAAC;QACD,IAAI,MAAwD,CAAC;QAC7D,IAAI,OAAO,GAAG,CAAC,CAAC;QAChB,IAAI,KAAK,EAAE,MAAM,GAAG,IAAI,YAAY,CAAC,QAAQ,CAAC,OAAO,EAAE,CAAC,EAAE,UAAU,CAAC,WAAW,CAAC,EAAE,CAAC;YAClF,IAAI,UAAU,CAAC,MAAM,EAAE,OAAO;gBAAE,MAAM,IAAI,UAAU,CAAC,SAAS,EAAE,8BAA8B,CAAC,CAAC;YAChG,IAAI,CAAC,MAAM,EAAE,CAAC;gBAAC,MAAM,GAAG,eAAe,CAAC,GAAG,CAAC,CAAC;gBAAC,SAAS;YAAC,CAAC;YACzD,MAAM,MAAM,GAAG,MAAM,CAAC,GAAG,CAAC,CAAC;YAC3B,OAAO,EAAE,CAAC;YACV,IAAI,CAAC,CAAC,UAAU,CAAC,OAAO,IAAI,MAAM,CAAC,YAAY,CAAC,OAAO,KAAK,UAAU,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC,UAAU,CAAC,YAAY,IAAI,MAAM,CAAC,YAAY,KAAK,UAAU,CAAC,YAAY,CAAC;gBAAE,MAAM,MAAM,CAAC;QACjL,CAAC;QACD,IAAI,CAAC,MAAM;YAAE,MAAM,IAAI,UAAU,CAAC,aAAa,EAAE,gCAAgC,CAAC,CAAC;QACnF,IAAI,eAAe,KAAK,OAAO,CAAC,IAAI,IAAI,OAAO,KAAK,OAAO,CAAC,WAAW;YAAE,MAAM,IAAI,UAAU,CAAC,mBAAmB,EAAE,kDAAkD,eAAe,WAAW,OAAO,WAAW,CAAC,CAAC;IACrN,CAAC;IAED,6FAA6F;IACtF,KAAK,CAAC,MAAM,CAAC,MAAc,EAAE,UAAU,GAA6B,EAAE;QAC3E,IAAI,CAAC,qBAAqB,CAAC,IAAI,CAAC,MAAM,CAAC;YAAE,MAAM,IAAI,UAAU,CAAC,eAAe,EAAE,8BAA8B,CAAC,CAAC;QAC/G,MAAM,MAAM,GAAG,oBAAoB,CAAC,MAAM,IAAI,CAAC,OAAO,CAAC,GAAG,IAAI,CAAC,WAAW,gBAAgB,MAAM,EAAE,EAAE,UAAU,CAAC,MAAM,CAAC,CAAC,CAAC;QACxH,IAAI,MAAM,CAAC,GAAG,KAAK,MAAM;YAAE,MAAM,IAAI,UAAU,CAAC,mBAAmB,EAAE,sCAAsC,CAAC,CAAC;QAC7G,OAAO,MAAM,CAAC;IAChB,CAAC;IAEO,KAAK,CAAC,OAAO,CAAC,MAAc,EAAE,SAAuB;QAC3D,MAAM,OAAO,GAAG,IAAI,WAAW,CAAC,OAAO,EAAE,EAAE,KAAK,EAAE,IAAI,EAAE,CAAC,CAAC;QAC1D,IAAI,IAAI,GAAG,EAAE,CAAC;QACd,IAAI,KAAK,GAAG,CAAC,CAAC;QACd,IAAI,CAAC;YACH,IAAI,KAAK,EAAE,MAAM,KAAK,IAAI,IAAI,CAAC,YAAY,CAAC,MAAM,EAAE,SAAS,EAAE,4CAA4C,CAAC,EAAE,CAAC;gBAC7G,KAAK,IAAI,KAAK,CAAC,MAAM,CAAC;gBACtB,IAAI,KAAK,GAAG,CAAC,GAAG,IAAI,GAAG,IAAI;oBAAE,MAAM,IAAI,UAAU,CAAC,cAAc,EAAE,sCAAsC,CAAC,CAAC;gBAC1G,IAAI,IAAI,OAAO,CAAC,MAAM,CAAC,KAAK,EAAE,EAAE,MAAM,EAAE,IAAI,EAAE,CAAC,CAAC;YAClD,CAAC;YACD,OAAO,IAAI,CAAC,KAAK,CAAC,IAAI,GAAG,OAAO,CAAC,MAAM,EAAE,CAAC,CAAC;QAC7C,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,IAAI,KAAK,YAAY,UAAU;gBAAE,MAAM,KAAK,CAAC;YAC7C,MAAM,IAAI,UAAU,CAAC,mBAAmB,EAAE,uCAAuC,EAAE,SAAS,EAAE,EAAE,KAAK,EAAE,KAAK,EAAE,CAAC,CAAC;QAClH,CAAC;IACH,CAAC;IAEO,KAAK,CAAC,CAAC,YAAY,CAAC,MAAc,EAAE,SAAkC,EAAE,SAAiB;QAC/F,MAAM,UAAU,GAAG,IAAI,eAAe,EAAE,CAAC;QACzC,MAAM,MAAM,GAAG,SAAS,CAAC,CAAC,CAAC,WAAW,CAAC,GAAG,CAAC,CAAC,SAAS,EAAE,UAAU,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,CAAC,UAAU,CAAC,MAAM,CAAC;QAC/F,MAAM,KAAK,GAAG,UAAU,CAAC,GAAG,EAAE,CAAC,UAAU,CAAC,KAAK,CAAC,IAAI,KAAK,CAAC,0BAA0B,CAAC,CAAC,EAAE,IAAI,CAAC,SAAS,CAAC,CAAC;QACxG,IAAI,MAA2D,CAAC;QAChE,IAAI,KAAK,GAAG,KAAK,CAAC;QAClB,IAAI,MAAM,GAAG,KAAK,CAAC;QACnB,IAAI,CAAC;YACH,MAAM,CAAC,cAAc,EAAE,CAAC;YACxB,MAAM,OAAO,GAA2B,EAAE,MAAM,EAAE,SAAS,EAAE,CAAC;YAC9D,IAAI,IAAI,CAAC,OAAO,CAAC,SAAS;gBAAE,OAAO,CAAC,YAAY,CAAC,GAAG,IAAI,CAAC,OAAO,CAAC,SAAS,CAAC;YAC3E,MAAM,QAAQ,GAAG,MAAM,SAAS,CAAC,CAAC,IAAI,CAAC,OAAO,CAAC,KAAK,IAAI,UAAU,CAAC,KAAK,CAAC,CAAC,MAAM,EAAE,EAAE,OAAO,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,CAAC,CAAC;YAChH,IAAI,QAAQ,CAAC,MAAM,KAAK,GAAG,EAAE,CAAC;gBAC5B,MAAM,QAAQ,CAAC,IAAI,EAAE,MAAM,EAAE,CAAC;gBAC9B,MAAM,IAAI,UAAU,CAAC,QAAQ,CAAC,MAAM,KAAK,GAAG,CAAC,CAAC,CAAC,WAAW,CAAC,CAAC,CAAC,YAAY,EAAE,uBAAuB,QAAQ,CAAC,MAAM,GAAG,EAAE,QAAQ,CAAC,MAAM,CAAC,CAAC;YACzI,CAAC;YACD,IAAI,CAAC,QAAQ,CAAC,IAAI;gBAAE,MAAM,IAAI,UAAU,CAAC,mBAAmB,EAAE,6BAA6B,CAAC,CAAC;YAC7F,MAAM,GAAG,QAAQ,CAAC,IAAI,CAAC,SAAS,EAAE,CAAC;YACnC,OAAO,IAAI,EAAE,CAAC;gBACZ,MAAM,KAAK,GAAG,MAAM,SAAS,CAAC,MAAM,CAAC,IAAI,EAAE,EAAE,MAAM,CAAC,CAAC;gBACrD,IAAI,KAAK,CAAC,IAAI,EAAE,CAAC;oBAAC,KAAK,GAAG,IAAI,CAAC;oBAAC,MAAM;gBAAC,CAAC;gBACxC,MAAM,CAAC,cAAc,EAAE,CAAC;gBACxB,MAAM,KAAK,CAAC,KAAK,CAAC;YACpB,CAAC;QACH,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,MAAM,GAAG,IAAI,CAAC;YACd,IAAI,MAAM,CAAC,OAAO;gBAAE,MAAM,IAAI,UAAU,CAAC,SAAS,EAAE,OAAO,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,SAAS,EAAE,wCAAwC,EAAE,SAAS,EAAE,EAAE,KAAK,EAAE,KAAK,EAAE,CAAC,CAAC;YAC5J,IAAI,KAAK,YAAY,UAAU;gBAAE,MAAM,KAAK,CAAC;YAC7C,MAAM,IAAI,UAAU,CAAC,aAAa,EAAE,oCAAoC,EAAE,SAAS,EAAE,EAAE,KAAK,EAAE,KAAK,EAAE,CAAC,CAAC;QACzG,CAAC;gBAAS,CAAC;YACT,YAAY,CAAC,KAAK,CAAC,CAAC;YACpB,IAAI,CAAC;gBACH,IAAI,MAAM,EAAE,CAAC;oBACX,IAAI,CAAC;wBAAC,IAAI,CAAC,KAAK;4BAAE,MAAM,MAAM,CAAC,MAAM,EAAE,CAAC;oBAAC,CAAC;oBAC1C,OAAO,KAAK,EAAE,CAAC;wBACb,iFAAiF;wBACjF,mFAAmF;wBACnF,IAAI,CAAC,MAAM,IAAI,CAAC,MAAM,CAAC,OAAO;4BAAE,MAAM,IAAI,UAAU,CAAC,aAAa,EAAE,sCAAsC,EAAE,SAAS,EAAE,EAAE,KAAK,EAAE,KAAK,EAAE,CAAC,CAAC;oBAC3I,CAAC;4BAAS,CAAC;wBAAC,MAAM,CAAC,WAAW,EAAE,CAAC;oBAAC,CAAC;gBACrC,CAAC;YACH,CAAC;oBAAS,CAAC;gBAAC,UAAU,CAAC,KAAK,EAAE,CAAC;YAAC,CAAC;QACnC,CAAC;IACH,CAAC;CACF"}

package/dist_ts/gleif/classes.gleiferror.d.ts

@@ -0,0 +1,6 @@
+export type TGleifErrorCode = 'invalid_input' | 'http_error' | 'not_found' | 'unreachable' | 'timeout' | 'aborted' | 'unexpected_answer' | 'invalid_archive' | 'invalid_csv' | 'record_limit';
+export declare class GleifError extends Error {
+    readonly code: TGleifErrorCode;
+    readonly httpStatus?: number | undefined;
+    constructor(code: TGleifErrorCode, messageArg: string, httpStatus?: number | undefined, optionsArg?: ErrorOptions);
+}

package/dist_ts/gleif/classes.gleiferror.js

@@ -0,0 +1,11 @@
+export class GleifError extends Error {
+    code;
+    httpStatus;
+    constructor(code, messageArg, httpStatus, optionsArg) {
+        super(messageArg, optionsArg);
+        this.code = code;
+        this.httpStatus = httpStatus;
+        this.name = 'GleifError';
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY2xhc3Nlcy5nbGVpZmVycm9yLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vdHMvZ2xlaWYvY2xhc3Nlcy5nbGVpZmVycm9yLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUVBLE1BQU0sT0FBTyxVQUFXLFNBQVEsS0FBSztJQUNQLElBQUk7SUFBdUQsVUFBVTtJQUFqRyxZQUE0QixJQUFxQixFQUFFLFVBQWtCLEVBQWtCLFVBQW1CLEVBQUUsVUFBeUI7UUFDbkksS0FBSyxDQUFDLFVBQVUsRUFBRSxVQUFVLENBQUMsQ0FBQztvQkFESixJQUFJOzBCQUF1RCxVQUFVO1FBRS9GLElBQUksQ0FBQyxJQUFJLEdBQUcsWUFBWSxDQUFDO0lBQzNCLENBQUM7Q0FDRiJ9

package/dist_ts/gleif/crosswalk.d.ts

@@ -0,0 +1,7 @@
+import type { IRegisterCourt, IRegisterReference } from '../handelsregister/interfaces.js';
+import type { IGleifRegisterNumber } from './interfaces.js';
+export declare const courtFromRegistrationAuthority: (raCodeArg: string) => IRegisterCourt | undefined;
+export declare const registrationAuthorityFromCourt: (courtCodeArg: string) => string | undefined;
+/** Anchored identifier only, with canonical type and location suffix; never guesses a register type. */
+export declare const parseRegistrationAuthorityEntityId: (entityIdArg: string) => IGleifRegisterNumber | undefined;
+export declare const registerReferenceFromRegistrationAuthority: (raCodeArg: string, entityIdArg: string) => IRegisterReference | undefined;

package/dist_ts/gleif/crosswalk.js

@@ -0,0 +1,25 @@
+import { registerCourts } from '../handelsregister/data.codelists.js';
+import { formatRegisterNumber, parseRegisterNumber, toRegisterType } from '../handelsregister/references.js';
+import { germanRegistrationAuthorities } from './data.crosswalk.js';
+export const courtFromRegistrationAuthority = (raCodeArg) => {
+    const courtCode = germanRegistrationAuthorities.find((authorityArg) => authorityArg.raCode === raCodeArg)?.courtCode;
+    return courtCode ? registerCourts.find((courtArg) => courtArg.code === courtCode) : undefined;
+};
+export const registrationAuthorityFromCourt = (courtCodeArg) => germanRegistrationAuthorities.find((authorityArg) => authorityArg.courtCode === courtCodeArg)?.raCode;
+/** Anchored identifier only, with canonical type and location suffix; never guesses a register type. */
+export const parseRegistrationAuthorityEntityId = (entityIdArg) => {
+    if (typeof entityIdArg !== 'string')
+        return undefined;
+    const match = /^(HRA|HRB|GnR|PR|VR|GsR)\s*\.?\s*(?:Nr\.?\s*)?(\d{1,9}(?:\s*[A-Za-zÄÖÜäöü]{1,5})?)$/i.exec(entityIdArg.trim());
+    if (!match)
+        return undefined;
+    const type = toRegisterType(match[1]);
+    const number = parseRegisterNumber(match[2]);
+    return type && number ? { type, number: formatRegisterNumber(number) } : undefined;
+};
+export const registerReferenceFromRegistrationAuthority = (raCodeArg, entityIdArg) => {
+    const court = courtFromRegistrationAuthority(raCodeArg);
+    const number = parseRegistrationAuthorityEntityId(entityIdArg);
+    return court && number ? { court, ...number } : undefined;
+};
+//# sourceMappingURL=data:application/json;base64,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

package/dist_ts/gleif/csv.d.ts

@@ -0,0 +1,2 @@
+/** Strict incremental CSV: quoted commas, doubled quotes, embedded CR/LF and split UTF-8. */
+export declare function parseCsvRows(sourceArg: AsyncIterable<Uint8Array>, maxRowCharsArg?: number): AsyncGenerator<string[]>;

package/dist_ts/gleif/csv.js

@@ -0,0 +1,75 @@
+import { GleifError } from './classes.gleiferror.js';
+/** Strict incremental CSV: quoted commas, doubled quotes, embedded CR/LF and split UTF-8. */
+export async function* parseCsvRows(sourceArg, maxRowCharsArg = 1024 * 1024) {
+    if (!Number.isSafeInteger(maxRowCharsArg) || maxRowCharsArg < 1) {
+        throw new GleifError('invalid_input', 'maxRowChars must be a positive safe integer.');
+    }
+    const decoder = new TextDecoder('utf-8', { fatal: true });
+    const parser = { state: 'start' };
+    let field = '';
+    let row = [];
+    let rowChars = 0;
+    let skipLf = false;
+    function* read(textArg) {
+        for (const character of textArg) {
+            if (skipLf) {
+                skipLf = false;
+                if (character === '\n')
+                    continue;
+            }
+            if (++rowChars > maxRowCharsArg)
+                throw new GleifError('record_limit', 'CSV row exceeds maxRowChars.');
+            if (parser.state === 'quoted') {
+                if (character === '"')
+                    parser.state = 'closed';
+                else
+                    field += character;
+                continue;
+            }
+            if (parser.state === 'closed' && character === '"') {
+                field += '"';
+                parser.state = 'quoted';
+            }
+            else if (character === ',') {
+                row.push(field);
+                field = '';
+                parser.state = 'start';
+            }
+            else if (character === '\n' || character === '\r') {
+                row.push(field);
+                // Empty physical lines are not records.
+                if (row.length !== 1 || row[0] !== '')
+                    yield row;
+                row = [];
+                field = '';
+                parser.state = 'start';
+                rowChars = 0;
+                skipLf = character === '\r';
+            }
+            else if (parser.state === 'start' && character === '"') {
+                parser.state = 'quoted';
+            }
+            else {
+                if (parser.state === 'closed' || character === '"')
+                    throw new GleifError('invalid_csv', 'Unexpected character outside a quoted CSV field.');
+                field += character;
+                parser.state = 'unquoted';
+            }
+        }
+    }
+    try {
+        for await (const chunk of sourceArg)
+            yield* read(decoder.decode(chunk, { stream: true }));
+        yield* read(decoder.decode());
+    }
+    catch (error) {
+        if (error instanceof TypeError)
+            throw new GleifError('invalid_csv', 'CSV is not valid UTF-8.', undefined, { cause: error });
+        throw error;
+    }
+    if (parser.state === 'quoted')
+        throw new GleifError('invalid_csv', 'Unterminated quoted CSV field.');
+    if (field !== '' || row.length || parser.state !== 'start')
+        yield [...row, field];
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist_ts/gleif/data.crosswalk.d.ts

@@ -0,0 +1,12 @@
+/** Generated by scripts/generate.gleif-crosswalk.ts; GLEIF RA list v1.9, 2026-09-30, CC0.
+ * Source: https://www.gleif.org/lei-data/code-lists/gleif-registration-authorities-list/2026-09-30_ra-list-v1.9.csv
+ * Every German RA and every opendata register court is accounted for. */
+import type { IGleifRegistrationAuthority, IGleifUnmappedCourt } from './interfaces.js';
+export declare const gleifRegistrationAuthoritiesSource: {
+    readonly version: "1.9";
+    readonly date: "2026-09-30";
+    readonly url: "https://www.gleif.org/lei-data/code-lists/gleif-registration-authorities-list/2026-09-30_ra-list-v1.9.csv";
+    readonly licence: "CC0-1.0";
+};
+export declare const germanRegistrationAuthorities: readonly IGleifRegistrationAuthority[];
+export declare const gleifUnmappedCourts: readonly IGleifUnmappedCourt[];