@aidc-toolkit/gs1 1.0.39-beta → 1.0.41-beta

package/src/gcp-length.ts

@@ -1,380 +1,431 @@
 import { omit } from "@aidc-toolkit/core";
 import type { GCPLengthCache } from "./gcp-length-cache.js";
-import { type GCPLengthData, type GCPLengthHeader, isGCPLengthData } from "./gcp-length-data.js";
+import { type GCPLengthData, isGCPLengthData } from "./gcp-length-data.js";
+import * as GCPLengthTree from "./gcp-length-tree.js";
 import { GTINLengths } from "./gtin-length.js";
 import { GTINValidator } from "./gtin-validator.js";
 import { type IdentifierType, IdentifierTypes } from "./identifier-type.js";
 import { IdentifierValidators, isNumericIdentifierValidator } from "./identifier-validators.js";
 import { LeaderTypes } from "./leader-type.js";
+import { i18nextGS1 } from "./locale/i18n.js";
 
 /**
- * Leaf of GS1 Company Prefix length tree.
+ * Interim branch of GS1 Company Prefix length tree with writeable child nodes.
  */
-export interface Leaf {
-    length: number;
+export interface InterimBranch {
+    readonly childNodes: Array<InterimBranch | GCPLengthTree.Leaf | undefined>;
 }
 
 /**
- * Branch of GS1 Company Prefix length tree.
- */
-export interface Branch {
-    childNodes: Array<Node | undefined>;
-}
-
-/**
- * Root of GS1 Company Prefix length tree.
- */
-export interface Root extends GCPLengthHeader, Branch {
-}
-
-/**
- * Node in GS1 Company Prefix length tree.
- */
-export type Node = Root | Branch | Leaf;
-
-/**
- * Determine if a node is a leaf.
+ * GS1 Company Prefix length service. The constructor takes a {@linkcode GCPLengthCache} object, which is responsible
+ * for managing the cache and source.
  *
- * @param node
- * Node.
+ * The first step is to load the GS1 Company Prefix length data. This is done using the
+ * {@linkcode GCPLength.load | load()} method, which works as follows:
  *
- * @returns
- * True if node is a leaf.
- */
-export function isLeaf(node: Node): node is Leaf {
-    return "length" in node;
-}
-
-/**
- * Entry in binary data to indicate that child node is undefined.
- */
-const BINARY_UNDEFINED = 0x0F;
-
-/**
- * Entry in binary data to indicate that child node is a branch.
- */
-const BINARY_BRANCH = 0x0E;
-
-/**
- * Build the GS1 Company Prefix length tree from a binary data array.
- *
- * @param binaryData
- * Binary data array.
+ * - If the next check date/time is in the future, the method returns immediately, regardless of whether any data is
+ * available. It does this to prevent a large number of requests to the source in the event of a failure.
+ * - Otherwise, if the cache date/time is undefined or less than the source date/time, it loads from the source,
+ * converts the data if necessary, and updates the cache.
+ * - Otherwise, it continues with the cached data.
+ * - The next check date/time is updated to the later of the source date/time plus one week and the current date/time
+ * plus one day.
  *
- * @param childNodes
- * Child nodes array to fill.
+ * The base class implementation of the `GCPLengthCache` manages only the cache itself, and it requires an
+ * application-provided storage implementation. The source is expected to be either a {@linkcode GCPLengthData} object
+ * (created via another cache implementation) or a {@linkcode GCPLengthSourceJSON} object, which is the format of the
+ * file provided by GS1.
  *
- * @param startIndex
- * Start index into binary data array.
- *
- * @returns
- * End index into binary data array.
+ * Once the data is loaded, the {@linkcode GCPLength.lengthOf | lengthOf()} method can be used to get the length of a
+ * GS1 Company Prefix for an identifier type and identifier.
  */
-function fromBinary(binaryData: Uint8Array, childNodes: Array<Node | undefined>, startIndex: number): number {
-    let endIndex = startIndex;
+export class GCPLength {
+    /**
+     * Entry in binary data to indicate that child node is undefined.
+     */
+    static readonly #BINARY_UNDEFINED = 0x0F;
+
+    /**
+     * Entry in binary data to indicate that child node is a branch.
+     */
+    static readonly #BINARY_BRANCH = 0x0E;
+
+    /**
+     * GS1 Company Prefix length cache.
+     */
+    readonly #gcpLengthCache: GCPLengthCache;
+
+    /**
+     * GS1 Company Prefix length tree root.
+     */
+    #root?: GCPLengthTree.Root;
+
+    /**
+     * Constructor.
+     *
+     * @param gcpLengthCache
+     * GS1 Company Prefix length cache.
+     */
+    constructor(gcpLengthCache: GCPLengthCache) {
+        this.#gcpLengthCache = gcpLengthCache;
+    }
 
-    const decompressedLengths = new Array<number>(10);
+    /**
+     * Get the GS1 Company Prefix length tree root.
+     *
+     * @returns
+     * GS1 Company Prefix length tree root.
+     */
+    get root(): GCPLengthTree.Root {
+        if (this.#root === undefined) {
+            throw new RangeError(i18nextGS1.t("GCPLength.gs1CompanyPrefixLengthDataNotLoaded"));
+        }
 
-    // Decompress lengths for the child nodes.
-    for (let childNodeIndex = 0; childNodeIndex < 10; childNodeIndex += 2) {
-        const byte = binaryData[endIndex++];
+        return this.#root;
+    }
 
-        decompressedLengths[childNodeIndex] = byte >> 4;
-        decompressedLengths[childNodeIndex + 1] = byte & 0x0F;
+    /**
+     * Get the date/time the GS1 Company Prefix length data was last updated.
+     */
+    get dateTime(): Date {
+        return this.root.dateTime;
     }
 
-    for (let childNodeIndex = 0; childNodeIndex < 10; childNodeIndex++) {
-        const length = decompressedLengths[childNodeIndex];
+    /**
+     * Get the disclaimer for the GS1 Company Prefix length data.
+     */
+    get disclaimer(): string {
+        return this.root.disclaimer;
+    }
 
-        if (length !== BINARY_UNDEFINED) {
-            let childNode: Node;
+    /**
+     * Build the GS1 Company Prefix length tree from a binary data array.
+     *
+     * @param binaryData
+     * Binary data array.
+     *
+     * @param childNodes
+     * Child nodes array to fill.
+     *
+     * @param startIndex
+     * Start index into binary data array.
+     *
+     * @returns
+     * End index into binary data array.
+     */
+    static #fromBinary(binaryData: Uint8Array, childNodes: Array<GCPLengthTree.Node | undefined>, startIndex: number): number {
+        let endIndex = startIndex;
+
+        const decompressedLengths = new Array<number>(10);
+
+        // Decompress lengths for the child nodes.
+        for (let childNodeIndex = 0; childNodeIndex < 10; childNodeIndex += 2) {
+            const byte = binaryData[endIndex++];
+
+            decompressedLengths[childNodeIndex] = byte >> 4;
+            decompressedLengths[childNodeIndex + 1] = byte & 0x0F;
+        }
 
-            if (length === BINARY_BRANCH) {
-                childNode = {
-                    childNodes: []
-                };
+        for (let childNodeIndex = 0; childNodeIndex < 10; childNodeIndex++) {
+            const length = decompressedLengths[childNodeIndex];
 
-                endIndex = fromBinary(binaryData, childNode.childNodes, endIndex);
-            } else {
-                childNode = {
-                    length
-                };
-            }
+            if (length !== GCPLength.#BINARY_UNDEFINED) {
+                let childNode: GCPLengthTree.Node;
 
-            // eslint-disable-next-line no-param-reassign -- Purpose is to build tree.
-            childNodes[childNodeIndex] = childNode;
-        }
-    }
+                if (length === GCPLength.#BINARY_BRANCH) {
+                    const childNodes: Array<GCPLengthTree.Node | undefined> = [];
 
-    return endIndex;
-}
+                    endIndex = GCPLength.#fromBinary(binaryData, childNodes, endIndex);
 
-/**
- * Add an entry to the tree by recursively walking the tree to a leaf.
- *
- * @param branch
- * Current branch.
- *
- * @param prefix
- * Remainder of current prefix.
- *
- * @param length
- * Current prefix length.
- *
- * @returns
- * Number of branches added; used to determine size of binary array.
- */
-function addEntry(branch: Branch, prefix: string, length: number): number {
-    const digit = Number(prefix.charAt(0));
+                    childNode = {
+                        childNodes
+                    };
+                } else {
+                    childNode = {
+                        length
+                    };
+                }
+
+                // eslint-disable-next-line no-param-reassign -- Purpose is to build tree.
+                childNodes[childNodeIndex] = childNode;
+            }
+        }
 
-    const existingChildNode = branch.childNodes[digit];
+        return endIndex;
+    }
 
-    let branchesAdded = 0;
+    /**
+     * Add an entry to the tree by recursively walking the tree to a leaf.
+     *
+     * @param branch
+     * Current (interim) branch under construction.
+     *
+     * @param prefix
+     * Remainder of current prefix.
+     *
+     * @param length
+     * Current prefix length.
+     *
+     * @returns
+     * Number of branches added; used to determine size of binary array.
+     */
+    static #addEntry(branch: InterimBranch, prefix: string, length: number): number {
+        const digit = Number(prefix.charAt(0));
+
+        const existingChildNode = branch.childNodes[digit];
+
+        let branchesAdded = 0;
+
+        if (prefix.length !== 1) {
+            let childBranch: InterimBranch;
+
+            if (existingChildNode === undefined) {
+                childBranch = {
+                    childNodes: []
+                };
 
-    if (prefix.length !== 1) {
-        let childBranch: Branch;
+                branchesAdded++;
+            } else {
+                if (GCPLengthTree.isLeaf(existingChildNode)) {
+                    // File format error or application bug; localization not necessary.
+                    throw new Error("Overlapping entry");
+                }
 
-        if (existingChildNode === undefined) {
-            childBranch = {
-                childNodes: []
-            };
+                childBranch = existingChildNode;
+            }
 
-            branchesAdded++;
+            // eslint-disable-next-line no-param-reassign -- Purpose is to build tree.
+            branch.childNodes[digit] = childBranch;
+
+            // Continue with remainder of prefix.
+            branchesAdded += GCPLength.#addEntry(childBranch, prefix.substring(1), length);
         } else {
-            if (isLeaf(existingChildNode)) {
+            if (existingChildNode !== undefined) {
                 // File format error or application bug; localization not necessary.
-                throw new Error("Overlapping entry");
+                throw new Error("Duplicate entry");
             }
 
-            childBranch = existingChildNode;
+            // eslint-disable-next-line no-param-reassign -- Purpose is to build tree.
+            branch.childNodes[digit] = {
+                length
+            };
         }
 
-        // eslint-disable-next-line no-param-reassign -- Purpose is to build tree.
-        branch.childNodes[digit] = childBranch;
+        return branchesAdded;
+    }
+
+    /**
+     * Get the length of a child node if defined and it's a leaf, otherwise mark it with 0x0E if defined (branch) or 0x0F
+     * (no branch) if not.
+     *
+     * @param childNode
+     * Child node.
+     *
+     * @returns
+     * Child node length, 0x0E (branch), or 0x0F (undefined).
+     */
+    static #childNodeValue(childNode: GCPLengthTree.Node | undefined): number {
+        return childNode !== undefined ? GCPLengthTree.isLeaf(childNode) ? childNode.length : GCPLength.#BINARY_BRANCH : GCPLength.#BINARY_UNDEFINED;
+    }
+
+    /**
+     * Add a branch to a binary data array.
+     *
+     * @param binaryData
+     * Binary data array.
+     *
+     * @param branch
+     * Branch.
+     *
+     * @param startIndex
+     * Start index into binary data array.
+     *
+     * @returns
+     * End index into binary data array.
+     */
+    static #toBinary(binaryData: Uint8Array, branch: GCPLengthTree.Branch, startIndex: number): number {
+        let endIndex = startIndex;
+
+        const childNodes = branch.childNodes;
+
+        // Add length or non-leaf indicators, compressing 10 nibbles into 5 bytes.
+        for (let childNodeIndex = 0; childNodeIndex < 10; childNodeIndex += 2) {
+            // eslint-disable-next-line no-param-reassign -- Purpose is to build array.
+            binaryData[endIndex++] = (GCPLength.#childNodeValue(childNodes[childNodeIndex]) << 4) | GCPLength.#childNodeValue(childNodes[childNodeIndex + 1]);
+        }
 
-        // Continue with remainder of prefix.
-        branchesAdded += addEntry(childBranch, prefix.substring(1), length);
-    } else {
-        if (existingChildNode !== undefined) {
-            // File format error or application bug; localization not necessary.
-            throw new Error("Duplicate entry");
+        // Process child nodes.
+        for (const childNode of childNodes) {
+            if (childNode !== undefined && !GCPLengthTree.isLeaf(childNode)) {
+                endIndex = GCPLength.#toBinary(binaryData, childNode, endIndex);
+            }
         }
 
-        // eslint-disable-next-line no-param-reassign -- Purpose is to build tree.
-        branch.childNodes[digit] = {
-            length
-        };
+        return endIndex;
     }
 
-    return branchesAdded;
-}
+    /**
+     * Add days to a date.
+     *
+     * @param date
+     * Date.
+     *
+     * @param days
+     * Days.
+     *
+     * @returns
+     * Future date.
+     */
+    static #addDays(date: Date, days: number): Date {
+        const futureDate = new Date(date);
+
+        futureDate.setDate(futureDate.getDate() + days);
+
+        return futureDate;
+    }
 
-/**
- * Get the length of a child node if defined and it's a leaf, otherwise mark it with 0x0E if defined (branch) or 0x0F
- * (no branch) if not.
- *
- * @param childNode
- * Child node.
- *
- * @returns
- * Child node length, 0x0E (branch), or 0x0F (undefined).
- */
-function childNodeValue(childNode: Node | undefined): number {
-    return childNode !== undefined ? isLeaf(childNode) ? childNode.length : BINARY_BRANCH : BINARY_UNDEFINED;
-}
+    /**
+     * Load the GS1 Company Prefix length data.
+     */
+    async load(): Promise<void> {
+        let root: GCPLengthTree.Root | undefined = undefined;
 
-/**
- * Add a branch to a binary data array.
- *
- * @param binaryData
- * Binary data array.
- *
- * @param branch
- * Branch.
- *
- * @param startIndex
- * Start index into binary data array.
- *
- * @returns
- * End index into binary data array.
- */
-function toBinary(binaryData: Uint8Array, branch: Branch, startIndex: number): number {
-    let endIndex = startIndex;
+        const gcpLengthCache = this.#gcpLengthCache;
 
-    const childNodes = branch.childNodes;
+        let nextCheckDateTime = await gcpLengthCache.nextCheckDateTime;
+        let cacheDateTime = await gcpLengthCache.cacheDateTime;
 
-    // Add length or non-leaf indicators, compressing 10 nibbles into 5 bytes.
-    for (let childNodeIndex = 0; childNodeIndex < 10; childNodeIndex += 2) {
-        // eslint-disable-next-line no-param-reassign -- Purpose is to build array.
-        binaryData[endIndex++] = (childNodeValue(childNodes[childNodeIndex]) << 4) | childNodeValue(childNodes[childNodeIndex + 1]);
-    }
+        const now = new Date();
+        const tomorrow = GCPLength.#addDays(now, 1);
 
-    // Process child nodes.
-    for (const childNode of childNodes) {
-        if (childNode !== undefined && !isLeaf(childNode)) {
-            endIndex = toBinary(binaryData, childNode, endIndex);
-        }
-    }
+        if (nextCheckDateTime === undefined || nextCheckDateTime.getTime() <= now.getTime()) {
+            const sourceDateTime = await gcpLengthCache.sourceDateTime;
 
-    return endIndex;
-}
+            if (cacheDateTime === undefined || cacheDateTime.getTime() < sourceDateTime.getTime()) {
+                const sourceData = await gcpLengthCache.sourceData;
 
-/**
- * Add days to a date.
- *
- * @param date
- * Date.
- *
- * @param days
- * Days.
- *
- * @returns
- * New date.
- */
-function addDays(date: Date, days: number): Date {
-    const futureDate = new Date(date);
-    futureDate.setDate(futureDate.getDate() + days);
+                let cacheData: GCPLengthData;
 
-    return futureDate;
-}
+                if (isGCPLengthData(sourceData)) {
+                    const childNodes: Array<GCPLengthTree.Node | undefined> = [];
 
-/**
- * Load the GS1 Company Prefix length data.
- *
- * @param gcpLengthCache
- * GS1 Company Prefix length cache.
- *
- * @returns
- * Root of tree.
- */
-export async function loadData(gcpLengthCache: GCPLengthCache): Promise<Root | undefined> {
-    let root: Root | undefined = undefined;
+                    GCPLength.#fromBinary(sourceData.data, childNodes, 0);
 
-    let nextCheckDateTime = await gcpLengthCache.nextCheckDateTime;
-    let cacheDateTime = await gcpLengthCache.cacheDateTime;
+                    root = {
+                        dateTime: sourceData.dateTime,
+                        disclaimer: sourceData.disclaimer,
+                        childNodes
+                    };
 
-    const now = new Date();
-    const tomorrow = addDays(now, 1);
+                    cacheData = sourceData;
+                } else {
+                    const interimRoot: InterimBranch = {
+                        childNodes: []
+                    };
 
-    if (nextCheckDateTime === undefined || nextCheckDateTime.getTime() <= now.getTime()) {
-        const sourceDateTime = await gcpLengthCache.sourceDateTime;
+                    let branchesAdded = 1;
 
-        if (cacheDateTime === undefined || cacheDateTime.getTime() < sourceDateTime.getTime()) {
-            const sourceData = await gcpLengthCache.sourceData;
+                    for (const entry of sourceData.GCPPrefixFormatList.entry) {
+                        branchesAdded += GCPLength.#addEntry(interimRoot, entry.prefix, entry.gcpLength);
+                    }
 
-            let cacheData: GCPLengthData;
+                    root = {
+                        dateTime: new Date(sourceData.GCPPrefixFormatList.date),
+                        // Join disclaimer as a single string.
+                        disclaimer: `${sourceData._disclaimer.reduce<string[]>((lines, line) => {
+                            if (lines.length === 0 || lines[lines.length - 1] === "" || line === "") {
+                                lines.push(line);
+                            } else {
+                                // Lines are part of the same paragraph.
+                                lines.push(`${lines.pop()} ${line}`);
+                            }
 
-            if (isGCPLengthData(sourceData)) {
-                root = {
-                    dateTime: sourceData.dateTime,
-                    disclaimer: sourceData.disclaimer,
-                    childNodes: []
-                };
-
-                fromBinary(sourceData.data, root.childNodes, 0);
+                            return lines;
+                        }, []).join("\n")}\n`,
+                        ...interimRoot
+                    };
 
-                cacheData = sourceData;
-            } else {
-                root = {
-                    dateTime: new Date(sourceData.GCPPrefixFormatList.date),
-                    // Join disclaimer as a single string.
-                    disclaimer: `${sourceData._disclaimer.reduce<string[]>((lines, line) => {
-                        if (lines.length === 0 || lines[lines.length - 1] === "" || line === "") {
-                            lines.push(line);
-                        } else {
-                            // Lines are part of the same paragraph.
-                            lines.push(`${lines.pop()} ${line}`);
-                        }
-
-                        return lines;
-                    }, []).join("\n")}\n`,
-                    childNodes: []
-                };
+                    // Each branch has ten (some possibly undefined) entries, two per byte.
+                    const data = new Uint8Array(branchesAdded * 5);
 
-                let branchesAdded = 1;
+                    GCPLength.#toBinary(data, root, 0);
 
-                for (const entry of sourceData.GCPPrefixFormatList.entry) {
-                    branchesAdded += addEntry(root, entry.prefix, entry.gcpLength);
+                    cacheData = {
+                        ...omit(root, "childNodes"),
+                        data
+                    };
                 }
 
-                // Each branch has ten (some possibly undefined) entries, two per byte.
-                const data = new Uint8Array(branchesAdded * 5);
+                // Next check date/time is a week from source date/time or tomorrow, whichever is later.
+                nextCheckDateTime = GCPLength.#addDays(sourceDateTime, 7);
+                if (nextCheckDateTime.getTime() < tomorrow.getTime()) {
+                    nextCheckDateTime = tomorrow;
+                }
 
-                toBinary(data, root, 0);
+                cacheDateTime = sourceDateTime;
 
-                cacheData = {
-                    ...omit(root, "childNodes"),
-                    data
-                };
-            }
-
-            // Next check date/time is a week from source date/time or tomorrow, whichever is later.
-            nextCheckDateTime = addDays(sourceDateTime, 7);
-            if (nextCheckDateTime.getTime() < tomorrow.getTime()) {
-                nextCheckDateTime = tomorrow;
+                await gcpLengthCache.update(nextCheckDateTime, cacheDateTime, cacheData);
+            } else {
+                // Next check date/time is tomorrow.
+                await gcpLengthCache.update(tomorrow);
             }
+        }
 
-            cacheDateTime = sourceDateTime;
+        // Root is undefined if cache data is still valid or retrying after prior failure.
+        if (root === undefined && cacheDateTime !== undefined) {
+            const cacheData = await gcpLengthCache.cacheData;
 
-            await gcpLengthCache.update(nextCheckDateTime, cacheDateTime, cacheData);
-        } else {
-            // Next check date/time is tomorrow.
-            await gcpLengthCache.update(tomorrow);
-        }
-    }
+            const childNodes: Array<GCPLengthTree.Node | undefined> = [];
 
-    // Root is undefined if cache data is still valid or retrying after prior failure.
-    if (root === undefined && cacheDateTime !== undefined) {
-        const cacheData = await gcpLengthCache.cacheData;
+            GCPLength.#fromBinary(cacheData.data, childNodes, 0);
 
-        root = {
-            ...omit(cacheData, "data"),
-            childNodes: []
-        };
+            root = {
+                ...omit(cacheData, "data"),
+                childNodes
+            };
+        }
 
-        fromBinary(cacheData.data, root.childNodes, 0);
+        // Update root only if successful.
+        if (root !== undefined) {
+            this.#root = root;
+        }
     }
 
-    return root;
-}
-
-/**
- * Get the length of a GS1 Company Prefix for an identifier.
- *
- * @param root
- * Root of tree.
- *
- * @param identifierType
- * Identifier type.
- *
- * @param identifier
- * Identifier.
- *
- * @returns
- * Length of GS1 Company Prefix, 0 if not a GS1 Company Prefix, or -1 if not found.
- */
-export function getFor(root: Root, identifierType: IdentifierType, identifier: string): number {
-    let identifierPrefix: string;
+    /**
+     * Get the length of a GS1 Company Prefix for an identifier.
+     *
+     * @param identifierType
+     * Identifier type.
+     *
+     * @param identifier
+     * Identifier.
+     *
+     * @returns
+     * Length of GS1 Company Prefix, 0 if not a GS1 Company Prefix, or -1 if not found.
+     */
+    lengthOf(identifierType: IdentifierType, identifier: string): number {
+        let identifierPrefix: string;
+
+        if (identifierType === IdentifierTypes.GTIN) {
+            // Normalize the GTIN, pad to 14 digits, and extract the identifier prefix at the first character.
+            identifierPrefix = GTINValidator.normalize(identifier).padStart(GTINLengths.GTIN14, "0").substring(1);
+        } else {
+            const identifierValidator = IdentifierValidators[identifierType];
 
-    if (identifierType === IdentifierTypes.GTIN) {
-        // Normalize the GTIN, pad to 14 digits, and extract the identifier prefix at the first character.
-        identifierPrefix = GTINValidator.normalize(identifier).padStart(GTINLengths.GTIN14, "0").substring(1);
-    } else {
-        const identifierValidator = IdentifierValidators[identifierType];
+            identifierValidator.validate(identifier);
 
-        identifierValidator.validate(identifier);
+            identifierPrefix = !isNumericIdentifierValidator(identifierValidator) || identifierValidator.leaderType !== LeaderTypes.ExtensionDigit ? identifier : identifier.substring(1);
+        }
 
-        identifierPrefix = !isNumericIdentifierValidator(identifierValidator) || identifierValidator.leaderType !== LeaderTypes.ExtensionDigit ? identifier : identifier.substring(1);
-    }
+        let node: GCPLengthTree.Node | undefined = this.root;
 
-    let node: Node | undefined = root;
+        let digitIndex = 0;
 
-    let digitIndex = 0;
+        // Traverse tree until exhausted or at a leaf.
+        while (node !== undefined && !GCPLengthTree.isLeaf(node)) {
+            node = node.childNodes[Number(identifierPrefix.charAt(digitIndex++))];
+        }
 
-    // Traverse tree until exhausted or at a leaf.
-    while (node !== undefined && !isLeaf(node)) {
-        node = node.childNodes[Number(identifierPrefix.charAt(digitIndex++))];
+        return node?.length ?? -1;
     }
-
-    return node?.length ?? -1;
 }