planning

node_modules/react-textarea-autosize/LICENSE

@@ -0,0 +1,20 @@
+The MIT License (MIT)
+
+Copyright (c) 2013 Andrey Popp
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the "Software"), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+the Software, and to permit persons to whom the Software is furnished to do so,
+subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

node_modules/react-textarea-autosize/README.md

@@ -0,0 +1,88 @@
+[![npm version](https://img.shields.io/npm/v/react-textarea-autosize.svg)](https://www.npmjs.com/package/react-textarea-autosize)
+[![npm](https://img.shields.io/npm/dm/react-textarea-autosize.svg)](https://www.npmjs.com/package/react-textarea-autosize)
+
+# react-textarea-autosize
+
+Drop-in replacement for the textarea component which automatically resizes
+textarea as content changes. A native React version of the popular
+[jQuery Autosize](http://www.jacklmoore.com/autosize/)! Weighs
+around <span class="weight">1.3KB</span> (minified & gzipped).
+
+This module supports IE9 and above.
+
+```javascript
+import TextareaAutosize from 'react-textarea-autosize';
+
+// If you use CommonJS syntax:
+// var TextareaAutosize = require('react-textarea-autosize').default;
+
+React.renderComponent(
+  <div>
+    <TextareaAutosize />
+  </div>,
+  document.getElementById('element'),
+);
+```
+
+## Install
+
+`npm install react-textarea-autosize`
+
+## Demo
+
+https://andarist.github.io/react-textarea-autosize/
+
+## Props
+
+### Special props:
+
+| prop                | type      | description                                                                                                                                                                                                                                        |
+| ------------------- | --------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `maxRows`           | `number`  | Maximum number of rows up to which the textarea can grow                                                                                                                                                                                           |
+| `minRows`           | `number`  | Minimum number of rows to show for textarea                                                                                                                                                                                                        |
+| `onHeightChange`    | `func`    | Function invoked on textarea height change, with height as first argument. The second function argument is an object containing additional information that might be useful for custom behaviors. Current options include `{ rowHeight: number }`. |
+| `cacheMeasurements` | `boolean` | Reuse previously computed measurements when computing height of textarea. Default: `false`                                                                                                                                                         |
+
+Apart from these, the component accepts all props that are accepted by `<textarea/>`, like `style`, `onChange`, `value`, etc.
+
+## FAQ
+
+### How to focus
+
+Get a ref to inner textarea:
+
+```js
+<TextareaAutosize ref={(tag) => (this.textarea = tag)} />
+```
+
+And then call a focus on that ref:
+
+```js
+this.textarea.focus();
+```
+
+To autofocus:
+
+```js
+<TextareaAutosize autoFocus />
+```
+
+(all HTML attributes are passed to inner textarea)
+
+### How to test it with jest and react-test-renderer if you need ref
+
+Because [jest](https://github.com/facebook/jest) provides polyfills for DOM
+objects by requiring [jsdom](https://github.com/tmpvar/jsdom) and
+[react-test-renderer](https://www.npmjs.com/package/react-test-renderer) doesn't
+provide refs for rendered components out of the box (calling ref callbacks with
+`null`), you need to supply a mocked ref in your tests in you need it for your tests.
+You can do it like this (more can be read
+[here](https://github.com/facebook/react/issues/7740#issuecomment-247335106)):
+
+```js
+const tree = renderer
+  .create(<TextareaAutosize />, {
+    createNodeMock: () => document.createElement('textarea'),
+  })
+  .toJSON();
+```

node_modules/react-textarea-autosize/dist/declarations/src/index.d.ts

@@ -0,0 +1,17 @@
+import * as React from 'react';
+type TextareaProps = React.TextareaHTMLAttributes<HTMLTextAreaElement>;
+type Style = Omit<NonNullable<TextareaProps['style']>, 'maxHeight' | 'minHeight'> & {
+    height?: number;
+};
+export type TextareaHeightChangeMeta = {
+    rowHeight: number;
+};
+export interface TextareaAutosizeProps extends Omit<TextareaProps, 'style'> {
+    maxRows?: number;
+    minRows?: number;
+    onHeightChange?: (height: number, meta: TextareaHeightChangeMeta) => void;
+    cacheMeasurements?: boolean;
+    style?: Style;
+}
+declare const _default: React.ForwardRefExoticComponent<TextareaAutosizeProps & React.RefAttributes<HTMLTextAreaElement>>;
+export default _default;

node_modules/react-textarea-autosize/dist/react-textarea-autosize.browser.cjs.default.js

@@ -0,0 +1 @@
+exports._default = require("./react-textarea-autosize.browser.cjs.js").default;

node_modules/react-textarea-autosize/dist/react-textarea-autosize.browser.cjs.js

@@ -0,0 +1,229 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var _extends = require('@babel/runtime/helpers/extends');
+var _objectWithoutPropertiesLoose = require('@babel/runtime/helpers/objectWithoutPropertiesLoose');
+var React = require('react');
+var useLatest = require('use-latest');
+var useComposedRef = require('use-composed-ref');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { 'default': e }; }
+
+function _interopNamespace(e) {
+  if (e && e.__esModule) return e;
+  var n = Object.create(null);
+  if (e) {
+    Object.keys(e).forEach(function (k) {
+      if (k !== 'default') {
+        var d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: function () { return e[k]; }
+        });
+      }
+    });
+  }
+  n["default"] = e;
+  return Object.freeze(n);
+}
+
+var React__namespace = /*#__PURE__*/_interopNamespace(React);
+var useLatest__default = /*#__PURE__*/_interopDefault(useLatest);
+var useComposedRef__default = /*#__PURE__*/_interopDefault(useComposedRef);
+
+var HIDDEN_TEXTAREA_STYLE = {
+  'min-height': '0',
+  'max-height': 'none',
+  height: '0',
+  visibility: 'hidden',
+  overflow: 'hidden',
+  position: 'absolute',
+  'z-index': '-1000',
+  top: '0',
+  right: '0',
+  display: 'block'
+};
+var forceHiddenStyles = function forceHiddenStyles(node) {
+  Object.keys(HIDDEN_TEXTAREA_STYLE).forEach(function (key) {
+    node.style.setProperty(key, HIDDEN_TEXTAREA_STYLE[key], 'important');
+  });
+};
+var forceHiddenStyles$1 = forceHiddenStyles;
+
+var hiddenTextarea = null;
+var getHeight = function getHeight(node, sizingData) {
+  var height = node.scrollHeight;
+  if (sizingData.sizingStyle.boxSizing === 'border-box') {
+    // border-box: add border, since height = content + padding + border
+    return height + sizingData.borderSize;
+  }
+
+  // remove padding, since height = content
+  return height - sizingData.paddingSize;
+};
+function calculateNodeHeight(sizingData, value, minRows, maxRows) {
+  if (minRows === void 0) {
+    minRows = 1;
+  }
+  if (maxRows === void 0) {
+    maxRows = Infinity;
+  }
+  if (!hiddenTextarea) {
+    hiddenTextarea = document.createElement('textarea');
+    hiddenTextarea.setAttribute('tabindex', '-1');
+    hiddenTextarea.setAttribute('aria-hidden', 'true');
+    forceHiddenStyles$1(hiddenTextarea);
+  }
+  if (hiddenTextarea.parentNode === null) {
+    document.body.appendChild(hiddenTextarea);
+  }
+  var paddingSize = sizingData.paddingSize,
+    borderSize = sizingData.borderSize,
+    sizingStyle = sizingData.sizingStyle;
+  var boxSizing = sizingStyle.boxSizing;
+  Object.keys(sizingStyle).forEach(function (_key) {
+    var key = _key;
+    hiddenTextarea.style[key] = sizingStyle[key];
+  });
+  forceHiddenStyles$1(hiddenTextarea);
+  hiddenTextarea.value = value;
+  var height = getHeight(hiddenTextarea, sizingData);
+  // Double set and calc due to Firefox bug: https://bugzilla.mozilla.org/show_bug.cgi?id=1795904
+  hiddenTextarea.value = value;
+  height = getHeight(hiddenTextarea, sizingData);
+
+  // measure height of a textarea with a single row
+  hiddenTextarea.value = 'x';
+  var rowHeight = hiddenTextarea.scrollHeight - paddingSize;
+  var minHeight = rowHeight * minRows;
+  if (boxSizing === 'border-box') {
+    minHeight = minHeight + paddingSize + borderSize;
+  }
+  height = Math.max(minHeight, height);
+  var maxHeight = rowHeight * maxRows;
+  if (boxSizing === 'border-box') {
+    maxHeight = maxHeight + paddingSize + borderSize;
+  }
+  height = Math.min(maxHeight, height);
+  return [height, rowHeight];
+}
+
+var noop = function noop() {};
+var pick = function pick(props, obj) {
+  return props.reduce(function (acc, prop) {
+    acc[prop] = obj[prop];
+    return acc;
+  }, {});
+};
+
+var SIZING_STYLE = ['borderBottomWidth', 'borderLeftWidth', 'borderRightWidth', 'borderTopWidth', 'boxSizing', 'fontFamily', 'fontSize', 'fontStyle', 'fontWeight', 'letterSpacing', 'lineHeight', 'paddingBottom', 'paddingLeft', 'paddingRight', 'paddingTop',
+// non-standard
+'tabSize', 'textIndent',
+// non-standard
+'textRendering', 'textTransform', 'width', 'wordBreak'];
+var isIE = !!document.documentElement.currentStyle ;
+var getSizingData = function getSizingData(node) {
+  var style = window.getComputedStyle(node);
+  if (style === null) {
+    return null;
+  }
+  var sizingStyle = pick(SIZING_STYLE, style);
+  var boxSizing = sizingStyle.boxSizing;
+
+  // probably node is detached from DOM, can't read computed dimensions
+  if (boxSizing === '') {
+    return null;
+  }
+
+  // IE (Edge has already correct behaviour) returns content width as computed width
+  // so we need to add manually padding and border widths
+  if (isIE && boxSizing === 'border-box') {
+    sizingStyle.width = parseFloat(sizingStyle.width) + parseFloat(sizingStyle.borderRightWidth) + parseFloat(sizingStyle.borderLeftWidth) + parseFloat(sizingStyle.paddingRight) + parseFloat(sizingStyle.paddingLeft) + 'px';
+  }
+  var paddingSize = parseFloat(sizingStyle.paddingBottom) + parseFloat(sizingStyle.paddingTop);
+  var borderSize = parseFloat(sizingStyle.borderBottomWidth) + parseFloat(sizingStyle.borderTopWidth);
+  return {
+    sizingStyle: sizingStyle,
+    paddingSize: paddingSize,
+    borderSize: borderSize
+  };
+};
+var getSizingData$1 = getSizingData;
+
+function useListener(target, type, listener) {
+  var latestListener = useLatest__default["default"](listener);
+  React__namespace.useLayoutEffect(function () {
+    var handler = function handler(ev) {
+      return latestListener.current(ev);
+    };
+
+    // might happen if document.fonts is not defined, for instance
+    if (!target) {
+      return;
+    }
+    target.addEventListener(type, handler);
+    return function () {
+      return target.removeEventListener(type, handler);
+    };
+  }, []);
+}
+var useWindowResizeListener = function useWindowResizeListener(listener) {
+  useListener(window, 'resize', listener);
+};
+var useFontsLoadedListener = function useFontsLoadedListener(listener) {
+  useListener(document.fonts, 'loadingdone', listener);
+};
+
+var _excluded = ["cacheMeasurements", "maxRows", "minRows", "onChange", "onHeightChange"];
+var TextareaAutosize = function TextareaAutosize(_ref, userRef) {
+  var cacheMeasurements = _ref.cacheMeasurements,
+    maxRows = _ref.maxRows,
+    minRows = _ref.minRows,
+    _ref$onChange = _ref.onChange,
+    onChange = _ref$onChange === void 0 ? noop : _ref$onChange,
+    _ref$onHeightChange = _ref.onHeightChange,
+    onHeightChange = _ref$onHeightChange === void 0 ? noop : _ref$onHeightChange,
+    props = _objectWithoutPropertiesLoose(_ref, _excluded);
+  var isControlled = props.value !== undefined;
+  var libRef = React__namespace.useRef(null);
+  var ref = useComposedRef__default["default"](libRef, userRef);
+  var heightRef = React__namespace.useRef(0);
+  var measurementsCacheRef = React__namespace.useRef();
+  var resizeTextarea = function resizeTextarea() {
+    var node = libRef.current;
+    var nodeSizingData = cacheMeasurements && measurementsCacheRef.current ? measurementsCacheRef.current : getSizingData$1(node);
+    if (!nodeSizingData) {
+      return;
+    }
+    measurementsCacheRef.current = nodeSizingData;
+    var _calculateNodeHeight = calculateNodeHeight(nodeSizingData, node.value || node.placeholder || 'x', minRows, maxRows),
+      height = _calculateNodeHeight[0],
+      rowHeight = _calculateNodeHeight[1];
+    if (heightRef.current !== height) {
+      heightRef.current = height;
+      node.style.setProperty('height', height + "px", 'important');
+      onHeightChange(height, {
+        rowHeight: rowHeight
+      });
+    }
+  };
+  var handleChange = function handleChange(event) {
+    if (!isControlled) {
+      resizeTextarea();
+    }
+    onChange(event);
+  };
+  {
+    React__namespace.useLayoutEffect(resizeTextarea);
+    useWindowResizeListener(resizeTextarea);
+    useFontsLoadedListener(resizeTextarea);
+    return /*#__PURE__*/React__namespace.createElement("textarea", _extends({}, props, {
+      onChange: handleChange,
+      ref: ref
+    }));
+  }
+};
+var index = /* #__PURE__ */React__namespace.forwardRef(TextareaAutosize);
+
+exports["default"] = index;

node_modules/react-textarea-autosize/dist/react-textarea-autosize.browser.cjs.mjs

@@ -0,0 +1,2 @@
+import "./react-textarea-autosize.browser.cjs.js";
+export { _default as default } from "./react-textarea-autosize.browser.cjs.default.js";

node_modules/react-textarea-autosize/dist/react-textarea-autosize.browser.development.cjs.default.js

@@ -0,0 +1 @@
+exports._default = require("./react-textarea-autosize.browser.development.cjs.js").default;

node_modules/react-textarea-autosize/dist/react-textarea-autosize.browser.development.cjs.js

@@ -0,0 +1,237 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var _extends = require('@babel/runtime/helpers/extends');
+var _objectWithoutPropertiesLoose = require('@babel/runtime/helpers/objectWithoutPropertiesLoose');
+var React = require('react');
+var useLatest = require('use-latest');
+var useComposedRef = require('use-composed-ref');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { 'default': e }; }
+
+function _interopNamespace(e) {
+  if (e && e.__esModule) return e;
+  var n = Object.create(null);
+  if (e) {
+    Object.keys(e).forEach(function (k) {
+      if (k !== 'default') {
+        var d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: function () { return e[k]; }
+        });
+      }
+    });
+  }
+  n["default"] = e;
+  return Object.freeze(n);
+}
+
+var React__namespace = /*#__PURE__*/_interopNamespace(React);
+var useLatest__default = /*#__PURE__*/_interopDefault(useLatest);
+var useComposedRef__default = /*#__PURE__*/_interopDefault(useComposedRef);
+
+var HIDDEN_TEXTAREA_STYLE = {
+  'min-height': '0',
+  'max-height': 'none',
+  height: '0',
+  visibility: 'hidden',
+  overflow: 'hidden',
+  position: 'absolute',
+  'z-index': '-1000',
+  top: '0',
+  right: '0',
+  display: 'block'
+};
+var forceHiddenStyles = function forceHiddenStyles(node) {
+  Object.keys(HIDDEN_TEXTAREA_STYLE).forEach(function (key) {
+    node.style.setProperty(key, HIDDEN_TEXTAREA_STYLE[key], 'important');
+  });
+};
+var forceHiddenStyles$1 = forceHiddenStyles;
+
+var hiddenTextarea = null;
+var getHeight = function getHeight(node, sizingData) {
+  var height = node.scrollHeight;
+  if (sizingData.sizingStyle.boxSizing === 'border-box') {
+    // border-box: add border, since height = content + padding + border
+    return height + sizingData.borderSize;
+  }
+
+  // remove padding, since height = content
+  return height - sizingData.paddingSize;
+};
+function calculateNodeHeight(sizingData, value, minRows, maxRows) {
+  if (minRows === void 0) {
+    minRows = 1;
+  }
+  if (maxRows === void 0) {
+    maxRows = Infinity;
+  }
+  if (!hiddenTextarea) {
+    hiddenTextarea = document.createElement('textarea');
+    hiddenTextarea.setAttribute('tabindex', '-1');
+    hiddenTextarea.setAttribute('aria-hidden', 'true');
+    forceHiddenStyles$1(hiddenTextarea);
+  }
+  if (hiddenTextarea.parentNode === null) {
+    document.body.appendChild(hiddenTextarea);
+  }
+  var paddingSize = sizingData.paddingSize,
+    borderSize = sizingData.borderSize,
+    sizingStyle = sizingData.sizingStyle;
+  var boxSizing = sizingStyle.boxSizing;
+  Object.keys(sizingStyle).forEach(function (_key) {
+    var key = _key;
+    hiddenTextarea.style[key] = sizingStyle[key];
+  });
+  forceHiddenStyles$1(hiddenTextarea);
+  hiddenTextarea.value = value;
+  var height = getHeight(hiddenTextarea, sizingData);
+  // Double set and calc due to Firefox bug: https://bugzilla.mozilla.org/show_bug.cgi?id=1795904
+  hiddenTextarea.value = value;
+  height = getHeight(hiddenTextarea, sizingData);
+
+  // measure height of a textarea with a single row
+  hiddenTextarea.value = 'x';
+  var rowHeight = hiddenTextarea.scrollHeight - paddingSize;
+  var minHeight = rowHeight * minRows;
+  if (boxSizing === 'border-box') {
+    minHeight = minHeight + paddingSize + borderSize;
+  }
+  height = Math.max(minHeight, height);
+  var maxHeight = rowHeight * maxRows;
+  if (boxSizing === 'border-box') {
+    maxHeight = maxHeight + paddingSize + borderSize;
+  }
+  height = Math.min(maxHeight, height);
+  return [height, rowHeight];
+}
+
+var noop = function noop() {};
+var pick = function pick(props, obj) {
+  return props.reduce(function (acc, prop) {
+    acc[prop] = obj[prop];
+    return acc;
+  }, {});
+};
+
+var SIZING_STYLE = ['borderBottomWidth', 'borderLeftWidth', 'borderRightWidth', 'borderTopWidth', 'boxSizing', 'fontFamily', 'fontSize', 'fontStyle', 'fontWeight', 'letterSpacing', 'lineHeight', 'paddingBottom', 'paddingLeft', 'paddingRight', 'paddingTop',
+// non-standard
+'tabSize', 'textIndent',
+// non-standard
+'textRendering', 'textTransform', 'width', 'wordBreak'];
+var isIE = !!document.documentElement.currentStyle ;
+var getSizingData = function getSizingData(node) {
+  var style = window.getComputedStyle(node);
+  if (style === null) {
+    return null;
+  }
+  var sizingStyle = pick(SIZING_STYLE, style);
+  var boxSizing = sizingStyle.boxSizing;
+
+  // probably node is detached from DOM, can't read computed dimensions
+  if (boxSizing === '') {
+    return null;
+  }
+
+  // IE (Edge has already correct behaviour) returns content width as computed width
+  // so we need to add manually padding and border widths
+  if (isIE && boxSizing === 'border-box') {
+    sizingStyle.width = parseFloat(sizingStyle.width) + parseFloat(sizingStyle.borderRightWidth) + parseFloat(sizingStyle.borderLeftWidth) + parseFloat(sizingStyle.paddingRight) + parseFloat(sizingStyle.paddingLeft) + 'px';
+  }
+  var paddingSize = parseFloat(sizingStyle.paddingBottom) + parseFloat(sizingStyle.paddingTop);
+  var borderSize = parseFloat(sizingStyle.borderBottomWidth) + parseFloat(sizingStyle.borderTopWidth);
+  return {
+    sizingStyle: sizingStyle,
+    paddingSize: paddingSize,
+    borderSize: borderSize
+  };
+};
+var getSizingData$1 = getSizingData;
+
+function useListener(target, type, listener) {
+  var latestListener = useLatest__default["default"](listener);
+  React__namespace.useLayoutEffect(function () {
+    var handler = function handler(ev) {
+      return latestListener.current(ev);
+    };
+
+    // might happen if document.fonts is not defined, for instance
+    if (!target) {
+      return;
+    }
+    target.addEventListener(type, handler);
+    return function () {
+      return target.removeEventListener(type, handler);
+    };
+  }, []);
+}
+var useWindowResizeListener = function useWindowResizeListener(listener) {
+  useListener(window, 'resize', listener);
+};
+var useFontsLoadedListener = function useFontsLoadedListener(listener) {
+  useListener(document.fonts, 'loadingdone', listener);
+};
+
+var _excluded = ["cacheMeasurements", "maxRows", "minRows", "onChange", "onHeightChange"];
+var TextareaAutosize = function TextareaAutosize(_ref, userRef) {
+  var cacheMeasurements = _ref.cacheMeasurements,
+    maxRows = _ref.maxRows,
+    minRows = _ref.minRows,
+    _ref$onChange = _ref.onChange,
+    onChange = _ref$onChange === void 0 ? noop : _ref$onChange,
+    _ref$onHeightChange = _ref.onHeightChange,
+    onHeightChange = _ref$onHeightChange === void 0 ? noop : _ref$onHeightChange,
+    props = _objectWithoutPropertiesLoose(_ref, _excluded);
+  if (props.style) {
+    if ('maxHeight' in props.style) {
+      throw new Error('Using `style.maxHeight` for <TextareaAutosize/> is not supported. Please use `maxRows`.');
+    }
+    if ('minHeight' in props.style) {
+      throw new Error('Using `style.minHeight` for <TextareaAutosize/> is not supported. Please use `minRows`.');
+    }
+  }
+  var isControlled = props.value !== undefined;
+  var libRef = React__namespace.useRef(null);
+  var ref = useComposedRef__default["default"](libRef, userRef);
+  var heightRef = React__namespace.useRef(0);
+  var measurementsCacheRef = React__namespace.useRef();
+  var resizeTextarea = function resizeTextarea() {
+    var node = libRef.current;
+    var nodeSizingData = cacheMeasurements && measurementsCacheRef.current ? measurementsCacheRef.current : getSizingData$1(node);
+    if (!nodeSizingData) {
+      return;
+    }
+    measurementsCacheRef.current = nodeSizingData;
+    var _calculateNodeHeight = calculateNodeHeight(nodeSizingData, node.value || node.placeholder || 'x', minRows, maxRows),
+      height = _calculateNodeHeight[0],
+      rowHeight = _calculateNodeHeight[1];
+    if (heightRef.current !== height) {
+      heightRef.current = height;
+      node.style.setProperty('height', height + "px", 'important');
+      onHeightChange(height, {
+        rowHeight: rowHeight
+      });
+    }
+  };
+  var handleChange = function handleChange(event) {
+    if (!isControlled) {
+      resizeTextarea();
+    }
+    onChange(event);
+  };
+  {
+    React__namespace.useLayoutEffect(resizeTextarea);
+    useWindowResizeListener(resizeTextarea);
+    useFontsLoadedListener(resizeTextarea);
+    return /*#__PURE__*/React__namespace.createElement("textarea", _extends({}, props, {
+      onChange: handleChange,
+      ref: ref
+    }));
+  }
+};
+var index = /* #__PURE__ */React__namespace.forwardRef(TextareaAutosize);
+
+exports["default"] = index;

node_modules/react-textarea-autosize/dist/react-textarea-autosize.browser.development.cjs.mjs

@@ -0,0 +1,2 @@
+import "./react-textarea-autosize.browser.development.cjs.js";
+export { _default as default } from "./react-textarea-autosize.browser.development.cjs.default.js";

node_modules/react-textarea-autosize/dist/react-textarea-autosize.browser.development.esm.js

@@ -0,0 +1,209 @@
+import _extends from '@babel/runtime/helpers/esm/extends';
+import _objectWithoutPropertiesLoose from '@babel/runtime/helpers/esm/objectWithoutPropertiesLoose';
+import * as React from 'react';
+import useLatest from 'use-latest';
+import useComposedRef from 'use-composed-ref';
+
+var HIDDEN_TEXTAREA_STYLE = {
+  'min-height': '0',
+  'max-height': 'none',
+  height: '0',
+  visibility: 'hidden',
+  overflow: 'hidden',
+  position: 'absolute',
+  'z-index': '-1000',
+  top: '0',
+  right: '0',
+  display: 'block'
+};
+var forceHiddenStyles = function forceHiddenStyles(node) {
+  Object.keys(HIDDEN_TEXTAREA_STYLE).forEach(function (key) {
+    node.style.setProperty(key, HIDDEN_TEXTAREA_STYLE[key], 'important');
+  });
+};
+var forceHiddenStyles$1 = forceHiddenStyles;
+
+var hiddenTextarea = null;
+var getHeight = function getHeight(node, sizingData) {
+  var height = node.scrollHeight;
+  if (sizingData.sizingStyle.boxSizing === 'border-box') {
+    // border-box: add border, since height = content + padding + border
+    return height + sizingData.borderSize;
+  }
+
+  // remove padding, since height = content
+  return height - sizingData.paddingSize;
+};
+function calculateNodeHeight(sizingData, value, minRows, maxRows) {
+  if (minRows === void 0) {
+    minRows = 1;
+  }
+  if (maxRows === void 0) {
+    maxRows = Infinity;
+  }
+  if (!hiddenTextarea) {
+    hiddenTextarea = document.createElement('textarea');
+    hiddenTextarea.setAttribute('tabindex', '-1');
+    hiddenTextarea.setAttribute('aria-hidden', 'true');
+    forceHiddenStyles$1(hiddenTextarea);
+  }
+  if (hiddenTextarea.parentNode === null) {
+    document.body.appendChild(hiddenTextarea);
+  }
+  var paddingSize = sizingData.paddingSize,
+    borderSize = sizingData.borderSize,
+    sizingStyle = sizingData.sizingStyle;
+  var boxSizing = sizingStyle.boxSizing;
+  Object.keys(sizingStyle).forEach(function (_key) {
+    var key = _key;
+    hiddenTextarea.style[key] = sizingStyle[key];
+  });
+  forceHiddenStyles$1(hiddenTextarea);
+  hiddenTextarea.value = value;
+  var height = getHeight(hiddenTextarea, sizingData);
+  // Double set and calc due to Firefox bug: https://bugzilla.mozilla.org/show_bug.cgi?id=1795904
+  hiddenTextarea.value = value;
+  height = getHeight(hiddenTextarea, sizingData);
+
+  // measure height of a textarea with a single row
+  hiddenTextarea.value = 'x';
+  var rowHeight = hiddenTextarea.scrollHeight - paddingSize;
+  var minHeight = rowHeight * minRows;
+  if (boxSizing === 'border-box') {
+    minHeight = minHeight + paddingSize + borderSize;
+  }
+  height = Math.max(minHeight, height);
+  var maxHeight = rowHeight * maxRows;
+  if (boxSizing === 'border-box') {
+    maxHeight = maxHeight + paddingSize + borderSize;
+  }
+  height = Math.min(maxHeight, height);
+  return [height, rowHeight];
+}
+
+var noop = function noop() {};
+var pick = function pick(props, obj) {
+  return props.reduce(function (acc, prop) {
+    acc[prop] = obj[prop];
+    return acc;
+  }, {});
+};
+
+var SIZING_STYLE = ['borderBottomWidth', 'borderLeftWidth', 'borderRightWidth', 'borderTopWidth', 'boxSizing', 'fontFamily', 'fontSize', 'fontStyle', 'fontWeight', 'letterSpacing', 'lineHeight', 'paddingBottom', 'paddingLeft', 'paddingRight', 'paddingTop',
+// non-standard
+'tabSize', 'textIndent',
+// non-standard
+'textRendering', 'textTransform', 'width', 'wordBreak'];
+var isIE = !!document.documentElement.currentStyle ;
+var getSizingData = function getSizingData(node) {
+  var style = window.getComputedStyle(node);
+  if (style === null) {
+    return null;
+  }
+  var sizingStyle = pick(SIZING_STYLE, style);
+  var boxSizing = sizingStyle.boxSizing;
+
+  // probably node is detached from DOM, can't read computed dimensions
+  if (boxSizing === '') {
+    return null;
+  }
+
+  // IE (Edge has already correct behaviour) returns content width as computed width
+  // so we need to add manually padding and border widths
+  if (isIE && boxSizing === 'border-box') {
+    sizingStyle.width = parseFloat(sizingStyle.width) + parseFloat(sizingStyle.borderRightWidth) + parseFloat(sizingStyle.borderLeftWidth) + parseFloat(sizingStyle.paddingRight) + parseFloat(sizingStyle.paddingLeft) + 'px';
+  }
+  var paddingSize = parseFloat(sizingStyle.paddingBottom) + parseFloat(sizingStyle.paddingTop);
+  var borderSize = parseFloat(sizingStyle.borderBottomWidth) + parseFloat(sizingStyle.borderTopWidth);
+  return {
+    sizingStyle: sizingStyle,
+    paddingSize: paddingSize,
+    borderSize: borderSize
+  };
+};
+var getSizingData$1 = getSizingData;
+
+function useListener(target, type, listener) {
+  var latestListener = useLatest(listener);
+  React.useLayoutEffect(function () {
+    var handler = function handler(ev) {
+      return latestListener.current(ev);
+    };
+
+    // might happen if document.fonts is not defined, for instance
+    if (!target) {
+      return;
+    }
+    target.addEventListener(type, handler);
+    return function () {
+      return target.removeEventListener(type, handler);
+    };
+  }, []);
+}
+var useWindowResizeListener = function useWindowResizeListener(listener) {
+  useListener(window, 'resize', listener);
+};
+var useFontsLoadedListener = function useFontsLoadedListener(listener) {
+  useListener(document.fonts, 'loadingdone', listener);
+};
+
+var _excluded = ["cacheMeasurements", "maxRows", "minRows", "onChange", "onHeightChange"];
+var TextareaAutosize = function TextareaAutosize(_ref, userRef) {
+  var cacheMeasurements = _ref.cacheMeasurements,
+    maxRows = _ref.maxRows,
+    minRows = _ref.minRows,
+    _ref$onChange = _ref.onChange,
+    onChange = _ref$onChange === void 0 ? noop : _ref$onChange,
+    _ref$onHeightChange = _ref.onHeightChange,
+    onHeightChange = _ref$onHeightChange === void 0 ? noop : _ref$onHeightChange,
+    props = _objectWithoutPropertiesLoose(_ref, _excluded);
+  if (props.style) {
+    if ('maxHeight' in props.style) {
+      throw new Error('Using `style.maxHeight` for <TextareaAutosize/> is not supported. Please use `maxRows`.');
+    }
+    if ('minHeight' in props.style) {
+      throw new Error('Using `style.minHeight` for <TextareaAutosize/> is not supported. Please use `minRows`.');
+    }
+  }
+  var isControlled = props.value !== undefined;
+  var libRef = React.useRef(null);
+  var ref = useComposedRef(libRef, userRef);
+  var heightRef = React.useRef(0);
+  var measurementsCacheRef = React.useRef();
+  var resizeTextarea = function resizeTextarea() {
+    var node = libRef.current;
+    var nodeSizingData = cacheMeasurements && measurementsCacheRef.current ? measurementsCacheRef.current : getSizingData$1(node);
+    if (!nodeSizingData) {
+      return;
+    }
+    measurementsCacheRef.current = nodeSizingData;
+    var _calculateNodeHeight = calculateNodeHeight(nodeSizingData, node.value || node.placeholder || 'x', minRows, maxRows),
+      height = _calculateNodeHeight[0],
+      rowHeight = _calculateNodeHeight[1];
+    if (heightRef.current !== height) {
+      heightRef.current = height;
+      node.style.setProperty('height', height + "px", 'important');
+      onHeightChange(height, {
+        rowHeight: rowHeight
+      });
+    }
+  };
+  var handleChange = function handleChange(event) {
+    if (!isControlled) {
+      resizeTextarea();
+    }
+    onChange(event);
+  };
+  {
+    React.useLayoutEffect(resizeTextarea);
+    useWindowResizeListener(resizeTextarea);
+    useFontsLoadedListener(resizeTextarea);
+    return /*#__PURE__*/React.createElement("textarea", _extends({}, props, {
+      onChange: handleChange,
+      ref: ref
+    }));
+  }
+};
+var index = /* #__PURE__ */React.forwardRef(TextareaAutosize);
+
+export { index as default };

node_modules/react-textarea-autosize/dist/react-textarea-autosize.browser.esm.js

@@ -0,0 +1,201 @@
+import _extends from '@babel/runtime/helpers/esm/extends';
+import _objectWithoutPropertiesLoose from '@babel/runtime/helpers/esm/objectWithoutPropertiesLoose';
+import * as React from 'react';
+import useLatest from 'use-latest';
+import useComposedRef from 'use-composed-ref';
+
+var HIDDEN_TEXTAREA_STYLE = {
+  'min-height': '0',
+  'max-height': 'none',
+  height: '0',
+  visibility: 'hidden',
+  overflow: 'hidden',
+  position: 'absolute',
+  'z-index': '-1000',
+  top: '0',
+  right: '0',
+  display: 'block'
+};
+var forceHiddenStyles = function forceHiddenStyles(node) {
+  Object.keys(HIDDEN_TEXTAREA_STYLE).forEach(function (key) {
+    node.style.setProperty(key, HIDDEN_TEXTAREA_STYLE[key], 'important');
+  });
+};
+var forceHiddenStyles$1 = forceHiddenStyles;
+
+var hiddenTextarea = null;
+var getHeight = function getHeight(node, sizingData) {
+  var height = node.scrollHeight;
+  if (sizingData.sizingStyle.boxSizing === 'border-box') {
+    // border-box: add border, since height = content + padding + border
+    return height + sizingData.borderSize;
+  }
+
+  // remove padding, since height = content
+  return height - sizingData.paddingSize;
+};
+function calculateNodeHeight(sizingData, value, minRows, maxRows) {
+  if (minRows === void 0) {
+    minRows = 1;
+  }
+  if (maxRows === void 0) {
+    maxRows = Infinity;
+  }
+  if (!hiddenTextarea) {
+    hiddenTextarea = document.createElement('textarea');
+    hiddenTextarea.setAttribute('tabindex', '-1');
+    hiddenTextarea.setAttribute('aria-hidden', 'true');
+    forceHiddenStyles$1(hiddenTextarea);
+  }
+  if (hiddenTextarea.parentNode === null) {
+    document.body.appendChild(hiddenTextarea);
+  }
+  var paddingSize = sizingData.paddingSize,
+    borderSize = sizingData.borderSize,
+    sizingStyle = sizingData.sizingStyle;
+  var boxSizing = sizingStyle.boxSizing;
+  Object.keys(sizingStyle).forEach(function (_key) {
+    var key = _key;
+    hiddenTextarea.style[key] = sizingStyle[key];
+  });
+  forceHiddenStyles$1(hiddenTextarea);
+  hiddenTextarea.value = value;
+  var height = getHeight(hiddenTextarea, sizingData);
+  // Double set and calc due to Firefox bug: https://bugzilla.mozilla.org/show_bug.cgi?id=1795904
+  hiddenTextarea.value = value;
+  height = getHeight(hiddenTextarea, sizingData);
+
+  // measure height of a textarea with a single row
+  hiddenTextarea.value = 'x';
+  var rowHeight = hiddenTextarea.scrollHeight - paddingSize;
+  var minHeight = rowHeight * minRows;
+  if (boxSizing === 'border-box') {
+    minHeight = minHeight + paddingSize + borderSize;
+  }
+  height = Math.max(minHeight, height);
+  var maxHeight = rowHeight * maxRows;
+  if (boxSizing === 'border-box') {
+    maxHeight = maxHeight + paddingSize + borderSize;
+  }
+  height = Math.min(maxHeight, height);
+  return [height, rowHeight];
+}
+
+var noop = function noop() {};
+var pick = function pick(props, obj) {
+  return props.reduce(function (acc, prop) {
+    acc[prop] = obj[prop];
+    return acc;
+  }, {});
+};
+
+var SIZING_STYLE = ['borderBottomWidth', 'borderLeftWidth', 'borderRightWidth', 'borderTopWidth', 'boxSizing', 'fontFamily', 'fontSize', 'fontStyle', 'fontWeight', 'letterSpacing', 'lineHeight', 'paddingBottom', 'paddingLeft', 'paddingRight', 'paddingTop',
+// non-standard
+'tabSize', 'textIndent',
+// non-standard
+'textRendering', 'textTransform', 'width', 'wordBreak'];
+var isIE = !!document.documentElement.currentStyle ;
+var getSizingData = function getSizingData(node) {
+  var style = window.getComputedStyle(node);
+  if (style === null) {
+    return null;
+  }
+  var sizingStyle = pick(SIZING_STYLE, style);
+  var boxSizing = sizingStyle.boxSizing;
+
+  // probably node is detached from DOM, can't read computed dimensions
+  if (boxSizing === '') {
+    return null;
+  }
+
+  // IE (Edge has already correct behaviour) returns content width as computed width
+  // so we need to add manually padding and border widths
+  if (isIE && boxSizing === 'border-box') {
+    sizingStyle.width = parseFloat(sizingStyle.width) + parseFloat(sizingStyle.borderRightWidth) + parseFloat(sizingStyle.borderLeftWidth) + parseFloat(sizingStyle.paddingRight) + parseFloat(sizingStyle.paddingLeft) + 'px';
+  }
+  var paddingSize = parseFloat(sizingStyle.paddingBottom) + parseFloat(sizingStyle.paddingTop);
+  var borderSize = parseFloat(sizingStyle.borderBottomWidth) + parseFloat(sizingStyle.borderTopWidth);
+  return {
+    sizingStyle: sizingStyle,
+    paddingSize: paddingSize,
+    borderSize: borderSize
+  };
+};
+var getSizingData$1 = getSizingData;
+
+function useListener(target, type, listener) {
+  var latestListener = useLatest(listener);
+  React.useLayoutEffect(function () {
+    var handler = function handler(ev) {
+      return latestListener.current(ev);
+    };
+
+    // might happen if document.fonts is not defined, for instance
+    if (!target) {
+      return;
+    }
+    target.addEventListener(type, handler);
+    return function () {
+      return target.removeEventListener(type, handler);
+    };
+  }, []);
+}
+var useWindowResizeListener = function useWindowResizeListener(listener) {
+  useListener(window, 'resize', listener);
+};
+var useFontsLoadedListener = function useFontsLoadedListener(listener) {
+  useListener(document.fonts, 'loadingdone', listener);
+};
+
+var _excluded = ["cacheMeasurements", "maxRows", "minRows", "onChange", "onHeightChange"];
+var TextareaAutosize = function TextareaAutosize(_ref, userRef) {
+  var cacheMeasurements = _ref.cacheMeasurements,
+    maxRows = _ref.maxRows,
+    minRows = _ref.minRows,
+    _ref$onChange = _ref.onChange,
+    onChange = _ref$onChange === void 0 ? noop : _ref$onChange,
+    _ref$onHeightChange = _ref.onHeightChange,
+    onHeightChange = _ref$onHeightChange === void 0 ? noop : _ref$onHeightChange,
+    props = _objectWithoutPropertiesLoose(_ref, _excluded);
+  var isControlled = props.value !== undefined;
+  var libRef = React.useRef(null);
+  var ref = useComposedRef(libRef, userRef);
+  var heightRef = React.useRef(0);
+  var measurementsCacheRef = React.useRef();
+  var resizeTextarea = function resizeTextarea() {
+    var node = libRef.current;
+    var nodeSizingData = cacheMeasurements && measurementsCacheRef.current ? measurementsCacheRef.current : getSizingData$1(node);
+    if (!nodeSizingData) {
+      return;
+    }
+    measurementsCacheRef.current = nodeSizingData;
+    var _calculateNodeHeight = calculateNodeHeight(nodeSizingData, node.value || node.placeholder || 'x', minRows, maxRows),
+      height = _calculateNodeHeight[0],
+      rowHeight = _calculateNodeHeight[1];
+    if (heightRef.current !== height) {
+      heightRef.current = height;
+      node.style.setProperty('height', height + "px", 'important');
+      onHeightChange(height, {
+        rowHeight: rowHeight
+      });
+    }
+  };
+  var handleChange = function handleChange(event) {
+    if (!isControlled) {
+      resizeTextarea();
+    }
+    onChange(event);
+  };
+  {
+    React.useLayoutEffect(resizeTextarea);
+    useWindowResizeListener(resizeTextarea);
+    useFontsLoadedListener(resizeTextarea);
+    return /*#__PURE__*/React.createElement("textarea", _extends({}, props, {
+      onChange: handleChange,
+      ref: ref
+    }));
+  }
+};
+var index = /* #__PURE__ */React.forwardRef(TextareaAutosize);
+
+export { index as default };

node_modules/react-textarea-autosize/dist/react-textarea-autosize.cjs.d.mts

@@ -0,0 +1,3 @@
+export * from "./declarations/src/index.js";
+export { _default as default } from "./react-textarea-autosize.cjs.default.js";
+//# sourceMappingURL=react-textarea-autosize.cjs.d.mts.map

node_modules/react-textarea-autosize/dist/react-textarea-autosize.cjs.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"react-textarea-autosize.cjs.d.mts","sourceRoot":"","sources":["./declarations/src/index.d.ts"],"names":[],"mappings":"AAAA"}

node_modules/react-textarea-autosize/dist/react-textarea-autosize.cjs.d.ts

@@ -0,0 +1,3 @@
+export * from "./declarations/src/index";
+export { default } from "./declarations/src/index";
+//# sourceMappingURL=react-textarea-autosize.cjs.d.ts.map

node_modules/react-textarea-autosize/dist/react-textarea-autosize.cjs.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"react-textarea-autosize.cjs.d.ts","sourceRoot":"","sources":["./declarations/src/index.d.ts"],"names":[],"mappings":"AAAA"}

node_modules/react-textarea-autosize/dist/react-textarea-autosize.cjs.default.d.ts

@@ -0,0 +1 @@
+export { default as _default } from "./declarations/src/index.js"

node_modules/react-textarea-autosize/dist/react-textarea-autosize.cjs.default.js

@@ -0,0 +1 @@
+exports._default = require("./react-textarea-autosize.cjs.js").default;

node_modules/react-textarea-autosize/dist/react-textarea-autosize.cjs.js

@@ -0,0 +1,56 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var _extends = require('@babel/runtime/helpers/extends');
+var _objectWithoutPropertiesLoose = require('@babel/runtime/helpers/objectWithoutPropertiesLoose');
+var React = require('react');
+var useComposedRef = require('use-composed-ref');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { 'default': e }; }
+
+function _interopNamespace(e) {
+  if (e && e.__esModule) return e;
+  var n = Object.create(null);
+  if (e) {
+    Object.keys(e).forEach(function (k) {
+      if (k !== 'default') {
+        var d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: function () { return e[k]; }
+        });
+      }
+    });
+  }
+  n["default"] = e;
+  return Object.freeze(n);
+}
+
+var React__namespace = /*#__PURE__*/_interopNamespace(React);
+var useComposedRef__default = /*#__PURE__*/_interopDefault(useComposedRef);
+
+var noop = function noop() {};
+
+var _excluded = ["cacheMeasurements", "maxRows", "minRows", "onChange", "onHeightChange"];
+var TextareaAutosize = function TextareaAutosize(_ref, userRef) {
+  _ref.cacheMeasurements;
+    _ref.maxRows;
+    _ref.minRows;
+    var _ref$onChange = _ref.onChange,
+    onChange = _ref$onChange === void 0 ? noop : _ref$onChange;
+    _ref.onHeightChange;
+    var props = _objectWithoutPropertiesLoose(_ref, _excluded);
+  props.value !== undefined;
+  var libRef = React__namespace.useRef(null);
+  var ref = useComposedRef__default["default"](libRef, userRef);
+  React__namespace.useRef(0);
+  React__namespace.useRef();
+  return /*#__PURE__*/React__namespace.createElement("textarea", _extends({}, props, {
+    onChange: onChange,
+    ref: ref
+  }));
+};
+var index = /* #__PURE__ */React__namespace.forwardRef(TextareaAutosize);
+
+exports["default"] = index;

