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

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

@@ -0,0 +1,260 @@
+/**
+ * Reading, validating and comparing a whole metadata document.
+ *
+ * A document arrives from three places - the box's `/snapshot`, a file this application wrote
+ * itself, and an import a user picked - and all three go through here. The rule of the format is
+ * that a document is validated **as a whole and rejected entirely** on the first error, because
+ * half an import is worse than none: the enums an object refers to have to exist, and that is not
+ * a property of any single entry.
+ *
+ * Every refusal is a {@link MetaError} with the code the specification names, so an import dialog
+ * can say "room/nowhere does not exist" rather than "invalid".
+ */
+import { byteLength, enumPaths, isValidIcon, isValidId, normaliseName, parsePath, requireDepth, requireRef, } from './paths.js';
+import { MAX_META_BYTES, META_FORMAT, MetaError, emptyDocument, } from './types.js';
+function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+/**
+ * One object, checked and brought into the shape the store keeps.
+ *
+ * `enums` and `meta` always exist afterwards; `orphaned` only when it is true, which is what
+ * `occulited` serialises and therefore what a byte comparison of two documents needs.
+ */
+export function normaliseObject(raw) {
+    if (!isRecord(raw)) {
+        throw new MetaError('invalid-name', 'an object has to be an object');
+    }
+    const name = normaliseName(raw['name']);
+    const enums = normaliseEnumList(raw['enums']);
+    const meta = normaliseMeta(raw['meta']);
+    const orphaned = raw['orphaned'] === true;
+    return orphaned ? { name, enums, meta, orphaned: true } : { name, enums, meta };
+}
+/** The `enums` array: strings that look like paths, without duplicates. Existence is checked later. */
+export function normaliseEnumList(raw) {
+    if (raw === undefined || raw === null) {
+        return [];
+    }
+    if (!Array.isArray(raw)) {
+        throw new MetaError('unknown-path', 'enums has to be an array of node paths');
+    }
+    const paths = [];
+    for (const entry of raw) {
+        if (typeof entry !== 'string' || parsePath(entry) === undefined) {
+            throw new MetaError('unknown-path', `${String(entry)} is not a node path`);
+        }
+        if (paths.includes(entry)) {
+            throw new MetaError('duplicate-path', `${entry} is listed twice`);
+        }
+        paths.push(entry);
+    }
+    return paths;
+}
+/**
+ * The `meta` block: one key per consumer namespace, any JSON below it.
+ *
+ * The store never interprets what is in there - that is the point of the namespace - so the only
+ * rules are the spelling of the key and the size of the whole block.
+ */
+export function normaliseMeta(raw) {
+    if (raw === undefined || raw === null) {
+        return {};
+    }
+    if (!isRecord(raw)) {
+        throw new MetaError('invalid-id', 'meta has to be an object of namespaces');
+    }
+    for (const namespace of Object.keys(raw)) {
+        if (!isValidId(namespace)) {
+            throw new MetaError('invalid-id', `${namespace} is not a valid meta namespace`);
+        }
+    }
+    if (byteLength(JSON.stringify(raw)) > MAX_META_BYTES) {
+        throw new MetaError('invalid-id', `meta may not be larger than ${String(MAX_META_BYTES)} bytes`);
+    }
+    return raw;
+}
+/** One node and its subtree, checked. Sibling ids are unique; depth is checked by the caller. */
+export function normaliseNode(raw) {
+    if (!isRecord(raw)) {
+        throw new MetaError('invalid-id', 'a node has to be an object');
+    }
+    const id = raw['id'];
+    if (typeof id !== 'string' || !isValidId(id)) {
+        throw new MetaError('invalid-id', `${String(id)} is not a valid node id`);
+    }
+    const name = normaliseName(raw['name']);
+    const icon = raw['icon'];
+    if (icon !== undefined && (typeof icon !== 'string' || !isValidIcon(icon))) {
+        // `JSON.stringify` and not `String()`: an icon that arrived as an object would otherwise be
+        // reported as "[object Object] is not a valid icon name", which is a message a user reads
+        throw new MetaError('invalid-id', `${JSON.stringify(icon)} is not a valid icon name`);
+    }
+    const children = normaliseNodes(raw['children']);
+    const node = {
+        id,
+        name,
+        ...(typeof icon === 'string' ? { icon } : {}),
+        ...(children.length > 0 ? { children } : {}),
+    };
+    return node;
+}
+/** A list of siblings: every one checked, no id twice. */
+export function normaliseNodes(raw) {
+    if (raw === undefined || raw === null) {
+        return [];
+    }
+    if (!Array.isArray(raw)) {
+        throw new MetaError('invalid-id', 'children has to be an array of nodes');
+    }
+    const nodes = raw.map((entry) => normaliseNode(entry));
+    const seen = new Set();
+    for (const node of nodes) {
+        if (seen.has(node.id)) {
+            throw new MetaError('duplicate-id', `${node.id} is used twice among its siblings`);
+        }
+        seen.add(node.id);
+    }
+    return nodes;
+}
+/** One enum: a localised name with at least `en`, and its tree. */
+export function normaliseEnum(id, raw) {
+    if (!isValidId(id)) {
+        throw new MetaError('invalid-id', `${id} is not a valid enum id`);
+    }
+    if (!isRecord(raw)) {
+        throw new MetaError('invalid-name', `enum ${id} has to be an object`);
+    }
+    const name = normaliseEnumName(raw['name']);
+    const tree = normaliseNodes(raw['tree']);
+    requireDepth(tree);
+    return { name, tree };
+}
+/**
+ * The localised name of an enum.
+ *
+ * `en` is required: it is the fallback every consumer falls back to, and an enum that has only a
+ * German name is unreadable in an English UI - the corpus refuses exactly that with `invalid-name`.
+ */
+export function normaliseEnumName(raw) {
+    if (!isRecord(raw)) {
+        throw new MetaError('invalid-name', 'an enum name has to be an object of languages');
+    }
+    const name = {};
+    for (const [language, value] of Object.entries(raw)) {
+        if (typeof value !== 'string') {
+            throw new MetaError('invalid-name', `the ${language} name has to be a string`);
+        }
+        name[language] = normaliseName(value);
+    }
+    if (name['en'] === undefined) {
+        throw new MetaError('invalid-name', 'an enum needs at least an English name');
+    }
+    return name;
+}
+/**
+ * A whole document, validated and normalised - the one entry point for anything untrusted.
+ *
+ * The order of the checks is the order of the specification's error codes: the format version
+ * first (a newer store is not something to guess at), then the enums, then the objects against the
+ * paths the enums define.
+ */
+export function parseDocument(raw) {
+    if (!isRecord(raw)) {
+        throw new MetaError('format-unsupported', 'a document has to be an object');
+    }
+    const format = raw['format'];
+    if (format !== META_FORMAT) {
+        throw new MetaError('format-unsupported', `format ${String(format)} is newer than this implementation reads (${String(META_FORMAT)})`);
+    }
+    const revision = raw['revision'];
+    if (typeof revision !== 'number' || !Number.isInteger(revision) || revision < 0) {
+        throw new MetaError('format-unsupported', 'revision has to be an integer of at least 0');
+    }
+    const enums = {};
+    const rawEnums = raw['enums'];
+    if (rawEnums !== undefined && rawEnums !== null) {
+        if (!isRecord(rawEnums)) {
+            throw new MetaError('unknown-enum', 'enums has to be an object');
+        }
+        for (const [id, definition] of Object.entries(rawEnums)) {
+            enums[id] = normaliseEnum(id, definition);
+        }
+    }
+    const known = knownPaths(enums);
+    const objects = {};
+    const rawObjects = raw['objects'];
+    if (rawObjects !== undefined && rawObjects !== null) {
+        if (!isRecord(rawObjects)) {
+            throw new MetaError('unknown-object', 'objects has to be an object');
+        }
+        for (const [ref, entry] of Object.entries(rawObjects)) {
+            requireRef(ref);
+            const object = normaliseObject(entry);
+            for (const path of object.enums) {
+                if (!known.has(path)) {
+                    throw new MetaError('unknown-path', `${ref}: ${path} does not exist`, { ref, path });
+                }
+            }
+            objects[ref] = object;
+        }
+    }
+    return { format: META_FORMAT, revision, objects, enums };
+}
+/** Every node path of every enum - what an object's `enums` entries are checked against. */
+export function knownPaths(enums) {
+    const known = new Set();
+    for (const [id, definition] of Object.entries(enums)) {
+        for (const path of enumPaths(id, definition)) {
+            known.add(path);
+        }
+    }
+    return known;
+}
+/**
+ * A document as JSON with its keys sorted, which is how two of them are compared.
+ *
+ * The format says key order is not significant and that a writer should sort for stable diffs, so
+ * sorting is both the comparison and the file this application writes. It is also the answer to
+ * "did this import change anything": an import whose result equals the document is not a revision.
+ */
+export function documentJson(document, space) {
+    return JSON.stringify(sortKeys(document), undefined, space);
+}
+/** Do two documents hold the same data? `revision` is not part of the answer. */
+export function documentEquals(a, b) {
+    return documentJson({ ...a, revision: 0 }) === documentJson({ ...b, revision: 0 });
+}
+function sortKeys(value) {
+    if (Array.isArray(value)) {
+        return value.map((entry) => sortKeys(entry));
+    }
+    if (isRecord(value)) {
+        const sorted = {};
+        for (const key of Object.keys(value).sort()) {
+            sorted[key] = sortKeys(value[key]);
+        }
+        return sorted;
+    }
+    return value;
+}
+/**
+ * A document out of anything, never throwing: a broken file becomes an empty store.
+ *
+ * The format says a reader that finds the document unparsable falls back to the `.bak` and reports
+ * that it did, never starts empty silently - so the caller gets the error and decides. This is the
+ * "and then what" for a caller that has already tried both files.
+ */
+export function parseDocumentOrEmpty(raw, onError) {
+    try {
+        return parseDocument(raw);
+    }
+    catch (error) {
+        if (error instanceof MetaError) {
+            onError?.(error);
+            return emptyDocument();
+        }
+        throw error;
+    }
+}
+//# sourceMappingURL=document.js.map

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

