@fin.cx/opendata 3.6.0 → 4.0.0

package/.smartconfig.json

@@ -5,7 +5,7 @@
       "githost": "gitlab.com",
       "gitscope": "fin.cx",
       "gitrepo": "opendata",
-      "description": "A comprehensive TypeScript library that manages open business data for German companies by integrating MongoDB, processing JSONL bulk data, and automating browser interactions for Handelsregister data retrieval.",
+      "description": "Open business and financial data for TypeScript: register lookups on the German register portal (handelsregister.de) without storage, and stock and crypto prices and fundamentals from several providers.",
       "npmPackagename": "@fin.cx/opendata",
       "license": "MIT",
       "projectDomain": "fin.cx",
@@ -14,31 +14,31 @@
         "open data",
         "German companies",
         "business data",
-        "MongoDB",
-        "JSONL",
-        "bulk processing",
-        "data management",
-        "automation",
-        "browser automation",
         "Handelsregister",
-        "web scraping",
-        "file processing",
+        "register portal",
+        "commercial register",
+        "XJustiz",
         "business registry",
-        "data retrieval"
+        "data retrieval",
+        "stock prices",
+        "cryptocurrency",
+        "fundamentals"
       ]
     },
     "release": {
-      "registries": [
-        "https://verdaccio.lossless.digital",
-        "https://registry.npmjs.org"
-      ],
-      "accessLevel": "public"
-    }
+      "targets": {
+        "npm": {
+          "registries": [
+            "https://verdaccio.lossless.digital",
+            "https://registry.npmjs.org"
+          ],
+          "accessLevel": "public"
+        }
+      }
+    },
+    "schemaVersion": 2
   },
   "@git.zone/tsdoc": {
     "legal": "\n## License and Legal Information\n\nThis repository contains open-source code that is licensed under the MIT License. A copy of the MIT License can be found in the [license](license) file within this repository. \n\n**Please note:** The MIT License does not grant permission to use the trade names, trademarks, service marks, or product names of the project, except as required for reasonable and customary use in describing the origin of the work and reproducing the content of the NOTICE file.\n\n### Trademarks\n\nThis project is owned and maintained by Task Venture Capital GmbH. The names and logos associated with Task Venture Capital GmbH and any related products or services are trademarks of Task Venture Capital GmbH and are not included within the scope of the MIT license granted herein. Use of these trademarks must comply with Task Venture Capital GmbH's Trademark Guidelines, and any usage must be approved in writing by Task Venture Capital GmbH.\n\n### Company Information\n\nTask Venture Capital GmbH  \nRegistered at District court Bremen HRB 35230 HB, Germany\n\nFor any legal inquiries or if you require further information, please contact us via email at hello@task.vc.\n\nBy using this repository, you acknowledge that you have read this section, agree to comply with its terms, and understand that the licensing of the code does not imply endorsement by Task Venture Capital GmbH of any derivative works.\n"
-  },
-  "@ship.zone/szci": {
-    "npmGlobalTools": []
   }
-}
+}

package/dist_ts/00_commitinfo_data.js

@@ -3,7 +3,7 @@
  */
 export const commitinfo = {
     name: '@fin.cx/opendata',
-    version: '3.6.0',
-    description: 'A comprehensive TypeScript library for accessing business data and real-time financial information. Features include German company data management with MongoDB integration, JSONL bulk processing, automated Handelsregister interactions, and real-time stock market data from multiple providers.'
+    version: '4.0.0',
+    description: 'Open business and financial data for TypeScript: register lookups on the German register portal (handelsregister.de) without storage, and stock and crypto prices and fundamentals from several providers.'
 };
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiMDBfY29tbWl0aW5mb19kYXRhLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vdHMvMDBfY29tbWl0aW5mb19kYXRhLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOztHQUVHO0FBQ0gsTUFBTSxDQUFDLE1BQU0sVUFBVSxHQUFHO0lBQ3hCLElBQUksRUFBRSxrQkFBa0I7SUFDeEIsT0FBTyxFQUFFLE9BQU87SUFDaEIsV0FBVyxFQUFFLHVTQUF1UztDQUNyVCxDQUFBIn0=
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiMDBfY29tbWl0aW5mb19kYXRhLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vdHMvMDBfY29tbWl0aW5mb19kYXRhLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOztHQUVHO0FBQ0gsTUFBTSxDQUFDLE1BQU0sVUFBVSxHQUFHO0lBQ3hCLElBQUksRUFBRSxrQkFBa0I7SUFDeEIsT0FBTyxFQUFFLE9BQU87SUFDaEIsV0FBVyxFQUFFLDRNQUE0TTtDQUMxTixDQUFBIn0=