node_modules/react-textarea-autosize/dist/react-textarea-autosize.cjs.mjs

@@ -0,0 +1,2 @@
+import "./react-textarea-autosize.cjs.js";
+export { _default as default } from "./react-textarea-autosize.cjs.default.js";

node_modules/react-textarea-autosize/dist/react-textarea-autosize.development.cjs.default.js

@@ -0,0 +1 @@
+exports._default = require("./react-textarea-autosize.development.cjs.js").default;

node_modules/react-textarea-autosize/dist/react-textarea-autosize.development.cjs.js

@@ -0,0 +1,64 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var _extends = require('@babel/runtime/helpers/extends');
+var _objectWithoutPropertiesLoose = require('@babel/runtime/helpers/objectWithoutPropertiesLoose');
+var React = require('react');
+var useComposedRef = require('use-composed-ref');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { 'default': e }; }
+
+function _interopNamespace(e) {
+  if (e && e.__esModule) return e;
+  var n = Object.create(null);
+  if (e) {
+    Object.keys(e).forEach(function (k) {
+      if (k !== 'default') {
+        var d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: function () { return e[k]; }
+        });
+      }
+    });
+  }
+  n["default"] = e;
+  return Object.freeze(n);
+}
+
+var React__namespace = /*#__PURE__*/_interopNamespace(React);
+var useComposedRef__default = /*#__PURE__*/_interopDefault(useComposedRef);
+
+var noop = function noop() {};
+
+var _excluded = ["cacheMeasurements", "maxRows", "minRows", "onChange", "onHeightChange"];
+var TextareaAutosize = function TextareaAutosize(_ref, userRef) {
+  _ref.cacheMeasurements;
+    _ref.maxRows;
+    _ref.minRows;
+    var _ref$onChange = _ref.onChange,
+    onChange = _ref$onChange === void 0 ? noop : _ref$onChange;
+    _ref.onHeightChange;
+    var props = _objectWithoutPropertiesLoose(_ref, _excluded);
+  if (props.style) {
+    if ('maxHeight' in props.style) {
+      throw new Error('Using `style.maxHeight` for <TextareaAutosize/> is not supported. Please use `maxRows`.');
+    }
+    if ('minHeight' in props.style) {
+      throw new Error('Using `style.minHeight` for <TextareaAutosize/> is not supported. Please use `minRows`.');
+    }
+  }
+  props.value !== undefined;
+  var libRef = React__namespace.useRef(null);
+  var ref = useComposedRef__default["default"](libRef, userRef);
+  React__namespace.useRef(0);
+  React__namespace.useRef();
+  return /*#__PURE__*/React__namespace.createElement("textarea", _extends({}, props, {
+    onChange: onChange,
+    ref: ref
+  }));
+};
+var index = /* #__PURE__ */React__namespace.forwardRef(TextareaAutosize);
+
+exports["default"] = index;

