data-navigator 2.2.0 → 2.2.2

package/dist/index.js

@@ -1,1452 +1,1339 @@
-function _array_like_to_array(arr, len) {
-    if (len == null || len > arr.length) len = arr.length;
-    for(var i = 0, arr2 = new Array(len); i < len; i++)arr2[i] = arr[i];
-    return arr2;
-}
-function _array_without_holes(arr) {
-    if (Array.isArray(arr)) return _array_like_to_array(arr);
-}
-function _define_property(obj, key, value) {
-    if (key in obj) {
-        Object.defineProperty(obj, key, {
-            value: value,
-            enumerable: true,
-            configurable: true,
-            writable: true
-        });
-    } else {
-        obj[key] = value;
-    }
-    return obj;
-}
-function _iterable_to_array(iter) {
-    if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter);
-}
-function _non_iterable_spread() {
-    throw new TypeError("Invalid attempt to spread non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
-}
-function _object_spread(target) {
-    for(var i = 1; i < arguments.length; i++){
-        var source = arguments[i] != null ? arguments[i] : {};
-        var ownKeys = Object.keys(source);
-        if (typeof Object.getOwnPropertySymbols === "function") {
-            ownKeys = ownKeys.concat(Object.getOwnPropertySymbols(source).filter(function(sym) {
-                return Object.getOwnPropertyDescriptor(source, sym).enumerable;
-            }));
-        }
-        ownKeys.forEach(function(key) {
-            _define_property(target, key, source[key]);
-        });
-    }
-    return target;
-}
-function ownKeys(object, enumerableOnly) {
-    var keys = Object.keys(object);
-    if (Object.getOwnPropertySymbols) {
-        var symbols = Object.getOwnPropertySymbols(object);
-        if (enumerableOnly) {
-            symbols = symbols.filter(function(sym) {
-                return Object.getOwnPropertyDescriptor(object, sym).enumerable;
-            });
-        }
-        keys.push.apply(keys, symbols);
-    }
-    return keys;
-}
-function _object_spread_props(target, source) {
-    source = source != null ? source : {};
-    if (Object.getOwnPropertyDescriptors) {
-        Object.defineProperties(target, Object.getOwnPropertyDescriptors(source));
-    } else {
-        ownKeys(Object(source)).forEach(function(key) {
-            Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
-        });
-    }
-    return target;
-}
-function _to_consumable_array(arr) {
-    return _array_without_holes(arr) || _iterable_to_array(arr) || _unsupported_iterable_to_array(arr) || _non_iterable_spread();
-}
-function _type_of(obj) {
-    "@swc/helpers - typeof";
-    return obj && typeof Symbol !== "undefined" && obj.constructor === Symbol ? "symbol" : typeof obj;
-}
-function _unsupported_iterable_to_array(o, minLen) {
-    if (!o) return;
-    if (typeof o === "string") return _array_like_to_array(o, minLen);
-    var n = Object.prototype.toString.call(o).slice(8, -1);
-    if (n === "Object" && o.constructor) n = o.constructor.name;
-    if (n === "Map" || n === "Set") return Array.from(n);
-    if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _array_like_to_array(o, minLen);
-}
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = function(target, all) {
-    for(var name in all)__defProp(target, name, {
-        get: all[name],
-        enumerable: true
-    });
-};
-var __copyProps = function(to, from, except, desc) {
-    if (from && typeof from === "object" || typeof from === "function") {
-        var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
-        try {
-            var _loop = function() {
-                var key = _step.value;
-                if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
-                    get: function() {
-                        return from[key];
-                    },
-                    enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
-                });
-            };
-            for(var _iterator = __getOwnPropNames(from)[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true)_loop();
-        } catch (err) {
-            _didIteratorError = true;
-            _iteratorError = err;
-        } finally{
-            try {
-                if (!_iteratorNormalCompletion && _iterator.return != null) {
-                    _iterator.return();
-                }
-            } finally{
-                if (_didIteratorError) {
-                    throw _iteratorError;
-                }
-            }
-        }
-    }
-    return to;
-};
-var __toCommonJS = function(mod) {
-    return __copyProps(__defProp({}, "__esModule", {
-        value: true
-    }), mod);
-};
-// src/index.ts
-var src_exports = {};
-__export(src_exports, {
-    default: function() {
-        return src_default;
-    }
-});
-module.exports = __toCommonJS(src_exports);
 // src/consts.ts
 var SemanticKeys = {
-    Escape: true,
-    Enter: true,
-    Backspace: true,
-    ArrowLeft: true,
-    ArrowRight: true,
-    ArrowUp: true,
-    ArrowDown: true
+  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"
+  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 TypicallyUnreservedKeys = ["KeyW", "KeyJ", "LeftBracket", "RightBracket", "Slash", "Backslash"];
 var TypicallyUnreservedKeyPairs = [
-    [
-        "LeftBracket",
-        "RightBracket"
-    ],
-    [
-        "Slash",
-        "Backslash"
-    ]
+  ["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"
-    }
+  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"
-    ]
+  ["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"
-    }
+  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
-    }
+  cssClass: void 0,
+  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 = function(d, descriptionOptions) {
-    var keys = Object.keys(d);
-    var description = "";
-    keys.forEach(function(key) {
-        description += "".concat(descriptionOptions && descriptionOptions.omitKeyNames ? "" : key + ": ").concat(d[key], ". ");
-    });
-    description += descriptionOptions && descriptionOptions.semanticLabel || "Data point.";
-    return description;
+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 = function(s) {
-    return "_" + s.replace(/[^a-zA-Z0-9_-]+/g, "_");
+var createValidId = (s) => {
+  return "_" + s.replace(/[^a-zA-Z0-9_-]+/g, "_");
 };
+
 // src/structure.ts
-var structure_default = function(options) {
-    if (options.dataType === "vega-lite" || options.dataType === "vl" || options.dataType === "Vega-Lite") {
-        return buildNodeStructureFromVegaLite(options);
-    } else {
-        return buildStructure(options);
-    }
+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 = function(options) {
-    var navigationRules = GenericLimitedNavigationRules;
-    var nodes = {};
-    var edges = {};
-    var elementData = {};
-    var total = 0;
-    var includeGroup = options.groupInclusionCriteria ? options.groupInclusionCriteria : function() {
-        return true;
-    };
-    var includeItem = options.itemInclusionCriteria ? options.itemInclusionCriteria : function() {
-        return true;
-    };
-    var includeDataProperties = options.datumInclusionCriteria ? options.datumInclusionCriteria : function() {
-        return true;
-    };
-    var offset = options.vegaLiteView._renderer._origin;
-    var groupParent = options.vegaLiteView._scenegraph.root.items[0].mark.items[0];
-    var idBuilder = function(i2, level) {
-        if (i2["data-navigator-id"]) {
-            return i2["data-navigator-id"];
-        }
-        var id = "dn-node-".concat(level, "-").concat(total);
-        total++;
-        i2["data-navigator-id"] = id;
-        return id;
-    };
-    var edgeBuilder = function(id) {
-        var node = nodes[id];
-        var index = node.index;
-        var level = node.level;
-        var parent = node.parent;
-        var edgeList = [];
-        var previous = parent.items[index - 1];
-        if (previous) {
-            var previousId = idBuilder(previous, level);
-            if (nodes[previousId]) {
-                var previousEdge = "".concat(previousId, "-").concat(node.id);
-                edgeList.push(previousEdge);
-                if (!edges[previousEdge]) {
-                    edges[previousEdge] = {
-                        source: previousId,
-                        target: node.id,
-                        navigationRules: [
-                            "left",
-                            "right"
-                        ]
-                    };
-                }
-            }
-        }
-        var next = parent.items[index + 1];
-        if (next) {
-            var nextId = idBuilder(next, level);
-            if (nodes[nextId]) {
-                var nextEdge = "".concat(node.id, "-").concat(nextId);
-                edgeList.push(nextEdge);
-                if (!edges[nextEdge]) {
-                    edges[nextEdge] = {
-                        source: node.id,
-                        target: nextId,
-                        navigationRules: [
-                            "left",
-                            "right"
-                        ]
-                    };
-                }
-            }
-        }
-        if (level === "group" && parent.items[index].items) {
-            var g = parent.items[index].items[0].mark.items[0].items || parent.items[index].items;
-            var firstChild = g[0];
-            var firstChildId = idBuilder(firstChild, "item");
-            if (nodes[firstChildId]) {
-                var firstChildEdge = "".concat(node.id, "-").concat(firstChildId);
-                edgeList.push(firstChildEdge);
-                if (!edges[firstChildEdge]) {
-                    edges[firstChildEdge] = {
-                        source: node.id,
-                        target: firstChildId,
-                        navigationRules: [
-                            "parent",
-                            "child"
-                        ]
-                    };
-                }
-            }
-        } else if (level === "item") {
-            var parentId = idBuilder(parent, "group");
-            if (nodes[parentId]) {
-                var parentEdge = "".concat(parentId, "-").concat(node.id);
-                edgeList.push(parentEdge);
-                if (!edges[parentEdge]) {
-                    edges[parentEdge] = {
-                        source: parentId,
-                        target: node.id,
-                        navigationRules: [
-                            "parent",
-                            "child"
-                        ]
-                    };
-                }
-            }
+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"]
+          };
         }
-        if (options.exitFunction) {
-            edgeList.push("any-exit");
-            if (!edges["any-exit"]) {
-                edges["any-exit"] = {
-                    source: options.getCurrent,
-                    target: options.exitFunction,
-                    navigationRules: [
-                        "exit"
-                    ]
-                };
-            }
+      }
+    }
+    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"]
+          };
         }
-        edgeList.push("any-undo");
-        if (!edges["any-undo"]) {
-            edges["any-undo"] = {
-                source: options.getCurrent,
-                target: options.getPrevious,
-                navigationRules: [
-                    "undo"
-                ]
-            };
+      }
+    }
+    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"]
+          };
         }
