@datocms/cma-client 5.0.0 → 5.1.0

package/src/utilities/structuredText.ts

@@ -0,0 +1,590 @@
+/**
+ * Tree manipulation utilities for DatoCMS structured text documents.
+ *
+ * Provides a set of low-level utilities for visiting, transforming, and querying
+ * structured text trees. Works with all tree variants (regular, request, nested).
+ */
+
+/**
+ * Recursively extract all possible node types that can appear in a tree structure
+ */
+type AllNodesInTree<T, Depth extends number = 10> = Depth extends 0
+  ? T extends readonly unknown[]
+    ? never
+    : T
+  : T extends readonly (infer U)[]
+    ? AllNodesInTree<U, Prev<Depth>>
+    : T extends { children: infer Children }
+      ? T | AllNodesInTree<Children, Prev<Depth>>
+      : T;
+
+type Prev<T extends number> = T extends 0
+  ? 0
+  : T extends 1
+    ? 0
+    : T extends 2
+      ? 1
+      : T extends 3
+        ? 2
+        : T extends 4
+          ? 3
+          : T extends 5
+            ? 4
+            : T extends 6
+              ? 5
+              : T extends 7
+                ? 6
+                : T extends 8
+                  ? 7
+                  : T extends 9
+                    ? 8
+                    : T extends 10
+                      ? 9
+                      : number;
+
+/**
+ * Path through the Structured Text tree structure
+ */
+export type TreePath = readonly (string | number)[];
+
+/**
+ * Generic predicate function type for Structured Text tree node filtering
+ */
+export type NodePredicate<T, R> = (
+  node: AllNodesInTree<T>,
+  parent: AllNodesInTree<T> | null,
+  path: TreePath,
+) => R;
+
+/**
+ * Check if a value has children property that is an array
+ */
+function hasChildren(node: unknown): node is { children: readonly unknown[] } {
+  return (
+    typeof node === 'object' &&
+    node !== null &&
+    'children' in node &&
+    Array.isArray(node.children)
+  );
+}
+
+/**
+ * Visit every node in the Structured Text tree, calling the visitor function for each.
+ * Uses pre-order traversal (parent is visited before its children).
+ *
+ * @template T - The type of the root node in the Structured Text tree
+ * @param node - The root node to start visiting from
+ * @param visitor - Synchronous function called for each node. Receives the node, its parent, and path through the Structured Text tree
+ */
+export function visitNodes<T>(
+  node: T,
+  visitor: NodePredicate<T, void>,
+  parent: AllNodesInTree<T> | null = null,
+  path: TreePath = [],
+): void {
+  // Visit current node
+  visitor(node as AllNodesInTree<T>, parent, path);
+
+  // Recursively visit children
+  if (hasChildren(node)) {
+    for (let index = 0; index < node.children.length; index++) {
+      const child = node.children[index];
+      visitNodes(child as T, visitor, node as AllNodesInTree<T>, [
+        ...path,
+        'children',
+        index,
+      ]);
+    }
+  }
+}
+
+/**
+ * Visit every node in the Structured Text tree, calling the visitor function for each.
+ * Uses pre-order traversal (parent is visited before its children).
+ *
+ * @template T - The type of the root node in the Structured Text tree
+ * @param node - The root node to start visiting from
+ * @param visitor - Asynchronous function called for each node. Receives the node, its parent, and path through the Structured Text tree
+ * @returns Promise that resolves when all nodes have been visited
+ */
+export async function visitNodesAsync<T>(
+  node: T,
+  visitor: NodePredicate<T, Promise<void>>,
+  parent: AllNodesInTree<T> | null = null,
+  path: TreePath = [],
+): Promise<void> {
+  // Visit current node
+  await visitor(node as AllNodesInTree<T>, parent, path);
+
+  // Recursively visit children
+  if (hasChildren(node)) {
+    for (let index = 0; index < node.children.length; index++) {
+      const child = node.children[index];
+      await visitNodesAsync(child as T, visitor, node as AllNodesInTree<T>, [
+        ...path,
+        'children',
+        index,
+      ]);
+    }
+  }
+}
+
+/**
+ * Transform nodes in the Structured Text tree by applying a mapping function.
+ * Creates a new tree structure with transformed nodes while preserving the Structured Text tree hierarchy.
+ *
+ * @template T - The type of nodes in the input Structured Text tree
+ * @template R - The type of nodes in the output tree
+ * @param node - The root node to start mapping from
+ * @param mapper - Synchronous function that transforms each node. Receives the node, its parent, and path
+ * @returns The transformed tree
+ */
+export function mapNodes<T, R>(
+  node: T,
+  mapper: NodePredicate<T, R>,
+  parent: AllNodesInTree<T> | null = null,
+  path: TreePath = [],
+): R {
+  // Transform current node
+  const transformedNode = mapper(node as AllNodesInTree<T>, parent, path);
+
+  // If the original node has children, recursively transform them
+  if (
+    hasChildren(node) &&
+    typeof transformedNode === 'object' &&
+    transformedNode !== null
+  ) {
+    const transformedChildren = node.children.map((child, index) =>
+      mapNodes(child as T, mapper, node as AllNodesInTree<T>, [
+        ...path,
+        'children',
+        index,
+      ]),
+    );
+
+    return {
+      ...transformedNode,
+      children: transformedChildren,
+    } as R;
+  }
+
+  return transformedNode;
+}
+
+/**
+ * Transform nodes in the Structured Text tree by applying a mapping function.
+ * Creates a new tree structure with transformed nodes while preserving the Structured Text tree hierarchy.
+ *
+ * @template T - The type of nodes in the input Structured Text tree
+ * @template R - The type of nodes in the output tree
+ * @param node - The root node to start mapping from
+ * @param mapper - Asynchronous function that transforms each node. Receives the node, its parent, and path
+ * @returns Promise that resolves to the transformed tree
+ */
+export async function mapNodesAsync<T, R>(
+  node: T,
+  mapper: NodePredicate<T, Promise<R>>,
+  parent: AllNodesInTree<T> | null = null,
+  path: TreePath = [],
+): Promise<R> {
+  // Transform current node
+  const transformedNode = await mapper(node as AllNodesInTree<T>, parent, path);
+
+  // If the original node has children, recursively transform them
+  if (
+    hasChildren(node) &&
+    typeof transformedNode === 'object' &&
+    transformedNode !== null
+  ) {
+    const transformedChildren = await Promise.all(
+      node.children.map((child, index) =>
+        mapNodesAsync(child as T, mapper, node as AllNodesInTree<T>, [
+          ...path,
+          'children',
+          index,
+        ]),
+      ),
+    );
+
+    return {
+      ...transformedNode,
+      children: transformedChildren,
+    } as R;
+  }
+
+  return transformedNode;
+}
+
+/**
+ * Find all nodes that match the predicate function using depth-first search.
+ * Returns an array containing all matching nodes along with their paths through the Structured Text tree.
+ *
+ * @template T - The type of nodes in the Structured Text tree
+ * @param node - The root node to start searching from
+ * @param predicate - Synchronous function that tests each node. Should return true for desired nodes
+ * @returns Array of objects, each containing a matching node and its path
+ */
+export function findAllNodes<T>(
+  node: T,
+  predicate: NodePredicate<T, boolean>,
+  parent: AllNodesInTree<T> | null = null,
+  path: TreePath = [],
+): Array<{ node: AllNodesInTree<T>; path: TreePath }> {
+  const results: Array<{ node: AllNodesInTree<T>; path: TreePath }> = [];
+
+  visitNodes(
+    node,
+    (currentNode, currentParent, currentPath) => {
+      if (predicate(currentNode, currentParent, currentPath)) {
+        results.push({ node: currentNode, path: currentPath });
+      }
+    },
+    parent,
+    path,
+  );
+
+  return results;
+}
+
+/**
+ * Find all nodes that match the predicate function using depth-first search.
+ * Returns an array containing all matching nodes along with their paths through the Structured Text tree.
+ *
+ * @template T - The type of nodes in the Structured Text tree
+ * @param node - The root node to start searching from
+ * @param predicate - Asynchronous function that tests each node. Should return true for desired nodes
+ * @returns Promise that resolves to an array of objects, each containing a matching node and its path
+ */
+export async function findAllNodesAsync<T>(
+  node: T,
+  predicate: NodePredicate<T, Promise<boolean>>,
+  parent: AllNodesInTree<T> | null = null,
+  path: TreePath = [],
+): Promise<Array<{ node: AllNodesInTree<T>; path: TreePath }>> {
+  const results: Array<{ node: AllNodesInTree<T>; path: TreePath }> = [];
+
+  await visitNodesAsync(
+    node,
+    async (currentNode, currentParent, currentPath) => {
+      if (await predicate(currentNode, currentParent, currentPath)) {
+        results.push({ node: currentNode, path: currentPath });
+      }
+    },
+    parent,
+    path,
+  );
+
+  return results;
+}
+
+/**
+ * Filter nodes in the Structured Text tree, removing those that don't match the predicate.
+ * Creates a new tree structure containing only nodes that pass the predicate test.
+ * Maintains the Structured Text tree hierarchy - if a parent node is kept, its structure is preserved.
+ *
+ * @template T - The type of nodes in the Structured Text tree
+ * @param node - The root node to start filtering from
+ * @param predicate - Synchronous function that tests each node. Nodes returning false are removed
+ * @returns The filtered tree, or null if root node is filtered out
+ */
+export function filterNodes<T>(
+  node: T,
+  predicate: NodePredicate<T, boolean>,
+  parent: AllNodesInTree<T> | null = null,
+  path: TreePath = [],
+): T | null {
+  // If current node doesn't match predicate, return null
+  if (!predicate(node as AllNodesInTree<T>, parent, path)) {
+    return null;
+  }
+
+  // If node has no children, return it as-is
+  if (!hasChildren(node)) {
+    return node;
+  }
+
+  // Filter children recursively
+  const childrenResults = node.children.map((child, index) =>
+    filterNodes(child as T, predicate, node as AllNodesInTree<T>, [
+      ...path,
+      'children',
+      index,
+    ]),
+  );
+  const filteredChildren = childrenResults.filter(
+    (child): child is NonNullable<typeof child> => child !== null,
+  );
+
+  return {
+    ...node,
+    children: filteredChildren,
+  } as T;
+}
+
+/**
+ * Filter nodes in the Structured Text tree, removing those that don't match the predicate.
+ * Creates a new tree structure containing only nodes that pass the predicate test.
+ * Maintains the Structured Text tree hierarchy - if a parent node is kept, its structure is preserved.
+ *
+ * @template T - The type of nodes in the Structured Text tree
+ * @param node - The root node to start filtering from
+ * @param predicate - Asynchronous function that tests each node. Nodes returning false are removed
+ * @returns Promise that resolves to the filtered tree, or null if root node is filtered out
+ */
+export async function filterNodesAsync<T>(
+  node: T,
+  predicate: NodePredicate<T, Promise<boolean>>,
+  parent: AllNodesInTree<T> | null = null,
+  path: TreePath = [],
+): Promise<T | null> {
+  // If current node doesn't match predicate, return null
+  if (!(await predicate(node as AllNodesInTree<T>, parent, path))) {
+    return null;
+  }
+
+  // If node has no children, return it as-is
+  if (!hasChildren(node)) {
+    return node;
+  }
+
+  // Filter children recursively
+  const childrenResults = await Promise.all(
+    node.children.map((child, index) =>
+      filterNodesAsync(child as T, predicate, node as AllNodesInTree<T>, [
+        ...path,
+        'children',
+        index,
+      ]),
+    ),
+  );
+  const filteredChildren = childrenResults.filter(
+    (child): child is NonNullable<typeof child> => child !== null,
+  );
+
+  return {
+    ...node,
+    children: filteredChildren,
+  } as T;
+}
+
+/**
+ * Reduce the Structured Text tree to a single value by applying a reducer function to each node.
+ * Uses pre-order traversal (parent is processed before its children).
+ * The reducer function is called for each node with the current accumulator value.
+ *
+ * @template T - The type of nodes in the Structured Text tree
+ * @template R - The type of the accumulated result
+ * @param node - The root node to start reducing from
+ * @param reducer - Synchronous function that processes each node and updates the accumulator
+ * @param initialValue - The initial value for the accumulator
+ * @returns The final accumulated value
+ */
+export function reduceNodes<T, R>(
+  node: T,
+  reducer: (
+    accumulator: R,
+    node: AllNodesInTree<T>,
+    parent: AllNodesInTree<T> | null,
+    path: TreePath,
+  ) => R,
+  initialValue: R,
+  parent: AllNodesInTree<T> | null = null,
+  path: TreePath = [],
+): R {
+  let accumulator = initialValue;
+
+  visitNodes(
+    node,
+    (currentNode, currentParent, currentPath) => {
+      accumulator = reducer(
+        accumulator,
+        currentNode,
+        currentParent,
+        currentPath,
+      );
+    },
+    parent,
+    path,
+  );
+
+  return accumulator;
+}
+
+/**
+ * Reduce the Structured Text tree to a single value by applying a reducer function to each node.
+ * Uses pre-order traversal (parent is processed before its children).
+ * The reducer function is called for each node with the current accumulator value.
+ *
+ * @template T - The type of nodes in the Structured Text tree
+ * @template R - The type of the accumulated result
+ * @param node - The root node to start reducing from
+ * @param reducer - Asynchronous function that processes each node and updates the accumulator
+ * @param initialValue - The initial value for the accumulator
+ * @returns Promise that resolves to the final accumulated value
+ */
+export async function reduceNodesAsync<T, R>(
+  node: T,
+  reducer: (
+    accumulator: R,
+    node: AllNodesInTree<T>,
+    parent: AllNodesInTree<T> | null,
+    path: TreePath,
+  ) => Promise<R>,
+  initialValue: R,
+  parent: AllNodesInTree<T> | null = null,
+  path: TreePath = [],
+): Promise<R> {
+  let accumulator = initialValue;
+
+  await visitNodesAsync(
+    node,
+    async (currentNode, currentParent, currentPath) => {
+      accumulator = await reducer(
+        accumulator,
+        currentNode,
+        currentParent,
+        currentPath,
+      );
+    },
+    parent,
+    path,
+  );
+
+  return accumulator;
+}
+
+/**
+ * Check if any node in the Structured Text tree matches the predicate function.
+ * Returns true as soon as the first matching node is found (short-circuit evaluation).
+ *
+ * @template T - The type of nodes in the Structured Text tree
+ * @param node - The root node to start searching from
+ * @param predicate - Synchronous function that tests each node. Should return true for matching nodes
+ * @returns True if any node matches, false otherwise
+ */
+export function someNode<T>(
+  node: T,
+  predicate: NodePredicate<T, boolean>,
+  parent: AllNodesInTree<T> | null = null,
+  path: TreePath = [],
+): boolean {
+  // Check current node
+  if (predicate(node as AllNodesInTree<T>, parent, path)) {
+    return true;
+  }
+
+  // Recursively check children
+  if (hasChildren(node)) {
+    for (let index = 0; index < node.children.length; index++) {
+      const child = node.children[index];
+      if (
+        someNode(child as T, predicate, node as AllNodesInTree<T>, [
+          ...path,
+          'children',
+          index,
+        ])
+      ) {
+        return true;
+      }
+    }
+  }
+
+  return false;
+}
+
+/**
+ * Check if any node in the Structured Text tree matches the predicate function.
+ * Returns true as soon as the first matching node is found (short-circuit evaluation).
+ *
+ * @template T - The type of nodes in the Structured Text tree
+ * @param node - The root node to start searching from
+ * @param predicate - Asynchronous function that tests each node. Should return true for matching nodes
+ * @returns Promise that resolves to true if any node matches, false otherwise
+ */
+export async function someNodeAsync<T>(
+  node: T,
+  predicate: NodePredicate<T, Promise<boolean>>,
+  parent: AllNodesInTree<T> | null = null,
+  path: TreePath = [],
+): Promise<boolean> {
+  // Check current node
+  if (await predicate(node as AllNodesInTree<T>, parent, path)) {
+    return true;
+  }
+
+  // Recursively check children
+  if (hasChildren(node)) {
+    for (let index = 0; index < node.children.length; index++) {
+      const child = node.children[index];
+      if (
+        await someNodeAsync(child as T, predicate, node as AllNodesInTree<T>, [
+          ...path,
+          'children',
+          index,
+        ])
+      ) {
+        return true;
+      }
+    }
+  }
+
+  return false;
+}
+
+/**
+ * Check if every node in the Structured Text tree matches the predicate function.
+ * Returns false as soon as the first non-matching node is found (short-circuit evaluation).
+ *
+ * @template T - The type of nodes in the Structured Text tree
+ * @param node - The root node to start testing from
+ * @param predicate - Synchronous function that tests each node. Should return true for valid nodes
+ * @returns True if all nodes match, false otherwise
+ */
+export function everyNode<T>(
+  node: T,
+  predicate: NodePredicate<T, boolean>,
+  parent: AllNodesInTree<T> | null = null,
+  path: TreePath = [],
+): boolean {
+  return !someNode(
+    node,
+    (
+      currentNode: AllNodesInTree<T>,
+      currentParent: AllNodesInTree<T> | null,
+      currentPath: TreePath,
+    ) => {
+      return !predicate(currentNode, currentParent, currentPath);
+    },
+    parent,
+    path,
+  );
+}
+
+/**
+ * Check if every node in the Structured Text tree matches the predicate function.
+ * Returns false as soon as the first non-matching node is found (short-circuit evaluation).
+ *
+ * @template T - The type of nodes in the Structured Text tree
+ * @param node - The root node to start testing from
+ * @param predicate - Asynchronous function that tests each node. Should return true for valid nodes
+ * @returns Promise that resolves to true if all nodes match, false otherwise
+ */
+export async function everyNodeAsync<T>(
+  node: T,
+  predicate: NodePredicate<T, Promise<boolean>>,
+  parent: AllNodesInTree<T> | null = null,
+  path: TreePath = [],
+): Promise<boolean> {
+  return !(await someNodeAsync(
+    node,
+    async (
+      currentNode: AllNodesInTree<T>,
+      currentParent: AllNodesInTree<T> | null,
+      currentPath: TreePath,
+    ) => {
+      return !(await predicate(currentNode, currentParent, currentPath));
+    },
+    parent,
+    path,
+  ));
+}