node_modules/react-textarea-autosize/dist/react-textarea-autosize.development.cjs.mjs

@@ -0,0 +1,2 @@
+import "./react-textarea-autosize.development.cjs.js";
+export { _default as default } from "./react-textarea-autosize.development.cjs.default.js";

node_modules/react-textarea-autosize/dist/react-textarea-autosize.development.esm.js

@@ -0,0 +1,37 @@
+import _extends from '@babel/runtime/helpers/esm/extends';
+import _objectWithoutPropertiesLoose from '@babel/runtime/helpers/esm/objectWithoutPropertiesLoose';
+import * as React from 'react';
+import useComposedRef from 'use-composed-ref';
+
+var noop = function noop() {};
+
+var _excluded = ["cacheMeasurements", "maxRows", "minRows", "onChange", "onHeightChange"];
+var TextareaAutosize = function TextareaAutosize(_ref, userRef) {
+  _ref.cacheMeasurements;
+    _ref.maxRows;
+    _ref.minRows;
+    var _ref$onChange = _ref.onChange,
+    onChange = _ref$onChange === void 0 ? noop : _ref$onChange;
+    _ref.onHeightChange;
+    var props = _objectWithoutPropertiesLoose(_ref, _excluded);
+  if (props.style) {
+    if ('maxHeight' in props.style) {
+      throw new Error('Using `style.maxHeight` for <TextareaAutosize/> is not supported. Please use `maxRows`.');
+    }
+    if ('minHeight' in props.style) {
+      throw new Error('Using `style.minHeight` for <TextareaAutosize/> is not supported. Please use `minRows`.');
+    }
+  }
+  props.value !== undefined;
+  var libRef = React.useRef(null);
+  var ref = useComposedRef(libRef, userRef);
+  React.useRef(0);
+  React.useRef();
+  return /*#__PURE__*/React.createElement("textarea", _extends({}, props, {
+    onChange: onChange,
+    ref: ref
+  }));
+};
+var index = /* #__PURE__ */React.forwardRef(TextareaAutosize);
+
+export { index as default };

