data-navigator 0.0.1 → 0.10.0

package/dist/index.js

@@ -0,0 +1,708 @@
+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 _to_consumable_array(arr) {
+    return _array_without_holes(arr) || _iterable_to_array(arr) || _unsupported_iterable_to_array(arr) || _non_iterable_spread();
+}
+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 defaultKeyBindings = {
+    ArrowLeft: "left",
+    ArrowRight: "right",
+    ArrowUp: "up",
+    ArrowDown: "down",
+    Period: "forward",
+    Comma: "backward",
+    Escape: "parent",
+    Enter: "child"
+};
+var GenericFullNavigationRules = {
+    down: {
+        keyCode: "ArrowDown",
+        direction: "target"
+    },
+    left: {
+        keyCode: "ArrowLeft",
+        direction: "source"
+    },
+    right: {
+        keyCode: "ArrowRight",
+        direction: "target"
+    },
+    up: {
+        keyCode: "ArrowUp",
+        direction: "source"
+    },
+    backward: {
+        keyCode: "Comma",
+        direction: "source"
+    },
+    child: {
+        keyCode: "Enter",
+        direction: "target"
+    },
+    parent: {
+        keyCode: "Backspace",
+        direction: "source"
+    },
+    forward: {
+        keyCode: "Period",
+        direction: "target"
+    },
+    exit: {
+        keyCode: "Escape",
+        direction: "target"
+    }
+};
+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: "",
+    dimensions: {
+        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: {
+        useForDimensions: false,
+        dimensions: 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;
+};
+// src/structure.ts
+var structure_default = function(options) {
+    if (options.dataType === "vega-lite" || options.dataType === "vl" || options.dataType === "Vega-Lite") {
+        return buildNodeStructureFromVegaLite(options);
+    } else {
+        console.warn("Apologies, we currently only have structure scaffolding for Vega-Lite, generic scaffolding coming soon!");
+        return;
+    }
+};
+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"
+                        ]
+                    };
+                }
+            }
+        }
+        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(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].dimensions = {};
+        elementData[renderId].dimensions.x = item.bounds.x1 + o[0];
+        elementData[renderId].dimensions.y = item.bounds.y1 + o[1];
+        elementData[renderId].dimensions.width = item.bounds.x2 - item.bounds.x1;
+        elementData[renderId].dimensions.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
+    };
+};
+// 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;
+        }
+        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;
+            }
+        }
+    };
+    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(options) {
+    var renderer = {};
+    var initialized = false;
+    var defaults = {
+        cssClass: NodeElementDefaults.cssClass,
+        dimensions: _object_spread({}, NodeElementDefaults.dimensions),
+        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.dimensions = options.defaults.dimensions ? _object_spread({}, defaults.dimensions, options.defaults.dimensions) : defaults.dimensions;
+        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() {
+        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.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.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) {
+                renderer.exitElement.style.display = "block";
+                renderer.clearStructure();
+                if (options.exitElement.callbacks && options.exitElement.callbacks.focus) {
+                    options.exitElement.callbacks.focus(e);
+                }
+            });
+            renderer.exitElement.addEventListener("blur", function(e) {
+                renderer.exitElement.style.display = "none";
+                if (options.exitElement.callbacks && 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 existingDimensions = {};
+        var resolveProp = function(prop, subprop, checkExisting) {
+            var p1 = d[prop] || defaults[prop];
+            var s1 = !(checkExisting && useExisting) ? p1[subprop] : existingDimensions[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);
+        };
+        useExisting = resolveProp("existingElement", "useForDimensions");
+        existingDimensions = resolveProp("existingElement", "dimensions");
+        var width = parseFloat(resolveProp("dimensions", "width", true) || 0);
+        var height = parseFloat(resolveProp("dimensions", "height", true) || 0);
+        var x = parseFloat(resolveProp("dimensions", "x", true) || 0);
+        var y = parseFloat(resolveProp("dimensions", "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", "-1");
+        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.");
+        }
+        nodeText.setAttribute("aria-label", label);
+        node.appendChild(nodeText);
+        var hasPath = resolveProp("dimensions", "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 + "";
+            svg.style.top = -y + "";
+            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 (node) {
+            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
+};