-        return edgeList;
-    };
-    var nodeBuilder = function(item, level, offset2, index, parent) {
-        var id = idBuilder(item, level);
-        var renderId = "render-" + id;
-        var 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(function(key) {
-                var 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;
-                }
-            });
+      }
+    } 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"]
+          };
         }
-        elementData[renderId].semantics = {};
-        elementData[renderId].semantics.label = options.nodeDescriber ? options.nodeDescriber(nodes[id].d, item, level) : describeNode(nodes[id].d);
-    };
-    var i = 0;
-    var groups = groupParent.items;
-    groups.forEach(function(group) {
-        if (includeGroup(group, i, options.vegaLiteSpec)) {
-            nodeBuilder(group, "group", offset, i, groupParent);
-            var j = 0;
-            var g = group.items[0].mark.items[0].items ? group.items[0].mark.items[0] : group;
-            g.items.forEach(function(item) {
-                if (includeItem(item, j, group, options.vegaLiteSpec)) {
-                    nodeBuilder(item, "item", offset, j, g);
-                }
-                j++;
-            });
+      }
+    }
+    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;
         }
-        i++;
-    });
-    Object.keys(nodes).forEach(function(n) {
-        nodes[n].edges = edgeBuilder(n);
-    });
-    return {
-        nodes: nodes,
-        edges: edges,
-        elementData: elementData,
-        navigationRules: navigationRules
-    };
-};
-var addSimpleDataIDs = function(options) {
-    var i = 0;
-    var keyCounter = {};
-    options.data.forEach(function(d) {
-        var id = typeof options.idKey === "function" ? options.idKey(d) : options.idKey;
-        d[id] = "_" + i;
-        if (options.keysForIdGeneration) {
-            options.keysForIdGeneration.forEach(function(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]++;
-                    }
-                }
-            });
+      });
+    }
+    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);
         }