node_modules/react-textarea-autosize/dist/react-textarea-autosize.development.worker.cjs.default.js

@@ -0,0 +1 @@
+exports._default = require("./react-textarea-autosize.development.worker.cjs.js").default;

node_modules/react-textarea-autosize/dist/react-textarea-autosize.development.worker.cjs.js

@@ -0,0 +1,64 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var _extends = require('@babel/runtime/helpers/extends');
+var _objectWithoutPropertiesLoose = require('@babel/runtime/helpers/objectWithoutPropertiesLoose');
+var React = require('react');
+var useComposedRef = require('use-composed-ref');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { 'default': e }; }
+
+function _interopNamespace(e) {
+  if (e && e.__esModule) return e;
+  var n = Object.create(null);
+  if (e) {
+    Object.keys(e).forEach(function (k) {
+      if (k !== 'default') {
+        var d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: function () { return e[k]; }
+        });
+      }
+    });
+  }
+  n["default"] = e;
+  return Object.freeze(n);
+}
+
+var React__namespace = /*#__PURE__*/_interopNamespace(React);
+var useComposedRef__default = /*#__PURE__*/_interopDefault(useComposedRef);
+
+var noop = function noop() {};
+
+var _excluded = ["cacheMeasurements", "maxRows", "minRows", "onChange", "onHeightChange"];
+var TextareaAutosize = function TextareaAutosize(_ref, userRef) {
+  _ref.cacheMeasurements;
+    _ref.maxRows;
+    _ref.minRows;
+    var _ref$onChange = _ref.onChange,
+    onChange = _ref$onChange === void 0 ? noop : _ref$onChange;
+    _ref.onHeightChange;
+    var props = _objectWithoutPropertiesLoose(_ref, _excluded);
+  if (props.style) {
+    if ('maxHeight' in props.style) {
+      throw new Error('Using `style.maxHeight` for <TextareaAutosize/> is not supported. Please use `maxRows`.');
+    }
+    if ('minHeight' in props.style) {
+      throw new Error('Using `style.minHeight` for <TextareaAutosize/> is not supported. Please use `minRows`.');
+    }
+  }
+  props.value !== undefined;
+  var libRef = React__namespace.useRef(null);
+  var ref = useComposedRef__default["default"](libRef, userRef);
+  React__namespace.useRef(0);
+  React__namespace.useRef();
+  return /*#__PURE__*/React__namespace.createElement("textarea", _extends({}, props, {
+    onChange: onChange,
+    ref: ref
+  }));
+};
+var index = /* #__PURE__ */React__namespace.forwardRef(TextareaAutosize);
+
+exports["default"] = index;

