homematic-manager 3.0.0-beta.2 → 3.0.0-beta.21

package/node_modules/@homematic-manager/core/dist/meta/types.d.ts

@@ -0,0 +1,143 @@
+/**
+ * The openccu-lite metadata store: the document, its enums and the errors it answers with.
+ *
+ * This is *their* format, not ours. `docs/meta-format.md` and `docs/meta-api.md` in the
+ * openccu-lite repository are normative (their D-16), two implementations exist - `occulited` in Go
+ * and this one in TypeScript - and a conformance corpus decides whether they agree
+ * (`packages/core/test/fixtures/meta/`, a copy of that repository's `fixtures/`). Nothing here may
+ * be "improved" without changing the specification and the corpus first: a divergence that the
+ * corpus does not catch is exactly the failure D-16 exists to prevent.
+ *
+ * Why it lives in `core` and not in `backend`: it is a data model with no I/O in it - trees, paths,
+ * refs, validation, revisions - and the UI needs the same tree walking the backend does. The HTTP
+ * client that talks to a box, and the provider that decides whether there is a box at all, are in
+ * `packages/backend/src/meta/`.
+ */
+/** The format version this implementation reads and writes. A higher one is refused. */
+export declare const META_FORMAT = 1;
+/** Levels of nodes below an enum. Deeper is `too-deep`. */
+export declare const MAX_TREE_DEPTH = 8;
+/** Longest name of an object or a node, in bytes of UTF-8. */
+export declare const MAX_NAME_BYTES = 255;
+/** Longest enum id, node id and `meta` namespace, in characters. */
+export declare const MAX_ID_LENGTH = 32;
+/** Largest `meta` block per object, serialised. */
+export declare const MAX_META_BYTES: number;
+/**
+ * Every error code of the metadata API, as the specification lists them.
+ *
+ * They are the contract: the corpus names them, the HTTP layer maps them to status codes, and the
+ * UI shows a message per code. A new one is a specification change.
+ */
+export type MetaErrorCode = 'invalid-ref' | 'invalid-name' | 'invalid-id' | 'unknown-object' | 'unknown-enum' | 'unknown-path' | 'duplicate-id' | 'duplicate-path' | 'has-members' | 'invalid-move' | 'too-deep' | 'format-unsupported' | 'revision-conflict' | 'forbidden';
+/** A refusal from the store, carrying the code the specification names. */
+export declare class MetaError extends Error {
+    readonly code: MetaErrorCode;
+    /** Whatever the code carries with it - `refs` for `has-members`, a location for an import. */
+    readonly detail: Record<string, unknown> | undefined;
+    constructor(code: MetaErrorCode, message?: string, detail?: Record<string, unknown>);
+}
+/** True for the error class of this module; a type guard that survives a `catch`. */
+export declare function isMetaError(value: unknown): value is MetaError;
+/**
+ * One device or channel: `<interface>.<address>`.
+ *
+ * `enums` and `meta` are always present after normalisation, `orphaned` only when it is true - the
+ * shape `occulited` serialises, so that a document written here and one written there compare
+ * equal byte for byte after `JSON.stringify` with sorted keys.
+ */
+export interface MetaObject {
+    readonly name: string;
+    readonly enums: readonly string[];
+    readonly meta: Readonly<Record<string, unknown>>;
+    readonly orphaned?: boolean;
+}
+/** A node of an enum tree. `children` is absent, not empty, when there are none. */
+export interface MetaNode {
+    readonly id: string;
+    readonly name: string;
+    readonly icon?: string;
+    readonly children?: readonly MetaNode[];
+}
+/** A taxonomy: localised display names and an ordered tree. */
+export interface MetaEnum {
+    /** BCP-47 primary tags to display names; `en` is required. */
+    readonly name: Readonly<Record<string, string>>;
+    readonly tree: readonly MetaNode[];
+}
+/** The whole store, as it is on disk and as `/snapshot` serves it. */
+export interface MetaDocument {
+    readonly format: number;
+    readonly revision: number;
+    readonly objects: Readonly<Record<string, MetaObject>>;
+    readonly enums: Readonly<Record<string, MetaEnum>>;
+}
+/** What a `PATCH /objects/{ref}` body may say. Absent fields are left alone. */
+export interface MetaObjectPatch {
+    readonly name?: string;
+    readonly enums?: readonly string[];
+    /** Merged per namespace; `null` removes one. */
+    readonly meta?: Readonly<Record<string, unknown>>;
+    /**
+     * Never accepted from a client (`forbidden`): the flag belongs to the process that owns the
+     * addresses, and a frontend that sets it would be claiming a device is gone because it cannot
+     * see it right now.
+     */
+    readonly orphaned?: boolean;
+}
+/** What a `PUT /objects/{ref}` body says. Missing optional fields are reset to their defaults. */
+export interface MetaObjectBody {
+    readonly name: string;
+    readonly enums?: readonly string[];
+    readonly meta?: Readonly<Record<string, unknown>>;
+}
+/** What a `PATCH /enums/{enum}/nodes/{path}` body may say. */
+export interface MetaNodePatch {
+    readonly name?: string;
+    readonly icon?: string;
+    /** A move; `null` moves the node to the root of its enum. */
+    readonly parent?: string | null;
+    /** The index among the new siblings. */
+    readonly position?: number;
+}
+/** `replace` (the default) swaps the store; `merge` keeps what the import does not mention. */
+export type MetaImportMode = 'replace' | 'merge';
+/** The kinds of the change stream, as the specification lists them. */
+export type MetaEventKind = 'object.updated' | 'object.deleted' | 'enum.created' | 'enum.updated' | 'enum.deleted' | 'node.created' | 'node.updated' | 'node.deleted' | 'node.moved' | 'import' | 'resync';
+/**
+ * One event of the change stream.
+ *
+ * Every event carries the revision it produced, which is how a consumer notices a gap: a revision
+ * that jumped by more than one means events were missed, and the answer to that is `?since=` or a
+ * fresh snapshot. Fields beyond `kind` and `revision` depend on the kind, so they are all optional
+ * here rather than a union that every consumer would have to narrow before it can log it.
+ */
+export interface MetaEvent {
+    readonly revision: number;
+    readonly kind: MetaEventKind;
+    readonly ref?: string;
+    readonly value?: MetaObject | MetaEnum | MetaNode;
+    readonly enum?: string;
+    readonly path?: string;
+    readonly from?: string;
+    readonly to?: string;
+    readonly objects?: number;
+    readonly enums?: number;
+}
+/** What `GET /api/meta/v1/version` answers - the runtime detection of the porting kit. */
+export interface MetaVersion {
+    readonly api: string;
+    readonly version: number;
+    readonly format: number;
+    readonly revision: number;
+    readonly implementation?: string;
+}
+/**
+ * The two enums a fresh store carries, what a CCU has: rooms and functions. They are ordinary
+ * enums; a user may delete them or add more. A floor is a room with rooms below it, so there is no
+ * default for it (a store from before 2026-09-11 may still carry a `floor` enum; it is kept).
+ */
+export declare const DEFAULT_ENUMS: Readonly<Record<string, MetaEnum>>;
+/** An empty store: revision 0 and the two defaults, exactly as `occulited` creates one. */
+export declare function emptyDocument(): MetaDocument;
+//# sourceMappingURL=types.d.ts.map