-        i++;
-    });
+        j++;
+      });
+    }
+    i++;
+  });
+  Object.keys(nodes).forEach((n) => {
+    nodes[n].edges = edgeBuilder(n);
+  });
+  return {
+    nodes,
+    edges,
+    elementData,
+    navigationRules
+  };
 };
-var buildNodes = function(options) {
-    var nodes = {};
-    options.data.forEach(function(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.");
-        }
-        var idKey = typeof options.idKey === "function" ? options.idKey(d) : options.idKey;
-        var id = d[idKey];
-        if (!id) {
-            console.error("Building nodes. Each datum in options.data must contain an id. When matching the id key string ".concat(idKey, ", this datum has no id: ").concat(JSON.stringify(d), "."));
-            return;
-        }
-        if (!nodes[id]) {
-            var renderIdKey = typeof options.renderIdKey === "function" ? options.renderIdKey(d) : options.renderIdKey;
-            nodes[id] = {
-                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: ".concat(id, "."));
-            return;
+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]++;
+          }
         }
-    });
-    return nodes;
+      });
+    }
+    i++;
+  });
 };
-var scaffoldDimensions = function(options, nodes) {
-    var _options_dimensions_parentOptions, _options_dimensions;
-    var dimensions = {};
-    if ((_options_dimensions = options.dimensions) === null || _options_dimensions === void 0 ? void 0 : (_options_dimensions_parentOptions = _options_dimensions.parentOptions) === null || _options_dimensions_parentOptions === void 0 ? void 0 : _options_dimensions_parentOptions.addLevel0) {
-        var level0 = options.dimensions.parentOptions.addLevel0;
-        nodes[level0.id] = _object_spread_props(_object_spread({}, level0), {
-            dimensionLevel: 0
-        });
+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.`
+      );
     }
-    var rules = _to_consumable_array(GenericFullNavigationDimensions);
-    var setExtents = function(val, dim) {
-        var min = dim.numericalExtents[0];
-        var max = dim.numericalExtents[1];
-        dim.numericalExtents[0] = min < val ? min : val;
-        dim.numericalExtents[1] = max > val ? max : val;
-    };
-    options.data.forEach(function(d) {
-        var ods = options.dimensions.values || [];
-        var i = 0;
-        ods.forEach(function(dim) {
-            if (!dim.dimensionKey) {
-                console.error("Building nodes, parsing dimensions. Each dimension in options.dimensions must contain a dimensionKey. This dimension has no key: ".concat(JSON.stringify(dim), "."));
-                return;
+    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;
             }
-            if (dim.dimensionKey in d) {
-                var _dim_operations;
-                var value = d[dim.dimensionKey];
-                var keepValue = typeof ((_dim_operations = dim.operations) === null || _dim_operations === void 0 ? void 0 : _dim_operations.filterFunction) === "function" ? dim.operations.filterFunction(d, dim) : true;
-                if (value !== void 0 && keepValue) {
-                    if (!dim.type) {
-                        dim.type = (typeof value === "undefined" ? "undefined" : _type_of(value)) === "bigint" || typeof value === "number" ? "numerical" : "categorical";
-                    }
-                    if (!dimensions[dim.dimensionKey]) {
-                        var _dim_operations1, _dim_operations2;
-                        var id2 = typeof dim.nodeId === "function" ? dim.nodeId(dim, options.data) : dim.nodeId || createValidId(dim.dimensionKey);
-                        var 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_operations1 = dim.operations) === null || _dim_operations1 === void 0 ? void 0 : _dim_operations1.compressSparseDivisions) || false,
-                                sortFunction: ((_dim_operations2 = dim.operations) === null || _dim_operations2 === void 0 ? void 0 : _dim_operations2.sortFunction) || void 0
-                            },
-                            behavior: dim.behavior || {
-                                extents: "circular"
-                            },
-                            navigationRules: dim.navigationRules || {
-                                sibling_sibling: rules.length ? _to_consumable_array(rules.shift()) : [
-                                    "previous_" + dim.dimensionKey,
-                                    "next_" + dim.dimensionKey
-                                ],
-                                parent_child: [
-                                    "parent_" + dim.dimensionKey,
-                                    "child"
-                                ]
-                            }
-                        };
-                        nodes[id2] = {
-                            id: id2,
-                            renderId: renderId,
-                            derivedNode: dim.dimensionKey,
-                            edges: [],
-                            dimensionLevel: 1,
-                            data: dimensions[dim.dimensionKey],
-                            renderingStrategy: dim.renderingStrategy || "singleSquare"
-                        };
-                    }
-                    var dimension = dimensions[dim.dimensionKey];
-                    var targetDivision = null;
-                    if (dim.type === "categorical") {
-                        var _dim_divisionOptions;
-                        var divisionId = typeof ((_dim_divisionOptions = dim.divisionOptions) === null || _dim_divisionOptions === void 0 ? void 0 : _dim_divisionOptions.divisionNodeIds) === "function" ? dim.divisionOptions.divisionNodeIds(dim.dimensionKey, value, i) : createValidId(dimension.nodeId + "_" + value);
-                        targetDivision = dimension.divisions[divisionId];
-                        if (!targetDivision) {
-                            var _dim_divisionOptions1, _dim_divisionOptions2, _dim_divisionOptions3;
-                            targetDivision = dimension.divisions[divisionId] = {
-                                id: divisionId,
-                                sortFunction: ((_dim_divisionOptions1 = dim.divisionOptions) === null || _dim_divisionOptions1 === void 0 ? void 0 : _dim_divisionOptions1.sortFunction) || void 0,
-                                values: {}
-                            };
-                            var divisionRenderId = typeof ((_dim_divisionOptions2 = dim.divisionOptions) === null || _dim_divisionOptions2 === void 0 ? void 0 : _dim_divisionOptions2.divisionRenderIds) === "function" ? dim.divisionOptions.divisionRenderIds(dim.dimensionKey, value, i) : divisionId;
-                            nodes[divisionId] = {
-                                id: divisionId,
-                                renderId: divisionRenderId,
-                                derivedNode: dim.dimensionKey,
-                                edges: [],
-                                dimensionLevel: 2,
-                                data: _object_spread({}, targetDivision),
-                                renderingStrategy: ((_dim_divisionOptions3 = dim.divisionOptions) === null || _dim_divisionOptions3 === void 0 ? void 0 : _dim_divisionOptions3.renderingStrategy) || "singleSquare"
-                            };
-                            nodes[divisionId].data[dim.dimensionKey] = value;
-                        }
-                    } else {
-                        targetDivision = dimension.divisions[dimension.nodeId];
-                        if (!targetDivision) {
-                            var _dim_divisionOptions4;
-                            targetDivision = dimension.divisions[dimension.nodeId] = {
-                                id: dimension.nodeId,
-                                sortFunction: ((_dim_divisionOptions4 = dim.divisionOptions) === null || _dim_divisionOptions4 === void 0 ? void 0 : _dim_divisionOptions4.sortFunction) || void 0,
-                                values: {}
-                            };
-                        }
-                        if (!dim.operations) {
-                            dim.operations = {};
-                        }
-                        var 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);
-                        }
-                    }
-                    var id = typeof options.idKey === "function" ? options.idKey(d) : options.idKey;
-                    targetDivision.values[d[id]] = d;
-                }
+          } else {
+            targetDivision = dimension.divisions[dimension.nodeId];
+            if (!targetDivision) {
+              targetDivision = dimension.divisions[dimension.nodeId] = {
+                id: dimension.nodeId,
+                sortFunction: dim.divisionOptions?.sortFunction || void 0,
+                values: {}
+              };
             }
-            i++;
-        });
-    });
-    Object.keys(dimensions).forEach(function(s) {
-        var _dimension_operations;
-        var dimension = dimensions[s];
-        var divisions = dimension.divisions;
-        if (dimension.type === "numerical") {
-            divisions[dimension.nodeId].values = Object.fromEntries(Object.entries(divisions[dimension.nodeId].values).sort(function(a, b) {
-                var _dimension_operations;
-                return typeof ((_dimension_operations = dimension.operations) === null || _dimension_operations === void 0 ? void 0 : _dimension_operations.sortFunction) === "function" ? dimension.operations.sortFunction(a[1], b[1], dimension) : a[1][s] - b[1][s];
-            }));
-            var values = divisions[dimension.nodeId].values;
-            if (dimension.numericalExtents[0] !== Infinity && dimension.subdivisions !== 1) {
-                var valueKeys = Object.keys(values);
-                var subDivisions = typeof dimension.subdivisions === "function" ? dimension.subdivisions(s, values) : dimension.subdivisions;
-                var range = dimension.numericalExtents[1] - dimension.numericalExtents[0];
-                var interval = range / subDivisions;
-                var i = dimension.numericalExtents[0] + interval;
-                var divisionCount = 0;
-                var index = 0;
-                for(i = dimension.numericalExtents[0] + interval; i <= dimension.numericalExtents[1]; i += interval){
-                    var _dimension_divisionOptions, _dimension_divisionOptions1, _dimension_divisionOptions2, _dimension_divisionOptions3;
-                    var divisionId = typeof ((_dimension_divisionOptions = dimension.divisionOptions) === null || _dimension_divisionOptions === void 0 ? void 0 : _dimension_divisionOptions.divisionNodeIds) === "function" ? dimension.divisionOptions.divisionNodeIds(s, i, i) : dimension.nodeId + "_" + i;
-                    dimension.divisions[divisionId] = {
-                        id: divisionId,
-                        sortFunction: ((_dimension_divisionOptions1 = dimension.divisionOptions) === null || _dimension_divisionOptions1 === void 0 ? void 0 : _dimension_divisionOptions1.sortFunction) || void 0,
-                        values: {}
-                    };
-                    var divisionRenderId = typeof ((_dimension_divisionOptions2 = dimension.divisionOptions) === null || _dimension_divisionOptions2 === void 0 ? void 0 : _dimension_divisionOptions2.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_divisionOptions3 = dimension.divisionOptions) === null || _dimension_divisionOptions3 === void 0 ? void 0 : _dimension_divisionOptions3.renderingStrategy) || "singleSquare"
-                    };
-                    var limit = false;
-                    while(!limit && index < valueKeys.length){
-                        var node = values[valueKeys[index]];
-                        var value = node[s];
-                        if (value <= i) {
-                            dimension.divisions[divisionId].values[node.id] = node;
-                        } else {
-                            i += interval;
-                            limit = true;
-                        }
-                        index++;
-                    }
-                    divisionCount++;
-                }
-                delete divisions[s];
+            if (!dim.operations) {
+              dim.operations = {};
             }
-        } else if (typeof ((_dimension_operations = dimension.operations) === null || _dimension_operations === void 0 ? void 0 : _dimension_operations.sortFunction) === "function") {
-            dimension.divisions = Object.fromEntries(Object.entries(divisions).sort(function(a, b) {
-                return dimension.operations.sortFunction(a[1], b[1], dimension);
-            }));
-        }
-        var divisionKeys = Object.keys(dimension.divisions);
-        divisionKeys.forEach(function(d) {
-            var division = dimension.divisions[d];
-            if (typeof division.sortFunction === "function") {
-                division.values = Object.fromEntries(Object.entries(division.values).sort(function(a, b) {
-                    return division.sortFunction(a[1], b[1], division);
-                }));
+            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(function(s) {
-        var dimension = dimensions[s];
-        if (dimension.operations.compressSparseDivisions) {
-            var divisionKeys = Object.keys(dimension.divisions);
-            var values = {};
-            var sparse = true;
-            divisionKeys.forEach(function(d) {
-                var division = dimension.divisions[d];
-                var valueKeys = Object.keys(division.values);
-                if (valueKeys.length <= 1) {
-                    valueKeys.forEach(function(vk) {
-                        values[vk] = _object_spread({}, division.values[vk]);
-                    });
-                } else {
-                    sparse = false;
-                }
-            });
-            if (sparse) {
-                var newDivision = {
-                    id: dimension.nodeId,
-                    values: values
-                };
-                divisionKeys.forEach(function(d) {
-                    delete nodes[d];
-                });
-                dimension.divisions = {};
-                dimension.divisions[dimension.nodeId] = newDivision;
+  });
+  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);
+          })
+        );
+      }
     });
-    if (options.dimensions.adjustDimensions) {
-        dimensions = options.dimensions.adjustDimensions(dimensions);
+  });
+  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;
+      }
     }
-    return dimensions;
+  });
+  if (options.dimensions.adjustDimensions) {
+    dimensions = options.dimensions.adjustDimensions(dimensions);
+  }
+  return dimensions;
 };
-var buildEdges = function(options, nodes, dimensions) {
-    var edges = {};
-    var addEdgeToNode = function(nodeId, edgeId) {
-        if (nodes[nodeId].edges.indexOf(edgeId) === -1) {
-            nodes[nodeId].edges.push(edgeId);
-        }
-    };
-    var createEdge = function(source, target, rules, addTo) {
-        var id = "".concat(source, "-").concat(target);
-        var targetId = !options.useDirectedEdges ? id : "".concat(target, "-").concat(id);
-        var addToSource = !addTo || addTo === "source";
-        var addToTarget = !addTo || addTo === "target";
-        var checkEdgeRules = function(eId) {
-            if (edges[eId]) {
-                var _edges_eId_navigationRules;
-                (_edges_eId_navigationRules = edges[eId].navigationRules).push.apply(_edges_eId_navigationRules, _to_consumable_array(rules || []));
-            } else {
-                edges[eId] = {
-                    source: source,
-                    target: target,
-                    navigationRules: rules ? _to_consumable_array(rules) : []
-                };
-            }
+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);
+      }
+    };
+    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 (addToTarget) {
-            addEdgeToNode(target, targetId);
+      }
+      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
+          );
         }
-    };
-    if (dimensions && Object.keys(dimensions).length) {
-        var _options_dimensions_parentOptions_level1Options, _options_dimensions_parentOptions, _options_dimensions, _options_dimensions1, _po_level1Options_behavior, _po_level1Options, _po_level1Options_navigationRules, _po_level1Options1, _po_level1Options_navigationRules1, _po_level1Options2;
-        var dimensionKeys = Object.keys(dimensions);
-        var hasOrder = (_options_dimensions = options.dimensions) === null || _options_dimensions === void 0 ? void 0 : (_options_dimensions_parentOptions = _options_dimensions.parentOptions) === null || _options_dimensions_parentOptions === void 0 ? void 0 : (_options_dimensions_parentOptions_level1Options = _options_dimensions_parentOptions.level1Options) === null || _options_dimensions_parentOptions_level1Options === void 0 ? void 0 : _options_dimensions_parentOptions_level1Options.order;
-        var order = hasOrder || dimensionKeys;
-        var l = 0;
-        var po = ((_options_dimensions1 = options.dimensions) === null || _options_dimensions1 === void 0 ? void 0 : _options_dimensions1.parentOptions) || {};
-        var extents = ((_po_level1Options = po.level1Options) === null || _po_level1Options === void 0 ? void 0 : (_po_level1Options_behavior = _po_level1Options.behavior) === null || _po_level1Options_behavior === void 0 ? void 0 : _po_level1Options_behavior.extents) || "terminal";
-        var level0 = po.addLevel0;
-        var parentRules = level0 ? ((_po_level1Options1 = po.level1Options) === null || _po_level1Options1 === void 0 ? void 0 : (_po_level1Options_navigationRules = _po_level1Options1.navigationRules) === null || _po_level1Options_navigationRules === void 0 ? void 0 : _po_level1Options_navigationRules.parent_child) || [
-            "parent",
-            "child"
-        ] : [];
-        var siblingRules = ((_po_level1Options2 = po.level1Options) === null || _po_level1Options2 === void 0 ? void 0 : (_po_level1Options_navigationRules1 = _po_level1Options2.navigationRules) === null || _po_level1Options_navigationRules1 === void 0 ? void 0 : _po_level1Options_navigationRules1.sibling_sibling) || [
-            "left",
-            "right"
-        ];
-        var 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");
+        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");
         }
-        order.forEach(function(n) {
-            var 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) {
-                var 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(function(s) {
-            var _dimension_behavior, _dimension_behavior1, _dimension_behavior2, _dimension_behavior3;
-            var dimension = dimensions[s];
-            var strat = ((_dimension_behavior = dimension.behavior) === null || _dimension_behavior === void 0 ? void 0 : _dimension_behavior.childmostNavigation) || "within";
-            var matchByIndex = function(i, _a, _b, c) {
-                return c.values[Object.keys(c.values)[i]] || void 0;
-            };
-            var match = strat === "across" && ((_dimension_behavior1 = dimension.behavior) === null || _dimension_behavior1 === void 0 ? void 0 : _dimension_behavior1.childmostMatching) ? (_dimension_behavior2 = dimension.behavior) === null || _dimension_behavior2 === void 0 ? void 0 : _dimension_behavior2.childmostMatching : matchByIndex;
-            var extents2 = ((_dimension_behavior3 = dimension.behavior) === null || _dimension_behavior3 === void 0 ? void 0 : _dimension_behavior3.extents) || "circular";
-            if (!dimension.divisions) {
-                console.error("Parsing dimensions. The dimension using the key ".concat(s, " is missing the divisions property. dimension.divisions should be supplied. ").concat(JSON.stringify(dimension), "."));
-            }
-            var divisionKeys = Object.keys(dimension.divisions);
-            var firstDivision = dimension.divisions[divisionKeys[0]];
-            if (divisionKeys.length !== 1) {
-                createEdge(dimension.nodeId, firstDivision.id, 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 {
-                var valueKeys = Object.keys(firstDivision.values);
-                var 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");
+              createEdge(v[id], parentId, dimension.navigationRules.parent_child, "source");
             }
-            var j = 0;
-            divisionKeys.forEach(function(d) {
-                var 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);
-                }
-                var valueKeys = Object.keys(division.values);
-                if (!options.useDirectedEdges) {
-                    createEdge(dimension.nodeId, division.id, dimension.navigationRules.parent_child, "target");
+            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 {
-                    createEdge(division.id, dimension.nodeId, dimension.navigationRules.parent_child, "source");
-                }
-                var 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");
-                var i = 0;
-                if (valueKeys.length > 1) {
-                    valueKeys.forEach(function(vk) {
-                        var v = division.values[vk];
-                        var id = typeof options.idKey === "function" ? options.idKey(v) : options.idKey;
-                        var 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") {
-                                var 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) {
-                                    var targetId1 = 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]][targetId1], dimension.navigationRules.sibling_sibling);
-                                } else {
-                                    var targetId2 = 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]][targetId2], 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) {
-                                var targetId3 = typeof options.idKey === "function" ? options.idKey(division.values[valueKeys[i + 1]]) : options.idKey;
-                                createEdge(v[id], division.values[valueKeys[i + 1]][targetId3], dimension.navigationRules.sibling_sibling);
-                            }
-                            if (!i && extents2 === "bridgedCousins") {
-                                if (j !== 0) {
-                                    var targetId4 = 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]][targetId4], v[id], dimension.navigationRules.sibling_sibling);
-                                } else {
-                                    var targetId5 = 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]][targetId5], 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 {
-                                var targetDivision = j === divisionKeys.length - 1 && extents2 === "circular" ? dimension.divisions[divisionKeys[0]] : dimension.divisions[divisionKeys[j + 1]];
-                                if (targetDivision) {
-                                    var target = match(i, v[id], division, targetDivision);
-                                    if (target) {
-                                        var targetId6 = typeof options.idKey === "function" ? options.idKey(target) : options.idKey;
-                                        createEdge(v[id], target[targetId6], dimension.navigationRules.sibling_sibling);
-                                    }
-                                }
-                            }
-                        }
-                        i++;
-                    });
-                }
-                j++;
-            });
-        });
-    }
-    Object.keys(nodes).forEach(function(nodeKey) {
-        var _options_genericEdges;
-        var node = nodes[nodeKey];
-        if ((_options_genericEdges = options.genericEdges) === null || _options_genericEdges === void 0 ? void 0 : _options_genericEdges.length) {
-            options.genericEdges.forEach(function(e) {
-                if (!edges[e.edgeId]) {
-                    edges[e.edgeId] = e.edge;
+                  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
+                  );
                 }
-                if (!e.conditional || e.conditional && e.conditional(node, e)) {
-                    node.edges.push(e.edgeId);
-                }
-            });
-        }
-    });
-    return edges;
-};
-var buildRules = function(options, edges, dimensions) {
-    var rules = options.navigationRules;
-    if (!rules) {
-        var 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 ".concat(dimKeys.length, ". Dimensions counted: ").concat(dimKeys.join(", "), "."));
-        }
-        var importedRules = {};
-        var used = {};
-        var needsKeys = {};
-        var sparePairs = _to_consumable_array(TypicallyUnreservedKeyPairs);
-        var spareKeys = _to_consumable_array(TypicallyUnreservedKeys);
-        var checkKeys = function(k1, k2) {
-            var isPair = k1 && k2;
-            var k1Assigned = false;
-            var k2Assigned = false;
-            if (importedRules[k1] || used[k1]) {
-                used[k1] = _object_spread({}, importedRules[k1]);
-                k1Assigned = true;
-            }
-            if (k2 && (importedRules[k2] || used[k2])) {
-                used[k2] = _object_spread({}, 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.");
+              } 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
+                  );
                 }
-                var pair = _to_consumable_array(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 (!i && extents2 === "bridgedCustom") {
+                createEdge(
+                  dimension.behavior.customBridgePrevious,
+                  v[id],
+                  dimension.navigationRules.sibling_sibling
+                );
+              }
             } else {
-                if (!used[k1] && spareKeys.length) {
-                    var key = spareKeys.shift();
-                    var newPairs = [];
-                    sparePairs.forEach(function(p) {
-                        if (key !== p[0] && key !== p[1]) {
-                            newPairs.push(p);
-                        }
-                    });
-                    sparePairs = newPairs;
-                    used[k1] = {
-                        direction: options.useDirectedEdges ? "target" : "source",
-                        key: key
-                    };
+              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);
+                  }
                 }
-                if (k2 && !used[k2] && spareKeys.length) {
-                    var key1 = spareKeys.shift();
-                    var newPairs1 = [];
-                    sparePairs.forEach(function(p) {
-                        if (key1 !== p[0] && key1 !== p[1]) {
-                            newPairs1.push(p);
-                        }
-                    });
-                    sparePairs = newPairs1;
-                    used[k2] = {
-                        direction: "target",
-                        key: key1
-                    };
-                }
-                if (!spareKeys.length) {
-                    if (!used[k1]) {
-                        needsKeys[k1] = k1;
-                    }
-                    if (k2 && !used[k2]) {
-                        needsKeys[k2] = k2;
-                    }
-                }
-            }
-        };
-        Object.keys(GenericFullNavigationRules).forEach(function(r) {
-            var rule = _object_spread({}, GenericFullNavigationRules[r]);
-            if (options.useDirectedEdges) {
-                rule.direction = "target";
+              }
             }
-            importedRules[r] = rule;
-        });
-        if (dimKeys.length) {
-            var _options_dimensions_parentOptions, _options_dimensions;
-            if ((_options_dimensions = options.dimensions) === null || _options_dimensions === void 0 ? void 0 : (_options_dimensions_parentOptions = _options_dimensions.parentOptions) === null || _options_dimensions_parentOptions === void 0 ? void 0 : _options_dimensions_parentOptions.addLevel0) {
-                var _options_dimensions_parentOptions_level1Options_navigationRules, _options_dimensions_parentOptions_level1Options;
-                var rules2 = ((_options_dimensions_parentOptions_level1Options = options.dimensions.parentOptions.level1Options) === null || _options_dimensions_parentOptions_level1Options === void 0 ? void 0 : (_options_dimensions_parentOptions_level1Options_navigationRules = _options_dimensions_parentOptions_level1Options.navigationRules) === null || _options_dimensions_parentOptions_level1Options_navigationRules === void 0 ? void 0 : _options_dimensions_parentOptions_level1Options_navigationRules.parent_child) || [
-                    "parent",
-                    "child"
-                ];
-                checkKeys(rules2[0], rules2[1]);
-            }
-            dimKeys.forEach(function(d) {
-                var pc = dimensions[d].navigationRules.parent_child;
-                var ss = dimensions[d].navigationRules.sibling_sibling;
-                checkKeys(pc[0], pc[1]);
-                checkKeys(ss[0], ss[1]);
-            });
+            i++;
+          });
         }
-        Object.keys(edges).forEach(function(e) {
-            edges[e].navigationRules.forEach(function(rule) {
-                if (!used[rule]) {
-                    checkKeys(rule);
-                }
-            });
-        });
-        if (Object.keys(needsKeys).length) {
-            var usedKeys = {};
-            Object.keys(used).forEach(function(k) {
-                usedKeys[used[k].key] = used[k].key;
-            });
-            Object.keys(importedRules).forEach(function(r) {
-                if (!usedKeys[importedRules[r].key] && !SemanticKeys[importedRules[r].key]) {
-                    spareKeys.push(importedRules[r].key);
-                }
-            });
-            var recheckKeys = _object_spread({}, needsKeys);
-            needsKeys = {};
-            Object.keys(recheckKeys).forEach(function(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: ".concat(Object.keys(needsKeys).join(", "), "."));
-            }
+        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);
         }
-        rules = used;
+      });
     }
-    return rules;
+  });
+  return edges;
 };
-var buildStructure = function(options) {
-    if (options.addIds) {
-        addSimpleDataIDs(options);
+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(", ")}.`
+      );
     }