node_modules/react-textarea-autosize/dist/react-textarea-autosize.development.worker.cjs.mjs

@@ -0,0 +1,2 @@
+import "./react-textarea-autosize.development.worker.cjs.js";
+export { _default as default } from "./react-textarea-autosize.development.worker.cjs.default.js";

node_modules/react-textarea-autosize/dist/react-textarea-autosize.development.worker.esm.js

@@ -0,0 +1,37 @@
+import _extends from '@babel/runtime/helpers/esm/extends';
+import _objectWithoutPropertiesLoose from '@babel/runtime/helpers/esm/objectWithoutPropertiesLoose';
+import * as React from 'react';
+import useComposedRef from 'use-composed-ref';
+
+var noop = function noop() {};
+
+var _excluded = ["cacheMeasurements", "maxRows", "minRows", "onChange", "onHeightChange"];
+var TextareaAutosize = function TextareaAutosize(_ref, userRef) {
+  _ref.cacheMeasurements;
+    _ref.maxRows;
+    _ref.minRows;
+    var _ref$onChange = _ref.onChange,
+    onChange = _ref$onChange === void 0 ? noop : _ref$onChange;
+    _ref.onHeightChange;
+    var props = _objectWithoutPropertiesLoose(_ref, _excluded);
+  if (props.style) {
+    if ('maxHeight' in props.style) {
+      throw new Error('Using `style.maxHeight` for <TextareaAutosize/> is not supported. Please use `maxRows`.');
+    }
+    if ('minHeight' in props.style) {
+      throw new Error('Using `style.minHeight` for <TextareaAutosize/> is not supported. Please use `minRows`.');
+    }
+  }
+  props.value !== undefined;
+  var libRef = React.useRef(null);
+  var ref = useComposedRef(libRef, userRef);
+  React.useRef(0);
+  React.useRef();
+  return /*#__PURE__*/React.createElement("textarea", _extends({}, props, {
+    onChange: onChange,
+    ref: ref
+  }));
+};
+var index = /* #__PURE__ */React.forwardRef(TextareaAutosize);
+
+export { index as default };

