@pie-lib/plot 4.0.4-next.3 → 4.0.4-next.31

package/dist/node_modules/.bun/react-draggable@4.6.0_6dbf9a050bc9aadb/node_modules/react-draggable/build/cjs/chunk-D5BXCJ5G.js

@@ -0,0 +1,503 @@
+import e from "../../../../../clsx@2.1.1/node_modules/clsx/dist/clsx.js";
+import * as t from "react";
+import n from "prop-types";
+import r from "react-dom";
+//#region ../../../node_modules/.bun/react-draggable@4.6.0+6dbf9a050bc9aadb/node_modules/react-draggable/build/cjs/chunk-D5BXCJ5G.mjs
+function i(e, t) {
+	for (let n = 0, r = e.length; n < r; n++) if (t.apply(t, [
+		e[n],
+		n,
+		e
+	])) return e[n];
+}
+function a(e) {
+	return typeof e == "function" || Object.prototype.toString.call(e) === "[object Function]";
+}
+function o(e) {
+	return typeof e == "number" && !isNaN(e);
+}
+function s(e) {
+	return parseInt(e, 10);
+}
+function c(e, t, n) {
+	if (e[t]) return /* @__PURE__ */ Error(`Invalid prop ${t} passed to ${n} - do not set this, set it on the child.`);
+}
+var l = [
+	"Moz",
+	"Webkit",
+	"O",
+	"ms"
+];
+function u(e = "transform") {
+	if (typeof window > "u") return "";
+	let t = window.document?.documentElement?.style;
+	if (!t || e in t) return "";
+	for (let n = 0; n < l.length; n++) if (d(e, l[n]) in t) return l[n];
+	return "";
+}
+function d(e, t) {
+	return t ? `${t}${f(e)}` : e;
+}
+function f(e) {
+	let t = "", n = !0;
+	for (let r = 0; r < e.length; r++) n ? (t += e[r].toUpperCase(), n = !1) : e[r] === "-" ? n = !0 : t += e[r];
+	return t;
+}
+var p = u(), m = "";
+function h(e, t) {
+	m ||= i([
+		"matches",
+		"webkitMatchesSelector",
+		"mozMatchesSelector",
+		"msMatchesSelector",
+		"oMatchesSelector"
+	], function(t) {
+		return a(e[t]);
+	}) ?? "";
+	let n = e[m];
+	return a(n) ? !!n.call(e, t) : !1;
+}
+function g(e, t, n) {
+	let r = e;
+	do {
+		if (h(r, t)) return !0;
+		if (r === n) return !1;
+		r = r.parentNode;
+	} while (r);
+	return !1;
+}
+function _(e, t, n, r) {
+	if (!e) return;
+	let i = {
+		capture: !0,
+		...r
+	}, a = n;
+	e.addEventListener ? e.addEventListener(t, a, i) : e.attachEvent ? e.attachEvent("on" + t, a) : e["on" + t] = a;
+}
+function v(e, t, n, r) {
+	if (!e) return;
+	let i = {
+		capture: !0,
+		...r
+	}, a = n;
+	e.removeEventListener ? e.removeEventListener(t, a, i) : e.detachEvent ? e.detachEvent("on" + t, a) : e["on" + t] = null;
+}
+function y(e) {
+	let t = e.clientHeight, n = e.ownerDocument.defaultView.getComputedStyle(e);
+	return t += s(n.borderTopWidth), t += s(n.borderBottomWidth), t;
+}
+function b(e) {
+	let t = e.clientWidth, n = e.ownerDocument.defaultView.getComputedStyle(e);
+	return t += s(n.borderLeftWidth), t += s(n.borderRightWidth), t;
+}
+function x(e) {
+	let t = e.clientHeight, n = e.ownerDocument.defaultView.getComputedStyle(e);
+	return t -= s(n.paddingTop), t -= s(n.paddingBottom), t;
+}
+function S(e) {
+	let t = e.clientWidth, n = e.ownerDocument.defaultView.getComputedStyle(e);
+	return t -= s(n.paddingLeft), t -= s(n.paddingRight), t;
+}
+function C(e, t, n) {
+	let r = t === t.ownerDocument.body ? {
+		left: 0,
+		top: 0
+	} : t.getBoundingClientRect();
+	return {
+		x: (e.clientX + t.scrollLeft - r.left) / n,
+		y: (e.clientY + t.scrollTop - r.top) / n
+	};
+}
+function w(e, t) {
+	let n = E(e, t, "px");
+	return { [d("transform", p)]: n };
+}
+function T(e, t) {
+	return E(e, t, "");
+}
+function E({ x: e, y: t }, n, r) {
+	let i = `translate(${e}${r},${t}${r})`;
+	return n && (i = `translate(${`${typeof n.x == "string" ? n.x : n.x + r}`}, ${`${typeof n.y == "string" ? n.y : n.y + r}`})` + i), i;
+}
+function D(e, t) {
+	return e.targetTouches && i(e.targetTouches, (e) => t === e.identifier) || e.changedTouches && i(e.changedTouches, (e) => t === e.identifier);
+}
+function O(e) {
+	if (e.targetTouches && e.targetTouches[0]) return e.targetTouches[0].identifier;
+	if (e.changedTouches && e.changedTouches[0]) return e.changedTouches[0].identifier;
+}
+function k(e) {
+	if (!e) return;
+	let t = e.getElementById("react-draggable-style-el");
+	t || (t = e.createElement("style"), t.type = "text/css", t.id = "react-draggable-style-el", t.innerHTML = ".react-draggable-transparent-selection *::-moz-selection {all: inherit;}\n", t.innerHTML += ".react-draggable-transparent-selection *::selection {all: inherit;}\n", e.getElementsByTagName("head")[0].appendChild(t)), e.body && M(e.body, "react-draggable-transparent-selection");
+}
+function A(e) {
+	window.requestAnimationFrame ? window.requestAnimationFrame(() => {
+		j(e);
+	}) : j(e);
+}
+function j(e) {
+	if (e) try {
+		e.body && N(e.body, "react-draggable-transparent-selection");
+		let t = e.selection;
+		if (t) t.empty();
+		else {
+			let t = (e.defaultView || window).getSelection();
+			t && t.type !== "Caret" && t.removeAllRanges();
+		}
+	} catch {}
+}
+function M(e, t) {
+	e.classList ? e.classList.add(t) : e.className.match(RegExp(`(?:^|\\s)${t}(?!\\S)`)) || (e.className += ` ${t}`);
+}
+function N(e, t) {
+	e.classList ? e.classList.remove(t) : e.className = e.className.replace(RegExp(`(?:^|\\s)${t}(?!\\S)`, "g"), "");
+}
+function P(e, t, n) {
+	if (!e.props.bounds) return [t, n];
+	let { bounds: r } = e.props;
+	r = typeof r == "string" ? r : V(r);
+	let i = H(e);
+	if (typeof r == "string") {
+		let { ownerDocument: e } = i, t = e.defaultView;
+		if (!t) throw Error("Cannot resolve the owner window of the draggable node.");
+		let n;
+		if (n = r === "parent" ? i.parentNode : i.getRootNode().querySelector(r), !(n instanceof t.HTMLElement)) throw Error("Bounds selector \"" + r + "\" could not find an element.");
+		let a = n, o = t.getComputedStyle(i), c = t.getComputedStyle(a);
+		r = {
+			left: -i.offsetLeft + s(c.paddingLeft) + s(o.marginLeft),
+			top: -i.offsetTop + s(c.paddingTop) + s(o.marginTop),
+			right: S(a) - b(i) - i.offsetLeft + s(c.paddingRight) - s(o.marginRight),
+			bottom: x(a) - y(i) - i.offsetTop + s(c.paddingBottom) - s(o.marginBottom)
+		};
+	}
+	return o(r.right) && (t = Math.min(t, r.right)), o(r.bottom) && (n = Math.min(n, r.bottom)), o(r.left) && (t = Math.max(t, r.left)), o(r.top) && (n = Math.max(n, r.top)), [t, n];
+}
+function F(e, t, n) {
+	return [Math.round(t / e[0]) * e[0], Math.round(n / e[1]) * e[1]];
+}
+function I(e) {
+	return e.props.axis === "both" || e.props.axis === "x";
+}
+function L(e) {
+	return e.props.axis === "both" || e.props.axis === "y";
+}
+function R(e, t, n) {
+	let r = typeof t == "number" ? D(e, t) : null;
+	if (typeof t == "number" && !r) return null;
+	let i = H(n), a = n.props.offsetParent || i.offsetParent || i.ownerDocument.body;
+	return C(r || e, a, n.props.scale);
+}
+function z(e, t, n) {
+	let r = !o(e.lastX), i = H(e);
+	return r ? {
+		node: i,
+		deltaX: 0,
+		deltaY: 0,
+		lastX: t,
+		lastY: n,
+		x: t,
+		y: n
+	} : {
+		node: i,
+		deltaX: t - e.lastX,
+		deltaY: n - e.lastY,
+		lastX: e.lastX,
+		lastY: e.lastY,
+		x: t,
+		y: n
+	};
+}
+function B(e, t) {
+	let n = e.props.scale;
+	return {
+		node: t.node,
+		x: e.state.x + t.deltaX / n,
+		y: e.state.y + t.deltaY / n,
+		deltaX: t.deltaX / n,
+		deltaY: t.deltaY / n,
+		lastX: e.state.x,
+		lastY: e.state.y
+	};
+}
+function V(e) {
+	return {
+		left: e.left,
+		top: e.top,
+		right: e.right,
+		bottom: e.bottom
+	};
+}
+function H(e) {
+	let t = e.findDOMNode();
+	if (!t) throw Error("<DraggableCore>: Unmounted during event!");
+	return t;
+}
+function U(...e) {
+	process.env.DRAGGABLE_DEBUG && console.log(...e);
+}
+var W = {
+	touch: {
+		start: "touchstart",
+		move: "touchmove",
+		stop: "touchend"
+	},
+	mouse: {
+		start: "mousedown",
+		move: "mousemove",
+		stop: "mouseup"
+	}
+}, G = W.mouse, K = class extends t.Component {
+	constructor() {
+		super(...arguments), this.dragging = !1, this.lastX = NaN, this.lastY = NaN, this.touchIdentifier = null, this.mounted = !1, this.handleDragStart = (e) => {
+			if (this.props.onMouseDown(e), !this.props.allowAnyClick && (typeof e.button == "number" && e.button !== 0 || e.ctrlKey)) return !1;
+			let t = this.findDOMNode();
+			if (!t || !t.ownerDocument || !t.ownerDocument.body) throw Error("<DraggableCore> not mounted on DragStart!");
+			let { ownerDocument: n } = t;
+			if (this.props.disabled || !(e.target instanceof n.defaultView.Node) || this.props.handle && !g(e.target, this.props.handle, t) || this.props.cancel && g(e.target, this.props.cancel, t)) return;
+			e.type === "touchstart" && !this.props.allowMobileScroll && e.preventDefault();
+			let r = O(e);
+			this.touchIdentifier = r;
+			let i = R(e, r, this);
+			if (i == null) return;
+			let { x: a, y: o } = i, s = z(this, a, o);
+			U("DraggableCore: handleDragStart: %j", s), U("calling", this.props.onStart), !(this.props.onStart(e, s) === !1 || this.mounted === !1) && (this.props.enableUserSelectHack && k(n), this.dragging = !0, this.lastX = a, this.lastY = o, _(n, G.move, this.handleDrag), _(n, G.stop, this.handleDragStop));
+		}, this.handleDrag = (e) => {
+			let t = R(e, this.touchIdentifier, this);
+			if (t == null) return;
+			let { x: n, y: r } = t;
+			if (Array.isArray(this.props.grid)) {
+				let e = n - this.lastX, t = r - this.lastY;
+				if ([e, t] = F(this.props.grid, e, t), !e && !t) return;
+				n = this.lastX + e, r = this.lastY + t;
+			}
+			let i = z(this, n, r);
+			if (U("DraggableCore: handleDrag: %j", i), this.props.onDrag(e, i) === !1 || this.mounted === !1) {
+				try {
+					this.handleDragStop(new MouseEvent("mouseup"));
+				} catch {
+					let e = document.createEvent("MouseEvents");
+					e.initMouseEvent("mouseup", !0, !0, window, 0, 0, 0, 0, 0, !1, !1, !1, !1, 0, null), this.handleDragStop(e);
+				}
+				return;
+			}
+			this.lastX = n, this.lastY = r;
+		}, this.handleDragStop = (e) => {
+			if (!this.dragging) return;
+			let t = R(e, this.touchIdentifier, this);
+			if (t == null) return;
+			let { x: n, y: r } = t;
+			if (Array.isArray(this.props.grid)) {
+				let e = n - this.lastX || 0, t = r - this.lastY || 0;
+				[e, t] = F(this.props.grid, e, t), n = this.lastX + e, r = this.lastY + t;
+			}
+			let i = z(this, n, r);
+			if (this.props.onStop(e, i) === !1 || this.mounted === !1) return !1;
+			let a = this.findDOMNode();
+			a && this.props.enableUserSelectHack && A(a.ownerDocument), U("DraggableCore: handleDragStop: %j", i), this.dragging = !1, this.lastX = NaN, this.lastY = NaN, a && (U("DraggableCore: Removing handlers"), v(a.ownerDocument, G.move, this.handleDrag), v(a.ownerDocument, G.stop, this.handleDragStop));
+		}, this.onMouseDown = (e) => (G = W.mouse, this.handleDragStart(e)), this.onMouseUp = (e) => (G = W.mouse, this.handleDragStop(e)), this.onTouchStart = (e) => (G = W.touch, this.handleDragStart(e)), this.onTouchEnd = (e) => (G = W.touch, this.handleDragStop(e));
+	}
+	componentDidMount() {
+		this.mounted = !0;
+		let e = this.findDOMNode();
+		e && _(e, W.touch.start, this.onTouchStart, { passive: !1 });
+	}
+	componentWillUnmount() {
+		this.mounted = !1;
+		let e = this.findDOMNode();
+		if (e) {
+			let { ownerDocument: t } = e;
+			v(t, W.mouse.move, this.handleDrag), v(t, W.touch.move, this.handleDrag), v(t, W.mouse.stop, this.handleDragStop), v(t, W.touch.stop, this.handleDragStop), v(e, W.touch.start, this.onTouchStart, { passive: !1 }), this.props.enableUserSelectHack && A(t);
+		}
+	}
+	findDOMNode() {
+		if (this.props?.nodeRef) return this.props.nodeRef.current;
+		let e = r;
+		return typeof e.findDOMNode == "function" ? e.findDOMNode(this) : (U("react-draggable: ReactDOM.findDOMNode is not available in React 19+. You must provide a nodeRef prop. See: https://github.com/react-grid-layout/react-draggable#noderef"), null);
+	}
+	render() {
+		return t.cloneElement(t.Children.only(this.props.children), {
+			onMouseDown: this.onMouseDown,
+			onMouseUp: this.onMouseUp,
+			onTouchEnd: this.onTouchEnd
+		});
+	}
+};
+K.displayName = "DraggableCore", K.propTypes = {
+	allowAnyClick: n.bool,
+	allowMobileScroll: n.bool,
+	children: n.node.isRequired,
+	disabled: n.bool,
+	enableUserSelectHack: n.bool,
+	offsetParent: function(e, t) {
+		if (e[t] && e[t].nodeType !== 1) throw Error("Draggable's offsetParent must be a DOM Node.");
+	},
+	grid: n.arrayOf(n.number),
+	handle: n.string,
+	cancel: n.string,
+	nodeRef: n.object,
+	onStart: n.func,
+	onDrag: n.func,
+	onStop: n.func,
+	onMouseDown: n.func,
+	scale: n.number,
+	className: c,
+	style: c,
+	transform: c
+}, K.defaultProps = {
+	allowAnyClick: !1,
+	allowMobileScroll: !1,
+	disabled: !1,
+	enableUserSelectHack: !0,
+	onStart: function() {},
+	onDrag: function() {},
+	onStop: function() {},
+	onMouseDown: function() {},
+	scale: 1
+};
+var q = class extends t.Component {
+	constructor(e) {
+		super(e), this.onDragStart = (e, t) => {
+			if (U("Draggable: onDragStart: %j", t), this.props.onStart(e, B(this, t)) === !1) return !1;
+			this.setState({
+				dragging: !0,
+				dragged: !0
+			});
+		}, this.onDrag = (e, t) => {
+			if (!this.state.dragging) return !1;
+			U("Draggable: onDrag: %j", t);
+			let n = B(this, t), r = {
+				x: n.x,
+				y: n.y,
+				slackX: 0,
+				slackY: 0
+			};
+			if (this.props.bounds) {
+				let { x: e, y: t } = r;
+				r.x += this.state.slackX, r.y += this.state.slackY;
+				let [i, a] = P(this, r.x, r.y);
+				r.x = i, r.y = a, r.slackX = this.state.slackX + (e - r.x), r.slackY = this.state.slackY + (t - r.y), n.x = r.x, n.y = r.y, n.deltaX = r.x - this.state.x, n.deltaY = r.y - this.state.y;
+			}
+			if (this.props.onDrag(e, n) === !1) return !1;
+			this.setState(r);
+		}, this.onDragStop = (e, t) => {
+			if (!this.state.dragging || this.props.onStop(e, B(this, t)) === !1) return !1;
+			U("Draggable: onDragStop: %j", t);
+			let n = {
+				dragging: !1,
+				slackX: 0,
+				slackY: 0
+			};
+			if (this.props.position) {
+				let { x: e, y: t } = this.props.position;
+				n.x = e, n.y = t;
+			}
+			this.setState(n);
+		}, this.state = {
+			dragging: !1,
+			dragged: !1,
+			x: e.position ? e.position.x : e.defaultPosition.x,
+			y: e.position ? e.position.y : e.defaultPosition.y,
+			prevPropsPosition: { ...e.position },
+			slackX: 0,
+			slackY: 0,
+			isElementSVG: !1
+		}, e.position && !(e.onDrag || e.onStop) && console.warn("A `position` was applied to this <Draggable>, without drag handlers. This will make this component effectively undraggable. Please attach `onDrag` or `onStop` handlers so you can adjust the `position` of this element.");
+	}
+	static getDerivedStateFromProps({ position: e }, { prevPropsPosition: t }) {
+		return e && (!t || e.x !== t.x || e.y !== t.y) ? (U("Draggable: getDerivedStateFromProps %j", {
+			position: e,
+			prevPropsPosition: t
+		}), {
+			x: e.x,
+			y: e.y,
+			prevPropsPosition: { ...e }
+		}) : null;
+	}
+	componentDidMount() {
+		window.SVGElement !== void 0 && this.findDOMNode() instanceof window.SVGElement && this.setState({ isElementSVG: !0 });
+	}
+	componentWillUnmount() {
+		this.state.dragging && this.setState({ dragging: !1 });
+	}
+	findDOMNode() {
+		if (this.props?.nodeRef) return this.props.nodeRef.current;
+		let e = r;
+		return typeof e.findDOMNode == "function" ? e.findDOMNode(this) : null;
+	}
+	render() {
+		let { axis: n, bounds: r, children: i, defaultPosition: a, defaultClassName: o, defaultClassNameDragging: s, defaultClassNameDragged: c, position: l, positionOffset: u, scale: d, ...f } = this.props, p = {}, m = null, h = !l || this.state.dragging, g = l || a, _ = {
+			x: I(this) && h ? this.state.x : g.x,
+			y: L(this) && h ? this.state.y : g.y
+		};
+		this.state.isElementSVG ? m = T(_, u) : p = w(_, u);
+		let v = t.Children.only(i), y = e(v.props.className || "", o, {
+			[s]: this.state.dragging,
+			[c]: this.state.dragged
+		});
+		return /* @__PURE__ */ t.createElement(K, {
+			...f,
+			onStart: this.onDragStart,
+			onDrag: this.onDrag,
+			onStop: this.onDragStop
+		}, t.cloneElement(v, {
+			className: y,
+			style: {
+				...v.props.style,
+				...p
+			},
+			transform: m
+		}));
+	}
+};
+q.displayName = "Draggable", q.propTypes = {
+	...K.propTypes,
+	axis: n.oneOf([
+		"both",
+		"x",
+		"y",
+		"none"
+	]),
+	bounds: n.oneOfType([
+		n.shape({
+			left: n.number,
+			right: n.number,
+			top: n.number,
+			bottom: n.number
+		}),
+		n.string,
+		n.oneOf([!1])
+	]),
+	defaultClassName: n.string,
+	defaultClassNameDragging: n.string,
+	defaultClassNameDragged: n.string,
+	defaultPosition: n.shape({
+		x: n.number,
+		y: n.number
+	}),
+	positionOffset: n.shape({
+		x: n.oneOfType([n.number, n.string]),
+		y: n.oneOfType([n.number, n.string])
+	}),
+	position: n.shape({
+		x: n.number,
+		y: n.number
+	}),
+	className: c,
+	style: c,
+	transform: c
+}, q.defaultProps = {
+	...K.defaultProps,
+	axis: "both",
+	bounds: !1,
+	defaultClassName: "react-draggable",
+	defaultClassNameDragging: "react-draggable-dragging",
+	defaultClassNameDragged: "react-draggable-dragged",
+	defaultPosition: {
+		x: 0,
+		y: 0
+	},
+	scale: 1
+};
+//#endregion
+export { q as Draggable, K as DraggableCore };

