@fin.cx/opendata 4.8.0 → 4.9.1

package/dist_ts/00_commitinfo_data.js

@@ -3,7 +3,7 @@
  */
 export const commitinfo = {
     name: '@fin.cx/opendata',
-    version: '4.8.0',
+    version: '4.9.1',
     description: 'Open business and financial data for TypeScript: register lookups on the German register portal (handelsregister.de) without storage, the statutory public holidays of the German federal states, the base rate of § 247 BGB, the German consumer price index with the arithmetic of index clauses, published financial statements read from their HTML, PDF or ESEF documents, and stock and crypto prices and fundamentals from several providers.'
 };
 //# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiMDBfY29tbWl0aW5mb19kYXRhLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vdHMvMDBfY29tbWl0aW5mb19kYXRhLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOztHQUVHO0FBQ0gsTUFBTSxDQUFDLE1BQU0sVUFBVSxHQUFHO0lBQ3hCLElBQUksRUFBRSxrQkFBa0I7SUFDeEIsT0FBTyxFQUFFLE9BQU87SUFDaEIsV0FBVyxFQUFFLHNiQUFzYjtDQUNwYyxDQUFBIn0=

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":"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"}

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[];