.-.-.-.-.-

PK�[�\��N��CONTRIBUTING.mdnu�[���# Contributing

## PRs and Contributions
 * Tests must pass.
 * Follow existing coding style.
 * If you fix a bug or add a feature, add a test.

## Issues
Things that will help get your question issue looked at:
 * Full and runnable JS code.
 * Clear description of the problem or unexpected behavior.
 * Clear description of the expected result.
 * Steps you have taken to debug it yourself.
PK�[�\�!�K��package.jsonnu�[���{
  "_from": "react-dnd-scrollzone-patch-react-17@^1.0.2",
  "_id": "react-dnd-scrollzone-patch-react-17@1.0.2",
  "_inBundle": false,
  "_integrity": "sha512-Wfhyc/Y/Veim29REBYm8nMmtDB5IwSmPPhXIuabBgsEa1MrVsuOwK9+7LmuP+mGbDOEP/S6G8+5XvDqPlRFK2g==",
  "_location": "/react-dnd-scrollzone-patch-react-17",
  "_phantomChildren": {},
  "_requested": {
    "type": "range",
    "registry": true,
    "raw": "react-dnd-scrollzone-patch-react-17@^1.0.2",
    "name": "react-dnd-scrollzone-patch-react-17",
    "escapedName": "react-dnd-scrollzone-patch-react-17",
    "rawSpec": "^1.0.2",
    "saveSpec": null,
    "fetchSpec": "^1.0.2"
  },
  "_requiredBy": [
    "/react-sortable-tree-patch-react-17"
  ],
  "_resolved": "https://registry.npmjs.org/react-dnd-scrollzone-patch-react-17/-/react-dnd-scrollzone-patch-react-17-1.0.2.tgz",
  "_shasum": "aa7e4c54268fe109246e790f1412427481b63067",
  "_spec": "react-dnd-scrollzone-patch-react-17@^1.0.2",
  "_where": "C:\\xampp\\htdocs\\emeraltd\\node_modules\\react-sortable-tree-patch-react-17",
  "author": {
    "name": "Nicholas Clawson",
    "email": "nickclaw@gmail.com",
    "url": "nickclaw.com"
  },
  "bugs": {
    "url": "http://github.com/frontend-collective/react-dnd-scrollzone/issues"
  },
  "bundleDependencies": false,
  "dependencies": {
    "hoist-non-react-statics": "^3.1.0",
    "lodash.throttle": "^4.0.1",
    "prop-types": "^15.5.9",
    "raf": "^3.2.0",
    "react-display-name": "^0.2.0"
  },
  "deprecated": false,
  "description": "A cross browser solution to scrolling during drag and drop.",
  "devDependencies": {
    "@babel/cli": "^7.0.0",
    "@babel/core": "^7.0.0",
    "@babel/plugin-proposal-class-properties": "^7.0.0",
    "@babel/preset-env": "^7.0.0",
    "@babel/preset-react": "^7.0.0",
    "@babel/register": "^7.0.0",
    "babel-eslint": "^10.0.1",
    "chai": "^4.2.0",
    "eslint": "^5.9.0",
    "eslint-config-airbnb": "^17.1.0",
    "eslint-plugin-import": "^2.14.0",
    "eslint-plugin-jsx-a11y": "^6.1.2",
    "eslint-plugin-react": "^7.11.1",
    "in-publish": "^2.0.0",
    "mocha": "^5.2.0",
    "react": "^17.0.1",
    "react-dnd": "^11.1.3",
    "react-dom": "^17.0.1",
    "sinon": "^7.1.1",
    "sinon-chai": "^3.2.0"
  },
  "homepage": "https://github.com/frontend-collective/react-dnd-scrollzone#readme",
  "keywords": [
    "react",
    "drag",
    "drop",
    "scroll",
    "dnd",
    "drag and drop",
    "polyfill",
    "auto"
  ],
  "license": "MIT",
  "main": "lib/index.js",
  "name": "react-dnd-scrollzone-patch-react-17",
  "peerDependencies": {
    "react": "^17.0.1",
    "react-dnd": "^11.1.3",
    "react-dom": "^17.0.1"
  },
  "repository": {
    "type": "git",
    "url": "git+https://github.com/frontend-collective/react-dnd-scrollzone.git"
  },
  "scripts": {
    "build": "rm -rf lib && babel src --out-dir lib",
    "lint": "eslint src",
    "postpublish": "git push origin master --tags",
    "prepublish": "in-publish && npm run test && npm run build || not-in-publish",
    "pretest": "npm run lint",
    "publish:major": "npm version major && npm publish",
    "publish:minor": "npm version minor && npm publish",
    "publish:patch": "npm version patch && npm publish",
    "test": "mocha test"
  },
  "version": "1.0.2"
}
PK�[�\ۍ�{�8�8lib/index.jsnu�[���"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.createHorizontalStrength = createHorizontalStrength;
exports.createVerticalStrength = createVerticalStrength;
exports.createScrollingComponent = createScrollingComponent;
exports.default = createScrollingComponentWithConsumer;
exports.defaultVerticalStrength = exports.defaultHorizontalStrength = void 0;

var _react = _interopRequireWildcard(require("react"));

var _propTypes = _interopRequireDefault(require("prop-types"));

var _lodash = _interopRequireDefault(require("lodash.throttle"));

var _raf = _interopRequireDefault(require("raf"));

var _reactDisplayName = _interopRequireDefault(require("react-display-name"));

var _reactDnd = require("react-dnd");

var _hoistNonReactStatics = _interopRequireDefault(require("hoist-non-react-statics"));

var _util = require("./util");

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }

function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }

function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } return _assertThisInitialized(self); }

function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }

function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }

function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }

