data-navigator 2.2.0 → 2.2.2

package/dist/index.mjs

@@ -1,1339 +0,0 @@
-// src/consts.ts
-var SemanticKeys = {
-  Escape: true,
-  Enter: true,
-  Backspace: true,
-  ArrowLeft: true,
-  ArrowRight: true,
-  ArrowUp: true,
-  ArrowDown: true
-};
-var defaultKeyBindings = {
-  ArrowLeft: "left",
-  ArrowRight: "right",
-  ArrowUp: "up",
-  ArrowDown: "down",
-  Period: "forward",
-  Comma: "backward",
-  Escape: "parent",
-  Enter: "child"
-};
-var TypicallyUnreservedKeys = ["KeyW", "KeyJ", "LeftBracket", "RightBracket", "Slash", "Backslash"];
-var TypicallyUnreservedKeyPairs = [
-  ["LeftBracket", "RightBracket"],
-  ["Slash", "Backslash"]
-];
-var GenericFullNavigationRules = {
-  left: {
-    key: "ArrowLeft",
-    direction: "source"
-  },
-  right: {
-    key: "ArrowRight",
-    direction: "target"
-  },
-  up: {
-    key: "ArrowUp",
-    direction: "source"
-  },
-  down: {
-    key: "ArrowDown",
-    direction: "target"
-  },
-  child: {
-    key: "Enter",
-    direction: "target"
-  },
-  parent: {
-    key: "Backspace",
-    direction: "source"
-  },
-  backward: {
-    key: "Comma",
-    direction: "source"
-  },
-  forward: {
-    key: "Period",
-    direction: "target"
-  },
-  previous: {
-    key: "Semicolon",
-    direction: "source"
-  },
-  next: {
-    key: "Quote",
-    direction: "target"
-  },
-  exit: {
-    key: "Escape",
-    direction: "target"
-  },
-  help: {
-    key: "KeyY",
-    direction: "target"
-  },
-  undo: {
-    key: "KeyZ",
-    direction: "target"
-  }
-};
-var GenericFullNavigationDimensions = [
-  ["left", "right"],
-  ["up", "down"],
-  ["backward", "forward"],
-  ["previous", "next"]
-];
-var GenericLimitedNavigationRules = {
-  right: {
-    key: "ArrowRight",
-    direction: "target"
-  },
-  left: {
-    key: "ArrowLeft",
-    direction: "source"
-  },
-  down: {
-    key: "ArrowDown",
-    direction: "target"
-  },
-  up: {
-    key: "ArrowUp",
-    direction: "source"
-  },
-  child: {
-    key: "Enter",
-    direction: "target"
-  },
-  parent: {
-    key: "Backspace",
-    direction: "source"
-  },
-  exit: {
-    key: "Escape",
-    direction: "target"
-  },
-  undo: {
-    key: "Period",
-    direction: "target"
-  },
-  legend: {
-    key: "KeyL",
-    direction: "target"
-  }
-};
-var NodeElementDefaults = {
-  cssClass: "",
-  spatialProperties: {
-    x: 0,
-    y: 0,
-    width: 0,
-    height: 0,
-    path: ""
-  },
-  semantics: {
-    label: "",
-    elementType: "div",
-    role: "image",
-    attributes: void 0
-  },
-  parentSemantics: {
-    label: "",
-    elementType: "figure",
-    role: "figure",
-    attributes: void 0
-  },
-  existingElement: {
-    useForSpatialProperties: false,
-    spatialProperties: void 0
-  }
-};
-
-// src/utilities.ts
-var describeNode = (d, descriptionOptions) => {
-  const keys = Object.keys(d);
-  let description = "";
-  keys.forEach((key) => {
-    description += `${descriptionOptions && descriptionOptions.omitKeyNames ? "" : key + ": "}${d[key]}. `;
-  });
-  description += descriptionOptions && descriptionOptions.semanticLabel || "Data point.";
-  return description;
-};
-var createValidId = (s) => {
-  return "_" + s.replace(/[^a-zA-Z0-9_-]+/g, "_");
-};
-
-// src/structure.ts
-var structure_default = (options) => {
-  if (options.dataType === "vega-lite" || options.dataType === "vl" || options.dataType === "Vega-Lite") {
-    return buildNodeStructureFromVegaLite(options);
-  } else {
-    return buildStructure(options);
-  }
-};
-var buildNodeStructureFromVegaLite = (options) => {
-  let navigationRules = GenericLimitedNavigationRules;
-  let nodes = {};
-  let edges = {};
-  let elementData = {};
-  let total = 0;
-  const includeGroup = options.groupInclusionCriteria ? options.groupInclusionCriteria : () => true;
-  const includeItem = options.itemInclusionCriteria ? options.itemInclusionCriteria : () => true;
-  const includeDataProperties = options.datumInclusionCriteria ? options.datumInclusionCriteria : () => true;
-  const offset = options.vegaLiteView._renderer._origin;
-  const groupParent = options.vegaLiteView._scenegraph.root.items[0].mark.items[0];
-  const idBuilder = (i2, level) => {
-    if (i2["data-navigator-id"]) {
-      return i2["data-navigator-id"];
-    }
-    const id = `dn-node-${level}-${total}`;
-    total++;
-    i2["data-navigator-id"] = id;
-    return id;
-  };
-  const edgeBuilder = (id) => {
-    const node = nodes[id];
-    const index = node.index;
-    const level = node.level;
-    const parent = node.parent;
-    const edgeList = [];
-    const previous = parent.items[index - 1];
-    if (previous) {
-      const previousId = idBuilder(previous, level);
-      if (nodes[previousId]) {
-        const previousEdge = `${previousId}-${node.id}`;
-        edgeList.push(previousEdge);
-        if (!edges[previousEdge]) {
-          edges[previousEdge] = {
-            source: previousId,
-            target: node.id,
-            navigationRules: ["left", "right"]
-          };
-        }
-      }
-    }
-    const next = parent.items[index + 1];
-    if (next) {
-      const nextId = idBuilder(next, level);
-      if (nodes[nextId]) {
-        const nextEdge = `${node.id}-${nextId}`;
-        edgeList.push(nextEdge);
-        if (!edges[nextEdge]) {
-          edges[nextEdge] = {
-            source: node.id,
-            target: nextId,
-            navigationRules: ["left", "right"]
-          };
-        }
-      }
-    }
-    if (level === "group" && parent.items[index].items) {
-      const g = parent.items[index].items[0].mark.items[0].items || parent.items[index].items;
-      const firstChild = g[0];
-      const firstChildId = idBuilder(firstChild, "item");
-      if (nodes[firstChildId]) {
-        const firstChildEdge = `${node.id}-${firstChildId}`;
-        edgeList.push(firstChildEdge);
-        if (!edges[firstChildEdge]) {
-          edges[firstChildEdge] = {
-            source: node.id,
-            target: firstChildId,
-            navigationRules: ["parent", "child"]
-          };
-        }
-      }
-    } else if (level === "item") {
-      const parentId = idBuilder(parent, "group");
-      if (nodes[parentId]) {
-        const parentEdge = `${parentId}-${node.id}`;
-        edgeList.push(parentEdge);
-        if (!edges[parentEdge]) {
-          edges[parentEdge] = {
-            source: parentId,
-            target: node.id,
-            navigationRules: ["parent", "child"]
-          };
-        }
-      }
-    }
-    if (options.exitFunction) {
-      edgeList.push("any-exit");
-      if (!edges["any-exit"]) {
-        edges["any-exit"] = {
-          source: options.getCurrent,
-          target: options.exitFunction,
-          navigationRules: ["exit"]
-        };
-      }
-    }
-    edgeList.push("any-undo");
-    if (!edges["any-undo"]) {
-      edges["any-undo"] = {
-        source: options.getCurrent,
-        target: options.getPrevious,
-        navigationRules: ["undo"]
-      };
-    }
-    return edgeList;
-  };
-  const nodeBuilder = (item, level, offset2, index, parent) => {
-    const id = idBuilder(item, level);
-    const renderId = "render-" + id;
-    const o = offset2 || [0, 0];
-    nodes[id] = {};
-    nodes[id].d = {};
-    nodes[id].id = id;
-    nodes[id].renderId = renderId;
-    nodes[id].index = index;
-    nodes[id].level = level;
-    nodes[id].parent = parent;
-    elementData[renderId] = {};
-    elementData[renderId].renderId = renderId;
-    elementData[renderId].spatialProperties = {};
-    elementData[renderId].spatialProperties.x = item.bounds.x1 + o[0];
-    elementData[renderId].spatialProperties.y = item.bounds.y1 + o[1];
-    elementData[renderId].spatialProperties.width = item.bounds.x2 - item.bounds.x1;
-    elementData[renderId].spatialProperties.height = item.bounds.y2 - item.bounds.y1;
-    elementData[renderId].cssClass = "dn-vega-lite-node";
-    if (item.datum) {
-      Object.keys(item.datum).forEach((key) => {
-        const value = item.datum[key];
-        if (includeDataProperties(key, value, item.datum, level, options.vegaLiteSpec)) {
-          nodes[id].d[options.keyRenamingHash && options.keyRenamingHash[key] ? options.keyRenamingHash[key] : key] = value;
-        }
-      });
-    }
-    elementData[renderId].semantics = {};
-    elementData[renderId].semantics.label = options.nodeDescriber ? options.nodeDescriber(nodes[id].d, item, level) : describeNode(nodes[id].d);
-  };
-  let i = 0;
-  const groups = groupParent.items;
-  groups.forEach((group) => {
-    if (includeGroup(group, i, options.vegaLiteSpec)) {
-      nodeBuilder(group, "group", offset, i, groupParent);
-      let j = 0;
-      const g = group.items[0].mark.items[0].items ? group.items[0].mark.items[0] : group;
-      g.items.forEach((item) => {
-        if (includeItem(item, j, group, options.vegaLiteSpec)) {
-          nodeBuilder(item, "item", offset, j, g);
-        }
-        j++;
-      });
-    }
-    i++;
-  });
-  Object.keys(nodes).forEach((n) => {
-    nodes[n].edges = edgeBuilder(n);
-  });
-  return {
-    nodes,
-    edges,
-    elementData,
-    navigationRules
-  };
-};
-var addSimpleDataIDs = (options) => {
-  let i = 0;
-  let keyCounter = {};
-  options.data.forEach((d) => {
-    const id = typeof options.idKey === "function" ? options.idKey(d) : options.idKey;
-    d[id] = "_" + i;
-    if (options.keysForIdGeneration) {
-      options.keysForIdGeneration.forEach((k) => {
-        if (k in d) {
-          if (typeof d[k] === "string") {
-            if (!keyCounter[k]) {
-              keyCounter[k] = 0;
-            }
-            if (!keyCounter[d[k]]) {
-              keyCounter[d[k]] = 0;
-            }
-            d[id] += "_" + k + keyCounter[k] + "_" + d[k] + keyCounter[d[k]];
-            keyCounter[k]++;
-            keyCounter[d[k]]++;
-          } else {
-            if (!keyCounter[k]) {
-              keyCounter[k] = 0;
-            }
-            d[id] += "_" + k + keyCounter[k];
-            keyCounter[k]++;
-          }
-        }
-      });
-    }
-    i++;
-  });
-};
-var buildNodes = (options) => {
-  let nodes = {};
-  options.data.forEach((d) => {
-    if (!options.idKey) {
-      console.error(
-        `Building nodes. A key string must be supplied in options.idKey to specify the id keys of every node.`
-      );
-    }
-    const idKey = typeof options.idKey === "function" ? options.idKey(d) : options.idKey;
-    const id = d[idKey];
-    if (!id) {
-      console.error(
-        `Building nodes. Each datum in options.data must contain an id. When matching the id key string ${idKey}, this datum has no id: ${JSON.stringify(
-          d
-        )}.`
-      );
-      return;
-    }
-    if (!nodes[id]) {
-      const renderIdKey = typeof options.renderIdKey === "function" ? options.renderIdKey(d) : options.renderIdKey;
-      nodes[id] = {
-        id,
-        edges: [],
-        renderId: renderIdKey ? d[renderIdKey] || "" : d.renderIdKey || "",
-        data: d
-      };
-    } else {
-      console.error(
-        `Building nodes. Each id for data in options.data must be unique. This id is not unique: ${id}.`
-      );
-      return;
-    }
-  });
-  return nodes;
-};
-var scaffoldDimensions = (options, nodes) => {
-  let dimensions = {};
-  if (options.dimensions?.parentOptions?.addLevel0) {
-    let level0 = options.dimensions.parentOptions.addLevel0;
-    nodes[level0.id] = { ...level0, dimensionLevel: 0 };
-  }
-  let rules = [...GenericFullNavigationDimensions];
-  const setExtents = (val, dim) => {
-    let min = dim.numericalExtents[0];
-    let max = dim.numericalExtents[1];
-    dim.numericalExtents[0] = min < val ? min : val;
-    dim.numericalExtents[1] = max > val ? max : val;
-  };
-  options.data.forEach((d) => {
-    let ods = options.dimensions.values || [];
-    let i = 0;
-    ods.forEach((dim) => {
-      if (!dim.dimensionKey) {
-        console.error(
-          `Building nodes, parsing dimensions. Each dimension in options.dimensions must contain a dimensionKey. This dimension has no key: ${JSON.stringify(
-            dim
-          )}.`
-        );
-        return;
-      }
-      if (dim.dimensionKey in d) {
-        let value = d[dim.dimensionKey];
-        let keepValue = typeof dim.operations?.filterFunction === "function" ? dim.operations.filterFunction(d, dim) : true;
-        if (value !== void 0 && keepValue) {
-          if (!dim.type) {
-            dim.type = typeof value === "bigint" || typeof value === "number" ? "numerical" : "categorical";
-          }
-          if (!dimensions[dim.dimensionKey]) {
-            let id2 = typeof dim.nodeId === "function" ? dim.nodeId(dim, options.data) : dim.nodeId || createValidId(dim.dimensionKey);
-            let renderId = typeof dim.renderId === "function" ? dim.renderId(dim, options.data) : dim.renderId || id2;
-            dimensions[dim.dimensionKey] = {
-              dimensionKey: dim.dimensionKey,
-              nodeId: id2,
-              divisions: {},
-              numericalExtents: [Infinity, -Infinity],
-              type: dim.type,
-              operations: {
-                compressSparseDivisions: dim.operations?.compressSparseDivisions || false,
-                sortFunction: dim.operations?.sortFunction || void 0
-              },
-              behavior: dim.behavior || {
-                extents: "circular"
-              },
-              navigationRules: dim.navigationRules || {
-                sibling_sibling: rules.length ? [...rules.shift()] : ["previous_" + dim.dimensionKey, "next_" + dim.dimensionKey],
-                parent_child: ["parent_" + dim.dimensionKey, "child"]
-              }
-            };
-            nodes[id2] = {
-              id: id2,
-              renderId,
-              derivedNode: dim.dimensionKey,
-              edges: [],
-              dimensionLevel: 1,
-              data: dimensions[dim.dimensionKey],
-              renderingStrategy: dim.renderingStrategy || "singleSquare"
-              // not sure what defaults we want yet
-            };
-          }
-          let dimension = dimensions[dim.dimensionKey];
-          let targetDivision = null;
-          if (dim.type === "categorical") {
-            let divisionId = typeof dim.divisionOptions?.divisionNodeIds === "function" ? dim.divisionOptions.divisionNodeIds(dim.dimensionKey, value, i) : createValidId(dimension.nodeId + "_" + value);
-            targetDivision = dimension.divisions[divisionId];
-            if (!targetDivision) {
-              targetDivision = dimension.divisions[divisionId] = {
-                id: divisionId,
-                sortFunction: dim.divisionOptions?.sortFunction || void 0,
-                values: {}
-              };
-              let divisionRenderId = typeof dim.divisionOptions?.divisionRenderIds === "function" ? dim.divisionOptions.divisionRenderIds(dim.dimensionKey, value, i) : divisionId;
-              nodes[divisionId] = {
-                id: divisionId,
-                renderId: divisionRenderId,
-                derivedNode: dim.dimensionKey,
-                edges: [],
-                dimensionLevel: 2,
-                data: { ...targetDivision },
-                renderingStrategy: dim.divisionOptions?.renderingStrategy || "singleSquare"
-                // not sure what defaults we want yet
-              };
-              nodes[divisionId].data[dim.dimensionKey] = value;
-            }
-          } else {
-            targetDivision = dimension.divisions[dimension.nodeId];
-            if (!targetDivision) {
-              targetDivision = dimension.divisions[dimension.nodeId] = {
-                id: dimension.nodeId,
-                sortFunction: dim.divisionOptions?.sortFunction || void 0,
-                values: {}
-              };
-            }
-            if (!dim.operations) {
-              dim.operations = {};
-            }
-            let subdivs = dim.operations.createNumericalSubdivisions;
-            dimension.subdivisions = typeof subdivs === "number" && subdivs < 1 ? 1 : subdivs || 1;
-            if (subdivs !== 1) {
-              if (!dimension.divisionOptions) {
-                dimension.divisionOptions = dim.divisionOptions;
-              }
-              setExtents(value, dimension);
-            }
-          }
-          const id = typeof options.idKey === "function" ? options.idKey(d) : options.idKey;
-          targetDivision.values[d[id]] = d;
-        }
-      }
-      i++;
-    });
-  });
-  Object.keys(dimensions).forEach((s) => {
-    let dimension = dimensions[s];
-    let divisions = dimension.divisions;
-    if (dimension.type === "numerical") {
-      divisions[dimension.nodeId].values = Object.fromEntries(
-        Object.entries(divisions[dimension.nodeId].values).sort((a, b) => {
-          return typeof dimension.operations?.sortFunction === "function" ? dimension.operations.sortFunction(a[1], b[1], dimension) : a[1][s] - b[1][s];
-        })
-      );
-      let values = divisions[dimension.nodeId].values;
-      if (dimension.numericalExtents[0] !== Infinity && dimension.subdivisions !== 1) {
-        let valueKeys = Object.keys(values);
-        let subDivisions = typeof dimension.subdivisions === "function" ? dimension.subdivisions(s, values) : dimension.subdivisions;
-        let range = dimension.numericalExtents[1] - dimension.numericalExtents[0];
-        let interval = range / subDivisions;
-        let i = dimension.numericalExtents[0] + interval;
-        let divisionCount = 0;
-        let index = 0;
-        for (i = dimension.numericalExtents[0] + interval; i <= dimension.numericalExtents[1]; i += interval) {
-          let divisionId = typeof dimension.divisionOptions?.divisionNodeIds === "function" ? dimension.divisionOptions.divisionNodeIds(s, i, i) : dimension.nodeId + "_" + i;
-          dimension.divisions[divisionId] = {
-            id: divisionId,
-            sortFunction: dimension.divisionOptions?.sortFunction || void 0,
-            values: {}
-          };
-          let divisionRenderId = typeof dimension.divisionOptions?.divisionRenderIds === "function" ? dimension.divisionOptions.divisionRenderIds(s, i, i) : divisionId;
-          nodes[divisionId] = {
-            id: divisionId,
-            renderId: divisionRenderId,
-            derivedNode: s,
-            edges: [],
-            data: dimension.divisions[divisionId],
-            dimensionLevel: 2,
-            renderingStrategy: dimension.divisionOptions?.renderingStrategy || "singleSquare"
-            // not sure what defaults we want yet
-          };
-          let limit = false;
-          while (!limit && index < valueKeys.length) {
-            let node = values[valueKeys[index]];
-            let value = node[s];
-            if (value <= i) {
-              dimension.divisions[divisionId].values[node.id] = node;
-            } else {
-              i += interval;
-              limit = true;
-            }
-            index++;
-          }
-          divisionCount++;
-        }
-        delete divisions[s];
-      }
-    } else if (typeof dimension.operations?.sortFunction === "function") {
-      dimension.divisions = Object.fromEntries(
-        Object.entries(divisions).sort((a, b) => {
-          return dimension.operations.sortFunction(a[1], b[1], dimension);
-        })
-      );
-    }
-    let divisionKeys = Object.keys(dimension.divisions);
-    divisionKeys.forEach((d) => {
-      let division = dimension.divisions[d];
-      if (typeof division.sortFunction === "function") {
-        division.values = Object.fromEntries(
-          Object.entries(division.values).sort((a, b) => {
-            return division.sortFunction(a[1], b[1], division);
-          })
-        );
-      }
-    });
-  });
-  Object.keys(dimensions).forEach((s) => {
-    let dimension = dimensions[s];
-    if (dimension.operations.compressSparseDivisions) {
-      const divisionKeys = Object.keys(dimension.divisions);
-      const values = {};
-      let sparse = true;
-      divisionKeys.forEach((d) => {
-        const division = dimension.divisions[d];
-        const valueKeys = Object.keys(division.values);
-        if (valueKeys.length <= 1) {
-          valueKeys.forEach((vk) => {
-            values[vk] = { ...division.values[vk] };
-          });
-        } else {
-          sparse = false;
-        }
-      });
-      if (sparse) {
-        const newDivision = {
-          id: dimension.nodeId,
-          values
-        };
-        divisionKeys.forEach((d) => {
-          delete nodes[d];
-        });
-        dimension.divisions = {};
-        dimension.divisions[dimension.nodeId] = newDivision;
-      }
-    }
-  });
-  if (options.dimensions.adjustDimensions) {
-    dimensions = options.dimensions.adjustDimensions(dimensions);
-  }
-  return dimensions;
-};
-var buildEdges = (options, nodes, dimensions) => {
-  let edges = {};
-  const addEdgeToNode = (nodeId, edgeId) => {
-    if (nodes[nodeId].edges.indexOf(edgeId) === -1) {
-      nodes[nodeId].edges.push(edgeId);
-    }
-  };
-  const createEdge = (source, target, rules, addTo) => {
-    const id = `${source}-${target}`;
-    let targetId = !options.useDirectedEdges ? id : `${target}-${id}`;
-    let addToSource = !addTo || addTo === "source";
-    let addToTarget = !addTo || addTo === "target";
-    const checkEdgeRules = (eId) => {
-      if (edges[eId]) {
-        edges[eId].navigationRules.push(...rules || []);
-      } else {
-        edges[eId] = {
-          source,
-          target,
-          navigationRules: rules ? [...rules] : []
-        };
-      }
-    };
-    checkEdgeRules(id);
-    if (options.useDirectedEdges && addToTarget) {
-      checkEdgeRules(targetId);
-    }
-    if (addToSource) {
-      addEdgeToNode(source, id);
-    }
-    if (addToTarget) {
-      addEdgeToNode(target, targetId);
-    }
-  };
-  if (dimensions && Object.keys(dimensions).length) {
-    const dimensionKeys = Object.keys(dimensions);
-    const hasOrder = options.dimensions?.parentOptions?.level1Options?.order;
-    let order = hasOrder || dimensionKeys;
-    let l = 0;
-    let po = options.dimensions?.parentOptions || {};
-    let extents = po.level1Options?.behavior?.extents || "terminal";
-    let level0 = po.addLevel0;
-    let parentRules = level0 ? po.level1Options?.navigationRules?.parent_child || ["parent", "child"] : [];
-    let siblingRules = po.level1Options?.navigationRules?.sibling_sibling || ["left", "right"];
-    let firstLevel1Node = typeof order[0] === "string" ? hasOrder ? nodes[order[0]] : nodes[dimensions[order[0]].nodeId] : order[0];
-    if (level0) {
-      createEdge(level0.id, firstLevel1Node.id, parentRules, "source");
-    }
-    order.forEach((n) => {
-      let level1Node = typeof n === "string" ? hasOrder ? nodes[n] : nodes[dimensions[n].nodeId] : n;
-      if (level1Node === n && !nodes[level1Node.id]) {
-        nodes[level1Node.id] = level1Node;
-      }
-      if (level0) {
-        if (!options.useDirectedEdges) {
-          createEdge(level0.id, level1Node.id, parentRules, "target");
-        } else {
-          createEdge(level1Node.id, level0.id, parentRules, "source");
-        }
-      }
-      if (l === order.length - 1 && extents === "circular") {
-        createEdge(level1Node.id, firstLevel1Node.id, siblingRules);
-      } else if (l === order.length - 1 && extents === "bridgedCustom") {
-        createEdge(level1Node.id, po.level1Options.behavior.customBridgePost, siblingRules);
-      } else if (l < order.length - 1) {
-        let nextLevel1Node = typeof order[l + 1] === "string" ? hasOrder ? (
-          // @ts-ignore: for some reason the same use of conditional check works above for order[0] (firstLevel1Node) but not for l+1 here
-          nodes[order[l + 1]]
-        ) : (
-          // @ts-ignore: for some reason the same use of conditional check works above for order[0] (firstLevel1Node) but not for l+1 here
-          nodes[dimensions[order[l + 1]].nodeId]
-        ) : order[l + 1];
-        createEdge(level1Node.id, nextLevel1Node.id, siblingRules);
-      }
-      if (!l && extents === "bridgedCustom") {
-        createEdge(po.level1Options.behavior.customBridgePost, level1Node.id, siblingRules);
-      }
-      l++;
-    });
-    dimensionKeys.forEach((s) => {
-      const dimension = dimensions[s];
-      const strat = dimension.behavior?.childmostNavigation || "within";
-      const matchByIndex = (i, _a, _b, c) => {
-        return c.values[Object.keys(c.values)[i]] || void 0;
-      };
-      const match = strat === "across" && dimension.behavior?.childmostMatching ? dimension.behavior?.childmostMatching : matchByIndex;
-      let extents2 = dimension.behavior?.extents || "circular";
-      if (!dimension.divisions) {
-        console.error(
-          `Parsing dimensions. The dimension using the key ${s} is missing the divisions property. dimension.divisions should be supplied. ${JSON.stringify(
-            dimension
-          )}.`
-        );
-      }
-      let divisionKeys = Object.keys(dimension.divisions);
-      const firstDivision = dimension.divisions[divisionKeys[0]];
-      if (divisionKeys.length !== 1) {
-        createEdge(dimension.nodeId, firstDivision.id, dimension.navigationRules.parent_child, "source");
-      } else {
-        let valueKeys = Object.keys(firstDivision.values);
-        let firstChildId = typeof options.idKey === "function" ? options.idKey(firstDivision.values[valueKeys[0]]) : options.idKey;
-        createEdge(
-          dimension.nodeId,
-          firstDivision.values[valueKeys[0]][firstChildId],
-          dimension.navigationRules.parent_child,
-          "source"
-        );
-      }
-      let j = 0;
-      divisionKeys.forEach((d) => {
-        let division = dimension.divisions[d];
-        if (j === divisionKeys.length - 1 && (extents2 === "circular" || extents2 === "bridgedCousins" || extents2 === "bridgedCustom")) {
-          createEdge(
-            division.id,
-            dimension.divisions[divisionKeys[0]].id,
-            dimension.navigationRules.sibling_sibling
-          );
-        } else if (j < divisionKeys.length - 1) {
-          createEdge(
-            division.id,
-            dimension.divisions[divisionKeys[j + 1]].id,
-            dimension.navigationRules.sibling_sibling
-          );
-        }
-        let valueKeys = Object.keys(division.values);
-        if (!options.useDirectedEdges) {
-          createEdge(dimension.nodeId, division.id, dimension.navigationRules.parent_child, "target");
-        } else {
-          createEdge(division.id, dimension.nodeId, dimension.navigationRules.parent_child, "source");
-        }
-        const firstChildId = typeof options.idKey === "function" ? options.idKey(division.values[valueKeys[0]]) : options.idKey;
-        createEdge(
-          division.id,
-          division.values[valueKeys[0]][firstChildId],
-          dimension.navigationRules.parent_child,
-          "source"
-        );
-        let i = 0;
-        if (valueKeys.length > 1) {
-          valueKeys.forEach((vk) => {
-            let v = division.values[vk];
-            const id = typeof options.idKey === "function" ? options.idKey(v) : options.idKey;
-            let parentId = divisionKeys.length !== 1 ? division.id : dimension.nodeId;
-            if (!options.useDirectedEdges) {
-              createEdge(parentId, v[id], dimension.navigationRules.parent_child, "target");
-            } else {
-              createEdge(v[id], parentId, dimension.navigationRules.parent_child, "source");
-            }
-            if (strat === "within") {
-              if (i === valueKeys.length - 1 && extents2 === "circular") {
-                const targetId = typeof options.idKey === "function" ? options.idKey(division.values[valueKeys[0]]) : options.idKey;
-                createEdge(
-                  v[id],
-                  division.values[valueKeys[0]][targetId],
-                  dimension.navigationRules.sibling_sibling
-                );
-              } else if (i === valueKeys.length - 1 && extents2 === "bridgedCousins") {
-                if (j !== divisionKeys.length - 1) {
-                  const targetId = typeof options.idKey === "function" ? options.idKey(
-                    dimension.divisions[divisionKeys[j + 1]].values[valueKeys[0]]
-                  ) : options.idKey;
-                  createEdge(
-                    v[id],
-                    dimension.divisions[divisionKeys[j + 1]].values[valueKeys[0]][targetId],
-                    dimension.navigationRules.sibling_sibling
-                  );
-                } else {
-                  const targetId = typeof options.idKey === "function" ? options.idKey(dimension.divisions[divisionKeys[0]].values[valueKeys[0]]) : options.idKey;
-                  createEdge(
-                    v[id],
-                    dimension.divisions[divisionKeys[0]].values[valueKeys[0]][targetId],
-                    dimension.navigationRules.sibling_sibling
-                  );
-                }
-              } else if (i === valueKeys.length - 1 && extents2 === "bridgedCustom") {
-                createEdge(
-                  v[id],
-                  dimension.behavior.customBridgePost,
-                  dimension.navigationRules.sibling_sibling
-                );
-              } else if (i < valueKeys.length - 1) {
-                const targetId = typeof options.idKey === "function" ? options.idKey(division.values[valueKeys[i + 1]]) : options.idKey;
-                createEdge(
-                  v[id],
-                  division.values[valueKeys[i + 1]][targetId],
-                  dimension.navigationRules.sibling_sibling
-                );
-              }
-              if (!i && extents2 === "bridgedCousins") {
-                if (j !== 0) {
-                  const targetId = typeof options.idKey === "function" ? options.idKey(
-                    dimension.divisions[divisionKeys[j - 1]].values[valueKeys[valueKeys.length - 1]]
-                  ) : options.idKey;
-                  createEdge(
-                    dimension.divisions[divisionKeys[j - 1]].values[valueKeys[valueKeys.length - 1]][targetId],
-                    v[id],
-                    dimension.navigationRules.sibling_sibling
-                  );
-                } else {
-                  const targetId = typeof options.idKey === "function" ? options.idKey(
-                    dimension.divisions[divisionKeys[divisionKeys.length - 1]].values[valueKeys[valueKeys.length - 1]]
-                  ) : options.idKey;
-                  createEdge(
-                    dimension.divisions[divisionKeys[divisionKeys.length - 1]].values[valueKeys[valueKeys.length - 1]][targetId],
-                    v[id],
-                    dimension.navigationRules.sibling_sibling
-                  );
-                }
-              } else if (!i && extents2 === "bridgedCustom") {
-                createEdge(
-                  dimension.behavior.customBridgePrevious,
-                  v[id],
-                  dimension.navigationRules.sibling_sibling
-                );
-              }
-            } else {
-              if (j === divisionKeys.length - 1 && extents2 === "bridgedCustom") {
-                createEdge(
-                  v[id],
-                  dimension.behavior.customBridgePost,
-                  dimension.navigationRules.sibling_sibling
-                );
-              } else if (!j && extents2 === "bridgedCustom") {
-                createEdge(
-                  dimension.behavior.customBridgePrevious,
-                  v[id],
-                  dimension.navigationRules.sibling_sibling
-                );
-              } else {
-                const targetDivision = j === divisionKeys.length - 1 && extents2 === "circular" ? dimension.divisions[divisionKeys[0]] : dimension.divisions[divisionKeys[j + 1]];
-                if (targetDivision) {
-                  const target = match(i, v[id], division, targetDivision);
-                  if (target) {
-                    const targetId = typeof options.idKey === "function" ? options.idKey(target) : options.idKey;
-                    createEdge(v[id], target[targetId], dimension.navigationRules.sibling_sibling);
-                  }
-                }
-              }
-            }
-            i++;
-          });
-        }
-        j++;
-      });
-    });
-  }
-  Object.keys(nodes).forEach((nodeKey) => {
-    const node = nodes[nodeKey];
-    if (options.genericEdges?.length) {
-      options.genericEdges.forEach((e) => {
-        if (!edges[e.edgeId]) {
-          edges[e.edgeId] = e.edge;
-        }
-        if (!e.conditional || e.conditional && e.conditional(node, e)) {
-          node.edges.push(e.edgeId);
-        }
-      });
-    }
-  });
-  return edges;
-};
-var buildRules = (options, edges, dimensions) => {
-  let rules = options.navigationRules;
-  if (!rules) {
-    let dimKeys = Object.keys(dimensions || {});
-    if (dimKeys.length > 6) {
-      console.error(
-        `Building navigationRules. Dimension count is too high to automatically generate key commands. It is recommend you reduce your dimensions to 6 or fewer for end-user experience. If not, you must provide your own navigation rules in options.navigationRules. Details: Count is ${dimKeys.length}. Dimensions counted: ${dimKeys.join(", ")}.`
-      );
-    }
-    let importedRules = {};
-    let used = {};
-    let needsKeys = {};
-    let sparePairs = [...TypicallyUnreservedKeyPairs];
-    let spareKeys = [...TypicallyUnreservedKeys];
-    const checkKeys = (k1, k2) => {
-      let isPair = k1 && k2;
-      let k1Assigned = false;
-      let k2Assigned = false;
-      if (importedRules[k1] || used[k1]) {
-        used[k1] = { ...importedRules[k1] };
-        k1Assigned = true;
-      }
-      if (k2 && (importedRules[k2] || used[k2])) {
-        used[k2] = { ...importedRules[k2] };
-        k2Assigned = true;
-      }
-      if (isPair && !k1Assigned && !k2Assigned) {
-        if (!sparePairs.length) {
-          console.error(
-            `Building navigationRules. Dimension count is too high to automatically generate key commands, we have run out of keyboard key pairs to assign. You must either provide your own navigation rules in options.navigationRules, provide rules when generating dimensions, or reduce dimension count.`
-          );
-        }
-        let pair = [...sparePairs.shift()];
-        spareKeys.splice(spareKeys.indexOf(pair[0]), 1);
-        spareKeys.splice(spareKeys.indexOf(pair[1]), 1);
-        used[k1] = {
-          direction: options.useDirectedEdges ? "target" : "source",
-          key: pair[0]
-        };
-        used[k2] = {
-          direction: "target",
-          key: pair[1]
-        };
-      } else {
-        if (!used[k1] && spareKeys.length) {
-          let key = spareKeys.shift();
-          let newPairs = [];
-          sparePairs.forEach((p) => {
-            if (key !== p[0] && key !== p[1]) {
-              newPairs.push(p);
-            }
-          });
-          sparePairs = newPairs;
-          used[k1] = {
-            direction: options.useDirectedEdges ? "target" : "source",
-            key
-          };
-        }
-        if (k2 && !used[k2] && spareKeys.length) {
-          let key = spareKeys.shift();
-          let newPairs = [];
-          sparePairs.forEach((p) => {
-            if (key !== p[0] && key !== p[1]) {
-              newPairs.push(p);
-            }
-          });
-          sparePairs = newPairs;
-          used[k2] = {
-            direction: "target",
-            key
-          };
-        }
-        if (!spareKeys.length) {
-          if (!used[k1]) {
-            needsKeys[k1] = k1;
-          }
-          if (k2 && !used[k2]) {
-            needsKeys[k2] = k2;
-          }
-        }
-      }
-    };
-    Object.keys(GenericFullNavigationRules).forEach((r) => {
-      let rule = { ...GenericFullNavigationRules[r] };
-      if (options.useDirectedEdges) {
-        rule.direction = "target";
-      }
-      importedRules[r] = rule;
-    });
-    if (dimKeys.length) {
-      if (options.dimensions?.parentOptions?.addLevel0) {
-        let rules2 = options.dimensions.parentOptions.level1Options?.navigationRules?.parent_child || [
-          "parent",
-          "child"
-        ];
-        checkKeys(rules2[0], rules2[1]);
-      }
-      dimKeys.forEach((d) => {
-        let pc = dimensions[d].navigationRules.parent_child;
-        let ss = dimensions[d].navigationRules.sibling_sibling;
-        checkKeys(pc[0], pc[1]);
-        checkKeys(ss[0], ss[1]);
-      });
-    }
-    Object.keys(edges).forEach((e) => {
-      edges[e].navigationRules.forEach((rule) => {
-        if (!used[rule]) {
-          checkKeys(rule);
-        }
-      });
-    });
-    if (Object.keys(needsKeys).length) {
-      let usedKeys = {};
-      Object.keys(used).forEach((k) => {
-        usedKeys[used[k].key] = used[k].key;
-      });
-      Object.keys(importedRules).forEach((r) => {
-        if (!usedKeys[importedRules[r].key] && !SemanticKeys[importedRules[r].key]) {
-          spareKeys.push(importedRules[r].key);
-        }
-      });
-      let recheckKeys = { ...needsKeys };
-      needsKeys = {};
-      Object.keys(recheckKeys).forEach((key) => {
-        checkKeys(key);
-      });
-      if (Object.keys(needsKeys).length) {
-        console.error(
-          `Building navigationRules. There are no more keys left to assign automatically. Recommended fixes: use fewer dimensions, use fewer GenericEdges, or build your own navigationRules. Rules remaining without keyboard keys: ${Object.keys(
-            needsKeys
-          ).join(", ")}.`
-        );
-      }
-    }
-    rules = used;
-  }
-  return rules;
-};
-var buildStructure = (options) => {
-  if (options.addIds) {
-    addSimpleDataIDs(options);
-  }
-  let nodes = buildNodes(options);
-  let dimensions = scaffoldDimensions(options, nodes);
-  let edges = buildEdges(options, nodes, dimensions);
-  let navigationRules = buildRules(options, edges, dimensions);
-  return {
-    nodes,
-    edges,
-    dimensions,
-    navigationRules
-  };
-};
-
-// src/input.ts
-var input_default = (options) => {
-  let inputHandler = {};
-  let keyBindings = defaultKeyBindings;
-  let directions = GenericFullNavigationRules;
-  inputHandler.moveTo = (id) => {
-    const target = options.structure.nodes[id];
-    if (target) {
-      return target;
-    }
-    return;
-  };
-  inputHandler.move = (currentFocus, direction) => {
-    if (currentFocus) {
-      const d = options.structure.nodes[currentFocus];
-      if (d.edges) {
-        let target = null;
-        let i = 0;
-        const navRule = directions[direction];
-        if (!navRule) {
-          return;
-        }
-        const findTarget = (rule, edge) => {
-          if (!(rule === direction)) {
-            return null;
-          }
-          let resolvedNodes = {
-            target: typeof edge.target === "string" ? edge.target : edge.target(d, currentFocus),
-            source: typeof edge.source === "string" ? edge.source : edge.source(d, currentFocus)
-          };
-          return !(resolvedNodes[navRule.direction] === currentFocus) ? resolvedNodes[navRule.direction] : null;
-        };
-        for (i = 0; i < d.edges.length; i++) {
-          const edge = options.structure.edges[d.edges[i]];
-          edge.navigationRules.forEach((rule) => {
-            if (!target) {
-              target = findTarget(rule, edge);
-            }
-          });
-          if (target) {
-            break;
-          }
-        }
-        if (target) {
-          return inputHandler.moveTo(target);
-        }
-        return void 0;
-      }
-    }
-  };
-  inputHandler.enter = () => {
-    if (options.entryPoint) {
-      return inputHandler.moveTo(options.entryPoint);
-    } else {
-      console.error("No entry point was specified in InputOptions, returning undefined");
-      return;
-    }
-  };
-  inputHandler.exit = () => {
-    if (options.exitPoint) {
-      return options.exitPoint;
-    } else {
-      console.error("No exit point was specified in InputOptions, returning undefined");
-      return;
-    }
-  };
-  inputHandler.keydownValidator = (e) => {
-    const direction = keyBindings[e.code];
-    if (direction) {
-      return direction;
-    }
-  };
-  inputHandler.focus = (renderId) => {
-    const node = document.getElementById(renderId);
-    if (node) {
-      node.focus();
-    }
-  };
-  inputHandler.setNavigationKeyBindings = (navKeyBindings) => {
-    if (!navKeyBindings) {
-      keyBindings = defaultKeyBindings;
-      directions = GenericFullNavigationRules;
-    } else {
-      keyBindings = {};
-      directions = navKeyBindings;
-      Object.keys(navKeyBindings).forEach((direction) => {
-        const navOption = navKeyBindings[direction];
-        keyBindings[navOption.key] = direction;
-      });
-    }
-  };
-  inputHandler.setNavigationKeyBindings(options.navigationRules);
-  return inputHandler;
-};
-
-// src/rendering.ts
-var rendering_default = (options) => {
-  const setActiveDescendant = (e) => {
-    renderer.wrapper.setAttribute("aria-activedescendant", e.srcElement.id);
-  };
-  const removeActiveDescendant = () => {
-    renderer.wrapper.setAttribute("aria-activedescendant", "");
-  };
-  let renderer = {};
-  let initialized = false;
-  let defaults = {
-    cssClass: NodeElementDefaults.cssClass,
-    spatialProperties: { ...NodeElementDefaults.spatialProperties },
-    semantics: { ...NodeElementDefaults.semantics },
-    parentSemantics: { ...NodeElementDefaults.parentSemantics },
-    existingElement: { ...NodeElementDefaults.existingElement }
-  };
-  if (options.defaults) {
-    defaults.cssClass = options.defaults.cssClass || defaults.cssClass;
-    defaults.spatialProperties = options.defaults.spatialProperties ? { ...defaults.spatialProperties, ...options.defaults.spatialProperties } : defaults.spatialProperties;
-    defaults.semantics = options.defaults.semantics ? { ...defaults.semantics, ...options.defaults.semantics } : defaults.semantics;
-    defaults.parentSemantics = options.defaults.parentSemantics ? { ...defaults.parentSemantics, ...options.defaults.parentSemantics } : defaults.parentSemantics;
-    defaults.existingElement = options.defaults.existingElement ? { ...defaults.existingElement, ...options.defaults.existingElement } : defaults.existingElement;
-  }
-  renderer.initialize = () => {
-    if (initialized) {
-      console.error(
-        `The renderer wrapper has already been initialized successfully, RenderingOptions.suffixId is: ${options.suffixId}. No further action was taken.`
-      );
-      return;
-    }
-    if (options.root && document.getElementById(options.root.id)) {
-      renderer.root = document.getElementById(options.root.id);
-    } else {
-      console.error(
-        "No root element found, cannot build: RenderingOptions.root.id must reference an existing DOM element in order to render children."
-      );
-      return;
-    }
-    renderer.root.style.position = "relative";
-    renderer.root.classList.add("dn-root");
-    if (!options.suffixId) {
-      console.error("No suffix id found: options.suffixId must be specified.");
-      return;
-    }
-    renderer.wrapper = document.createElement("div");
-    renderer.wrapper.id = "dn-wrapper-" + options.suffixId;
-    renderer.wrapper.setAttribute("role", "application");
-    renderer.wrapper.setAttribute("aria-label", options.root.description || "Data navigation structure");
-    renderer.wrapper.setAttribute("aria-activedescendant", "");
-    renderer.wrapper.classList.add("dn-wrapper");
-    renderer.wrapper.style.width = options.root && options.root.width ? options.root.width : "100%";
-    if (options.root && options.root.height) {
-      renderer.wrapper.style.height = options.root.height;
-    }
-    if (options.entryButton && options.entryButton.include) {
-      renderer.entryButton = document.createElement("button");
-      renderer.entryButton.id = "dn-entry-button-" + options.suffixId;
-      renderer.entryButton.classList.add("dn-entry-button");
-      renderer.entryButton.innerText = `Enter navigation area`;
-      if (options.entryButton.callbacks && options.entryButton.callbacks.click) {
-        renderer.entryButton.addEventListener("click", options.entryButton.callbacks.click);
-      }
-      if (options.entryButton.callbacks && options.entryButton.callbacks.focus) {
-        renderer.entryButton.addEventListener("focus", options.entryButton.callbacks.focus);
-      }
-      renderer.wrapper.appendChild(renderer.entryButton);
-    }
-    renderer.root.appendChild(renderer.wrapper);
-    if (options.exitElement?.include) {
-      renderer.exitElement = document.createElement("div");
-      renderer.exitElement.id = "dn-exit-" + options.suffixId;
-      renderer.exitElement.classList.add("dn-exit-position");
-      renderer.exitElement.innerText = `End of data structure.`;
-      renderer.exitElement.setAttribute("aria-label", `End of data structure.`);
-      renderer.exitElement.setAttribute("role", "note");
-      renderer.exitElement.setAttribute("tabindex", "-1");
-      renderer.exitElement.style.display = "none";
-      renderer.exitElement.addEventListener("focus", (e) => {
-        renderer.exitElement.style.display = "block";
-        renderer.clearStructure();
-        if (options.exitElement?.callbacks?.focus) {
-          options.exitElement.callbacks.focus(e);
-        }
-      });
-      renderer.exitElement.addEventListener("blur", (e) => {
-        renderer.exitElement.style.display = "none";
-        if (options.exitElement?.callbacks?.blur) {
-          options.exitElement.callbacks.blur(e);
-        }
-      });
-      renderer.root.appendChild(renderer.exitElement);
-    }
-    initialized = true;
-    return renderer.root;
-  };
-  renderer.render = (nodeData) => {
-    const id = nodeData.renderId + "";
-    let d = options.elementData[id];
-    if (!d) {
-      console.warn(`Render data not found with renderId: ${id}. Failed to render.`);
-      return;
-    }
-    if (!initialized) {
-      console.error("render() was called before initialize(), renderer must be initialized first.");
-      return;
-    }
-    let useExisting = false;
-    let existingSpatialProperties = {};
-    const resolveProp = (prop, subprop, checkExisting) => {
-      const p1 = d[prop] || defaults[prop];
-      const s1 = !(checkExisting && useExisting) ? p1[subprop] : existingSpatialProperties[subprop];
-      const s2 = defaults[prop][subprop];
-      return typeof p1 === "function" ? p1(d, nodeData.datum) : typeof s1 === "function" ? s1(d, nodeData.datum) : s1 || s2 || (!subprop ? p1 : void 0);
-    };
-    useExisting = resolveProp("existingElement", "useForSpatialProperties");
-    existingSpatialProperties = resolveProp("existingElement", "spatialProperties");
-    const width = parseFloat(resolveProp("spatialProperties", "width", true) || 0);
-    const height = parseFloat(resolveProp("spatialProperties", "height", true) || 0);
-    const x = parseFloat(resolveProp("spatialProperties", "x", true) || 0);
-    const y = parseFloat(resolveProp("spatialProperties", "y", true) || 0);
-    const node = document.createElement(resolveProp("parentSemantics", "elementType"));
-    const wrapperAttrs = resolveProp("parentSemantics", "attributes");
-    if (typeof wrapperAttrs === "object") {
-      Object.keys(wrapperAttrs).forEach((wrapperAttr) => {
-        node.setAttribute(wrapperAttr, wrapperAttrs[wrapperAttr]);
-      });
-    }
-    node.setAttribute("role", resolveProp("parentSemantics", "role"));
-    node.id = id;
-    node.classList.add("dn-node");
-    node.classList.add(resolveProp("cssClass"));
-    node.style.width = width + "px";
-    node.style.height = height + "px";
-    node.style.left = x + "px";
-    node.style.top = y + "px";
-    node.setAttribute("tabindex", "0");
-    node.addEventListener("focus", setActiveDescendant);
-    node.addEventListener("blur", removeActiveDescendant);
-    const nodeText = document.createElement(resolveProp("semantics", "elementType"));
-    const attributes = resolveProp("semantics", "attributes");
-    if (typeof attributes === "object") {
-      Object.keys(attributes).forEach((attribute) => {
-        node.setAttribute(attribute, attributes[attribute]);
-      });
-    }
-    nodeText.setAttribute("role", resolveProp("semantics", "role"));
-    nodeText.classList.add("dn-node-text");
-    if (d.showText) {
-      nodeText.innerText = d.semantics.label;
-    }
-    const label = resolveProp("semantics", "label");
-    if (!label) {
-      console.error(
-        "Accessibility error: a label must be supplied to every rendered element using semantics.label."
-      );
-    }
-    nodeText.setAttribute("aria-label", label);
-    node.appendChild(nodeText);
-    const hasPath = resolveProp("spatialProperties", "path");
-    if (hasPath) {
-      const totalWidth = width + x + 10;
-      const totalHeight = height + y + 10;
-      const svg = document.createElementNS("http://www.w3.org/2000/svg", "svg");
-      svg.setAttribute("width", totalWidth + "");
-      svg.setAttribute("height", totalHeight + "");
-      svg.setAttribute("viewBox", `0 0 ${totalWidth} ${totalHeight}`);
-      svg.style.left = -x + "px";
-      svg.style.top = -y + "px";
-      svg.classList.add("dn-node-svg");
-      svg.setAttribute("role", "presentation");
-      svg.setAttribute("focusable", "false");
-      const path = document.createElementNS("http://www.w3.org/2000/svg", "path");
-      path.setAttribute("d", hasPath);
-      path.classList.add("dn-node-path");
-      svg.appendChild(path);
-      node.appendChild(svg);
-    }
-    renderer.wrapper.appendChild(node);
-    return node;
-  };
-  renderer.remove = (renderId) => {
-    const node = document.getElementById(renderId);
-    if (renderer.wrapper.getAttribute("aria-activedescendant") === renderId) {
-      renderer.wrapper.setAttribute("aria-activedescendant", "");
-    }
-    if (node) {
-      node.removeEventListener("focus", setActiveDescendant);
-      node.removeEventListener("blur", removeActiveDescendant);
-      node.remove();
-    }
-  };
-  renderer.clearStructure = () => {
-    [...renderer.wrapper.children].forEach((child) => {
-      if (!(renderer.entryButton && renderer.entryButton === child)) {
-        renderer.remove(child.id);
-      }
-    });
-  };
-  return renderer;
-};
-
-// src/index.ts
-var src_default = { structure: structure_default, input: input_default, rendering: rendering_default };
-export {
-  src_default as default
-};