node_modules/react-textarea-autosize/dist/react-textarea-autosize.esm.js

@@ -0,0 +1,29 @@
+import _extends from '@babel/runtime/helpers/esm/extends';
+import _objectWithoutPropertiesLoose from '@babel/runtime/helpers/esm/objectWithoutPropertiesLoose';
+import * as React from 'react';
+import useComposedRef from 'use-composed-ref';
+
+var noop = function noop() {};
+
+var _excluded = ["cacheMeasurements", "maxRows", "minRows", "onChange", "onHeightChange"];
+var TextareaAutosize = function TextareaAutosize(_ref, userRef) {
+  _ref.cacheMeasurements;
+    _ref.maxRows;
+    _ref.minRows;
+    var _ref$onChange = _ref.onChange,
+    onChange = _ref$onChange === void 0 ? noop : _ref$onChange;
+    _ref.onHeightChange;
+    var props = _objectWithoutPropertiesLoose(_ref, _excluded);
+  props.value !== undefined;
+  var libRef = React.useRef(null);
+  var ref = useComposedRef(libRef, userRef);
+  React.useRef(0);
+  React.useRef();
+  return /*#__PURE__*/React.createElement("textarea", _extends({}, props, {
+    onChange: onChange,
+    ref: ref
+  }));
+};
+var index = /* #__PURE__ */React.forwardRef(TextareaAutosize);
+
+export { index as default };