package/node_modules/@homematic-manager/core/dist/meta/types.js

@@ -0,0 +1,63 @@
+/**
+ * The openccu-lite metadata store: the document, its enums and the errors it answers with.
+ *
+ * This is *their* format, not ours. `docs/meta-format.md` and `docs/meta-api.md` in the
+ * openccu-lite repository are normative (their D-16), two implementations exist - `occulited` in Go
+ * and this one in TypeScript - and a conformance corpus decides whether they agree
+ * (`packages/core/test/fixtures/meta/`, a copy of that repository's `fixtures/`). Nothing here may
+ * be "improved" without changing the specification and the corpus first: a divergence that the
+ * corpus does not catch is exactly the failure D-16 exists to prevent.
+ *
+ * Why it lives in `core` and not in `backend`: it is a data model with no I/O in it - trees, paths,
+ * refs, validation, revisions - and the UI needs the same tree walking the backend does. The HTTP
+ * client that talks to a box, and the provider that decides whether there is a box at all, are in
+ * `packages/backend/src/meta/`.
+ */
+/** The format version this implementation reads and writes. A higher one is refused. */
+export const META_FORMAT = 1;
+/** Levels of nodes below an enum. Deeper is `too-deep`. */
+export const MAX_TREE_DEPTH = 8;
+/** Longest name of an object or a node, in bytes of UTF-8. */
+export const MAX_NAME_BYTES = 255;
+/** Longest enum id, node id and `meta` namespace, in characters. */
+export const MAX_ID_LENGTH = 32;
+/** Largest `meta` block per object, serialised. */
+export const MAX_META_BYTES = 16 * 1024;
+/** A refusal from the store, carrying the code the specification names. */
+export class MetaError extends Error {
+    code;
+    /** Whatever the code carries with it - `refs` for `has-members`, a location for an import. */
+    detail;
+    constructor(code, message, detail) {
+        super(message ?? code);
+        this.name = 'MetaError';
+        this.code = code;
+        this.detail = detail;
+    }
+}
+/** True for the error class of this module; a type guard that survives a `catch`. */
+export function isMetaError(value) {
+    return value instanceof MetaError;
+}
+/**
+ * The two enums a fresh store carries, what a CCU has: rooms and functions. They are ordinary
+ * enums; a user may delete them or add more. A floor is a room with rooms below it, so there is no
+ * default for it (a store from before 2026-09-11 may still carry a `floor` enum; it is kept).
+ */
+export const DEFAULT_ENUMS = Object.freeze({
+    room: { name: { de: 'Räume', en: 'Rooms' }, tree: [] },
+    function: { name: { de: 'Gewerke', en: 'Functions' }, tree: [] },
+});
+/** An empty store: revision 0 and the two defaults, exactly as `occulited` creates one. */
+export function emptyDocument() {
+    return {
+        format: META_FORMAT,
+        revision: 0,
+        objects: {},
+        enums: {
+            room: { name: { ...DEFAULT_ENUMS['room']?.name }, tree: [] },
+            function: { name: { ...DEFAULT_ENUMS['function']?.name }, tree: [] },
+        },
+    };
+}
+//# sourceMappingURL=types.js.map