package/dist/node_modules/.bun/react-draggable@4.6.0_6dbf9a050bc9aadb/node_modules/react-draggable/build/cjs/cjs.js

@@ -0,0 +1,5 @@
+import { Draggable as e } from "./chunk-D5BXCJ5G.js";
+//#region ../../../node_modules/.bun/react-draggable@4.6.0+6dbf9a050bc9aadb/node_modules/react-draggable/build/cjs/cjs.mjs
+var t = e;
+//#endregion
+export { t as cjs_default };

package/dist/root.d.ts

@@ -0,0 +1,68 @@
+/**
+ * @synced-from pie-lib/packages/plot/src/root.jsx
+ * @auto-generated
+ *
+ * This file is automatically synced from pie-elements and converted to TypeScript.
+ * Manual edits will be overwritten on next sync.
+ * To make changes, edit the upstream JavaScript file and run sync again.
+ */
+import React from 'react';
+import PropTypes from 'prop-types';
+export declare class Root extends React.Component {
+    constructor(props: any);
+    static propTypes: {
+        title: PropTypes.Requireable<string>;
+        children: PropTypes.Validator<NonNullable<NonNullable<PropTypes.ReactNodeLike>>>;
+        defineChart: PropTypes.Requireable<boolean>;
+        disabledLabels: PropTypes.Requireable<boolean>;
+        disabledTitle: PropTypes.Requireable<boolean>;
+        graphProps: PropTypes.Validator<NonNullable<PropTypes.InferProps<{
+            scale: PropTypes.Validator<NonNullable<PropTypes.InferProps<{
+                x: PropTypes.Validator<(...args: any[]) => any>;
+                y: PropTypes.Validator<(...args: any[]) => any>;
+            }>>>;
+            snap: PropTypes.Validator<NonNullable<PropTypes.InferProps<{
+                x: PropTypes.Validator<(...args: any[]) => any>;
+                y: PropTypes.Validator<(...args: any[]) => any>;
+            }>>>;
+            domain: PropTypes.Validator<NonNullable<PropTypes.InferProps<{
+                min: PropTypes.Validator<number>;
+                max: PropTypes.Validator<number>;
+                step: PropTypes.Requireable<number>;
+            }>>>;
+            range: PropTypes.Validator<NonNullable<PropTypes.InferProps<{
+                min: PropTypes.Validator<number>;
+                max: PropTypes.Validator<number>;
+                step: PropTypes.Requireable<number>;
+            }>>>;
+            size: PropTypes.Validator<NonNullable<PropTypes.InferProps<{
+                width: PropTypes.Validator<number>;
+                height: PropTypes.Validator<number>;
+            }>>>;
+        }>>>;
+        isChart: PropTypes.Requireable<boolean>;
+        labels: PropTypes.Requireable<object>;
+        labelsPlaceholders: PropTypes.Requireable<object>;
+        onChangeTitle: PropTypes.Requireable<(...args: any[]) => any>;
+        onMouseMove: PropTypes.Requireable<(...args: any[]) => any>;
+        showLabels: PropTypes.Requireable<boolean>;
+        showTitle: PropTypes.Requireable<boolean>;
+        showPixelGuides: PropTypes.Requireable<boolean>;
+        rootRef: PropTypes.Requireable<(...args: any[]) => any>;
+        onChangeLabels: PropTypes.Requireable<(...args: any[]) => any>;
+        titlePlaceholder: PropTypes.Requireable<string>;
+        mathMlOptions: PropTypes.Requireable<object>;
+        labelsCharactersLimit: PropTypes.Requireable<number>;
+    };
+    mouseMove: any;
+    componentDidMount(): void;
+    componentWillUnmount(): void;
+    componentDidUpdate(prevProps: any): void;
+    onChangeLabel: any;
+    measureTitleHeight: any;
+    handleKeyDown: any;
+    setupVisibilityObserver: any;
+    cleanupVisibilityObserver: any;
+    render(): React.JSX.Element;
+}
+export default Root;