node_modules/react-textarea-autosize/dist/react-textarea-autosize.worker.cjs.default.js

@@ -0,0 +1 @@
+exports._default = require("./react-textarea-autosize.worker.cjs.js").default;

node_modules/react-textarea-autosize/dist/react-textarea-autosize.worker.cjs.js

@@ -0,0 +1,56 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var _extends = require('@babel/runtime/helpers/extends');
+var _objectWithoutPropertiesLoose = require('@babel/runtime/helpers/objectWithoutPropertiesLoose');
+var React = require('react');
+var useComposedRef = require('use-composed-ref');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { 'default': e }; }
+
+function _interopNamespace(e) {
+  if (e && e.__esModule) return e;
+  var n = Object.create(null);
+  if (e) {
+    Object.keys(e).forEach(function (k) {
+      if (k !== 'default') {
+        var d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: function () { return e[k]; }
+        });
+      }
+    });
+  }
+  n["default"] = e;
+  return Object.freeze(n);
+}
+
+var React__namespace = /*#__PURE__*/_interopNamespace(React);
+var useComposedRef__default = /*#__PURE__*/_interopDefault(useComposedRef);
+
+var noop = function noop() {};
+
+var _excluded = ["cacheMeasurements", "maxRows", "minRows", "onChange", "onHeightChange"];
+var TextareaAutosize = function TextareaAutosize(_ref, userRef) {
+  _ref.cacheMeasurements;
+    _ref.maxRows;
+    _ref.minRows;
+    var _ref$onChange = _ref.onChange,
+    onChange = _ref$onChange === void 0 ? noop : _ref$onChange;
+    _ref.onHeightChange;
+    var props = _objectWithoutPropertiesLoose(_ref, _excluded);
+  props.value !== undefined;
+  var libRef = React__namespace.useRef(null);
+  var ref = useComposedRef__default["default"](libRef, userRef);
+  React__namespace.useRef(0);
+  React__namespace.useRef();
+  return /*#__PURE__*/React__namespace.createElement("textarea", _extends({}, props, {
+    onChange: onChange,
+    ref: ref
+  }));
+};
+var index = /* #__PURE__ */React__namespace.forwardRef(TextareaAutosize);
+
+exports["default"] = index;