-    var nodes = buildNodes(options);
-    var dimensions = scaffoldDimensions(options, nodes);
-    var edges = buildEdges(options, nodes, dimensions);
-    var navigationRules = buildRules(options, edges, dimensions);
-    return {
-        nodes: nodes,
-        edges: edges,
-        dimensions: dimensions,
-        navigationRules: navigationRules
-    };
-};
-// src/input.ts
-var input_default = function(options) {
-    var inputHandler = {};
-    var keyBindings = defaultKeyBindings;
-    var directions = GenericFullNavigationRules;
-    inputHandler.moveTo = function(id) {
-        var target = options.structure.nodes[id];
-        if (target) {
-            return target;
+    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.`
+          );
         }
-        return;
-    };
-    inputHandler.move = function(currentFocus, direction) {
-        if (currentFocus) {
-            var d = options.structure.nodes[currentFocus];
-            if (d.edges) {
-                var _loop = function() {
-                    var edge = options.structure.edges[d.edges[i]];
-                    edge.navigationRules.forEach(function(rule) {
-                        if (!target) {
-                            target = findTarget(rule, edge);
-                        }
-                    });
-                    if (target) {
-                        return "break";
-                    }
-                };
-                var target = null;
-                var i = 0;
-                var navRule = directions[direction];
-                if (!navRule) {
-                    return;
-                }
-                var findTarget = function(rule, edge) {
-                    if (!(rule === direction)) {
-                        return null;
-                    }
-                    var 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++){
-                    var _ret = _loop();
-                    if (_ret === "break") break;
-                }
-                if (target) {
-                    return inputHandler.moveTo(target);
-                }
-                return void 0;
+        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
+          };
         }
-    };
-    inputHandler.enter = function() {
-        if (options.entryPoint) {
-            return inputHandler.moveTo(options.entryPoint);
-        } else {
-            console.error("No entry point was specified in InputOptions, returning undefined");
-            return;
-        }
-    };
-    inputHandler.exit = function() {
-        if (options.exitPoint) {
-            return options.exitPoint;
-        } else {
-            console.error("No exit point was specified in InputOptions, returning undefined");
-            return;
+        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
+          };
         }
-    };
-    inputHandler.keydownValidator = function(e) {
-        var direction = keyBindings[e.code];
-        if (direction) {
-            return direction;
+        if (!spareKeys.length) {
+          if (!used[k1]) {
+            needsKeys[k1] = k1;
+          }
+          if (k2 && !used[k2]) {
+            needsKeys[k2] = k2;
+          }
         }
+      }
     };
-    inputHandler.focus = function(renderId) {
-        var node = document.getElementById(renderId);
-        if (node) {
-            node.focus();
+    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);
         }
-    };
-    inputHandler.setNavigationKeyBindings = function(navKeyBindings) {
-        if (!navKeyBindings) {
-            keyBindings = defaultKeyBindings;
-            directions = GenericFullNavigationRules;
-        } else {
-            keyBindings = {};
-            directions = navKeyBindings;
-            Object.keys(navKeyBindings).forEach(function(direction) {
-                var navOption = navKeyBindings[direction];
-                keyBindings[navOption.key] = direction;
-            });
+      });
+    });
+    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);
         }
-    };
-    inputHandler.setNavigationKeyBindings(options.navigationRules);
-    return inputHandler;
+      });
+      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;
 };
-// src/rendering.ts
-var rendering_default = function(options) {
-    var setActiveDescendant = function(e) {
-        renderer.wrapper.setAttribute("aria-activedescendant", e.srcElement.id);
-    };
-    var removeActiveDescendant = function() {
-        renderer.wrapper.setAttribute("aria-activedescendant", "");
-    };
-    var renderer = {};
-    var initialized = false;
-    var defaults = {
-        cssClass: NodeElementDefaults.cssClass,
-        spatialProperties: _object_spread({}, NodeElementDefaults.spatialProperties),
-        semantics: _object_spread({}, NodeElementDefaults.semantics),
-        parentSemantics: _object_spread({}, NodeElementDefaults.parentSemantics),
-        existingElement: _object_spread({}, NodeElementDefaults.existingElement)
-    };
-    if (options.defaults) {
-        defaults.cssClass = options.defaults.cssClass || defaults.cssClass;
-        defaults.spatialProperties = options.defaults.spatialProperties ? _object_spread({}, defaults.spatialProperties, options.defaults.spatialProperties) : defaults.spatialProperties;
-        defaults.semantics = options.defaults.semantics ? _object_spread({}, defaults.semantics, options.defaults.semantics) : defaults.semantics;
-        defaults.parentSemantics = options.defaults.parentSemantics ? _object_spread({}, defaults.parentSemantics, options.defaults.parentSemantics) : defaults.parentSemantics;
-        defaults.existingElement = options.defaults.existingElement ? _object_spread({}, defaults.existingElement, options.defaults.existingElement) : defaults.existingElement;
+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;
     }
-    renderer.initialize = function() {
-        var _options_exitElement;
-        if (initialized) {
-            console.error("The renderer wrapper has already been initialized successfully, RenderingOptions.suffixId is: ".concat(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 = options.exitElement) === null || _options_exitElement === void 0 ? void 0 : _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", function(e) {
-                var _options_exitElement_callbacks, _options_exitElement;
-                renderer.exitElement.style.display = "block";
-                renderer.clearStructure();
-                if ((_options_exitElement = options.exitElement) === null || _options_exitElement === void 0 ? void 0 : (_options_exitElement_callbacks = _options_exitElement.callbacks) === null || _options_exitElement_callbacks === void 0 ? void 0 : _options_exitElement_callbacks.focus) {
-                    options.exitElement.callbacks.focus(e);
-                }
-            });
-            renderer.exitElement.addEventListener("blur", function(e) {
-                var _options_exitElement_callbacks, _options_exitElement;
-                renderer.exitElement.style.display = "none";
-                if ((_options_exitElement = options.exitElement) === null || _options_exitElement === void 0 ? void 0 : (_options_exitElement_callbacks = _options_exitElement.callbacks) === null || _options_exitElement_callbacks === void 0 ? void 0 : _options_exitElement_callbacks.blur) {
-                    options.exitElement.callbacks.blur(e);
-                }
-            });
-            renderer.root.appendChild(renderer.exitElement);
+    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;
         }
-        initialized = true;
-        return renderer.root;
-    };
-    renderer.render = function(nodeData) {
-        var id = nodeData.renderId + "";
-        var d = options.elementData[id];
-        if (!d) {
-            console.warn("Render data not found with renderId: ".concat(id, ". Failed to render."));
-            return;
-        }
-        if (!initialized) {
-            console.error("render() was called before initialize(), renderer must be initialized first.");
-            return;
-        }
-        var useExisting = false;
-        var existingSpatialProperties = {};
-        var resolveProp = function(prop, subprop, checkExisting) {
-            var p1 = d[prop] || defaults[prop];
-            var s1 = !(checkExisting && useExisting) ? p1[subprop] : existingSpatialProperties[subprop];
-            var 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);
+        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;
         };
-        useExisting = resolveProp("existingElement", "useForSpatialProperties");
-        existingSpatialProperties = resolveProp("existingElement", "spatialProperties");
-        var width = parseFloat(resolveProp("spatialProperties", "width", true) || 0);
-        var height = parseFloat(resolveProp("spatialProperties", "height", true) || 0);
-        var x = parseFloat(resolveProp("spatialProperties", "x", true) || 0);
-        var y = parseFloat(resolveProp("spatialProperties", "y", true) || 0);
-        var node = document.createElement(resolveProp("parentSemantics", "elementType"));
-        var wrapperAttrs = resolveProp("parentSemantics", "attributes");
-        if (typeof wrapperAttrs === "object") {
-            Object.keys(wrapperAttrs).forEach(function(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);
-        var nodeText = document.createElement(resolveProp("semantics", "elementType"));
-        var attributes = resolveProp("semantics", "attributes");
-        if (typeof attributes === "object") {
-            Object.keys(attributes).forEach(function(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;
-        }
-        var label = resolveProp("semantics", "label");
-        if (!label) {
-            console.error("Accessibility error: a label must be supplied to every rendered element using semantics.label.");
+        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;
+          }
         }
-        nodeText.setAttribute("aria-label", label);
-        node.appendChild(nodeText);
-        var hasPath = resolveProp("spatialProperties", "path");
-        if (hasPath) {
-            var totalWidth = width + x + 10;
-            var totalHeight = height + y + 10;
-            var svg = document.createElementNS("http://www.w3.org/2000/svg", "svg");
-            svg.setAttribute("width", totalWidth + "");
-            svg.setAttribute("height", totalHeight + "");
-            svg.setAttribute("viewBox", "0 0 ".concat(totalWidth, " ").concat(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");
-            var 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);
+        if (target) {
+          return inputHandler.moveTo(target);
         }
-        renderer.wrapper.appendChild(node);
-        return node;
-    };
-    renderer.remove = function(renderId) {
-        var node = document.getElementById(renderId);
-        if (renderer.wrapper.getAttribute("aria-activedescendant") === renderId) {
-            renderer.wrapper.setAttribute("aria-activedescendant", "");
+        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);
         }
-        if (node) {
-            node.removeEventListener("focus", setActiveDescendant);
-            node.removeEventListener("blur", removeActiveDescendant);
-            node.remove();
+      });
+      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);
     };
-    renderer.clearStructure = function() {
-        _to_consumable_array(renderer.wrapper.children).forEach(function(child) {
-            if (!(renderer.entryButton && renderer.entryButton === child)) {
-                renderer.remove(child.id);
-            }
-        });
-    };
-    return renderer;
+    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
+var src_default = { structure: structure_default, input: input_default, rendering: rendering_default };
+export {
+  src_default as default
 };