package/node_modules/@homematic-manager/core/dist/meta/view.d.ts

@@ -0,0 +1,50 @@
+/**
+ * Trees to the flat things a UI and a downstream consumer show.
+ *
+ * openccu-lite's rooms and functions are trees; everything that ever consumed ReGa's rooms and
+ * functions expects **arrays of names**, and the porting rule is explicit that they stay arrays of
+ * names (invariant 3 of their porting prompt: whatever an integration publishes keeps its fields).
+ * So this is the one place where a tree becomes a list, and it is a read: nothing here writes.
+ */
+import { type FlatNode } from './paths.js';
+import type { MetaDocument, MetaEnum, MetaObject } from './types.js';
+/** The display name of an enum in a language, with English and then the id behind it. */
+export declare function enumTitle(id: string, definition: MetaEnum | undefined, language: string): string;
+/** The node a path addresses, or `undefined` - the lookup a grid does per membership. */
+export declare function nodeAt(enums: Readonly<Record<string, MetaEnum>>, path: string): FlatNode | undefined;
+/** The name of the node a path addresses; the path itself when it does not resolve. */
+export declare function pathName(enums: Readonly<Record<string, MetaEnum>>, path: string): string;
+export interface EnumNamesOptions {
+    /**
+     * Also list the nodes above the ones the object is assigned to.
+     *
+     * A channel in `room/eg/wohnzimmer` *is* in `room/eg` - that is what the tree buys, and a
+     * consumer that filters "everything on the ground floor" wants to see it. A grid column wants
+     * the leaf alone, which is the default.
+     */
+    readonly ancestors?: boolean;
+    /** Only this enum; every enum when absent. */
+    readonly enumId?: string;
+}
+/**
+ * The names one object carries in one enum, in tree order and without repetition.
+ *
+ * Tree order and not assignment order: two channels in the same two rooms must produce the same
+ * two strings in the same sequence, or every consumer downstream sees a change that is not one.
+ */
+export declare function enumNames(enums: Readonly<Record<string, MetaEnum>>, paths: readonly string[], options?: EnumNamesOptions): string[];
+/** Every enum flattened once, for a select or a tree view. */
+export declare function flattenAll(enums: Readonly<Record<string, MetaEnum>>): Record<string, FlatNode[]>;
+/** What one object looks like to a consumer that thinks in ReGa's flat rooms and functions. */
+export interface MetaSummary {
+    readonly name: string;
+    readonly rooms: readonly string[];
+    readonly functions: readonly string[];
+    readonly paths: readonly string[];
+    readonly orphaned: boolean;
+}
+/** One object as names: what the grid, an MQTT payload and a node output all want. */
+export declare function summarise(enums: Readonly<Record<string, MetaEnum>>, object: MetaObject, options?: EnumNamesOptions): MetaSummary;
+/** Every object of a document as {@link MetaSummary}, keyed by ref. */
+export declare function summariseAll(document: MetaDocument, options?: EnumNamesOptions): Record<string, MetaSummary>;
+//# sourceMappingURL=view.d.ts.map