var DEFAULT_BUFFER = 150;

function createHorizontalStrength(_buffer) {
  return function defaultHorizontalStrength(_ref, point) {
    var x = _ref.x,
        w = _ref.w,
        y = _ref.y,
        h = _ref.h;
    var buffer = Math.min(w / 2, _buffer);
    var inRange = point.x >= x && point.x <= x + w;
    var inBox = inRange && point.y >= y && point.y <= y + h;

if (inBox) {
      if (point.x < x + buffer) {
        return (point.x - x - buffer) / buffer;
      }

if (point.x > x + w - buffer) {
        return -(x + w - point.x - buffer) / buffer;
      }
    }

return 0;
  };
}

function createVerticalStrength(_buffer) {
  return function defaultVerticalStrength(_ref2, point) {
    var y = _ref2.y,
        h = _ref2.h,
        x = _ref2.x,
        w = _ref2.w;
    var buffer = Math.min(h / 2, _buffer);
    var inRange = point.y >= y && point.y <= y + h;
    var inBox = inRange && point.x >= x && point.x <= x + w;

if (inBox) {
      if (point.y < y + buffer) {
        return (point.y - y - buffer) / buffer;
      }

if (point.y > y + h - buffer) {
        return -(y + h - point.y - buffer) / buffer;
      }
    }

return 0;
  };
}

var defaultHorizontalStrength = createHorizontalStrength(DEFAULT_BUFFER);
exports.defaultHorizontalStrength = defaultHorizontalStrength;
var defaultVerticalStrength = createVerticalStrength(DEFAULT_BUFFER);
exports.defaultVerticalStrength = defaultVerticalStrength;