package/dist/cjs/buildBlockRecord.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"buildBlockRecord.js","sourceRoot":"","sources":["../../src/buildBlockRecord.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,gEAAoD;AAGpD,mDAA6C;AAE7C,SAAgB,gBAAgB,CAAC,IAAwC;IACvE,OAAO,KAAK,CAAC,oBAAoB,CAA+B,IAAI,EAAE;QACpE,IAAI,EAAE,gBAAI,CAAC,IAAI;QACf,UAAU,EAAE,GAAG;QACf,aAAa,EAAE,CAAC,WAAW,CAAC;KAC7B,CAAC,CAAC,IAAI,CAAC;AACV,CAAC;AAND,4CAMC"}

package/dist/cjs/idUtils.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"idUtils.js","sourceRoot":"","sources":["../../src/idUtils.ts"],"names":[],"mappings":";;;AAAA,6BAA0B;AAE1B,SAAS,6BAA6B,CAAC,KAAiB;IACtD,IAAM,MAAM,GACV,OAAO,MAAM,KAAK,WAAW;QAC3B,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,KAAK,EAAE,UAAC,IAAI,IAAK,OAAA,MAAM,CAAC,YAAY,CAAC,IAAI,CAAC,EAAzB,CAAyB,CAAC,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC;QACvE,CAAC,CAAC,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,QAAQ,CAAC,QAAQ,CAAC,CAAC;IAE5C,oDAAoD;IACpD,OAAO,CACL,MAAM;QACJ,mBAAmB;SAClB,OAAO,CAAC,KAAK,EAAE,GAAG,CAAC;QACpB,mBAAmB;SAClB,OAAO,CAAC,KAAK,EAAE,GAAG,CAAC;QACpB,oBAAoB;SACnB,SAAS,CAAC,CAAC,EAAE,EAAE,CAAC,CACpB,CAAC;AACJ,CAAC;AAED,SAAS,6BAA6B,CAAC,aAAqB;IAC1D,sDAAsD;IACtD,IAAM,MAAM,GAAG,aAAa;QAC1B,mBAAmB;SAClB,OAAO,CAAC,IAAI,EAAE,GAAG,CAAC;QACnB,mBAAmB;SAClB,OAAO,CAAC,IAAI,EAAE,GAAG,CAAC,CAAC;IAEtB,OAAO,OAAO,MAAM,KAAK,WAAW;QAClC,CAAC,CAAC,UAAU,CAAC,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,EAAE,UAAC,CAAC,IAAK,OAAA,CAAC,CAAC,UAAU,CAAC,CAAC,CAAC,EAAf,CAAe,CAAC;QACvD,CAAC,CAAC,IAAI,UAAU,CAAC,MAAM,CAAC,IAAI,CAAC,MAAM,EAAE,QAAQ,CAAC,CAAC,CAAC;AACpD,CAAC;AAED,SAAgB,SAAS,CAAC,EAAU;IAClC,4GAA4G;IAC5G,IAAI,OAAO,CAAC,IAAI,CAAC,EAAE,CAAC,EAAE;QACpB,IAAM,KAAK,GAAG,MAAM,CAAC,EAAE,CAAC,CAAC;QACzB,IAAM,gBAAgB,GAAG,eAAe,CAAC,CAAC,iCAAiC;QAC3E,OAAO,KAAK,IAAI,gBAAgB,CAAC;KAClC;IAED,IAAM,KAAK,GAAG,6BAA6B,CAAC,EAAE,CAAC,CAAC;IAEhD,qBAAqB;IACrB,IAAI,KAAK,CAAC,MAAM,KAAK,EAAE,EAAE;QACvB,OAAO,KAAK,CAAC;KACd;IAED,sDAAsD;IACtD,6BAA6B;IAE7B,IAAM,OAAO,GAAG,KAAK,CAAC,EAAE,CAAC,CAAC,CAAE,CAAC;IAE7B,gDAAgD;IAChD,IAAI,CAAC,OAAO,GAAG,GAAU,CAAC,KAAK,GAAU,EAAE;QACzC,OAAO,KAAK,CAAC;KACd;IAED,uDAAuD;IACvD,+CAA+C;IAE/C,IAAM,OAAO,GAAG,KAAK,CAAC,EAAE,CAAC,CAAC,CAAE,IAAI,CAAC,CAAC;IAElC,gDAAgD;IAChD,IAAI,OAAO,KAAK,GAAG,EAAE;QACnB,OAAO,KAAK,CAAC;KACd;IAED,OAAO,IAAI,CAAC;AACd,CAAC;AApCD,8BAoCC;AAED,SAAgB,UAAU;IACxB,IAAM,KAAK,GAAG,IAAA,SAAE,EAAC,IAAI,EAAE,IAAI,UAAU,CAAC,EAAE,CAAC,CAAC,CAAC;IAE3C,oEAAoE;IACpE,EAAE;IACF,iEAAiE;IACjE,mEAAmE;IACnE,mCAAmC;IAEnC,6DAA6D;IAE7D,KAAK,CAAC,CAAC,CAAC,GAAG,KAAK,CAAC,CAAC,CAAE,GAAG,IAAI,CAAC;IAE5B,IAAM,MAAM,GAAG,6BAA6B,CAAC,KAAK,CAAC,CAAC;IAEpD,OAAO,MAAM,CAAC;AAChB,CAAC;AAhBD,gCAgBC"}