package/node_modules/@homematic-manager/core/dist/meta/view.js

@@ -0,0 +1,103 @@
+/**
+ * Trees to the flat things a UI and a downstream consumer show.
+ *
+ * openccu-lite's rooms and functions are trees; everything that ever consumed ReGa's rooms and
+ * functions expects **arrays of names**, and the porting rule is explicit that they stay arrays of
+ * names (invariant 3 of their porting prompt: whatever an integration publishes keeps its fields).
+ * So this is the one place where a tree becomes a list, and it is a read: nothing here writes.
+ */
+import { findNode, flattenEnum, parsePath } from './paths.js';
+/** The display name of an enum in a language, with English and then the id behind it. */
+export function enumTitle(id, definition, language) {
+    return definition?.name[language] ?? definition?.name['en'] ?? id;
+}
+/** The node a path addresses, or `undefined` - the lookup a grid does per membership. */
+export function nodeAt(enums, path) {
+    const parsed = parsePath(path);
+    if (!parsed || parsed.ids.length === 0) {
+        return undefined;
+    }
+    const definition = enums[parsed.enumId];
+    if (!definition) {
+        return undefined;
+    }
+    const node = findNode(definition.tree, parsed.ids);
+    if (!node) {
+        return undefined;
+    }
+    const trail = [];
+    for (let depth = 1; depth <= parsed.ids.length; depth += 1) {
+        const step = findNode(definition.tree, parsed.ids.slice(0, depth));
+        if (step) {
+            trail.push(step.name);
+        }
+    }
+    return { path, node, depth: parsed.ids.length, trail };
+}
+/** The name of the node a path addresses; the path itself when it does not resolve. */
+export function pathName(enums, path) {
+    return nodeAt(enums, path)?.node.name ?? path;
+}
+/**
+ * The names one object carries in one enum, in tree order and without repetition.
+ *
+ * Tree order and not assignment order: two channels in the same two rooms must produce the same
+ * two strings in the same sequence, or every consumer downstream sees a change that is not one.
+ */
+export function enumNames(enums, paths, options = {}) {
+    const wanted = new Set();
+    for (const path of paths) {
+        const parsed = parsePath(path);
+        if (!parsed || parsed.ids.length === 0) {
+            continue;
+        }
+        if (options.enumId !== undefined && parsed.enumId !== options.enumId) {
+            continue;
+        }
+        wanted.add(path);
+        if (options.ancestors === true) {
+            for (let depth = 1; depth < parsed.ids.length; depth += 1) {
+                wanted.add([parsed.enumId, ...parsed.ids.slice(0, depth)].join('/'));
+            }
+        }
+    }
+    const names = [];
+    for (const [id, definition] of Object.entries(enums)) {
+        if (options.enumId !== undefined && id !== options.enumId) {
+            continue;
+        }
+        for (const entry of flattenEnum(id, definition)) {
+            if (wanted.has(entry.path) && !names.includes(entry.node.name)) {
+                names.push(entry.node.name);
+            }
+        }
+    }
+    return names;
+}
+/** Every enum flattened once, for a select or a tree view. */
+export function flattenAll(enums) {
+    const flat = {};
+    for (const [id, definition] of Object.entries(enums)) {
+        flat[id] = flattenEnum(id, definition);
+    }
+    return flat;
+}
+/** One object as names: what the grid, an MQTT payload and a node output all want. */
+export function summarise(enums, object, options = {}) {
+    return {
+        name: object.name,
+        rooms: enumNames(enums, object.enums, { ...options, enumId: 'room' }),
+        functions: enumNames(enums, object.enums, { ...options, enumId: 'function' }),
+        paths: object.enums,
+        orphaned: object.orphaned === true,
+    };
+}
+/** Every object of a document as {@link MetaSummary}, keyed by ref. */
+export function summariseAll(document, options = {}) {
+    const summaries = {};
+    for (const [ref, object] of Object.entries(document.objects)) {
+        summaries[ref] = summarise(document.enums, object, options);
+    }
+    return summaries;
+}
+//# sourceMappingURL=view.js.map

