data-navigator 2.2.0 → 2.2.2

package/dist/index.cjs

@@ -0,0 +1,1453 @@
+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 __export(target, all) {
+    for(var name in all)__defProp(target, name, {
+        get: all[name],
+        enumerable: true
+    });
+};
+var __copyProps = function __copyProps(to, from, except, desc) {
+    if (from && (typeof from === "undefined" ? "undefined" : _type_of(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 get() {
+                        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 __toCommonJS(mod) {
+    return __copyProps(__defProp({}, "__esModule", {
+        value: true
+    }), mod);
+};
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+    default: function _default() {
+        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
+};
+var defaultKeyBindings = {
+    ArrowLeft: "left",
+    ArrowRight: "right",
+    ArrowUp: "up",
+    ArrowDown: "down",
+    Period: "forward",
+    Comma: "backward",
+    Escape: "parent",
+    Enter: "child"
+};
+var TypicallyUnreservedKeys = [
+    "KeyW",
+    "KeyJ",
+    "LeftBracket",
+    "RightBracket",
+    "Slash",
+    "Backslash"
+];
+var TypicallyUnreservedKeyPairs = [
+    [
+        "LeftBracket",
+        "RightBracket"
+    ],
+    [
+        "Slash",
+        "Backslash"
+    ]
+];
+var GenericFullNavigationRules = {
+    left: {
+        key: "ArrowLeft",
+        direction: "source"
+    },
+    right: {
+        key: "ArrowRight",
+        direction: "target"
+    },
+    up: {
+        key: "ArrowUp",
+        direction: "source"
+    },
+    down: {
+        key: "ArrowDown",
+        direction: "target"
+    },
+    child: {
+        key: "Enter",
+        direction: "target"
+    },
+    parent: {
+        key: "Backspace",
+        direction: "source"
+    },
+    backward: {
+        key: "Comma",
+        direction: "source"
+    },
+    forward: {
+        key: "Period",
+        direction: "target"
+    },
+    previous: {
+        key: "Semicolon",
+        direction: "source"
+    },
+    next: {
+        key: "Quote",
+        direction: "target"
+    },
+    exit: {
+        key: "Escape",
+        direction: "target"
+    },
+    help: {
+        key: "KeyY",
+        direction: "target"
+    },
+    undo: {
+        key: "KeyZ",
+        direction: "target"
+    }
+};
+var GenericFullNavigationDimensions = [
+    [
+        "left",
+        "right"
+    ],
+    [
+        "up",
+        "down"
+    ],
+    [
+        "backward",
+        "forward"
+    ],
+    [
+        "previous",
+        "next"
+    ]
+];
+var GenericLimitedNavigationRules = {
+    right: {
+        key: "ArrowRight",
+        direction: "target"
+    },
+    left: {
+        key: "ArrowLeft",
+        direction: "source"
+    },
+    down: {
+        key: "ArrowDown",
+        direction: "target"
+    },
+    up: {
+        key: "ArrowUp",
+        direction: "source"
+    },
+    child: {
+        key: "Enter",
+        direction: "target"
+    },
+    parent: {
+        key: "Backspace",
+        direction: "source"
+    },
+    exit: {
+        key: "Escape",
+        direction: "target"
+    },
+    undo: {
+        key: "Period",
+        direction: "target"
+    },
+    legend: {
+        key: "KeyL",
+        direction: "target"
+    }
+};
+var NodeElementDefaults = {
+    cssClass: 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 describeNode(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 createValidId = function createValidId(s) {
+    return "_" + s.replace(/[^a-zA-Z0-9_-]+/g, "_");
+};
+// src/structure.ts
+var structure_default = function 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 buildNodeStructureFromVegaLite(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 idBuilder(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 edgeBuilder(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"
+                        ]
+                    };
+                }
+            }
+        }
+        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;
+    };
+    var nodeBuilder = function nodeBuilder(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;
+                }
+            });
+        }
+        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++;
+            });
+        }
+        i++;
+    });
+    Object.keys(nodes).forEach(function(n) {
+        nodes[n].edges = edgeBuilder(n);
+    });
+    return {
+        nodes: nodes,
+        edges: edges,
+        elementData: elementData,
+        navigationRules: navigationRules
+    };
+};
+var addSimpleDataIDs = function addSimpleDataIDs(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]++;
+                    }
+                }
+            });
+        }
+        i++;
+    });
+};
+var buildNodes = function buildNodes(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;
+        }
+    });
+    return nodes;
+};
+var scaffoldDimensions = function scaffoldDimensions(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 rules = _to_consumable_array(GenericFullNavigationDimensions);
+    var setExtents = function setExtents(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;
+            }
+            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;
+                }
+            }
+            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];
+            }
+        } 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);
+                }));
+            }
+        });
+    });
+    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;
+            }
+        }
+    });
+    if (options.dimensions.adjustDimensions) {
+        dimensions = options.dimensions.adjustDimensions(dimensions);
+    }
+    return dimensions;
+};
+var buildEdges = function buildEdges(options, nodes, dimensions) {
+    var edges = {};
+    var addEdgeToNode = function addEdgeToNode(nodeId, edgeId) {
+        if (nodes[nodeId].edges.indexOf(edgeId) === -1) {
+            nodes[nodeId].edges.push(edgeId);
+        }
+    };
+    var createEdge = function createEdge(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 checkEdgeRules(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) : []
+                };
+            }
+        };
+        checkEdgeRules(id);
+        if (options.useDirectedEdges && addToTarget) {
+            checkEdgeRules(targetId);
+        }
+        if (addToSource) {
+            addEdgeToNode(source, id);
+        }
+        if (addToTarget) {
+            addEdgeToNode(target, targetId);
+        }
+    };
+    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");
+        }
+        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 matchByIndex(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");
+            } 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");
+            }
+            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");
+                } 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;
+                }
+                if (!e.conditional || e.conditional && e.conditional(node, e)) {
+                    node.edges.push(e.edgeId);
+                }
+            });
+        }
+    });
+    return edges;
+};
+var buildRules = function buildRules(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 checkKeys(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.");
+                }
+                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 (!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 (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]);
+            });
+        }
+        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(", "), "."));
+            }
+        }
+        rules = used;
+    }
+    return rules;
+};
+var buildStructure = function buildStructure(options) {
+    if (options.addIds) {
+        addSimpleDataIDs(options);
+    }
+    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 input_default(options) {
+    var inputHandler = {};
+    var keyBindings = defaultKeyBindings;
+    var directions = GenericFullNavigationRules;
+    inputHandler.moveTo = function(id) {
+        var target = options.structure.nodes[id];
+        if (target) {
+            return target;
+        }
+        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 findTarget(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;
+            }
+        }
+    };
+    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;
+        }
+    };
+    inputHandler.keydownValidator = function(e) {
+        var direction = keyBindings[e.code];
+        if (direction) {
+            return direction;
+        }
+    };
+    inputHandler.focus = function(renderId) {
+        var node = document.getElementById(renderId);
+        if (node) {
+            node.focus();
+        }
+    };
+    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;
+            });
+        }
+    };
+    inputHandler.setNavigationKeyBindings(options.navigationRules);
+    return inputHandler;
+};
+// src/rendering.ts
+var rendering_default = function rendering_default(options) {
+    var setActiveDescendant = function setActiveDescendant(e) {
+        renderer.wrapper.setAttribute("aria-activedescendant", e.srcElement.id);
+    };
+    var removeActiveDescendant = function removeActiveDescendant() {
+        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;
+    }
+    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);
+        }
+        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 resolveProp(prop, subprop, checkExisting) {
+            var _defaults_prop;
+            var p1 = d[prop] || defaults[prop];
+            var s1 = !(checkExisting && useExisting) ? p1 === null || p1 === void 0 ? void 0 : p1[subprop] : existingSpatialProperties[subprop];
+            var s2 = (_defaults_prop = defaults[prop]) === null || _defaults_prop === void 0 ? void 0 : _defaults_prop[subprop];
+            return typeof p1 === "function" ? p1(d, nodeData.datum) : typeof s1 === "function" ? s1(d, nodeData.datum) : s1 || s2 || (!subprop ? p1 : void 0);
+        };
+        useExisting = resolveProp("existingElement", "useForSpatialProperties");
+        existingSpatialProperties = resolveProp("existingElement", "spatialProperties");
+        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 === "undefined" ? "undefined" : _type_of(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 === "undefined" ? "undefined" : _type_of(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.");
+        }
+        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);
+        }
+        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", "");
+        }
+        if (node) {
+            node.removeEventListener("focus", setActiveDescendant);
+            node.removeEventListener("blur", removeActiveDescendant);
+            node.remove();
+        }
+    };
+    renderer.clearStructure = function() {
+        _to_consumable_array(renderer.wrapper.children).forEach(function(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
+};