package/dist/esm/buildBlockRecord.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"buildBlockRecord.js","sourceRoot":"","sources":["../../src/buildBlockRecord.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,MAAM,4BAA4B,CAAC;AAGpD,OAAO,EAAE,IAAI,EAAE,MAAM,uBAAuB,CAAC;AAE7C,MAAM,UAAU,gBAAgB,CAAC,IAAwC;IACvE,OAAO,KAAK,CAAC,oBAAoB,CAA+B,IAAI,EAAE;QACpE,IAAI,EAAE,IAAI,CAAC,IAAI;QACf,UAAU,EAAE,GAAG;QACf,aAAa,EAAE,CAAC,WAAW,CAAC;KAC7B,CAAC,CAAC,IAAI,CAAC;AACV,CAAC"}

package/dist/esm/idUtils.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"idUtils.js","sourceRoot":"","sources":["../../src/idUtils.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,EAAE,EAAE,MAAM,MAAM,CAAC;AAE1B,SAAS,6BAA6B,CAAC,KAAiB;IACtD,IAAM,MAAM,GACV,OAAO,MAAM,KAAK,WAAW;QAC3B,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,KAAK,EAAE,UAAC,IAAI,IAAK,OAAA,MAAM,CAAC,YAAY,CAAC,IAAI,CAAC,EAAzB,CAAyB,CAAC,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC;QACvE,CAAC,CAAC,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,QAAQ,CAAC,QAAQ,CAAC,CAAC;IAE5C,oDAAoD;IACpD,OAAO,CACL,MAAM;QACJ,mBAAmB;SAClB,OAAO,CAAC,KAAK,EAAE,GAAG,CAAC;QACpB,mBAAmB;SAClB,OAAO,CAAC,KAAK,EAAE,GAAG,CAAC;QACpB,oBAAoB;SACnB,SAAS,CAAC,CAAC,EAAE,EAAE,CAAC,CACpB,CAAC;AACJ,CAAC;AAED,SAAS,6BAA6B,CAAC,aAAqB;IAC1D,sDAAsD;IACtD,IAAM,MAAM,GAAG,aAAa;QAC1B,mBAAmB;SAClB,OAAO,CAAC,IAAI,EAAE,GAAG,CAAC;QACnB,mBAAmB;SAClB,OAAO,CAAC,IAAI,EAAE,GAAG,CAAC,CAAC;IAEtB,OAAO,OAAO,MAAM,KAAK,WAAW;QAClC,CAAC,CAAC,UAAU,CAAC,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,EAAE,UAAC,CAAC,IAAK,OAAA,CAAC,CAAC,UAAU,CAAC,CAAC,CAAC,EAAf,CAAe,CAAC;QACvD,CAAC,CAAC,IAAI,UAAU,CAAC,MAAM,CAAC,IAAI,CAAC,MAAM,EAAE,QAAQ,CAAC,CAAC,CAAC;AACpD,CAAC;AAED,MAAM,UAAU,SAAS,CAAC,EAAU;IAClC,4GAA4G;IAC5G,IAAI,OAAO,CAAC,IAAI,CAAC,EAAE,CAAC,EAAE;QACpB,IAAM,KAAK,GAAG,MAAM,CAAC,EAAE,CAAC,CAAC;QACzB,IAAM,gBAAgB,GAAG,eAAe,CAAC,CAAC,iCAAiC;QAC3E,OAAO,KAAK,IAAI,gBAAgB,CAAC;KAClC;IAED,IAAM,KAAK,GAAG,6BAA6B,CAAC,EAAE,CAAC,CAAC;IAEhD,qBAAqB;IACrB,IAAI,KAAK,CAAC,MAAM,KAAK,EAAE,EAAE;QACvB,OAAO,KAAK,CAAC;KACd;IAED,sDAAsD;IACtD,6BAA6B;IAE7B,IAAM,OAAO,GAAG,KAAK,CAAC,EAAE,CAAC,CAAC,CAAE,CAAC;IAE7B,gDAAgD;IAChD,IAAI,CAAC,OAAO,GAAG,GAAU,CAAC,KAAK,GAAU,EAAE;QACzC,OAAO,KAAK,CAAC;KACd;IAED,uDAAuD;IACvD,+CAA+C;IAE/C,IAAM,OAAO,GAAG,KAAK,CAAC,EAAE,CAAC,CAAC,CAAE,IAAI,CAAC,CAAC;IAElC,gDAAgD;IAChD,IAAI,OAAO,KAAK,GAAG,EAAE;QACnB,OAAO,KAAK,CAAC;KACd;IAED,OAAO,IAAI,CAAC;AACd,CAAC;AAED,MAAM,UAAU,UAAU;IACxB,IAAM,KAAK,GAAG,EAAE,CAAC,IAAI,EAAE,IAAI,UAAU,CAAC,EAAE,CAAC,CAAC,CAAC;IAE3C,oEAAoE;IACpE,EAAE;IACF,iEAAiE;IACjE,mEAAmE;IACnE,mCAAmC;IAEnC,6DAA6D;IAE7D,KAAK,CAAC,CAAC,CAAC,GAAG,KAAK,CAAC,CAAC,CAAE,GAAG,IAAI,CAAC;IAE5B,IAAM,MAAM,GAAG,6BAA6B,CAAC,KAAK,CAAC,CAAC;IAEpD,OAAO,MAAM,CAAC;AAChB,CAAC"}