@@ -0,0 +1,27 @@
+/**
+ * Following somebody else's store: one event of the change stream applied to a document.
+ *
+ * This is the other half of the metadata API. A consumer fetches `/snapshot` once and then keeps up
+ * from `/events/sse`; re-fetching the snapshot on every rename would work and would be wrong on a
+ * box with four hundred channels and a user dragging rooms around.
+ *
+ * The rule that makes it safe is the revision. Every event carries the one it produced, and a
+ * document only ever moves **forward by exactly one**: an event that skips a revision means one was
+ * missed, and the only honest answer to that is `'resync'` - fetch the snapshot again. Guessing
+ * would leave a consumer subtly out of step with the box, which is the failure nobody notices until
+ * a name is wrong in one application and right in the other.
+ */
+import type { MetaDocument, MetaEvent } from './types.js';
+/** What {@link applyEvent} answers: the next document, or "fetch the snapshot again". */
+export type FollowResult = MetaDocument | 'resync';
+/**
+ * One event applied.
+ *
+ * `'resync'` for an `import` (the whole store was replaced), an explicit `resync`, a revision that
+ * is not the next one, and any event this implementation cannot make sense of - a store that is
+ * unsure is a store that re-reads, never one that carries on.
+ */
+export declare function applyEvent(document: MetaDocument, event: MetaEvent): FollowResult;
+/** Every event of a replay, stopping at the first one that needs a snapshot. */
+export declare function applyEvents(document: MetaDocument, events: readonly MetaEvent[]): FollowResult;
+//# sourceMappingURL=follow.d.ts.map

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