function createScrollingComponent(WrappedComponent) {
  var ScrollingComponent =
  /*#__PURE__*/
  function (_Component) {
    _inherits(ScrollingComponent, _Component);

// Update scaleX and scaleY every 100ms or so
    // and start scrolling if necessary
    function ScrollingComponent(props, ctx) {
      var _this;

_classCallCheck(this, ScrollingComponent);

_this = _possibleConstructorReturn(this, _getPrototypeOf(ScrollingComponent).call(this, props, ctx));

_defineProperty(_assertThisInitialized(_assertThisInitialized(_this)), "updateScrolling", (0, _lodash.default)(function (evt) {
        var _this$container$getBo = _this.container.getBoundingClientRect(),
            x = _this$container$getBo.left,
            y = _this$container$getBo.top,
            w = _this$container$getBo.width,
            h = _this$container$getBo.height;

var box = {
          x: x,
          y: y,
          w: w,
          h: h
        };
        var coords = (0, _util.getCoords)(evt); // calculate strength

var _this$props = _this.props,
            horizontalStrength = _this$props.horizontalStrength,
            verticalStrength = _this$props.verticalStrength;
        _this.scaleX = horizontalStrength(box, coords);
        _this.scaleY = verticalStrength(box, coords); // start scrolling if we need to

if (!_this.frame && (_this.scaleX || _this.scaleY)) {
          _this.startScrolling();
        }
      }, 100, {
        trailing: false
      }));

_defineProperty(_assertThisInitialized(_assertThisInitialized(_this)), "handleEvent", function (evt) {
        if (_this.dragging && !_this.attached) {
          _this.attach();

_this.updateScrolling(evt);
        }
      });

_this.wrappedInstance = _react.default.createRef();
      _this.scaleX = 0;
      _this.scaleY = 0;
      _this.frame = null;
      _this.attached = false;
      _this.dragging = false;
      return _this;
    }

_createClass(ScrollingComponent, [{
      key: "componentDidMount",
      value: function componentDidMount() {
        var _this2 = this;

this.container = this.wrappedInstance.current;

if (this.container && typeof this.container.addEventListener === 'function') {
          this.container.addEventListener('dragover', this.handleEvent);
        } // touchmove events don't seem to work across siblings, so we unfortunately
        // have to attach the listeners to the body

window.document.body.removeEventListener('touchmove', this.handleEvent);
        this.clearMonitorSubscription();
        this.stopScrolling();
      }
    }, {
      key: "handleMonitorChange",
      value: function handleMonitorChange() {
        var dragDropManager = this.props.dragDropManager;
        var isDragging = dragDropManager.getMonitor().isDragging();

if (!this.dragging && isDragging) {
          this.dragging = true;
        } else if (this.dragging && !isDragging) {
          this.dragging = false;
          this.stopScrolling();
        }
      }
    }, {
      key: "attach",
      value: function attach() {
        this.attached = true;
        window.document.body.addEventListener('dragover', this.updateScrolling);
        window.document.body.addEventListener('touchmove', this.updateScrolling);
      }
    }, {
      key: "detach",
      value: function detach() {
        this.attached = false;
        window.document.body.removeEventListener('dragover', this.updateScrolling);
        window.document.body.removeEventListener('touchmove', this.updateScrolling);
      }
    }, {
      key: "startScrolling",
      value: function startScrolling() {
        var _this3 = this;

var i = 0;

var tick = function tick() {
          var scaleX = _this3.scaleX,
              scaleY = _this3.scaleY,
              container = _this3.container;
          var _this3$props = _this3.props,
              strengthMultiplier = _this3$props.strengthMultiplier,
              onScrollChange = _this3$props.onScrollChange; // stop scrolling if there's nothing to do

if (strengthMultiplier === 0 || scaleX + scaleY === 0) {
            _this3.stopScrolling();

return;
          } // there's a bug in safari where it seems like we can't get
          // mousemove events from a container that also emits a scroll
          // event that same frame. So we double the strengthMultiplier and only adjust
          // the scroll position at 30fps

i += 1;

if (i % 2) {
            var scrollLeft = container.scrollLeft,
                scrollTop = container.scrollTop,
                scrollWidth = container.scrollWidth,
                scrollHeight = container.scrollHeight,
                clientWidth = container.clientWidth,
                clientHeight = container.clientHeight;
            var newLeft = scaleX ? container.scrollLeft = (0, _util.intBetween)(0, scrollWidth - clientWidth, scrollLeft + scaleX * strengthMultiplier) : scrollLeft;
            var newTop = scaleY ? container.scrollTop = (0, _util.intBetween)(0, scrollHeight - clientHeight, scrollTop + scaleY * strengthMultiplier) : scrollTop;
            onScrollChange(newLeft, newTop);
          }

_this3.frame = (0, _raf.default)(tick);
        };

tick();
      }
    }, {
      key: "stopScrolling",
      value: function stopScrolling() {
        this.detach();
        this.scaleX = 0;
        this.scaleY = 0;

if (this.frame) {
          _raf.default.cancel(this.frame);

this.frame = null;
        }
      }
    }, {
      key: "render",
      value: function render() {
        var _this$props2 = this.props,
            strengthMultiplier = _this$props2.strengthMultiplier,
            verticalStrength = _this$props2.verticalStrength,
            horizontalStrength = _this$props2.horizontalStrength,
            onScrollChange = _this$props2.onScrollChange,
            props = _objectWithoutProperties(_this$props2, ["strengthMultiplier", "verticalStrength", "horizontalStrength", "onScrollChange"]);

return _react.default.createElement(WrappedComponent, _extends({
          ref: this.wrappedInstance
        }, props));
      }
    }]);

return ScrollingComponent;
  }(_react.Component);

_defineProperty(ScrollingComponent, "displayName", "Scrolling(".concat((0, _reactDisplayName.default)(WrappedComponent), ")"));

_defineProperty(ScrollingComponent, "propTypes", {
    // eslint-disable-next-line react/forbid-prop-types
    dragDropManager: _propTypes.default.object.isRequired,
    onScrollChange: _propTypes.default.func,
    verticalStrength: _propTypes.default.func,
    horizontalStrength: _propTypes.default.func,
    strengthMultiplier: _propTypes.default.number
  });

_defineProperty(ScrollingComponent, "defaultProps", {
    onScrollChange: _util.noop,
    verticalStrength: defaultVerticalStrength,
    horizontalStrength: defaultHorizontalStrength,
    strengthMultiplier: 30
  });

return (0, _hoistNonReactStatics.default)(ScrollingComponent, WrappedComponent);
}

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.noop = noop;
exports.intBetween = intBetween;
exports.getCoords = getCoords;