package/dist_ts/handelsregister/classes.handelsregisterclient.d.ts

@@ -0,0 +1,64 @@
+import type { IHandelsregisterClientOptions, IRegisterCallOptions, IRegisterEntry, IRegisterReferenceInput, IRegisterSearchResult, TRegisterSearchQuery } from './interfaces.js';
+/**
+ * Looks up entries of the German commercial, cooperative, partnership, association and civil-law
+ * partnership registers on the register portal of the federal states (handelsregister.de), over
+ * plain HTTP and without storage.
+ *
+ * Every call opens its own visit to the portal and forgets it afterwards: nothing is cached or
+ * shared between calls. The client never repeats a request by itself, never logs, and asks its
+ * gate before every request the portal's terms count:
+ * - `search()` makes one counted search;
+ * - `getEntry()` makes one counted search and, when the portal offers structured content for the
+ *   entry, one counted retrieval.
+ *
+ * Each search also loads the search form and the result list, two pages the terms do not count.
+ *
+ * The portal's terms allow single lookups for information only, at most 60 searches or
+ * retrievals per hour, and no systematic retrieval to build or update a copy of the registers.
+ */
+export declare class HandelsregisterClient {
+    private gate;
+    private portalUrl;
+    private userAgent;
+    private requestTimeoutMs;
+    private maxResponseBytes;
+    private now;
+    constructor(optionsArg: IHandelsregisterClientOptions);
+    /**
+     * Searches the registers by name or by register number. Returns every row the portal lists, in
+     * its order, and whether the portal cut the list at its maximum. One counted search.
+     *
+     * A number is searched by its digits: rows with any location suffix are returned.
+     */
+    search(queryArg: TRegisterSearchQuery, optionsArg?: IRegisterCallOptions): Promise<IRegisterSearchResult>;
+    /**
+     * Retrieves one register sheet: its row in the result list and, when the portal offers it, the
+     * parsed structured content (SI). Closed sheets are included, so a deleted entry is found with
+     * its status. One counted search, plus one counted retrieval when there is structured content.
+     *
+     * Fails with `not_found` when no sheet has the number at that court (with the entries whose
+     * location suffix differs in `matches`), and with `ambiguous` when a number without suffix fits
+     * several sheets. Never picks one of several.
+     */
+    getEntry(referenceArg: IRegisterReferenceInput, optionsArg?: IRegisterCallOptions): Promise<IRegisterEntry>;
+    private openSession;
+    private planSearch;
+    /**
+     * Asks the gate for one counted request. A refusal that is a `HandelsregisterError` reaches the
+     * caller with the step it guarded and the requests the call had counted before it; any other
+     * error of the gate reaches the caller unchanged.
+     */
+    private acquireSlot;
+    private runSearch;
+    private pickRow;
+    private retrieveStructuredContent;
+    /** the structured content must describe the sheet of the row it was retrieved for */
+    private checkContentBelongsToRow;
+    private htmlDocumentOf;
+    /** the register courts the search form offers */
+    private courtsOf;
+    /** refuses with the portal's words when the page is its notice of a blocked retrieval */
+    private throwIfBlocked;
+    /** the message the search form shows, when the portal answered with the form again */
+    private searchFormMessage;
+}

package/dist_ts/handelsregister/classes.handelsregisterclient.js