@@ -0,0 +1,180 @@
+/**
+ * Following somebody else's store: one event of the change stream applied to a document.
+ *
+ * This is the other half of the metadata API. A consumer fetches `/snapshot` once and then keeps up
+ * from `/events/sse`; re-fetching the snapshot on every rename would work and would be wrong on a
+ * box with four hundred channels and a user dragging rooms around.
+ *
+ * The rule that makes it safe is the revision. Every event carries the one it produced, and a
+ * document only ever moves **forward by exactly one**: an event that skips a revision means one was
+ * missed, and the only honest answer to that is `'resync'` - fetch the snapshot again. Guessing
+ * would leave a consumer subtly out of step with the box, which is the failure nobody notices until
+ * a name is wrong in one application and right in the other.
+ */
+import { findNode, parsePath, pathMatches } from './paths.js';
+import { insertAt, removeAt } from './tree.js';
+/**
+ * One event applied.
+ *
+ * `'resync'` for an `import` (the whole store was replaced), an explicit `resync`, a revision that
+ * is not the next one, and any event this implementation cannot make sense of - a store that is
+ * unsure is a store that re-reads, never one that carries on.
+ */
+export function applyEvent(document, event) {
+    if (event.kind === 'resync' || event.kind === 'import') {
+        return 'resync';
+    }
+    if (event.revision <= document.revision) {
+        // an event we have already seen - a replay after a reconnect. Nothing to do, and certainly
+        // not a resync: `?since=` is allowed to hand us the same event twice.
+        return document;
+    }
+    if (event.revision !== document.revision + 1) {
+        return 'resync';
+    }
+    const next = applyChange(document, event);
+    return next === undefined ? 'resync' : { ...next, revision: event.revision };
+}
+/** Every event of a replay, stopping at the first one that needs a snapshot. */
+export function applyEvents(document, events) {
+    let current = document;
+    for (const event of events) {
+        const next = applyEvent(current, event);
+        if (next === 'resync') {
+            return 'resync';
+        }
+        current = next;
+    }
+    return current;
+}
+function applyChange(document, event) {
+    switch (event.kind) {
+        case 'object.updated': {
+            if (event.ref === undefined || event.value === undefined) {
+                return undefined;
+            }
+            return { ...document, objects: { ...document.objects, [event.ref]: event.value } };
+        }
+        case 'object.deleted': {
+            if (event.ref === undefined) {
+                return undefined;
+            }
+            const objects = { ...document.objects };
+            // eslint-disable-next-line @typescript-eslint/no-dynamic-delete -- the key is a ref
+            delete objects[event.ref];
+            return { ...document, objects };
+        }
+        case 'enum.created':
+        case 'enum.updated': {
+            if (event.enum === undefined || event.value === undefined) {
+                return undefined;
+            }
+            return { ...document, enums: { ...document.enums, [event.enum]: event.value } };
+        }
+        case 'enum.deleted': {
+            if (event.enum === undefined) {
+                return undefined;
+            }
+            const enums = { ...document.enums };
+            // eslint-disable-next-line @typescript-eslint/no-dynamic-delete -- the key is an enum id
+            delete enums[event.enum];
+            return detach({ ...document, enums }, [event.enum]);
+        }
+        case 'node.created': {
+            const target = parsePath(event.path ?? '');
+            const definition = document.enums[target?.enumId ?? ''];
+            if (!target || !definition || event.value === undefined) {
+                return undefined;
+            }
+            const parentIds = target.ids.slice(0, -1);
+            if (parentIds.length > 0 && !findNode(definition.tree, parentIds)) {
+                // the parent is not in our copy of the tree, so this consumer is already out of
+                // step; inserting nowhere would leave it there silently
+                return undefined;
+            }
+            const tree = insertAt(definition.tree, parentIds, event.value);
+            return withEnum(document, target.enumId, { name: definition.name, tree });
+        }
+        case 'node.updated': {
+            const target = parsePath(event.path ?? '');
+            const definition = document.enums[target?.enumId ?? ''];
+            if (!target || !definition || event.value === undefined) {
+                return undefined;
+            }
+            const current = findNode(definition.tree, target.ids);
+            if (!current) {
+                // an update of a node we do not have: same story, and `'resync'` is the only honest
+                // answer to it
+                return undefined;
+            }
+            const updated = event.value;
+            // the event carries the node without its subtree; keeping the children we have is what
+            // makes a rename a rename and not a delete of everything below it
+            const node = {
+                ...updated,
+                ...(current.children === undefined ? {} : { children: current.children }),
+            };
+            const parentIds = target.ids.slice(0, -1);
+            const position = indexOf(definition.tree, target.ids);
+            const tree = insertAt(removeAt(definition.tree, target.ids), parentIds, node, position);
+            return withEnum(document, target.enumId, { name: definition.name, tree });
+        }
+        case 'node.deleted': {
+            const target = parsePath(event.path ?? '');
+            const definition = document.enums[target?.enumId ?? ''];
+            if (!target || !definition) {
+                return undefined;
+            }
+            if (!findNode(definition.tree, target.ids)) {
+                return undefined;
+            }
+            const tree = removeAt(definition.tree, target.ids);
+            return detach(withEnum(document, target.enumId, { name: definition.name, tree }), [event.path ?? '']);
+        }
+        case 'node.moved': {
+            const from = parsePath(event.from ?? '');
+            const to = parsePath(event.to ?? '');
+            const definition = document.enums[from?.enumId ?? ''];
+            if (!from || !to || !definition || from.enumId !== to.enumId) {
+                return undefined;
+            }
+            const node = findNode(definition.tree, from.ids);
+            if (!node) {
+                return undefined;
+            }
+            const tree = insertAt(removeAt(definition.tree, from.ids), to.ids.slice(0, -1), node);
+            return rewrite(withEnum(document, from.enumId, { name: definition.name, tree }), event.from ?? '', event.to ?? '');
+        }
+        default:
+            return undefined;
+    }
+}
+function indexOf(tree, ids) {
+    const parentIds = ids.slice(0, -1);
+    const id = ids[ids.length - 1];
+    const siblings = parentIds.length === 0 ? tree : (findNode(tree, parentIds)?.children ?? []);
+    const index = siblings.findIndex((node) => node.id === id);
+    return index === -1 ? undefined : index;
+}
+function withEnum(document, id, definition) {
+    return { ...document, enums: { ...document.enums, [id]: definition } };
+}
+/** Member paths of a subtree that is gone; the box removed them in the same revision. */
+function detach(document, targets) {
+    const objects = {};
+    for (const [ref, object] of Object.entries(document.objects)) {
+        const enums = object.enums.filter((path) => !targets.some((target) => pathMatches(path, target)));
+        objects[ref] = enums.length === object.enums.length ? object : { ...object, enums };
+    }
+    return { ...document, objects };
+}
+/** Member paths of a subtree that moved; likewise part of the move's own revision. */
+function rewrite(document, from, to) {
+    const objects = {};
+    for (const [ref, object] of Object.entries(document.objects)) {
+        const enums = object.enums.map((path) => (pathMatches(path, from) ? `${to}${path.slice(from.length)}` : path));
+        objects[ref] = { ...object, enums };
+    }
+    return { ...document, objects };
+}
+//# sourceMappingURL=follow.js.map

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