node_modules/react-textarea-autosize/dist/react-textarea-autosize.worker.cjs.mjs

@@ -0,0 +1,2 @@
+import "./react-textarea-autosize.worker.cjs.js";
+export { _default as default } from "./react-textarea-autosize.worker.cjs.default.js";

node_modules/react-textarea-autosize/dist/react-textarea-autosize.worker.esm.js

@@ -0,0 +1,29 @@
+import _extends from '@babel/runtime/helpers/esm/extends';
+import _objectWithoutPropertiesLoose from '@babel/runtime/helpers/esm/objectWithoutPropertiesLoose';
+import * as React from 'react';
+import useComposedRef from 'use-composed-ref';
+
+var noop = function noop() {};
+
+var _excluded = ["cacheMeasurements", "maxRows", "minRows", "onChange", "onHeightChange"];
+var TextareaAutosize = function TextareaAutosize(_ref, userRef) {
+  _ref.cacheMeasurements;
+    _ref.maxRows;
+    _ref.minRows;
+    var _ref$onChange = _ref.onChange,
+    onChange = _ref$onChange === void 0 ? noop : _ref$onChange;
+    _ref.onHeightChange;
+    var props = _objectWithoutPropertiesLoose(_ref, _excluded);
+  props.value !== undefined;
+  var libRef = React.useRef(null);
+  var ref = useComposedRef(libRef, userRef);
+  React.useRef(0);
+  React.useRef();
+  return /*#__PURE__*/React.createElement("textarea", _extends({}, props, {
+    onChange: onChange,
+    ref: ref
+  }));
+};
+var index = /* #__PURE__ */React.forwardRef(TextareaAutosize);
+
+export { index as default };

node_modules/react-textarea-autosize/package.json

@@ -0,0 +1,148 @@
+{
+  "name": "react-textarea-autosize",
+  "description": "textarea component for React which grows with content",
+  "version": "8.5.4",
+  "keywords": [
+    "autosize",
+    "grow",
+    "react",
+    "react-component",
+    "textarea"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Andarist/react-textarea-autosize.git"
+  },
+  "license": "MIT",
+  "main": "dist/react-textarea-autosize.cjs.js",
+  "module": "dist/react-textarea-autosize.esm.js",
+  "browser": {
+    "./dist/react-textarea-autosize.esm.js": "./dist/react-textarea-autosize.browser.esm.js"
+  },
+  "exports": {
+    ".": {
+      "types": {
+        "import": "./dist/react-textarea-autosize.cjs.mjs",
+        "default": "./dist/react-textarea-autosize.cjs.js"
+      },
+      "development": {
+        "worker": {
+          "module": "./dist/react-textarea-autosize.development.worker.esm.js",
+          "import": "./dist/react-textarea-autosize.development.worker.cjs.mjs",
+          "default": "./dist/react-textarea-autosize.development.worker.cjs.js"
+        },
+        "browser": {
+          "module": "./dist/react-textarea-autosize.browser.development.esm.js",
+          "import": "./dist/react-textarea-autosize.browser.development.cjs.mjs",
+          "default": "./dist/react-textarea-autosize.browser.development.cjs.js"
+        },
+        "module": "./dist/react-textarea-autosize.development.esm.js",
+        "import": "./dist/react-textarea-autosize.development.cjs.mjs",
+        "default": "./dist/react-textarea-autosize.development.cjs.js"
+      },
+      "worker": {
+        "module": "./dist/react-textarea-autosize.worker.esm.js",
+        "import": "./dist/react-textarea-autosize.worker.cjs.mjs",
+        "default": "./dist/react-textarea-autosize.worker.cjs.js"
+      },
+      "browser": {
+        "module": "./dist/react-textarea-autosize.browser.esm.js",
+        "import": "./dist/react-textarea-autosize.browser.cjs.mjs",
+        "default": "./dist/react-textarea-autosize.browser.cjs.js"
+      },
+      "module": "./dist/react-textarea-autosize.esm.js",
+      "import": "./dist/react-textarea-autosize.cjs.mjs",
+      "default": "./dist/react-textarea-autosize.cjs.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "imports": {
+    "#is-browser": {
+      "worker": "./src/resolved-conditions/worker.ts",
+      "browser": "./src/resolved-conditions/browser.ts",
+      "default": "./src/resolved-conditions/node.ts"
+    },
+    "#is-development": {
+      "development": "./src/resolved-conditions/development.ts",
+      "default": "./src/resolved-conditions/production.ts"
+    }
+  },
+  "sideEffects": false,
+  "files": [
+    "dist"
+  ],
+  "author": "Andrey Popp <8mayday@gmail.com> (httsps://andreypopp.com/)",
+  "contributors": [
+    "Mateusz Burzyński <mateuszburzynski@gmail.com> (https://github.com/Andarist)"
+  ],
+  "scripts": {
+    "prebuild": "npm run clean",
+    "build": "preconstruct build",
+    "docs:dev": "npm run dev --prefix example",
+    "docs:build": "npm run build --prefix example",
+    "docs:publish": "npm run docs:build && cd ./example/dist && git init && git commit --allow-empty -m 'update docs' && git checkout -b gh-pages && touch .nojekyll && git add . && git commit -am 'update docs' && git push git@github.com:Andarist/react-textarea-autosize gh-pages --force",
+    "clean": "rimraf dist",
+    "lint": "eslint --ext .js,.ts,.tsx src",
+    "prepare": "npm run build",
+    "changeset": "changeset",
+    "prerelease": "npm run lint && npm test",
+    "release": "changeset publish",
+    "test": "jest",
+    "test:watch": "npm test -- --watch"
+  },
+  "peerDependencies": {
+    "react": "^16.8.0 || ^17.0.0 || ^18.0.0"
+  },
+  "dependencies": {
+    "@babel/runtime": "^7.20.13",
+    "use-composed-ref": "^1.3.0",
+    "use-latest": "^1.2.1"
+  },
+  "devDependencies": {
+    "@babel/core": "^7.21.3",
+    "@babel/plugin-proposal-object-rest-spread": "^7.20.7",
+    "@babel/plugin-transform-runtime": "^7.21.0",
+    "@babel/preset-env": "^7.20.2",
+    "@babel/preset-react": "^7.18.6",
+    "@babel/preset-typescript": "^7.21.0",
+    "@changesets/changelog-github": "^0.4.4",
+    "@changesets/cli": "^2.22.0",
+    "@preconstruct/cli": "^2.8.1",
+    "@testing-library/jest-dom": "^5.16.5",
+    "@testing-library/react": "^10.4.9",
+    "@types/react": "^16.14.35",
+    "@types/react-dom": "^16.9.17",
+    "@typescript-eslint/eslint-plugin": "^5.51.0",
+    "@typescript-eslint/parser": "^5.51.0",
+    "babel-eslint": "11.0.0-beta.2",
+    "bytes": "^3.1.0",
+    "cross-env": "^7.0.2",
+    "eslint": "^8.33.0",
+    "eslint-config-prettier": "^8.6.0",
+    "eslint-plugin-prettier": "^4.2.1",
+    "eslint-plugin-react": "^7.32.2",
+    "husky": "^4.2.5",
+    "jest": "^29.4.2",
+    "jest-environment-jsdom": "^29.4.2",
+    "lint-staged": "^10.2.8",
+    "parcel": "2.0.0-nightly.454",
+    "prettier": "^2.8.4",
+    "react": "^16.13.1",
+    "react-dom": "^16.13.1",
+    "rimraf": "^3.0.2",
+    "terser": "^4.7.0",
+    "typescript": "^5.1.3"
+  },
+  "engines": {
+    "node": ">=10"
+  },
+  "packageManager": "yarn@3.1.1",
+  "preconstruct": {
+    "exports": {
+      "importConditionDefaultExport": "default"
+    },
+    "___experimentalFlags_WILL_CHANGE_IN_PATCH": {
+      "importsConditions": true
+    }
+  }
+}