package/node_modules/@homematic-manager/core/dist/rpc/methods.d.ts

@@ -39,6 +39,16 @@ export interface RpcMethod {
 export declare const RPC_METHODS: Readonly<Record<string, RpcMethod>>;
 /** The method names of the catalogue, in specification order. */
 export declare const RPC_METHOD_NAMES: readonly string[];
+/**
+ * Task 26 (openccu-lite 28.9): the methods of eQ-3's *Homematic IP Legacy API (XML-RPC) Addendum*
+ * that the 2.x file never had. They exist on the HmIP interface only, and they are never offered
+ * on their own: an interface has to list them in `system.listMethods` first (see {@link methodsFor}),
+ * so a BidCos console does not get calls that can only fail. What the addendum adds is the
+ * signature - without it the console drew no argument form for them at all.
+ */
+export declare const HMIP_ADDENDUM_METHODS: Readonly<Record<string, RpcMethod>>;
+/** The names of the addendum, for tests and for a UI that wants to know what is HmIP-only. */
+export declare const HMIP_ADDENDUM_METHOD_NAMES: readonly string[];
 /** The catalogue entry of a method, or `undefined` for one nobody documented. */
 export declare function rpcMethod(name: string): RpcMethod | undefined;
 /** An entry for a method the catalogue does not know: no arguments, no help, name only. */

package/node_modules/@homematic-manager/core/dist/rpc/methods.js

@@ -812,9 +812,59 @@ export const RPC_METHODS = {
 };
 /** The method names of the catalogue, in specification order. */
 export const RPC_METHOD_NAMES = Object.keys(RPC_METHODS);
+/**
+ * Task 26 (openccu-lite 28.9): the methods of eQ-3's *Homematic IP Legacy API (XML-RPC) Addendum*
+ * that the 2.x file never had. They exist on the HmIP interface only, and they are never offered
+ * on their own: an interface has to list them in `system.listMethods` first (see {@link methodsFor}),
+ * so a BidCos console does not get calls that can only fail. What the addendum adds is the
+ * signature - without it the console drew no argument form for them at all.
+ */
+export const HMIP_ADDENDUM_METHODS = {
+    suppressServiceMessages: {
+        name: 'suppressServiceMessages',
+        params: [
+            {
+                name: 'address',
+                type: 'channel_address',
+            },
+            {
+                name: 'parameter',
+                type: 'value_key',
+            },
+            {
+                name: 'suppress',
+                type: 'bool',
+            },
+        ],
+        returns: 'void',
+        help: {
+            de: 'Unterdrückt die Servicemeldung eines Parameters mit dem Service-Flag (nur HmIP). Der Parameter address ist die Kanaladresse, parameter der Name eines Parameters mit dem Service-Flag in seiner Beschreibung oder „“ für alle Service-Parameter des Kanals. Mit suppress=true meldet die Schnittstelle einen Wert, der keine Meldung auslöst (UNREACH wird immer false); suppress=false hebt die Unterdrückung wieder auf.',
+            en: 'Suppresses the service message of a parameter with the Service flag (HmIP only). The parameter address is the channel address, parameter the name of a parameter carrying the Service flag in its description, or "" for every service parameter of the channel. With suppress=true the interface reports a value that raises no message (UNREACH is always false); suppress=false lifts the suppression again.',
+        },
+    },
+    getSuppressedServiceMessages: {
+        name: 'getSuppressedServiceMessages',
+        params: [
+            {
+                name: 'address',
+                type: 'channel_address',
+            },
+        ],
+        returns: 'String[]',
+        help: {
+            de: 'Gibt die Namen der Parameter zurück, deren Servicemeldungen für den Kanal address zurzeit unterdrückt sind (nur HmIP, siehe suppressServiceMessages).',
+            en: 'Returns the names of the parameters whose service messages are currently suppressed for the channel address (HmIP only, see suppressServiceMessages).',
+        },
+    },
+};
+/** The names of the addendum, for tests and for a UI that wants to know what is HmIP-only. */
+export const HMIP_ADDENDUM_METHOD_NAMES = Object.keys(HMIP_ADDENDUM_METHODS);
 /** The catalogue entry of a method, or `undefined` for one nobody documented. */
 export function rpcMethod(name) {
-    return Object.prototype.hasOwnProperty.call(RPC_METHODS, name) ? RPC_METHODS[name] : undefined;
+    if (Object.prototype.hasOwnProperty.call(RPC_METHODS, name)) {
+        return RPC_METHODS[name];
+    }
+    return Object.prototype.hasOwnProperty.call(HMIP_ADDENDUM_METHODS, name) ? HMIP_ADDENDUM_METHODS[name] : undefined;
 }
 /** An entry for a method the catalogue does not know: no arguments, no help, name only. */
 export function unknownRpcMethod(name) {

package/node_modules/@homematic-manager/core/dist/rpc/text.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Free text from the interface processes that arrived with the wrong character set.
+ *
+ * Every XML-RPC client of the backend decodes answers as ISO-8859-1 (`INTERFACE_ENCODING`), which is
+ * what rfd and hmipserver send for units such as `°C`. A link's `NAME` and `DESCRIPTION` are the
+ * exception: rfd stores them as whatever bytes its writer sent and hands those bytes back, and both
+ * writers send UTF-8 - the CCU WebUI's default description "Standardverknüpfung" and every
+ * `setLinkInfo` of `homematic-xmlrpc`, which writes its requests as UTF-8. Read as ISO-8859-1, the
+ * two bytes of an "ü" become "ü" (B-23, #156).
+ */
+/**
+ * Undoes an ISO-8859-1 decode of UTF-8 bytes: "Standardverknüpfung" becomes "Standardverknüpfung".
+ *
+ * Only a string that *is* such a decode is changed. Every character has to fit into one byte (a
+ * string with "€" in it was not decoded as ISO-8859-1), at least one of them has to be above ASCII,
+ * and the bytes together have to be valid UTF-8. Real ISO-8859-1 text fails the last test on its
+ * own - "°C" is `B0 43` and "Küche" is `4B FC 63 68 65`, and neither `B0` nor `FC` can stand where
+ * they stand in UTF-8 - so it comes back untouched, and so does plain ASCII. The browser and Node
+ * both have `TextDecoder`, which is why this lives in the core and not next to `Buffer`.
+ */
+export declare function repairMisdecodedUtf8(value: string): string;
+//# sourceMappingURL=text.d.ts.map

package/node_modules/@homematic-manager/core/dist/rpc/text.js

@@ -0,0 +1,46 @@
+/**
+ * Free text from the interface processes that arrived with the wrong character set.
+ *
+ * Every XML-RPC client of the backend decodes answers as ISO-8859-1 (`INTERFACE_ENCODING`), which is
+ * what rfd and hmipserver send for units such as `°C`. A link's `NAME` and `DESCRIPTION` are the
+ * exception: rfd stores them as whatever bytes its writer sent and hands those bytes back, and both
+ * writers send UTF-8 - the CCU WebUI's default description "Standardverknüpfung" and every
+ * `setLinkInfo` of `homematic-xmlrpc`, which writes its requests as UTF-8. Read as ISO-8859-1, the
+ * two bytes of an "ü" become "ü" (B-23, #156).
+ */
+/** Strict: a byte sequence that is not UTF-8 throws instead of turning into U+FFFD. */
+const UTF8 = new TextDecoder('utf-8', { fatal: true });
+/**
+ * Undoes an ISO-8859-1 decode of UTF-8 bytes: "Standardverknüpfung" becomes "Standardverknüpfung".
+ *
+ * Only a string that *is* such a decode is changed. Every character has to fit into one byte (a
+ * string with "€" in it was not decoded as ISO-8859-1), at least one of them has to be above ASCII,
+ * and the bytes together have to be valid UTF-8. Real ISO-8859-1 text fails the last test on its
+ * own - "°C" is `B0 43` and "Küche" is `4B FC 63 68 65`, and neither `B0` nor `FC` can stand where
+ * they stand in UTF-8 - so it comes back untouched, and so does plain ASCII. The browser and Node
+ * both have `TextDecoder`, which is why this lives in the core and not next to `Buffer`.
+ */
+export function repairMisdecodedUtf8(value) {
+    const bytes = new Uint8Array(value.length);
+    let aboveAscii = false;
+    for (let index = 0; index < value.length; index += 1) {
+        const code = value.charCodeAt(index);
+        if (code > 0xff) {
+            return value;
+        }
+        if (code > 0x7f) {
+            aboveAscii = true;
+        }
+        bytes[index] = code;
+    }
+    if (!aboveAscii) {
+        return value;
+    }
+    try {
+        return UTF8.decode(bytes);
+    }
+    catch {
+        return value;
+    }
+}
+//# sourceMappingURL=text.js.map