@@ -0,0 +1,16 @@
+/**
+ * The metadata model of openccu-lite (their D-16), in one place.
+ *
+ * `types` is the format, `paths` its small rules, `document` the validator, `store` every operation
+ * of the API with its revisions, and `view` the way from a tree to the arrays of names every
+ * consumer downstream has always been given.
+ */
+export * from './types.js';
+export * from './paths.js';
+export * from './document.js';
+export * from './store.js';
+export * from './view.js';
+export * from './tree.js';
+export * from './slug.js';
+export * from './follow.js';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1,16 @@
+/**
+ * The metadata model of openccu-lite (their D-16), in one place.
+ *
+ * `types` is the format, `paths` its small rules, `document` the validator, `store` every operation
+ * of the API with its revisions, and `view` the way from a tree to the arrays of names every
+ * consumer downstream has always been given.
+ */
+export * from './types.js';
+export * from './paths.js';
+export * from './document.js';
+export * from './store.js';
+export * from './view.js';
+export * from './tree.js';
+export * from './slug.js';
+export * from './follow.js';
+//# sourceMappingURL=index.js.map

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

@@ -0,0 +1,96 @@
+/**
+ * Refs, ids, names and node paths of the metadata store - the small rules the whole format rests on.
+ *
+ * They are separate from `store.ts` because both the store and the UI need them: the grid has to
+ * turn `room/eg/wohnzimmer` into "Wohnzimmer", and a dialog has to know that a node id may not
+ * contain a slash before it lets somebody type one.
+ */
+import { type MetaEnum, type MetaNode } from './types.js';
+/** A ref split into its two halves. */
+export interface MetaRef {
+    readonly interfaceName: string;
+    readonly address: string;
+}
+/**
+ * `<interface>.<address>` split at the **first** dot, or `undefined`.
+ *
+ * The interface name never contains a dot; the address may (it does not today, but the rule is the
+ * separator, not the shape of what follows it). `BidCos-RF.JEQ0230153:1` is a channel,
+ * `BidCos-RF.JEQ0230153` the device it belongs to.
+ */
+export declare function parseRef(ref: string): MetaRef | undefined;
+/** The ref of an address on an interface. The inverse of {@link parseRef}. */
+export declare function makeRef(interfaceName: string, address: string): string;
+/** Is this a ref the store accepts? */
+export declare function isValidRef(ref: string): boolean;
+/** Throws `invalid-ref` when it is not. */
+export declare function requireRef(ref: string): MetaRef;
+/** Enum id, node id or `meta` namespace: `[a-z0-9][a-z0-9-]*`, at most 32 characters. */
+export declare function isValidId(id: string): boolean;
+/** Throws `invalid-id` when it is not. */
+export declare function requireId(id: string): string;
+/** Icons are optional and lax; an unknown name is ignored by the UI, not an error. */
+export declare function isValidIcon(icon: string): boolean;
+/**
+ * The name as it will be stored: trimmed.
+ *
+ * Empty after trimming, longer than 255 bytes or carrying a line break is `invalid-name`. The trim
+ * is why `"  Heizung Bad  "` written over `"Heizung Bad"` is not a change and does not bump the
+ * revision - the corpus checks exactly that.
+ */
+export declare function normaliseName(name: unknown): string;
+/**
+ * Bytes of UTF-8 in a string.
+ *
+ * `TextEncoder` rather than `Buffer.byteLength`: this package runs in the browser as well as in
+ * Node, and the byte limits of the format are a rule about UTF-8, not about a Node API.
+ */
+export declare function byteLength(value: string): number;
+/** A node path split into the enum it belongs to and the ids below it. */
+export interface MetaPath {
+    readonly enumId: string;
+    readonly ids: readonly string[];
+}
+/**
+ * `room/eg/wohnzimmer` → `{enumId: 'room', ids: ['eg', 'wohnzimmer']}`.
+ *
+ * `room` alone is a valid *query* target (everything in any room) but never a membership target -
+ * an object belongs to nodes, not to enums. The caller decides which of the two it wants; this
+ * only splits.
+ */
+export declare function parsePath(path: string): MetaPath | undefined;
+/** The path of a node under a parent path. */
+export declare function childPath(parent: string, id: string): string;
+/**
+ * The path without its last segment, or `undefined` when there is nothing to strip.
+ *
+ * For a root node (`room/eg`) that is the enum id (`room`), which is not a node path - the caller
+ * that moves a node treats "the parent is the bare enum id" as "move to the root".
+ */
+export declare function parentPath(path: string): string | undefined;
+/** Is `path` the node `target` or anything below it? The subtree rule of a membership query. */
+export declare function pathMatches(path: string, target: string): boolean;
+/** The node a path addresses inside one enum's tree, or `undefined`. */
+export declare function findNode(tree: readonly MetaNode[], ids: readonly string[]): MetaNode | undefined;
+/** One entry of a flattened tree: the path, the node and how deep it sits. */
+export interface FlatNode {
+    readonly path: string;
+    readonly node: MetaNode;
+    readonly depth: number;
+    /** The names from the root down to and including this node. */
+    readonly trail: readonly string[];
+}
+/**
+ * Every node of one enum, depth first, in display order.
+ *
+ * This is what turns a tree into the flat things a UI needs: a select with indented entries, the
+ * "all rooms" list, and the check that a path exists at all.
+ */
+export declare function flattenEnum(enumId: string, definition: MetaEnum): FlatNode[];
+/** Every path of one enum, as a set - the cheap way to check membership targets in bulk. */
+export declare function enumPaths(enumId: string, definition: MetaEnum): Set<string>;
+/** The deepest level any node of this tree sits at; `0` for an empty tree. */
+export declare function treeDepth(tree: readonly MetaNode[]): number;
+/** Throws `too-deep` when a tree is deeper than the eight levels the format allows. */
+export declare function requireDepth(tree: readonly MetaNode[]): void;
+//# sourceMappingURL=paths.d.ts.map