@@ -0,0 +1,397 @@
+import { HandelsregisterError } from './classes.handelsregistererror.js';
+import { PortalSession } from './classes.portalsession.js';
+import { defaultMaxResponseBytes, defaultPortalUrl, defaultRequestTimeoutMs, defaultUserAgent, registerTypes, structuredContentNotice, } from './constants.js';
+import { registerCourts } from './data.codelists.js';
+import * as forms from './forms.js';
+import * as html from './html.js';
+import { readResultList } from './parse.searchresults.js';
+import { parseStructuredContent } from './parse.structuredcontent.js';
+import { parseRegisterNumber } from './references.js';
+const searchFormPath = '/rp_web/erweitertesuche/welcome.xhtml';
+const searchFormId = 'form';
+const field = {
+    keywords: 'form:schlagwoerter',
+    keywordMode: 'form:schlagwortOptionen',
+    seat: 'form:NiederlassungSitz',
+    registerType: 'form:registerArt_input',
+    registerNumber: 'form:registerNummer',
+    court: 'form:registergericht_input',
+    pageSize: 'form:ergebnisseProSeite_input',
+    includeClosed: 'form:auchGeloeschte_input',
+    searchButton: 'form:btnSuche',
+};
+const searchFormMessagesId = 'form:messagesSuchMaske';
+/**
+ * The page the portal shows when it refuses a retrieval: for the TOR network and for addresses it
+ * has blocked (the portal's FAQ, question 6)
+ */
+const blockedRetrievalPattern = /Leider können wir den Dokumentenabruf[^.]*\./;
+const keywordModes = { all: '1', any: '2', exact: '3' };
+const maxKeywordLength = 500;
+const invalidQuery = (messageArg) => new HandelsregisterError('invalid_query', messageArg, { countedRequests: 0 });
+/** the error with the step and the counted requests of the call it ended */
+const inCall = (errorArg, progressArg) => new HandelsregisterError(errorArg.code, errorArg.message, {
+    status: errorArg.status,
+    retryAt: errorArg.retryAt,
+    step: errorArg.step ?? progressArg.step,
+    countedRequests: progressArg.countedRequests,
+    matches: errorArg.matches,
+    portalMessage: errorArg.portalMessage,
+    cause: errorArg.cause,
+});
+const checkType = (typeArg) => {
+    if (typeArg === undefined) {
+        return undefined;
+    }
+    const type = registerTypes.find((knownArg) => knownArg === typeArg);
+    if (!type) {
+        throw invalidQuery(`Unknown register type; use one of ${registerTypes.join(', ')}.`);
+    }
+    return type;
+};
+const checkCourt = (courtCodeArg) => {
+    if (courtCodeArg === undefined) {
+        return '';
+    }
+    if (!registerCourts.some((courtArg) => courtArg.code === courtCodeArg)) {
+        throw invalidQuery('Unknown register court code; see registerCourts.');
+    }
+    return courtCodeArg;
+};
+const checkNumber = (numberArg) => {
+    const parts = parseRegisterNumber(numberArg);
+    if (!parts) {
+        throw invalidQuery('A register number is digits, optionally followed by a location suffix such as HB.');
+    }
+    return parts;
+};
+const decodeUtf8 = (bytesArg) => new TextDecoder('utf-8').decode(bytesArg);
+/**
+ * Looks up entries of the German commercial, cooperative, partnership, association and civil-law
+ * partnership registers on the register portal of the federal states (handelsregister.de), over
+ * plain HTTP and without storage.
+ *
+ * Every call opens its own visit to the portal and forgets it afterwards: nothing is cached or
+ * shared between calls. The client never repeats a request by itself, never logs, and asks its
+ * gate before every request the portal's terms count:
+ * - `search()` makes one counted search;
+ * - `getEntry()` makes one counted search and, when the portal offers structured content for the
+ *   entry, one counted retrieval.
+ *
+ * Each search also loads the search form and the result list, two pages the terms do not count.
+ *
+ * The portal's terms allow single lookups for information only, at most 60 searches or
+ * retrievals per hour, and no systematic retrieval to build or update a copy of the registers.
+ */
+export class HandelsregisterClient {
+    gate;
+    portalUrl;
+    userAgent;
+    requestTimeoutMs;
+    maxResponseBytes;
+    now;
+    constructor(optionsArg) {
+        if (!optionsArg || !optionsArg.gate) {
+            throw new TypeError('HandelsregisterClient needs a gate; see SlidingWindowGate.');
+        }
+        this.gate = optionsArg.gate;
+        this.portalUrl = optionsArg.portalUrl ?? defaultPortalUrl;
+        this.userAgent = optionsArg.userAgent ?? defaultUserAgent;
+        this.requestTimeoutMs = optionsArg.requestTimeoutMs ?? defaultRequestTimeoutMs;
+        this.maxResponseBytes = optionsArg.maxResponseBytes ?? defaultMaxResponseBytes;
+        this.now = optionsArg.now ?? Date.now;
+        const protocol = new URL(this.portalUrl).protocol;
+        if (protocol !== 'https:' && protocol !== 'http:') {
+            throw new TypeError('portalUrl must be an http or https URL.');
+        }
+    }
+    /**
+     * Searches the registers by name or by register number. Returns every row the portal lists, in
+     * its order, and whether the portal cut the list at its maximum. One counted search.
+     *
+     * A number is searched by its digits: rows with any location suffix are returned.
+     */
+    async search(queryArg, optionsArg = {}) {
+        const plan = this.planSearch(queryArg);
+        const progress = { countedRequests: 0 };
+        const { list } = await this.runSearch(plan, progress, this.openSession(optionsArg, progress));
+        const result = {
+            matches: list.rows.map((rowArg) => rowArg.match),
+            truncated: list.truncated,
+            retrievedAt: this.now(),
+            countedRequests: progress.countedRequests,
+            notice: structuredContentNotice,
+        };
+        if (list.portalNotice) {
+            result.portalNotice = list.portalNotice;
+        }
+        return result;
+    }
+    /**
+     * Retrieves one register sheet: its row in the result list and, when the portal offers it, the
+     * parsed structured content (SI). Closed sheets are included, so a deleted entry is found with
+     * its status. One counted search, plus one counted retrieval when there is structured content.
+     *
+     * Fails with `not_found` when no sheet has the number at that court (with the entries whose
+     * location suffix differs in `matches`), and with `ambiguous` when a number without suffix fits
+     * several sheets. Never picks one of several.
+     */
+    async getEntry(referenceArg, optionsArg = {}) {
+        const type = checkType(referenceArg.type);
+        if (!type) {
+            throw invalidQuery('A reference needs a register type.');
+        }
+        const courtCode = checkCourt(referenceArg.courtCode);
+        if (!courtCode) {
+            throw invalidQuery('A reference needs a register court.');
+        }
+        const number = checkNumber(referenceArg.number);
+        const progress = { countedRequests: 0 };
+        const session = this.openSession(optionsArg, progress);
+        const outcome = await this.runSearch({ keywords: '', keywordMode: keywordModes.all, seat: '', registerType: type, digits: number.digits, courtCode, includeClosed: true }, progress, session);
+        const row = this.pickRow(outcome.list, { courtCode, type, number }, progress);
+        let structuredContent = null;
+        let retrievedAt = this.now();
+        if (row.match.documents.includes('SI')) {
+            structuredContent = await this.retrieveStructuredContent(row, outcome, session, progress);
+            retrievedAt = this.now();
+        }
+        return {
+            match: row.match,
+            structuredContent,
+            retrievedAt,
+            countedRequests: progress.countedRequests,
+            notice: structuredContentNotice,
+        };
+    }
+    openSession(optionsArg, progressArg) {
+        return new PortalSession({
+            portalUrl: this.portalUrl,
+            userAgent: this.userAgent,
+            requestTimeoutMs: this.requestTimeoutMs,
+            maxResponseBytes: this.maxResponseBytes,
+            signal: optionsArg.signal,
+        }, progressArg);
+    }
+    planSearch(queryArg) {
+        if ('name' in queryArg) {
+            const keywords = queryArg.name.replace(/\s+/g, ' ').trim();
+            if (!keywords) {
+                throw invalidQuery('A name search needs at least one keyword.');
+            }
+            if (keywords.length > maxKeywordLength) {
+                throw invalidQuery(`A name search takes at most ${maxKeywordLength} characters.`);
+            }
+            const mode = queryArg.match ?? 'all';
+            if (!(mode in keywordModes)) {
+                throw invalidQuery('match is all, any or exact.');
+            }
+            return {
+                keywords,
+                keywordMode: keywordModes[mode],
+                seat: (queryArg.seat ?? '').replace(/\s+/g, ' ').trim(),
+                registerType: checkType(queryArg.type) ?? '',
+                digits: '',
+                courtCode: checkCourt(queryArg.courtCode),
+                includeClosed: queryArg.includeClosed === true,
+            };
+        }
+        const type = checkType(queryArg.type);
+        if (!type) {
+            throw invalidQuery('A number search needs a register type.');
+        }
+        return {
+            keywords: '',
+            keywordMode: keywordModes.all,
+            seat: '',
+            registerType: type,
+            digits: checkNumber(queryArg.number).digits,
+            courtCode: checkCourt(queryArg.courtCode),
+            includeClosed: queryArg.includeClosed === true,
+        };
+    }
+    /**
+     * Asks the gate for one counted request. A refusal that is a `HandelsregisterError` reaches the
+     * caller with the step it guarded and the requests the call had counted before it; any other
+     * error of the gate reaches the caller unchanged.
+     */
+    async acquireSlot(kindArg, stepArg, progressArg) {
+        try {
+            await this.gate.acquire({ kind: kindArg });
+        }
+        catch (error) {
+            if (error instanceof HandelsregisterError) {
+                throw inCall(error, { step: stepArg, countedRequests: progressArg.countedRequests });
+            }
+            throw error;
+        }
+    }
+    async runSearch(planArg, progressArg, sessionArg) {
+        await this.acquireSlot('search', 'search', progressArg);
+        try {
+            progressArg.step = 'search_form';
+            const formPage = await sessionArg.get(sessionArg.resolve(searchFormPath));
+            const formDocument = this.htmlDocumentOf(formPage, 'The search form is not a web page.');
+            if (html.documentLanguage(formDocument) !== 'de') {
+                throw new HandelsregisterError('unexpected_response', 'The search form is not in German.');
+            }
+            const form = forms.readForm(formDocument, searchFormId);
+            if (!form) {
+                throw new HandelsregisterError('unexpected_response', 'The page holds no search form.');
+            }
+            const missing = Object.values(field).find((nameArg) => !form.controlNames.has(nameArg));
+            if (missing) {
+                throw new HandelsregisterError('unexpected_response', 'The search form lacks a field this version fills.');
+            }
+            const courts = this.courtsOf(form);
+            if (planArg.courtCode && !courts.some((courtArg) => courtArg.code === planArg.courtCode)) {
+                throw new HandelsregisterError('invalid_query', 'The portal does not offer this register court.');
+            }
+            if (planArg.registerType && !(form.options.get(field.registerType) ?? []).some((optionArg) => optionArg.value === planArg.registerType)) {
+                throw new HandelsregisterError('unexpected_response', 'The search form does not offer this register type.');
+            }
+            if (!(form.options.get(field.pageSize) ?? []).some((optionArg) => optionArg.value === '100')) {
+                throw new HandelsregisterError('unexpected_response', 'The search form does not offer 100 results per page.');
+            }
+            const fields = [...form.fields];
+            forms.setField(fields, field.keywords, planArg.keywords);
+            forms.setField(fields, field.keywordMode, planArg.keywordMode);
+            forms.setField(fields, field.seat, planArg.seat);
+            forms.setField(fields, field.registerType, planArg.registerType);
+            forms.setField(fields, field.registerNumber, planArg.digits);
+            forms.setField(fields, field.court, planArg.courtCode);
+            forms.setField(fields, field.pageSize, '100');
+            if (planArg.includeClosed) {
+                forms.setField(fields, field.includeClosed, 'on');
+            }
+            else {
+                forms.removeField(fields, field.includeClosed);
+            }
+            forms.setField(fields, field.searchButton, '');
+            progressArg.step = 'search';
+            progressArg.countedRequests += 1;
+            const resultPage = await sessionArg.post(sessionArg.resolve(form.action, formPage.url), fields);
+            progressArg.step = 'result_list';
+            const resultText = decodeUtf8(resultPage.body);
+            try {
+                return { list: readResultList(resultText, courts), pageUrl: resultPage.url };
+            }
+            catch (error) {
+                if (error instanceof HandelsregisterError && error.code === 'unexpected_response') {
+                    this.throwIfBlocked(resultText);
+                    const message = this.searchFormMessage(resultText);
+                    if (message) {
+                        throw new HandelsregisterError('unexpected_response', 'The portal answered the search with a message instead of a result list.', {
+                            portalMessage: message,
+                        });
+                    }
+                }
+                throw error;
+            }
+        }
+        catch (error) {
+            throw error instanceof HandelsregisterError ? inCall(error, progressArg) : error;
+        }
+    }
+    pickRow(listArg, referenceArg, progressArg) {
+        const sameNumber = listArg.rows.filter((rowArg) => {
+            const reference = rowArg.match.reference;
+            const number = parseRegisterNumber(reference.number);
+            return reference.court.code === referenceArg.courtCode && reference.type === referenceArg.type && number?.digits === referenceArg.number.digits;
+        });
+        const fitting = referenceArg.number.suffix
+            ? sameNumber.filter((rowArg) => parseRegisterNumber(rowArg.match.reference.number)?.suffix === referenceArg.number.suffix)
+            : sameNumber;
+        const matches = sameNumber.map((rowArg) => rowArg.match);
+        if (fitting.length === 0) {
+            throw new HandelsregisterError('not_found', 'No register sheet has this number at this court.', {
+                step: 'result_list',
+                countedRequests: progressArg.countedRequests,
+                matches,
+            });
+        }
+        if (fitting.length > 1) {
+            throw new HandelsregisterError('ambiguous', 'Several register sheets have this number at this court.', {
+                step: 'result_list',
+                countedRequests: progressArg.countedRequests,
+                matches,
+            });
+        }
+        return fitting[0];
+    }
+    async retrieveStructuredContent(rowArg, outcomeArg, sessionArg, progressArg) {
+        await this.acquireSlot('retrieval', 'structured_content', progressArg);
+        try {
+            progressArg.step = 'structured_content';
+            const resultForm = outcomeArg.list.form;
+            const submission = rowArg.documentSubmissions.get('SI');
+            if (!resultForm || !submission) {
+                throw new HandelsregisterError('unexpected_response', 'The result list offers structured content without a way to retrieve it.');
+            }
+            const fields = [...resultForm.fields];
+            for (const [name, value] of submission) {
+                forms.setField(fields, name, value);
+            }
+            progressArg.countedRequests += 1;
+            const answer = await sessionArg.post(sessionArg.resolve(resultForm.action, outcomeArg.pageUrl), fields);
+            if (/html/i.test(answer.contentType)) {
+                this.throwIfBlocked(decodeUtf8(answer.body));
+                throw new HandelsregisterError('unexpected_response', 'The portal answered with a page instead of the structured content.');
+            }
+            let xml;
+            try {
+                xml = new TextDecoder('utf-8', { fatal: true }).decode(answer.body);
+            }
+            catch (error) {
+                throw new HandelsregisterError('invalid_structured_content', 'The structured content is not valid UTF-8.', { cause: error });
+            }
+            const content = parseStructuredContent(xml);
+            this.checkContentBelongsToRow(content, rowArg.match);
+            return content;
+        }
+        catch (error) {
+            throw error instanceof HandelsregisterError ? inCall(error, progressArg) : error;
+        }
+    }
+    /** the structured content must describe the sheet of the row it was retrieved for */
+    checkContentBelongsToRow(contentArg, matchArg) {
+        const reference = matchArg.reference;
+        const contentNumber = contentArg.register.number ? parseRegisterNumber(contentArg.register.number) : undefined;
+        const rowNumber = parseRegisterNumber(reference.number);
+        if ((contentArg.register.courtCode !== undefined && contentArg.register.courtCode !== reference.court.code) ||
+            (contentArg.register.type !== undefined && contentArg.register.type !== reference.type) ||
+            (contentNumber !== undefined && contentNumber.digits !== rowNumber?.digits)) {
+            throw new HandelsregisterError('unexpected_response', 'The structured content belongs to another register sheet.');
+        }
+    }
+    htmlDocumentOf(pageArg, messageArg) {
+        if (!/html/i.test(pageArg.contentType)) {
+            throw new HandelsregisterError('unexpected_response', messageArg);
+        }
+        return html.parseHtml(decodeUtf8(pageArg.body));
+    }
+    /** the register courts the search form offers */
+    courtsOf(formArg) {
+        return (formArg.options.get(field.court) ?? [])
+            .filter((optionArg) => optionArg.value !== '')
+            .map((optionArg) => ({ code: optionArg.value, name: optionArg.label }));
+    }
+    /** refuses with the portal's words when the page is its notice of a blocked retrieval */
+    throwIfBlocked(htmlArg) {
+        const document = html.parseHtml(htmlArg);
+        const notice = blockedRetrievalPattern.exec(html.textOf(document));
+        if (notice) {
+            throw new HandelsregisterError('refused', 'The register portal refused the retrieval from this address.', {
+                portalMessage: notice[0],
+            });
+        }
+    }
+    /** the message the search form shows, when the portal answered with the form again */
+    searchFormMessage(htmlArg) {
+        const document = html.parseHtml(htmlArg);
+        const messages = html.findById(document, searchFormMessagesId);
+        const text = messages ? html.textOf(messages) : '';
+        return text ? text : undefined;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"classes.handelsregisterclient.js","sourceRoot":"","sources":["../../ts/handelsregister/classes.handelsregisterclient.ts"],"names":[],"mappings":"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"}

package/dist_ts/handelsregister/classes.handelsregistererror.d.ts

@@ -0,0 +1,56 @@
+import type { IRegisterMatch } from './interfaces.js';
+/**
+ * Why a call failed:
+ * - `invalid_query`: the query or reference cannot be sent as it is (nothing was sent);
+ * - `rate_limited`: `SlidingWindowGate` refused the request; `retryAt` says when the next is possible;
+ * - `aborted`: the caller's signal aborted the call;
+ * - `timeout`: a request to the portal took longer than the client's limit;
+ * - `unreachable`: the portal could not be reached (name resolution, connection, TLS);
+ * - `refused`: the portal answered with an HTTP error, for example 403 when it blocks an address,
+ *   429 or 503 when it is overloaded (`status` carries the code), or with its notice that it refuses
+ *   retrievals from this address (`portalMessage` carries its words);
+ * - `too_large`: an answer exceeded the client's size limit;
+ * - `unexpected_response`: an answer did not have the shape this version reads: the portal changed
+ *   its pages, answered in another language, or showed an error page;
+ * - `not_found`: no register sheet matches the reference;
+ * - `ambiguous`: several register sheets match the reference; `matches` lists them;
+ * - `invalid_structured_content`: the structured register content could not be read.
+ */
+export type THandelsregisterErrorCode = 'invalid_query' | 'rate_limited' | 'aborted' | 'timeout' | 'unreachable' | 'refused' | 'too_large' | 'unexpected_response' | 'not_found' | 'ambiguous' | 'invalid_structured_content';
+/** the step of a call that failed */
+export type THandelsregisterStep = 'search_form' | 'search' | 'result_list' | 'structured_content';
+export interface IHandelsregisterErrorDetails {
+    status?: number;
+    retryAt?: number;
+    step?: THandelsregisterStep;
+    countedRequests?: number;
+    matches?: IRegisterMatch[];
+    portalMessage?: string;
+    cause?: unknown;
+}
+/**
+ * The typed error of the register client. Its message names the failure and never contains
+ * register data, so it can be logged.
+ */
+export declare class HandelsregisterError extends Error {
+    readonly code: THandelsregisterErrorCode;
+    /** the HTTP status of a refusal */
+    readonly status?: number;
+    /** epoch ms of the next possible request (`rate_limited`) */
+    readonly retryAt?: number;
+    /** the step that failed */
+    readonly step?: THandelsregisterStep;
+    /**
+     * counted requests the call had sent before it failed. A request that was sent may have counted
+     * at the portal even when its answer did not arrive.
+     */
+    readonly countedRequests?: number;
+    /**
+     * the candidates of an `ambiguous` reference, and for `not_found` the entries with the same
+     * number whose location suffix differs
+     */
+    readonly matches?: IRegisterMatch[];
+    /** a message the portal showed instead of the expected page, German */
+    readonly portalMessage?: string;
+    constructor(codeArg: THandelsregisterErrorCode, messageArg: string, detailsArg?: IHandelsregisterErrorDetails);
+}