function noop() {}

function intBetween(min, max, val) {
  return Math.floor(Math.min(max, Math.max(min, val)));
}

function getCoords(evt) {
  if (evt.type === 'touchmove') {
    return {
      x: evt.changedTouches[0].clientX,
      y: evt.changedTouches[0].clientY
    };
  }

return {
    x: evt.clientX,
    y: evt.clientY
  };
}PK�[�\�����
.editorconfignu�[���root = true

[*]
indent_style = space
indent_size = 2
end_of_line = lf
charset = utf-8
trim_trailing_whitespace = true
insert_final_newline = true
PK�[�\3�mLLLICENSEnu�[���(The MIT License)

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.
PK�[�\ŲE��	README.mdnu�[���# frontend-collective-react-dnd-scrollzone

Forked from https://github.com/azuqua/react-dnd-scrollzone with support for react-dnd@7.

Cross browser compatible scrolling containers for drag and drop interactions.

### [Basic Example](./examples/basic)

```js
import React, { Component } from 'react';
import { DragDropContextProvider } from 'react-dnd';
import HTML5Backend from 'react-dnd-html5-backend';
import withScrolling from 'react-dnd-scrollzone';
import DragItem from './DragItem';
import './App.css';

const ScrollingComponent = withScrolling('div');

const ITEMS = [1,2,3,4,5,6,7,8,9,10];

export default class App extends Component {
  render() {
    return (
      <DragDropContextProvider backend={HTML5Backend}>
        <ScrollingComponent className="App">
          {ITEMS.map(n => (
            <DragItem key={n} label={`Item ${n}`} />
          ))}
        </ScrollingComponent>
      </DragDropContextProvider>
    );
  }
}
```

Note: You should replace the original `div` you would like to make scrollable with the `ScrollingComponent`.

### Easing Example

```js
import React, { Component } from 'react';
import { DragDropContextProvider } from 'react-dnd';
import HTML5Backend from 'react-dnd-html5-backend';
import withScrolling, { createHorizontalStrength, createVerticalStrength } from 'react-dnd-scrollzone';
import DragItem from './DragItem';
import './App.css';

const ScrollZone = withScrolling('ul');
const linearHorizontalStrength = createHorizontalStrength(150);
const linearVerticalStrength = createVerticalStrength(150);
const ITEMS = [1,2,3,4,5,6,7,8,9,10];

// this easing function is from https://gist.github.com/gre/1650294 and
// expects/returns a number between [0, 1], however strength functions
// expects/returns a value between [-1, 1]
function ease(val) {
  const t = (val + 1) / 2; // [-1, 1] -> [0, 1]
  const easedT = t<.5 ? 2*t*t : -1+(4-2*t)*t;
  return easedT * 2 - 1; // [0, 1] -> [-1, 1]
}

function hStrength(box, point) {
  return ease(linearHorizontalStrength(box, point));
}

function vStrength(box, point) {
  return ease(linearVerticalStrength(box, point));
}

export default App(props) {
  return (
    <DragDropContextProvider backend={HTML5Backend}>
      <ScrollingComponent
        className="App"
        verticalStrength={vStrength}
        horizontalStrength={hStrength} >

{ITEMS.map(n => (
          <DragItem key={n} label={`Item ${n}`} />
        ))}
      </ScrollingComponent>
    </DragDropContextProvider>
  );
}
```
Note: You should replace the original `div` you would like to make scrollable with the `ScrollingComponent`.

### Virtualized Example

Since react-dnd-scrollzone utilizes the Higher Order Components (HOC) pattern, drag and drop scrolling behaviour can easily be added to existing components. For example to speedup huge lists by using [react-virtualized](https://github.com/bvaughn/react-virtualized) for a windowed view where only the visible rows are rendered:

```js
import React from 'react';
import { DragDropContextProvider } from 'react-dnd';
import HTML5Backend from 'react-dnd-html5-backend';
import withScrolling from 'react-dnd-scrollzone';
import { List } from 'react-virtualized';
import DragItem from './DragItem';
import './App.css';

const ScrollingVirtualList = withScrolling(List);

// creates array with 1000 entries
const ITEMS = Array.from(Array(1000)).map((e,i)=> `Item ${i}`);

export default App(props) {
  return (
    <DragDropContextProvider backend={HTML5Backend}>
      <ScrollingVirtualList
        className="App"
        height={600}
        width={800}
        rowCount={ITEMS.length}
        rowHeight={34}
        rowRenderer={
          ({ key, index, style }) => (
            <DragItem
              key={key}
              style={style}
              label={ITEMS[index]}
            />
          )
        }
       />
    </DragDropContextProvider>
  );
}
```

### API

#### `withScrolling`

A React higher order component with the following properties:

```js
const ScrollZone = withScrolling(String|Component);

{children}
</Scrollzone>
```
Apply the withScrolling function to any html-identifier ("div", "ul" etc) or react component to add drag and drop scrolling behaviour.

* `horizontalStrength` a function that returns the strength of the horizontal scroll direction
 * `verticalStrength` - a function that returns the strength of the vertical scroll direction
 * `strengthMultiplier` - strength multiplier, play around with this (default 30)
 * `onScrollChange` - a function that is called when `scrollLeft` or `scrollTop` of the component are changed. Called with those two arguments in that order.

The strength functions are both called with two arguments. An object representing the rectangle occupied by the Scrollzone, and an object representing the coordinates of mouse.

They should return a value between -1 and 1.
 * Negative values scroll up or left.
 * Positive values scroll down or right.
 * 0 stops all scrolling.

#### `createVerticalStrength(buffer)` and `createHorizontalStrength(buffer)`

These allow you to create linearly scaling strength functions with a sensitivity different than the default value of 150px.

##### Example

```js
import withScrolling, { createVerticalStrength, createHorizontalStrength } from 'react-dnd-scrollzone';

const Scrollzone = withScrolling('ul');
const vStrength = createVerticalStrength(500);
const hStrength = createHorizontalStrength(300);

// zone will scroll when the cursor drags within
// 500px of the top/bottom and 300px of the left/right
const zone = (
  <Scrollzone verticalStrength={vStrength} horizontalStrength={hStrength}>

</Scrollzone>
);
```
PK�[�\��Z.eslintrc.jsnu�[���module.exports = {
    parser: 'babel-eslint',
    extends: 'airbnb',

rules: {
        'react/jsx-filename-extension': 0,
        'no-unused-vars': 0,
        'react/prop-types': 0,
    },

env: {
        browser: true,
        mocha: true
    },
}
PK�[�\��n""CHANGELOG.mdnu�[���# Changelog

### `v4.0.0`
* Change `speed` prop to `strengthMultiplier`
* Adds a hard dependency on using `react-dnd` which was theoretically
  optional before.
* Fix double dispatch of `onDragOver` prop
* Default strength functions always return 0 if the point is anywhere
  outside the box.

### `v3.2.0`
* Use `prop-types` package instead of deprecated `React.PropTypes`

### `v3.1.0`
* Add `onScrollChange` prop

### `v3.0.0`
* Export a higher order component instead of a component.
* Set displayName on component
* Hoist non-react static properties

##### Before (v2)
```js
import Scrollzone from 'react-dnd-scrollzone';
const zone = <Scrollzone />;
```

##### After (v3)
```js
import withScrolling from 'react-dnd-scrollzone';
const Scrollzone = withScrolling('div');
const zone = <Scrollzone />;
```

### `v2.0.0`
* Remove `buffer` prop.
* Add `horizontalStrength` and `verticalStrength` props.
* Add `createVerticalStrength` and `createHorizontalStrength` exports.
* Fix bug with strength calculations and large buffers.
* Fix bug with scrolling not always stopping when drop targets are nested.

##### Before (v1)
```js
import Scrollzone from 'react-dnd-scrollzone';
const zone = <Scrollzone buffer={300} />;
```

##### After (v2)
```js
import Scrollzone, { createVerticalStrength, createHorizontalStrength } from 'react-dnd-scrollzone';
const vStrength = createVerticalStrength(300);
const hStrength = createHorizontalStrength(300);
const zone = <Scrollzone verticalStrength={vStrength} horizontalStrength={hStrength} />;
```

### `v1.1.0`
* Initial release.
PK�[�\��N��CONTRIBUTING.mdnu�[���PK�[�\�!�K���package.jsonnu�[���PK�[�\ۍ�{�8�8�lib/index.jsnu�[���PK�[�\޹����Glib/util.jsnu�[���PK�[�\�����
J.editorconfignu�[���PK�[�\3�mLL�JLICENSEnu�[���PK�[�\ŲE��	WOREADME.mdnu�[���PK�[�\��Z<f.eslintrc.jsnu�[���PK�[�\��n""zgCHANGELOG.mdnu�[���PK		��m

/home/emeraadmin/.htpasswds/../public_html/ADVIA/../4d695/react-dnd-scrollzone-patch-react-17.zip