{"version":3,"sources":["webpack:///./node_modules/gridstack/dist/types.js","webpack:///./node_modules/gridstack/dist/gridstack-engine.js","webpack:///./node_modules/gridstack/dist/dd-gridstack.js","webpack:///./node_modules/gridstack/dist/dd-draggable.js","webpack:///./node_modules/gridstack/dist/dd-droppable.js","webpack:///./node_modules/gridstack/dist/gridstack.js","webpack:///./node_modules/gridstack/dist/dd-resizable-handle.js","webpack:///./node_modules/gridstack/dist/dd-resizable.js","webpack:///./node_modules/gridstack/dist/gridstack.min.css","webpack:///./node_modules/gridstack/dist/dd-touch.js","webpack:///./node_modules/gridstack/dist/dd-base-impl.js","webpack:///./node_modules/gridstack/dist/dd-element.js","webpack:///./node_modules/gridstack/dist/utils.js","webpack:///./node_modules/gridstack/dist/dd-manager.js"],"names":["Object","defineProperty","exports","value","dragInDefaultOptions","gridDefaults","alwaysShowResizeHandle","animate","auto","cellHeight","cellHeightThrottle","cellHeightUnit","column","draggable","handle","appendTo","scroll","itemClass","margin","marginUnit","maxRow","minRow","oneColumnSize","placeholderClass","placeholderText","removableOptions","accept","resizable","handles","rtl","GridStackEngine","utils_1","opts","this","addedNodes","removedNodes","_float","float","nodes","onChange","flag","batchMode","_prevFloat","saveInitial","_packNodes","_notify","node","nn","_hasLocked","_moving","_skipDown","y","collide","opt","sortNodes","nested","swap","area","_useEntireRowArea","x","w","h","skip","didMove","newOpt","pack","moved","locked","assign","moveNode","Utils","copyPos","undefined","skip2","find","n","isIntercepted","filter","o","collides","rect","_rect","r0","r","forEach","r2","yOver","Number","MAX_VALUE","xOver","overMax","over","Math","min","top","right","bottom","left","a","b","_doSwap","_dirty","touching","isTouching","t","length","batchUpdate","copyNodes","autoPosition","addNode","val","dir","sort","_updating","_orig","newY","i","resizing","_id","_idSeq","defaults","noResize","noMove","isNaN","nodeBoundFix","before","maxW","maxH","minW","max","minH","_inColumnResize","findCacheLayout","copy","cacheOneLayout","samePos","verify","dirtyNodes","concat","getDirtyNodes","_lastTried","some","nodeList","found","floor","box","triggerAddEvent","dup","prepareNode","_temporaryRemoved","_removeDOM","findEmptyPosition","push","_fixCollisions","removeDOM","triggerEvent","_layouts","changedPosConstrain","clonedNode","clone","map","canMove","getRow","el","gridstackNode","c","_willFitPos","cleanupNode","content","grid","p","_a","_b","wasUndefinedPack","prevPos","collideAll","needToMove","activeDrag","directionCollideCoverage","subGridDynamic","_isTemp","areaIntercept","a1","a2","makeSubGrid","reduce","row","saveElement","len","layout","list","wl","l","removeInternalForSave","ratio","round","prevColumn","cacheLayout","newNodes","domOrder","cacheNodes","lastIndex","cacheNode","j","findIndex","splice","move","scale","clear","index","_c","prop","DDGridStack","dd_manager_1","dd_element_1","key","_getDDElements","dEl","ddResizable","cleanResizable","setupResizable","getAttribute","autoHide","start","stop","resize","ddDraggable","cleanDraggable","setupDraggable","drag","_accept","ddDroppable","cleanDroppable","setupDroppable","ddElement","disabled","name","callback","on","event","DDManager","dragElement","target","helper","off","els","create","hosts","getElements","e","DDElement","init","d","DDDraggable","dd_base_impl_1","dd_touch_1","DDBaseImplement","option","super","handleName","substring","dragEl","classList","contains","querySelector","_mouseDown","bind","_mouseMove","_mouseUp","enable","addEventListener","isTouch","touchstart","pointerdown","remove","add","forDestroy","disable","removeEventListener","dragTimeout","window","clearTimeout","dragging","mouseDownEvent","destroy","keys","mouseHandled","button","nodeName","toLowerCase","closest","dropElement","document","touchmove","touchend","preventDefault","activeElement","blur","ev","initEvent","type","ui","s","_dragFollow","pauseDrag","pause","isInteger","setTimeout","_callDrag","abs","_createHelper","_setupHelperContainmentStyle","dragOffset","_getDragOffset","helperContainment","_setupHelperStyle","parentElement","style","position","parentOriginStylePosition","_removeHelperStyle","drop","cloneNode","body","parentNode","dragElementOriginStyle","originStyleProp","pointerEvents","width","height","willChange","transition","_isAboutToRemove","containmentRect","offset","clientX","offsetLeft","clientY","offsetTop","getComputedStyle","match","parent","xformOffsetX","xformOffsetY","testEl","createElement","addElStyles","opacity","zIndex","appendChild","testElPosition","getBoundingClientRect","removeChild","targetOffset","DDDroppable","_mouseEnter","_mouseLeave","_setupAccept","pointerenter","pointerleave","_canDrop","stopPropagation","_ui","out","parentDrop","matches","__createBinding","m","k","k2","enumerable","get","__exportStar","hasOwnProperty","GridStack","gridstack_engine_1","types_1","dd_gridstack_1","dd","_gsEventHandler","_extraDragRow","rowAttr","toNumber","anyOpts","minWidth","_alwaysShowResizeHandle","cloneDeep","staticGrid","toBool","handleClass","_initMargin","disableOneColumnMode","_widthOrContainer","_prevColumn","getColumn","direction","parentGridItem","closestUpByClass","subGrid","_isAutoCellHeight","_styleSheetClass","_setStaticClass","engineClass","engine","cbNodes","_writePosAttr","_updateStyles","getGridItems","_prepareElement","children","load","setAnimation","dragIn","setupDragIn","dragInOptions","_setupRemoveDrop","_setupAcceptWidget","_updateWindowResizeEvent","options","elOrString","getGridElement","gridstack","console","error","selector","grids","getGridElements","addRemoveCB","doc","implementation","createHTMLDocument","innerHTML","class","_placeholder","placeholderChild","className","placeholder","arguments","domAttr","_readAttr","_writeAttr","_insertNotAppend","prepend","_updateContainerHeight","_ignoreLayoutsNodeChange","_triggerAddEvent","_triggerChangeEvent","ops","nodeToAdd","saveContent","subGridTemplate","makeWidget","autoColumn","newItem","newItemOpt","_removeDD","_prepareDragDropByNode","update","addGrid","_autoColumn","addWidget","simulateMouseEvent","_event","nodeThatRemoved","pGrid","removeWidget","saveGridOpt","save","sub","listOrOpt","marginBottom","marginTop","marginRight","marginLeft","origShow","removeInternalAndSame","addRemove","items","prevCB","removed","id","item","_triggerRemoveEvent","forcePixel","offsetHeight","rows","parseInt","marginDiff","cellWidth","data","parseHeight","unit","clientWidth","innerWidth","compact","domNodes","oldColumn","oneColumnModeDomSort","updateNodeWidths","Array","from","setStatic","removeAll","_removeStylesheet","removeAttribute","useDocRelative","containerPos","documentElement","scrollTop","relativeLeft","relativeTop","columnWidth","rowHeight","isAreaEmpty","getElement","indexOf","split","noData","detail","log","removeNode","doAnimate","updateClass","recurse","warn","changed","ddChanged","cleanNodes","beginUpdate","endUpdate","willItFit","elements","layoutsNodesChange","_triggerEvent","CustomEvent","bubbles","Event","dispatchEvent","_styles","removeStylesheet","forceUpdate","prefix","styleLocation","styleInHead","createStylesheet","nonce","_max","addCSSRule","getHeight","setAttribute","String","removeProperty","minHeight","same","attrs","classes","changedColumn","oneColumn","_cellHeightThrottle","throttle","onParentResize","forceRemove","workTodo","_windowResizeBind","margins","isDraggable","enableMove","enableResize","doEnable","disableDrag","movable","disableResize","_initDD","acceptWidgets","removable","droppable","onDrag","_onStartMoving","_dragOrResize","canAccept","_leave","getCellHeight","_isExternal","offsetWidth","_gridstackNodeOrig","_itemRemoving","removeAsSubGrid","wasAdded","origNode","oGrid","removePositioningStyles","trashEl","isDroppable","onStartMoving","dragOrResize","onEndMoving","gridToNotify","_lastUiPosition","_prevYPix","cacheRects","mLeft","mRight","mTop","mBottom","mHeight","mWidth","distance","updateScrollPosition","prev","extra","updateScrollResize","size","moveNodeCheck","restoreInitial","obsolete","Engine","GDRev","DDResizableHandle","host","moving","_init","userSelect","DDResizable","dd_resizable_handle_1","newRect","originalRect","scrolled","temporalRect","_mouseOver","_mouseOut","_setupAutoHide","_setupHandlers","_removeHandlers","updateHandles","updateAutoHide","overResizeElement","handlerDirection","handlers","trim","_resizeStart","_resizeStop","_resizing","scrollEl","getScrollElement","scrollY","startEvent","_setupHelper","_applyChange","_getChange","_cleanHelper","elOriginStyleVal","_originStyleProp","oEvent","offsetX","offsetY","constrain","_constrainSize","oWidth","oHeight","maxWidth","MAX_SAFE_INTEGER","maxHeight","containmentEl","___CSS_LOADER_API_IMPORT___","module","DocumentTouch","navigator","maxTouchPoints","msMaxTouchPoints","DDTouch","simulatedType","touches","cancelable","touch","changedTouches","simulatedEvent","createEvent","initMouseEvent","screenX","screenY","simulatePointerMouseEvent","touchHandled","pointerLeaveTimeout","wasDragging","releasePointerCapture","pointerId","_eventRegister","_disabled","eventName","dd_resizable_1","dd_draggable_1","dd_droppable_1","updateOption","obsoleteAttr","obsoleteOptsDel","obsoleteOpts","self","f","oldName","newName","rev","wrapper","args","apply","prototype","info","oldAttr","querySelectorAll","getElementById","x0","x1","y0","y1","col","styleSheet","cssText","createTextNode","insertBefore","firstChild","getElementsByTagName","sheet","rules","addRule","insertRule","v","Boolean","Error","parseFloat","sources","source","doMinMax","removeEl","func","delay","isWaiting","scrollingElement","test","overflow","overflowY","innerHeightOrClientHeight","innerHeight","clientHeight","offsetDiffDown","offsetDiffUp","prevScroll","pointerPosY","scrollBy","behavior","obj","skipFields","ret","styles","isArray","evt","which","buttons","dataTransfer","ctrlKey","altKey","shiftKey","metaKey"],"mappings":"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","file":"vendor.gridstack.ce80b7ca628e5f489166.chunk.js","sourcesContent":["\"use strict\";\r\n/**\r\n * types.ts 7.3.0\r\n * Copyright (c) 2021 Alain Dumesny - see GridStack root license\r\n */\r\nObject.defineProperty(exports, \"__esModule\", { value: true });\r\nexports.dragInDefaultOptions = exports.gridDefaults = void 0;\r\n// default values for grid options - used during init and when saving out\r\nexports.gridDefaults = {\r\n    alwaysShowResizeHandle: 'mobile',\r\n    animate: true,\r\n    auto: true,\r\n    cellHeight: 'auto',\r\n    cellHeightThrottle: 100,\r\n    cellHeightUnit: 'px',\r\n    column: 12,\r\n    draggable: { handle: '.grid-stack-item-content', appendTo: 'body', scroll: true },\r\n    handle: '.grid-stack-item-content',\r\n    itemClass: 'grid-stack-item',\r\n    margin: 10,\r\n    marginUnit: 'px',\r\n    maxRow: 0,\r\n    minRow: 0,\r\n    oneColumnSize: 768,\r\n    placeholderClass: 'grid-stack-placeholder',\r\n    placeholderText: '',\r\n    removableOptions: { accept: '.grid-stack-item' },\r\n    resizable: { handles: 'se' },\r\n    rtl: 'auto',\r\n};\r\n/** default dragIn options */\r\nexports.dragInDefaultOptions = {\r\n    handle: '.grid-stack-item-content',\r\n    appendTo: 'body',\r\n};\r\n//# sourceMappingURL=types.js.map","\"use strict\";\r\n/**\r\n * gridstack-engine.ts 7.3.0\r\n * Copyright (c) 2021-2022 Alain Dumesny - see GridStack root license\r\n */\r\nObject.defineProperty(exports, \"__esModule\", { value: true });\r\nexports.GridStackEngine = void 0;\r\nconst utils_1 = require(\"./utils\");\r\n/**\r\n * Defines the GridStack engine that does most no DOM grid manipulation.\r\n * See GridStack methods and vars for descriptions.\r\n *\r\n * NOTE: values should not be modified directly - call the main GridStack API instead\r\n */\r\nclass GridStackEngine {\r\n    constructor(opts = {}) {\r\n        this.addedNodes = [];\r\n        this.removedNodes = [];\r\n        this.column = opts.column || 12;\r\n        this.maxRow = opts.maxRow;\r\n        this._float = opts.float;\r\n        this.nodes = opts.nodes || [];\r\n        this.onChange = opts.onChange;\r\n    }\r\n    batchUpdate(flag = true) {\r\n        if (!!this.batchMode === flag)\r\n            return this;\r\n        this.batchMode = flag;\r\n        if (flag) {\r\n            this._prevFloat = this._float;\r\n            this._float = true; // let things go anywhere for now... will restore and possibly reposition later\r\n            this.saveInitial(); // since begin update (which is called multiple times) won't do this\r\n        }\r\n        else {\r\n            this._float = this._prevFloat;\r\n            delete this._prevFloat;\r\n            this._packNodes()._notify();\r\n        }\r\n        return this;\r\n    }\r\n    // use entire row for hitting area (will use bottom reverse sorted first) if we not actively moving DOWN and didn't already skip\r\n    _useEntireRowArea(node, nn) {\r\n        return (!this.float || this.batchMode && !this._prevFloat) && !this._hasLocked && (!node._moving || node._skipDown || nn.y <= node.y);\r\n    }\r\n    /** @internal fix collision on given 'node', going to given new location 'nn', with optional 'collide' node already found.\r\n     * return true if we moved. */\r\n    _fixCollisions(node, nn = node, collide, opt = {}) {\r\n        this.sortNodes(-1); // from last to first, so recursive collision move items in the right order\r\n        collide = collide || this.collide(node, nn); // REAL area collide for swap and skip if none...\r\n        if (!collide)\r\n            return false;\r\n        // swap check: if we're actively moving in gravity mode, see if we collide with an object the same size\r\n        if (node._moving && !opt.nested && !this.float) {\r\n            if (this.swap(node, collide))\r\n                return true;\r\n        }\r\n        // during while() collisions MAKE SURE to check entire row so larger items don't leap frog small ones (push them all down starting last in grid)\r\n        let area = nn;\r\n        if (this._useEntireRowArea(node, nn)) {\r\n            area = { x: 0, w: this.column, y: nn.y, h: nn.h };\r\n            collide = this.collide(node, area, opt.skip); // force new hit\r\n        }\r\n        let didMove = false;\r\n        let newOpt = { nested: true, pack: false };\r\n        while (collide = collide || this.collide(node, area, opt.skip)) { // could collide with more than 1 item... so repeat for each\r\n            let moved;\r\n            // if colliding with a locked item OR moving down with top gravity (and collide could move up) -> skip past the collide,\r\n            // but remember that skip down so we only do this once (and push others otherwise).\r\n            if (collide.locked || node._moving && !node._skipDown && nn.y > node.y && !this.float &&\r\n                // can take space we had, or before where we're going\r\n                (!this.collide(collide, Object.assign(Object.assign({}, collide), { y: node.y }), node) || !this.collide(collide, Object.assign(Object.assign({}, collide), { y: nn.y - collide.h }), node))) {\r\n                node._skipDown = (node._skipDown || nn.y > node.y);\r\n                moved = this.moveNode(node, Object.assign(Object.assign(Object.assign({}, nn), { y: collide.y + collide.h }), newOpt));\r\n                if (collide.locked && moved) {\r\n                    utils_1.Utils.copyPos(nn, node); // moving after lock become our new desired location\r\n                }\r\n                else if (!collide.locked && moved && opt.pack) {\r\n                    // we moved after and will pack: do it now and keep the original drop location, but past the old collide to see what else we might push way\r\n                    this._packNodes();\r\n                    nn.y = collide.y + collide.h;\r\n                    utils_1.Utils.copyPos(node, nn);\r\n                }\r\n                didMove = didMove || moved;\r\n            }\r\n            else {\r\n                // move collide down *after* where we will be, ignoring where we are now (don't collide with us)\r\n                moved = this.moveNode(collide, Object.assign(Object.assign(Object.assign({}, collide), { y: nn.y + nn.h, skip: node }), newOpt));\r\n            }\r\n            if (!moved) {\r\n                return didMove;\r\n            } // break inf loop if we couldn't move after all (ex: maxRow, fixed)\r\n            collide = undefined;\r\n        }\r\n        return didMove;\r\n    }\r\n    /** return the nodes that intercept the given node. Optionally a different area can be used, as well as a second node to skip */\r\n    collide(skip, area = skip, skip2) {\r\n        return this.nodes.find(n => n !== skip && n !== skip2 && utils_1.Utils.isIntercepted(n, area));\r\n    }\r\n    collideAll(skip, area = skip, skip2) {\r\n        return this.nodes.filter(n => n !== skip && n !== skip2 && utils_1.Utils.isIntercepted(n, area));\r\n    }\r\n    /** does a pixel coverage collision based on where we started, returning the node that has the most coverage that is >50% mid line */\r\n    directionCollideCoverage(node, o, collides) {\r\n        if (!o.rect || !node._rect)\r\n            return;\r\n        let r0 = node._rect; // where started\r\n        let r = Object.assign({}, o.rect); // where we are\r\n        // update dragged rect to show where it's coming from (above or below, etc...)\r\n        if (r.y > r0.y) {\r\n            r.h += r.y - r0.y;\r\n            r.y = r0.y;\r\n        }\r\n        else {\r\n            r.h += r0.y - r.y;\r\n        }\r\n        if (r.x > r0.x) {\r\n            r.w += r.x - r0.x;\r\n            r.x = r0.x;\r\n        }\r\n        else {\r\n            r.w += r0.x - r.x;\r\n        }\r\n        let collide;\r\n        collides.forEach(n => {\r\n            if (n.locked || !n._rect)\r\n                return;\r\n            let r2 = n._rect; // overlapping target\r\n            let yOver = Number.MAX_VALUE, xOver = Number.MAX_VALUE, overMax = 0.5; // need >50%\r\n            // depending on which side we started from, compute the overlap % of coverage\r\n            // (ex: from above/below we only compute the max horizontal line coverage)\r\n            if (r0.y < r2.y) { // from above\r\n                yOver = ((r.y + r.h) - r2.y) / r2.h;\r\n            }\r\n            else if (r0.y + r0.h > r2.y + r2.h) { // from below\r\n                yOver = ((r2.y + r2.h) - r.y) / r2.h;\r\n            }\r\n            if (r0.x < r2.x) { // from the left\r\n                xOver = ((r.x + r.w) - r2.x) / r2.w;\r\n            }\r\n            else if (r0.x + r0.w > r2.x + r2.w) { // from the right\r\n                xOver = ((r2.x + r2.w) - r.x) / r2.w;\r\n            }\r\n            let over = Math.min(xOver, yOver);\r\n            if (over > overMax) {\r\n                overMax = over;\r\n                collide = n;\r\n            }\r\n        });\r\n        o.collide = collide; // save it so we don't have to find it again\r\n        return collide;\r\n    }\r\n    /** does a pixel coverage returning the node that has the most coverage by area */\r\n    /*\r\n    protected collideCoverage(r: GridStackPosition, collides: GridStackNode[]): {collide: GridStackNode, over: number} {\r\n      let collide: GridStackNode;\r\n      let overMax = 0;\r\n      collides.forEach(n => {\r\n        if (n.locked || !n._rect) return;\r\n        let over = Utils.areaIntercept(r, n._rect);\r\n        if (over > overMax) {\r\n          overMax = over;\r\n          collide = n;\r\n        }\r\n      });\r\n      return {collide, over: overMax};\r\n    }\r\n    */\r\n    /** called to cache the nodes pixel rectangles used for collision detection during drag */\r\n    cacheRects(w, h, top, right, bottom, left) {\r\n        this.nodes.forEach(n => n._rect = {\r\n            y: n.y * h + top,\r\n            x: n.x * w + left,\r\n            w: n.w * w - left - right,\r\n            h: n.h * h - top - bottom\r\n        });\r\n        return this;\r\n    }\r\n    /** called to possibly swap between 2 nodes (same size or column, not locked, touching), returning true if successful */\r\n    swap(a, b) {\r\n        if (!b || b.locked || !a || a.locked)\r\n            return false;\r\n        function _doSwap() {\r\n            let x = b.x, y = b.y;\r\n            b.x = a.x;\r\n            b.y = a.y; // b -> a position\r\n            if (a.h != b.h) {\r\n                a.x = x;\r\n                a.y = b.y + b.h; // a -> goes after b\r\n            }\r\n            else if (a.w != b.w) {\r\n                a.x = b.x + b.w;\r\n                a.y = y; // a -> goes after b\r\n            }\r\n            else {\r\n                a.x = x;\r\n                a.y = y; // a -> old b position\r\n            }\r\n            a._dirty = b._dirty = true;\r\n            return true;\r\n        }\r\n        let touching; // remember if we called it (vs undefined)\r\n        // same size and same row or column, and touching\r\n        if (a.w === b.w && a.h === b.h && (a.x === b.x || a.y === b.y) && (touching = utils_1.Utils.isTouching(a, b)))\r\n            return _doSwap();\r\n        if (touching === false)\r\n            return; // IFF ran test and fail, bail out\r\n        // check for taking same columns (but different height) and touching\r\n        if (a.w === b.w && a.x === b.x && (touching || (touching = utils_1.Utils.isTouching(a, b)))) {\r\n            if (b.y < a.y) {\r\n                let t = a;\r\n                a = b;\r\n                b = t;\r\n            } // swap a <-> b vars so a is first\r\n            return _doSwap();\r\n        }\r\n        if (touching === false)\r\n            return;\r\n        // check if taking same row (but different width) and touching\r\n        if (a.h === b.h && a.y === b.y && (touching || (touching = utils_1.Utils.isTouching(a, b)))) {\r\n            if (b.x < a.x) {\r\n                let t = a;\r\n                a = b;\r\n                b = t;\r\n            } // swap a <-> b vars so a is first\r\n            return _doSwap();\r\n        }\r\n        return false;\r\n    }\r\n    isAreaEmpty(x, y, w, h) {\r\n        let nn = { x: x || 0, y: y || 0, w: w || 1, h: h || 1 };\r\n        return !this.collide(nn);\r\n    }\r\n    /** re-layout grid items to reclaim any empty space */\r\n    compact() {\r\n        if (this.nodes.length === 0)\r\n            return this;\r\n        this.batchUpdate()\r\n            .sortNodes();\r\n        let copyNodes = this.nodes;\r\n        this.nodes = []; // pretend we have no nodes to conflict layout to start with...\r\n        copyNodes.forEach(node => {\r\n            if (!node.locked) {\r\n                node.autoPosition = true;\r\n            }\r\n            this.addNode(node, false); // 'false' for add event trigger\r\n            node._dirty = true; // will force attr update\r\n        });\r\n        return this.batchUpdate(false);\r\n    }\r\n    /** enable/disable floating widgets (default: `false`) See [example](http://gridstackjs.com/demo/float.html) */\r\n    set float(val) {\r\n        if (this._float === val)\r\n            return;\r\n        this._float = val || false;\r\n        if (!val) {\r\n            this._packNodes()._notify();\r\n        }\r\n    }\r\n    /** float getter method */\r\n    get float() { return this._float || false; }\r\n    /** sort the nodes array from first to last, or reverse. Called during collision/placement to force an order */\r\n    sortNodes(dir) {\r\n        this.nodes = utils_1.Utils.sort(this.nodes, dir, this.column);\r\n        return this;\r\n    }\r\n    /** @internal called to top gravity pack the items back OR revert back to original Y positions when floating */\r\n    _packNodes() {\r\n        if (this.batchMode) {\r\n            return this;\r\n        }\r\n        this.sortNodes(); // first to last\r\n        if (this.float) {\r\n            // restore original Y pos\r\n            this.nodes.forEach(n => {\r\n                if (n._updating || n._orig === undefined || n.y === n._orig.y)\r\n                    return;\r\n                let newY = n.y;\r\n                while (newY > n._orig.y) {\r\n                    --newY;\r\n                    let collide = this.collide(n, { x: n.x, y: newY, w: n.w, h: n.h });\r\n                    if (!collide) {\r\n                        n._dirty = true;\r\n                        n.y = newY;\r\n                    }\r\n                }\r\n            });\r\n        }\r\n        else {\r\n            // top gravity pack\r\n            this.nodes.forEach((n, i) => {\r\n                if (n.locked)\r\n                    return;\r\n                while (n.y > 0) {\r\n                    let newY = i === 0 ? 0 : n.y - 1;\r\n                    let canBeMoved = i === 0 || !this.collide(n, { x: n.x, y: newY, w: n.w, h: n.h });\r\n                    if (!canBeMoved)\r\n                        break;\r\n                    // Note: must be dirty (from last position) for GridStack::OnChange CB to update positions\r\n                    // and move items back. The user 'change' CB should detect changes from the original\r\n                    // starting position instead.\r\n                    n._dirty = (n.y !== newY);\r\n                    n.y = newY;\r\n                }\r\n            });\r\n        }\r\n        return this;\r\n    }\r\n    /**\r\n     * given a random node, makes sure it's coordinates/values are valid in the current grid\r\n     * @param node to adjust\r\n     * @param resizing if out of bound, resize down or move into the grid to fit ?\r\n     */\r\n    prepareNode(node, resizing) {\r\n        node = node || {};\r\n        node._id = node._id || GridStackEngine._idSeq++;\r\n        // if we're missing position, have the grid position us automatically (before we set them to 0,0)\r\n        if (node.x === undefined || node.y === undefined || node.x === null || node.y === null) {\r\n            node.autoPosition = true;\r\n        }\r\n        // assign defaults for missing required fields\r\n        let defaults = { x: 0, y: 0, w: 1, h: 1 };\r\n        utils_1.Utils.defaults(node, defaults);\r\n        if (!node.autoPosition) {\r\n            delete node.autoPosition;\r\n        }\r\n        if (!node.noResize) {\r\n            delete node.noResize;\r\n        }\r\n        if (!node.noMove) {\r\n            delete node.noMove;\r\n        }\r\n        // check for NaN (in case messed up strings were passed. can't do parseInt() || defaults.x above as 0 is valid #)\r\n        if (typeof node.x == 'string') {\r\n            node.x = Number(node.x);\r\n        }\r\n        if (typeof node.y == 'string') {\r\n            node.y = Number(node.y);\r\n        }\r\n        if (typeof node.w == 'string') {\r\n            node.w = Number(node.w);\r\n        }\r\n        if (typeof node.h == 'string') {\r\n            node.h = Number(node.h);\r\n        }\r\n        if (isNaN(node.x)) {\r\n            node.x = defaults.x;\r\n            node.autoPosition = true;\r\n        }\r\n        if (isNaN(node.y)) {\r\n            node.y = defaults.y;\r\n            node.autoPosition = true;\r\n        }\r\n        if (isNaN(node.w)) {\r\n            node.w = defaults.w;\r\n        }\r\n        if (isNaN(node.h)) {\r\n            node.h = defaults.h;\r\n        }\r\n        return this.nodeBoundFix(node, resizing);\r\n    }\r\n    /** part2 of preparing a node to fit inside our grid - checks for x,y,w from grid dimensions */\r\n    nodeBoundFix(node, resizing) {\r\n        let before = node._orig || utils_1.Utils.copyPos({}, node);\r\n        if (node.maxW) {\r\n            node.w = Math.min(node.w, node.maxW);\r\n        }\r\n        if (node.maxH) {\r\n            node.h = Math.min(node.h, node.maxH);\r\n        }\r\n        if (node.minW && node.minW <= this.column) {\r\n            node.w = Math.max(node.w, node.minW);\r\n        }\r\n        if (node.minH) {\r\n            node.h = Math.max(node.h, node.minH);\r\n        }\r\n        // if user loaded a larger than allowed widget for current # of columns (or force 1 column mode),\r\n        // remember it's position & width so we can restore back (1 -> 12 column) #1655 #1985\r\n        // IFF we're not in the middle of column resizing!\r\n        const saveOrig = this.column === 1 || node.x + node.w > this.column;\r\n        if (saveOrig && this.column < 12 && !this._inColumnResize && node._id && this.findCacheLayout(node, 12) === -1) {\r\n            let copy = Object.assign({}, node); // need _id + positions\r\n            if (copy.autoPosition) {\r\n                delete copy.x;\r\n                delete copy.y;\r\n            }\r\n            else\r\n                copy.x = Math.min(11, copy.x);\r\n            copy.w = Math.min(12, copy.w);\r\n            this.cacheOneLayout(copy, 12);\r\n        }\r\n        if (node.w > this.column) {\r\n            node.w = this.column;\r\n        }\r\n        else if (node.w < 1) {\r\n            node.w = 1;\r\n        }\r\n        if (this.maxRow && node.h > this.maxRow) {\r\n            node.h = this.maxRow;\r\n        }\r\n        else if (node.h < 1) {\r\n            node.h = 1;\r\n        }\r\n        if (node.x < 0) {\r\n            node.x = 0;\r\n        }\r\n        if (node.y < 0) {\r\n            node.y = 0;\r\n        }\r\n        if (node.x + node.w > this.column) {\r\n            if (resizing) {\r\n                node.w = this.column - node.x;\r\n            }\r\n            else {\r\n                node.x = this.column - node.w;\r\n            }\r\n        }\r\n        if (this.maxRow && node.y + node.h > this.maxRow) {\r\n            if (resizing) {\r\n                node.h = this.maxRow - node.y;\r\n            }\r\n            else {\r\n                node.y = this.maxRow - node.h;\r\n            }\r\n        }\r\n        if (!utils_1.Utils.samePos(node, before)) {\r\n            node._dirty = true;\r\n        }\r\n        return node;\r\n    }\r\n    /** returns a list of modified nodes from their original values */\r\n    getDirtyNodes(verify) {\r\n        // compare original x,y,w,h instead as _dirty can be a temporary state\r\n        if (verify) {\r\n            return this.nodes.filter(n => n._dirty && !utils_1.Utils.samePos(n, n._orig));\r\n        }\r\n        return this.nodes.filter(n => n._dirty);\r\n    }\r\n    /** @internal call this to call onChange callback with dirty nodes so DOM can be updated */\r\n    _notify(removedNodes) {\r\n        if (this.batchMode || !this.onChange)\r\n            return this;\r\n        let dirtyNodes = (removedNodes || []).concat(this.getDirtyNodes());\r\n        this.onChange(dirtyNodes);\r\n        return this;\r\n    }\r\n    /** @internal remove dirty and last tried info */\r\n    cleanNodes() {\r\n        if (this.batchMode)\r\n            return this;\r\n        this.nodes.forEach(n => {\r\n            delete n._dirty;\r\n            delete n._lastTried;\r\n        });\r\n        return this;\r\n    }\r\n    /** @internal called to save initial position/size to track real dirty state.\r\n     * Note: should be called right after we call change event (so next API is can detect changes)\r\n     * as well as right before we start move/resize/enter (so we can restore items to prev values) */\r\n    saveInitial() {\r\n        this.nodes.forEach(n => {\r\n            n._orig = utils_1.Utils.copyPos({}, n);\r\n            delete n._dirty;\r\n        });\r\n        this._hasLocked = this.nodes.some(n => n.locked);\r\n        return this;\r\n    }\r\n    /** @internal restore all the nodes back to initial values (called when we leave) */\r\n    restoreInitial() {\r\n        this.nodes.forEach(n => {\r\n            if (utils_1.Utils.samePos(n, n._orig))\r\n                return;\r\n            utils_1.Utils.copyPos(n, n._orig);\r\n            n._dirty = true;\r\n        });\r\n        this._notify();\r\n        return this;\r\n    }\r\n    /** find the first available empty spot for the given node width/height, updating the x,y attributes. return true if found.\r\n     * optionally you can pass your own existing node list and column count, otherwise defaults to that engine data.\r\n     */\r\n    findEmptyPosition(node, nodeList = this.nodes, column = this.column) {\r\n        nodeList = utils_1.Utils.sort(nodeList, -1, column);\r\n        let found = false;\r\n        for (let i = 0; !found; ++i) {\r\n            let x = i % column;\r\n            let y = Math.floor(i / column);\r\n            if (x + node.w > column) {\r\n                continue;\r\n            }\r\n            let box = { x, y, w: node.w, h: node.h };\r\n            if (!nodeList.find(n => utils_1.Utils.isIntercepted(box, n))) {\r\n                node.x = x;\r\n                node.y = y;\r\n                delete node.autoPosition;\r\n                found = true;\r\n            }\r\n        }\r\n        return found;\r\n    }\r\n    /** call to add the given node to our list, fixing collision and re-packing */\r\n    addNode(node, triggerAddEvent = false) {\r\n        let dup = this.nodes.find(n => n._id === node._id);\r\n        if (dup)\r\n            return dup; // prevent inserting twice! return it instead.\r\n        // skip prepareNode if we're in middle of column resize (not new) but do check for bounds!\r\n        node = this._inColumnResize ? this.nodeBoundFix(node) : this.prepareNode(node);\r\n        delete node._temporaryRemoved;\r\n        delete node._removeDOM;\r\n        if (node.autoPosition && this.findEmptyPosition(node)) {\r\n            delete node.autoPosition; // found our slot\r\n        }\r\n        this.nodes.push(node);\r\n        if (triggerAddEvent) {\r\n            this.addedNodes.push(node);\r\n        }\r\n        this._fixCollisions(node);\r\n        if (!this.batchMode) {\r\n            this._packNodes()._notify();\r\n        }\r\n        return node;\r\n    }\r\n    removeNode(node, removeDOM = true, triggerEvent = false) {\r\n        if (!this.nodes.find(n => n === node)) {\r\n            // TEST console.log(`Error: GridStackEngine.removeNode() node._id=${node._id} not found!`)\r\n            return this;\r\n        }\r\n        if (triggerEvent) { // we wait until final drop to manually track removed items (rather than during drag)\r\n            this.removedNodes.push(node);\r\n        }\r\n        if (removeDOM)\r\n            node._removeDOM = true; // let CB remove actual HTML (used to set _id to null, but then we loose layout info)\r\n        // don't use 'faster' .splice(findIndex(),1) in case node isn't in our list, or in multiple times.\r\n        this.nodes = this.nodes.filter(n => n !== node);\r\n        return this._packNodes()\r\n            ._notify([node]);\r\n    }\r\n    removeAll(removeDOM = true) {\r\n        delete this._layouts;\r\n        if (this.nodes.length === 0)\r\n            return this;\r\n        removeDOM && this.nodes.forEach(n => n._removeDOM = true); // let CB remove actual HTML (used to set _id to null, but then we loose layout info)\r\n        this.removedNodes = this.nodes;\r\n        this.nodes = [];\r\n        return this._notify(this.removedNodes);\r\n    }\r\n    /** checks if item can be moved (layout constrain) vs moveNode(), returning true if was able to move.\r\n     * In more complicated cases (maxRow) it will attempt at moving the item and fixing\r\n     * others in a clone first, then apply those changes if still within specs. */\r\n    moveNodeCheck(node, o) {\r\n        // if (node.locked) return false;\r\n        if (!this.changedPosConstrain(node, o))\r\n            return false;\r\n        o.pack = true;\r\n        // simpler case: move item directly...\r\n        if (!this.maxRow) {\r\n            return this.moveNode(node, o);\r\n        }\r\n        // complex case: create a clone with NO maxRow (will check for out of bounds at the end)\r\n        let clonedNode;\r\n        let clone = new GridStackEngine({\r\n            column: this.column,\r\n            float: this.float,\r\n            nodes: this.nodes.map(n => {\r\n                if (n === node) {\r\n                    clonedNode = Object.assign({}, n);\r\n                    return clonedNode;\r\n                }\r\n                return Object.assign({}, n);\r\n            })\r\n        });\r\n        if (!clonedNode)\r\n            return false;\r\n        // check if we're covering 50% collision and could move\r\n        let canMove = clone.moveNode(clonedNode, o) && clone.getRow() <= this.maxRow;\r\n        // else check if we can force a swap (float=true, or different shapes) on non-resize\r\n        if (!canMove && !o.resizing && o.collide) {\r\n            let collide = o.collide.el.gridstackNode; // find the source node the clone collided with at 50%\r\n            if (this.swap(node, collide)) { // swaps and mark dirty\r\n                this._notify();\r\n                return true;\r\n            }\r\n        }\r\n        if (!canMove)\r\n            return false;\r\n        // if clone was able to move, copy those mods over to us now instead of caller trying to do this all over!\r\n        // Note: we can't use the list directly as elements and other parts point to actual node, so copy content\r\n        clone.nodes.filter(n => n._dirty).forEach(c => {\r\n            let n = this.nodes.find(a => a._id === c._id);\r\n            if (!n)\r\n                return;\r\n            utils_1.Utils.copyPos(n, c);\r\n            n._dirty = true;\r\n        });\r\n        this._notify();\r\n        return true;\r\n    }\r\n    /** return true if can fit in grid height constrain only (always true if no maxRow) */\r\n    willItFit(node) {\r\n        delete node._willFitPos;\r\n        if (!this.maxRow)\r\n            return true;\r\n        // create a clone with NO maxRow and check if still within size\r\n        let clone = new GridStackEngine({\r\n            column: this.column,\r\n            float: this.float,\r\n            nodes: this.nodes.map(n => { return Object.assign({}, n); })\r\n        });\r\n        let n = Object.assign({}, node); // clone node so we don't mod any settings on it but have full autoPosition and min/max as well! #1687\r\n        this.cleanupNode(n);\r\n        delete n.el;\r\n        delete n._id;\r\n        delete n.content;\r\n        delete n.grid;\r\n        clone.addNode(n);\r\n        if (clone.getRow() <= this.maxRow) {\r\n            node._willFitPos = utils_1.Utils.copyPos({}, n);\r\n            return true;\r\n        }\r\n        return false;\r\n    }\r\n    /** true if x,y or w,h are different after clamping to min/max */\r\n    changedPosConstrain(node, p) {\r\n        // first make sure w,h are set for caller\r\n        p.w = p.w || node.w;\r\n        p.h = p.h || node.h;\r\n        if (node.x !== p.x || node.y !== p.y)\r\n            return true;\r\n        // check constrained w,h\r\n        if (node.maxW) {\r\n            p.w = Math.min(p.w, node.maxW);\r\n        }\r\n        if (node.maxH) {\r\n            p.h = Math.min(p.h, node.maxH);\r\n        }\r\n        if (node.minW) {\r\n            p.w = Math.max(p.w, node.minW);\r\n        }\r\n        if (node.minH) {\r\n            p.h = Math.max(p.h, node.minH);\r\n        }\r\n        return (node.w !== p.w || node.h !== p.h);\r\n    }\r\n    /** return true if the passed in node was actually moved (checks for no-op and locked) */\r\n    moveNode(node, o) {\r\n        var _a, _b;\r\n        if (!node || /*node.locked ||*/ !o)\r\n            return false;\r\n        let wasUndefinedPack;\r\n        if (o.pack === undefined) {\r\n            wasUndefinedPack = o.pack = true;\r\n        }\r\n        // constrain the passed in values and check if we're still changing our node\r\n        if (typeof o.x !== 'number') {\r\n            o.x = node.x;\r\n        }\r\n        if (typeof o.y !== 'number') {\r\n            o.y = node.y;\r\n        }\r\n        if (typeof o.w !== 'number') {\r\n            o.w = node.w;\r\n        }\r\n        if (typeof o.h !== 'number') {\r\n            o.h = node.h;\r\n        }\r\n        let resizing = (node.w !== o.w || node.h !== o.h);\r\n        let nn = utils_1.Utils.copyPos({}, node, true); // get min/max out first, then opt positions next\r\n        utils_1.Utils.copyPos(nn, o);\r\n        nn = this.nodeBoundFix(nn, resizing);\r\n        utils_1.Utils.copyPos(o, nn);\r\n        if (utils_1.Utils.samePos(node, o))\r\n            return false;\r\n        let prevPos = utils_1.Utils.copyPos({}, node);\r\n        // check if we will need to fix collision at our new location\r\n        let collides = this.collideAll(node, nn, o.skip);\r\n        let needToMove = true;\r\n        if (collides.length) {\r\n            let activeDrag = node._moving && !o.nested;\r\n            // check to make sure we actually collided over 50% surface area while dragging\r\n            let collide = activeDrag ? this.directionCollideCoverage(node, o, collides) : collides[0];\r\n            // if we're enabling creation of sub-grids on the fly, see if we're covering 80% of either one, if we didn't already do that\r\n            if (activeDrag && collide && ((_b = (_a = node.grid) === null || _a === void 0 ? void 0 : _a.opts) === null || _b === void 0 ? void 0 : _b.subGridDynamic) && !node.grid._isTemp) {\r\n                let over = utils_1.Utils.areaIntercept(o.rect, collide._rect);\r\n                let a1 = utils_1.Utils.area(o.rect);\r\n                let a2 = utils_1.Utils.area(collide._rect);\r\n                let perc = over / (a1 < a2 ? a1 : a2);\r\n                if (perc > .8) {\r\n                    collide.grid.makeSubGrid(collide.el, undefined, node);\r\n                    collide = undefined;\r\n                }\r\n            }\r\n            if (collide) {\r\n                needToMove = !this._fixCollisions(node, nn, collide, o); // check if already moved...\r\n            }\r\n            else {\r\n                needToMove = false; // we didn't cover >50% for a move, skip...\r\n                if (wasUndefinedPack)\r\n                    delete o.pack;\r\n            }\r\n        }\r\n        // now move (to the original ask vs the collision version which might differ) and repack things\r\n        if (needToMove) {\r\n            node._dirty = true;\r\n            utils_1.Utils.copyPos(node, nn);\r\n        }\r\n        if (o.pack) {\r\n            this._packNodes()\r\n                ._notify();\r\n        }\r\n        return !utils_1.Utils.samePos(node, prevPos); // pack might have moved things back\r\n    }\r\n    getRow() {\r\n        return this.nodes.reduce((row, n) => Math.max(row, n.y + n.h), 0);\r\n    }\r\n    beginUpdate(node) {\r\n        if (!node._updating) {\r\n            node._updating = true;\r\n            delete node._skipDown;\r\n            if (!this.batchMode)\r\n                this.saveInitial();\r\n        }\r\n        return this;\r\n    }\r\n    endUpdate() {\r\n        let n = this.nodes.find(n => n._updating);\r\n        if (n) {\r\n            delete n._updating;\r\n            delete n._skipDown;\r\n        }\r\n        return this;\r\n    }\r\n    /** saves a copy of the largest column layout (eg 12 even when rendering oneColumnMode) so we don't loose orig layout,\r\n     * returning a list of widgets for serialization */\r\n    save(saveElement = true) {\r\n        var _a;\r\n        // use the highest layout for any saved info so we can have full detail on reload #1849\r\n        let len = (_a = this._layouts) === null || _a === void 0 ? void 0 : _a.length;\r\n        let layout = len && this.column !== (len - 1) ? this._layouts[len - 1] : null;\r\n        let list = [];\r\n        this.sortNodes();\r\n        this.nodes.forEach(n => {\r\n            let wl = layout === null || layout === void 0 ? void 0 : layout.find(l => l._id === n._id);\r\n            let w = Object.assign({}, n);\r\n            // use layout info instead if set\r\n            if (wl) {\r\n                w.x = wl.x;\r\n                w.y = wl.y;\r\n                w.w = wl.w;\r\n            }\r\n            utils_1.Utils.removeInternalForSave(w, !saveElement);\r\n            list.push(w);\r\n        });\r\n        return list;\r\n    }\r\n    /** @internal called whenever a node is added or moved - updates the cached layouts */\r\n    layoutsNodesChange(nodes) {\r\n        if (!this._layouts || this._inColumnResize)\r\n            return this;\r\n        // remove smaller layouts - we will re-generate those on the fly... larger ones need to update\r\n        this._layouts.forEach((layout, column) => {\r\n            if (!layout || column === this.column)\r\n                return this;\r\n            if (column < this.column) {\r\n                this._layouts[column] = undefined;\r\n            }\r\n            else {\r\n                // we save the original x,y,w (h isn't cached) to see what actually changed to propagate better.\r\n                // NOTE: we don't need to check against out of bound scaling/moving as that will be done when using those cache values. #1785\r\n                let ratio = column / this.column;\r\n                nodes.forEach(node => {\r\n                    if (!node._orig)\r\n                        return; // didn't change (newly added ?)\r\n                    let n = layout.find(l => l._id === node._id);\r\n                    if (!n)\r\n                        return; // no cache for new nodes. Will use those values.\r\n                    // Y changed, push down same amount\r\n                    // TODO: detect doing item 'swaps' will help instead of move (especially in 1 column mode)\r\n                    if (node.y !== node._orig.y) {\r\n                        n.y += (node.y - node._orig.y);\r\n                    }\r\n                    // X changed, scale from new position\r\n                    if (node.x !== node._orig.x) {\r\n                        n.x = Math.round(node.x * ratio);\r\n                    }\r\n                    // width changed, scale from new width\r\n                    if (node.w !== node._orig.w) {\r\n                        n.w = Math.round(node.w * ratio);\r\n                    }\r\n                    // ...height always carries over from cache\r\n                });\r\n            }\r\n        });\r\n        return this;\r\n    }\r\n    /**\r\n     * @internal Called to scale the widget width & position up/down based on the column change.\r\n     * Note we store previous layouts (especially original ones) to make it possible to go\r\n     * from say 12 -> 1 -> 12 and get back to where we were.\r\n     *\r\n     * @param prevColumn previous number of columns\r\n     * @param column  new column number\r\n     * @param nodes different sorted list (ex: DOM order) instead of current list\r\n     * @param layout specify the type of re-layout that will happen (position, size, etc...).\r\n     * Note: items will never be outside of the current column boundaries. default (moveScale). Ignored for 1 column\r\n     */\r\n    updateNodeWidths(prevColumn, column, nodes, layout = 'moveScale') {\r\n        var _a;\r\n        if (!this.nodes.length || !column || prevColumn === column)\r\n            return this;\r\n        // cache the current layout in case they want to go back (like 12 -> 1 -> 12) as it requires original data\r\n        this.cacheLayout(this.nodes, prevColumn);\r\n        this.batchUpdate(); // do this EARLY as it will call saveInitial() so we can detect where we started for _dirty and collision\r\n        let newNodes = [];\r\n        // if we're going to 1 column and using DOM order rather than default sorting, then generate that layout\r\n        let domOrder = false;\r\n        if (column === 1 && (nodes === null || nodes === void 0 ? void 0 : nodes.length)) {\r\n            domOrder = true;\r\n            let top = 0;\r\n            nodes.forEach(n => {\r\n                n.x = 0;\r\n                n.w = 1;\r\n                n.y = Math.max(n.y, top);\r\n                top = n.y + n.h;\r\n            });\r\n            newNodes = nodes;\r\n            nodes = [];\r\n        }\r\n        else {\r\n            nodes = utils_1.Utils.sort(this.nodes, -1, prevColumn); // current column reverse sorting so we can insert last to front (limit collision)\r\n        }\r\n        // see if we have cached previous layout IFF we are going up in size (restore) otherwise always\r\n        // generate next size down from where we are (looks more natural as you gradually size down).\r\n        let cacheNodes = [];\r\n        if (column > prevColumn) {\r\n            cacheNodes = this._layouts[column] || [];\r\n            // ...if not, start with the largest layout (if not already there) as down-scaling is more accurate\r\n            // by pretending we came from that larger column by assigning those values as starting point\r\n            let lastIndex = this._layouts.length - 1;\r\n            if (!cacheNodes.length && prevColumn !== lastIndex && ((_a = this._layouts[lastIndex]) === null || _a === void 0 ? void 0 : _a.length)) {\r\n                prevColumn = lastIndex;\r\n                this._layouts[lastIndex].forEach(cacheNode => {\r\n                    let n = nodes.find(n => n._id === cacheNode._id);\r\n                    if (n) {\r\n                        // still current, use cache info positions\r\n                        n.x = cacheNode.x;\r\n                        n.y = cacheNode.y;\r\n                        n.w = cacheNode.w;\r\n                    }\r\n                });\r\n            }\r\n        }\r\n        // if we found cache re-use those nodes that are still current\r\n        cacheNodes.forEach(cacheNode => {\r\n            let j = nodes.findIndex(n => n._id === cacheNode._id);\r\n            if (j !== -1) {\r\n                // still current, use cache info positions\r\n                if (cacheNode.autoPosition || isNaN(cacheNode.x) || isNaN(cacheNode.y)) {\r\n                    this.findEmptyPosition(cacheNode, newNodes);\r\n                }\r\n                if (!cacheNode.autoPosition) {\r\n                    nodes[j].x = cacheNode.x;\r\n                    nodes[j].y = cacheNode.y;\r\n                    nodes[j].w = cacheNode.w;\r\n                    newNodes.push(nodes[j]);\r\n                }\r\n                nodes.splice(j, 1);\r\n            }\r\n        });\r\n        // ...and add any extra non-cached ones\r\n        if (nodes.length) {\r\n            if (typeof layout === 'function') {\r\n                layout(column, prevColumn, newNodes, nodes);\r\n            }\r\n            else if (!domOrder) {\r\n                let ratio = column / prevColumn;\r\n                let move = (layout === 'move' || layout === 'moveScale');\r\n                let scale = (layout === 'scale' || layout === 'moveScale');\r\n                nodes.forEach(node => {\r\n                    // NOTE: x + w could be outside of the grid, but addNode() below will handle that\r\n                    node.x = (column === 1 ? 0 : (move ? Math.round(node.x * ratio) : Math.min(node.x, column - 1)));\r\n                    node.w = ((column === 1 || prevColumn === 1) ? 1 :\r\n                        scale ? (Math.round(node.w * ratio) || 1) : (Math.min(node.w, column)));\r\n                    newNodes.push(node);\r\n                });\r\n                nodes = [];\r\n            }\r\n        }\r\n        // finally re-layout them in reverse order (to get correct placement)\r\n        if (!domOrder)\r\n            newNodes = utils_1.Utils.sort(newNodes, -1, column);\r\n        this._inColumnResize = true; // prevent cache update\r\n        this.nodes = []; // pretend we have no nodes to start with (add() will use same structures) to simplify layout\r\n        newNodes.forEach(node => {\r\n            this.addNode(node, false); // 'false' for add event trigger\r\n            delete node._orig; // make sure the commit doesn't try to restore things back to original\r\n        });\r\n        this.batchUpdate(false);\r\n        delete this._inColumnResize;\r\n        return this;\r\n    }\r\n    /**\r\n     * call to cache the given layout internally to the given location so we can restore back when column changes size\r\n     * @param nodes list of nodes\r\n     * @param column corresponding column index to save it under\r\n     * @param clear if true, will force other caches to be removed (default false)\r\n     */\r\n    cacheLayout(nodes, column, clear = false) {\r\n        let copy = [];\r\n        nodes.forEach((n, i) => {\r\n            n._id = n._id || GridStackEngine._idSeq++; // make sure we have an id in case this is new layout, else re-use id already set\r\n            copy[i] = { x: n.x, y: n.y, w: n.w, _id: n._id }; // only thing we change is x,y,w and id to find it back\r\n        });\r\n        this._layouts = clear ? [] : this._layouts || []; // use array to find larger quick\r\n        this._layouts[column] = copy;\r\n        return this;\r\n    }\r\n    /**\r\n     * call to cache the given node layout internally to the given location so we can restore back when column changes size\r\n     * @param node single node to cache\r\n     * @param column corresponding column index to save it under\r\n     */\r\n    cacheOneLayout(n, column) {\r\n        n._id = n._id || GridStackEngine._idSeq++;\r\n        let l = { x: n.x, y: n.y, w: n.w, _id: n._id };\r\n        if (n.autoPosition) {\r\n            delete l.x;\r\n            delete l.y;\r\n            l.autoPosition = true;\r\n        }\r\n        this._layouts = this._layouts || [];\r\n        this._layouts[column] = this._layouts[column] || [];\r\n        let index = this.findCacheLayout(n, column);\r\n        if (index === -1)\r\n            this._layouts[column].push(l);\r\n        else\r\n            this._layouts[column][index] = l;\r\n        return this;\r\n    }\r\n    findCacheLayout(n, column) {\r\n        var _a, _b, _c;\r\n        return (_c = (_b = (_a = this._layouts) === null || _a === void 0 ? void 0 : _a[column]) === null || _b === void 0 ? void 0 : _b.findIndex(l => l._id === n._id)) !== null && _c !== void 0 ? _c : -1;\r\n    }\r\n    /** called to remove all internal values but the _id */\r\n    cleanupNode(node) {\r\n        for (let prop in node) {\r\n            if (prop[0] === '_' && prop !== '_id')\r\n                delete node[prop];\r\n        }\r\n        return this;\r\n    }\r\n}\r\nexports.GridStackEngine = GridStackEngine;\r\n/** @internal unique global internal _id counter NOT starting at 0 */\r\nGridStackEngine._idSeq = 1;\r\n//# sourceMappingURL=gridstack-engine.js.map","\"use strict\";\r\n/**\r\n * dd-gridstack.ts 7.3.0\r\n * Copyright (c) 2021 Alain Dumesny - see GridStack root license\r\n */\r\nObject.defineProperty(exports, \"__esModule\", { value: true });\r\nexports.DDGridStack = void 0;\r\nconst utils_1 = require(\"./utils\");\r\nconst dd_manager_1 = require(\"./dd-manager\");\r\nconst dd_element_1 = require(\"./dd-element\");\r\n// let count = 0; // TEST\r\n/**\r\n * HTML Native Mouse and Touch Events Drag and Drop functionality.\r\n */\r\nclass DDGridStack {\r\n    resizable(el, opts, key, value) {\r\n        this._getDDElements(el).forEach(dEl => {\r\n            if (opts === 'disable' || opts === 'enable') {\r\n                dEl.ddResizable && dEl.ddResizable[opts](); // can't create DD as it requires options for setupResizable()\r\n            }\r\n            else if (opts === 'destroy') {\r\n                dEl.ddResizable && dEl.cleanResizable();\r\n            }\r\n            else if (opts === 'option') {\r\n                dEl.setupResizable({ [key]: value });\r\n            }\r\n            else {\r\n                const grid = dEl.el.gridstackNode.grid;\r\n                let handles = dEl.el.getAttribute('gs-resize-handles') ? dEl.el.getAttribute('gs-resize-handles') : grid.opts.resizable.handles;\r\n                let autoHide = !grid.opts.alwaysShowResizeHandle;\r\n                dEl.setupResizable(Object.assign(Object.assign(Object.assign({}, grid.opts.resizable), { handles, autoHide }), {\r\n                    start: opts.start,\r\n                    stop: opts.stop,\r\n                    resize: opts.resize\r\n                }));\r\n            }\r\n        });\r\n        return this;\r\n    }\r\n    draggable(el, opts, key, value) {\r\n        this._getDDElements(el).forEach(dEl => {\r\n            if (opts === 'disable' || opts === 'enable') {\r\n                dEl.ddDraggable && dEl.ddDraggable[opts](); // can't create DD as it requires options for setupDraggable()\r\n            }\r\n            else if (opts === 'destroy') {\r\n                dEl.ddDraggable && dEl.cleanDraggable();\r\n            }\r\n            else if (opts === 'option') {\r\n                dEl.setupDraggable({ [key]: value });\r\n            }\r\n            else {\r\n                const grid = dEl.el.gridstackNode.grid;\r\n                dEl.setupDraggable(Object.assign(Object.assign({}, grid.opts.draggable), {\r\n                    // containment: (grid.parentGridItem && !grid.opts.dragOut) ? grid.el.parentElement : (grid.opts.draggable.containment || null),\r\n                    start: opts.start,\r\n                    stop: opts.stop,\r\n                    drag: opts.drag\r\n                }));\r\n            }\r\n        });\r\n        return this;\r\n    }\r\n    dragIn(el, opts) {\r\n        this._getDDElements(el).forEach(dEl => dEl.setupDraggable(opts));\r\n        return this;\r\n    }\r\n    droppable(el, opts, key, value) {\r\n        if (typeof opts.accept === 'function' && !opts._accept) {\r\n            opts._accept = opts.accept;\r\n            opts.accept = (el) => opts._accept(el);\r\n        }\r\n        this._getDDElements(el).forEach(dEl => {\r\n            if (opts === 'disable' || opts === 'enable') {\r\n                dEl.ddDroppable && dEl.ddDroppable[opts]();\r\n            }\r\n            else if (opts === 'destroy') {\r\n                if (dEl.ddDroppable) { // error to call destroy if not there\r\n                    dEl.cleanDroppable();\r\n                }\r\n            }\r\n            else if (opts === 'option') {\r\n                dEl.setupDroppable({ [key]: value });\r\n            }\r\n            else {\r\n                dEl.setupDroppable(opts);\r\n            }\r\n        });\r\n        return this;\r\n    }\r\n    /** true if element is droppable */\r\n    isDroppable(el) {\r\n        return !!(el && el.ddElement && el.ddElement.ddDroppable && !el.ddElement.ddDroppable.disabled);\r\n    }\r\n    /** true if element is draggable */\r\n    isDraggable(el) {\r\n        return !!(el && el.ddElement && el.ddElement.ddDraggable && !el.ddElement.ddDraggable.disabled);\r\n    }\r\n    /** true if element is draggable */\r\n    isResizable(el) {\r\n        return !!(el && el.ddElement && el.ddElement.ddResizable && !el.ddElement.ddResizable.disabled);\r\n    }\r\n    on(el, name, callback) {\r\n        this._getDDElements(el).forEach(dEl => dEl.on(name, (event) => {\r\n            callback(event, dd_manager_1.DDManager.dragElement ? dd_manager_1.DDManager.dragElement.el : event.target, dd_manager_1.DDManager.dragElement ? dd_manager_1.DDManager.dragElement.helper : null);\r\n        }));\r\n        return this;\r\n    }\r\n    off(el, name) {\r\n        this._getDDElements(el).forEach(dEl => dEl.off(name));\r\n        return this;\r\n    }\r\n    /** @internal returns a list of DD elements, creating them on the fly by default */\r\n    _getDDElements(els, create = true) {\r\n        let hosts = utils_1.Utils.getElements(els);\r\n        if (!hosts.length)\r\n            return [];\r\n        let list = hosts.map(e => e.ddElement || (create ? dd_element_1.DDElement.init(e) : null));\r\n        if (!create) {\r\n            list.filter(d => d);\r\n        } // remove nulls\r\n        return list;\r\n    }\r\n}\r\nexports.DDGridStack = DDGridStack;\r\n//# sourceMappingURL=dd-gridstack.js.map","\"use strict\";\r\n/**\r\n * dd-draggable.ts 7.3.0\r\n * Copyright (c) 2021-2022 Alain Dumesny - see GridStack root license\r\n */\r\nObject.defineProperty(exports, \"__esModule\", { value: true });\r\nexports.DDDraggable = void 0;\r\nconst dd_manager_1 = require(\"./dd-manager\");\r\nconst utils_1 = require(\"./utils\");\r\nconst dd_base_impl_1 = require(\"./dd-base-impl\");\r\nconst dd_touch_1 = require(\"./dd-touch\");\r\n// let count = 0; // TEST\r\nclass DDDraggable extends dd_base_impl_1.DDBaseImplement {\r\n    constructor(el, option = {}) {\r\n        super();\r\n        this.el = el;\r\n        this.option = option;\r\n        // get the element that is actually supposed to be dragged by\r\n        let handleName = option.handle.substring(1);\r\n        this.dragEl = el.classList.contains(handleName) ? el : el.querySelector(option.handle) || el;\r\n        // create var event binding so we can easily remove and still look like TS methods (unlike anonymous functions)\r\n        this._mouseDown = this._mouseDown.bind(this);\r\n        this._mouseMove = this._mouseMove.bind(this);\r\n        this._mouseUp = this._mouseUp.bind(this);\r\n        this.enable();\r\n    }\r\n    on(event, callback) {\r\n        super.on(event, callback);\r\n    }\r\n    off(event) {\r\n        super.off(event);\r\n    }\r\n    enable() {\r\n        if (this.disabled === false)\r\n            return;\r\n        super.enable();\r\n        this.dragEl.addEventListener('mousedown', this._mouseDown);\r\n        if (dd_touch_1.isTouch) {\r\n            this.dragEl.addEventListener('touchstart', dd_touch_1.touchstart);\r\n            this.dragEl.addEventListener('pointerdown', dd_touch_1.pointerdown);\r\n            // this.dragEl.style.touchAction = 'none'; // not needed unlike pointerdown doc comment\r\n        }\r\n        this.el.classList.remove('ui-draggable-disabled');\r\n        this.el.classList.add('ui-draggable');\r\n    }\r\n    disable(forDestroy = false) {\r\n        if (this.disabled === true)\r\n            return;\r\n        super.disable();\r\n        this.dragEl.removeEventListener('mousedown', this._mouseDown);\r\n        if (dd_touch_1.isTouch) {\r\n            this.dragEl.removeEventListener('touchstart', dd_touch_1.touchstart);\r\n            this.dragEl.removeEventListener('pointerdown', dd_touch_1.pointerdown);\r\n        }\r\n        this.el.classList.remove('ui-draggable');\r\n        if (!forDestroy)\r\n            this.el.classList.add('ui-draggable-disabled');\r\n    }\r\n    destroy() {\r\n        if (this.dragTimeout)\r\n            window.clearTimeout(this.dragTimeout);\r\n        delete this.dragTimeout;\r\n        if (this.dragging)\r\n            this._mouseUp(this.mouseDownEvent);\r\n        this.disable(true);\r\n        delete this.el;\r\n        delete this.helper;\r\n        delete this.option;\r\n        super.destroy();\r\n    }\r\n    updateOption(opts) {\r\n        Object.keys(opts).forEach(key => this.option[key] = opts[key]);\r\n        return this;\r\n    }\r\n    /** @internal call when mouse goes down before a dragstart happens */\r\n    _mouseDown(e) {\r\n        // don't let more than one widget handle mouseStart\r\n        if (dd_manager_1.DDManager.mouseHandled)\r\n            return;\r\n        if (e.button !== 0)\r\n            return true; // only left click\r\n        // make sure we are not clicking on known object that handles mouseDown (TODO: make this extensible ?) #2054\r\n        const skipMouseDown = ['input', 'textarea', 'button', 'select', 'option'];\r\n        const name = e.target.nodeName.toLowerCase();\r\n        if (skipMouseDown.find(skip => skip === name))\r\n            return true;\r\n        // also check for content editable\r\n        if (e.target.closest('[contenteditable=\"true\"]'))\r\n            return true;\r\n        // REMOVE: why would we get the event if it wasn't for us or child ?\r\n        // make sure we are clicking on a drag handle or child of it...\r\n        // Note: we don't need to check that's handle is an immediate child, as mouseHandled will prevent parents from also handling it (lowest wins)\r\n        // let className = this.option.handle.substring(1);\r\n        // let el = e.target as HTMLElement;\r\n        // while (el && !el.classList.contains(className)) { el = el.parentElement; }\r\n        // if (!el) return;\r\n        this.mouseDownEvent = e;\r\n        delete this.dragging;\r\n        delete dd_manager_1.DDManager.dragElement;\r\n        delete dd_manager_1.DDManager.dropElement;\r\n        // document handler so we can continue receiving moves as the item is 'fixed' position, and capture=true so WE get a first crack\r\n        document.addEventListener('mousemove', this._mouseMove, true); // true=capture, not bubble\r\n        document.addEventListener('mouseup', this._mouseUp, true);\r\n        if (dd_touch_1.isTouch) {\r\n            this.dragEl.addEventListener('touchmove', dd_touch_1.touchmove);\r\n            this.dragEl.addEventListener('touchend', dd_touch_1.touchend);\r\n        }\r\n        e.preventDefault();\r\n        // preventDefault() prevents blur event which occurs just after mousedown event.\r\n        // if an editable content has focus, then blur must be call\r\n        if (document.activeElement)\r\n            document.activeElement.blur();\r\n        dd_manager_1.DDManager.mouseHandled = true;\r\n        return true;\r\n    }\r\n    /** @internal method to call actual drag event */\r\n    _callDrag(e) {\r\n        if (!this.dragging)\r\n            return;\r\n        const ev = utils_1.Utils.initEvent(e, { target: this.el, type: 'drag' });\r\n        if (this.option.drag) {\r\n            this.option.drag(ev, this.ui());\r\n        }\r\n        this.triggerEvent('drag', ev);\r\n    }\r\n    /** @internal called when the main page (after successful mousedown) receives a move event to drag the item around the screen */\r\n    _mouseMove(e) {\r\n        var _a;\r\n        // console.log(`${count++} move ${e.x},${e.y}`)\r\n        let s = this.mouseDownEvent;\r\n        if (this.dragging) {\r\n            this._dragFollow(e);\r\n            // delay actual grid handling drag until we pause for a while if set\r\n            if (dd_manager_1.DDManager.pauseDrag) {\r\n                const pause = Number.isInteger(dd_manager_1.DDManager.pauseDrag) ? dd_manager_1.DDManager.pauseDrag : 100;\r\n                if (this.dragTimeout)\r\n                    window.clearTimeout(this.dragTimeout);\r\n                this.dragTimeout = window.setTimeout(() => this._callDrag(e), pause);\r\n            }\r\n            else {\r\n                this._callDrag(e);\r\n            }\r\n        }\r\n        else if (Math.abs(e.x - s.x) + Math.abs(e.y - s.y) > 3) {\r\n            /**\r\n             * don't start unless we've moved at least 3 pixels\r\n             */\r\n            this.dragging = true;\r\n            dd_manager_1.DDManager.dragElement = this;\r\n            // if we're dragging an actual grid item, set the current drop as the grid (to detect enter/leave)\r\n            let grid = (_a = this.el.gridstackNode) === null || _a === void 0 ? void 0 : _a.grid;\r\n            if (grid) {\r\n                dd_manager_1.DDManager.dropElement = grid.el.ddElement.ddDroppable;\r\n            }\r\n            else {\r\n                delete dd_manager_1.DDManager.dropElement;\r\n            }\r\n            this.helper = this._createHelper(e);\r\n            this._setupHelperContainmentStyle();\r\n            this.dragOffset = this._getDragOffset(e, this.el, this.helperContainment);\r\n            const ev = utils_1.Utils.initEvent(e, { target: this.el, type: 'dragstart' });\r\n            this._setupHelperStyle(e);\r\n            if (this.option.start) {\r\n                this.option.start(ev, this.ui());\r\n            }\r\n            this.triggerEvent('dragstart', ev);\r\n        }\r\n        e.preventDefault(); // needed otherwise we get text sweep text selection as we drag around\r\n        return true;\r\n    }\r\n    /** @internal call when the mouse gets released to drop the item at current location */\r\n    _mouseUp(e) {\r\n        var _a;\r\n        document.removeEventListener('mousemove', this._mouseMove, true);\r\n        document.removeEventListener('mouseup', this._mouseUp, true);\r\n        if (dd_touch_1.isTouch) {\r\n            this.dragEl.removeEventListener('touchmove', dd_touch_1.touchmove, true);\r\n            this.dragEl.removeEventListener('touchend', dd_touch_1.touchend, true);\r\n        }\r\n        if (this.dragging) {\r\n            delete this.dragging;\r\n            // reset the drop target if dragging over ourself (already parented, just moving during stop callback below)\r\n            if (((_a = dd_manager_1.DDManager.dropElement) === null || _a === void 0 ? void 0 : _a.el) === this.el.parentElement) {\r\n                delete dd_manager_1.DDManager.dropElement;\r\n            }\r\n            this.helperContainment.style.position = this.parentOriginStylePosition || null;\r\n            if (this.helper === this.el) {\r\n                this._removeHelperStyle();\r\n            }\r\n            else {\r\n                this.helper.remove();\r\n            }\r\n            const ev = utils_1.Utils.initEvent(e, { target: this.el, type: 'dragstop' });\r\n            if (this.option.stop) {\r\n                this.option.stop(ev); // NOTE: destroy() will be called when removing item, so expect NULL ptr after!\r\n            }\r\n            this.triggerEvent('dragstop', ev);\r\n            // call the droppable method to receive the item\r\n            if (dd_manager_1.DDManager.dropElement) {\r\n                dd_manager_1.DDManager.dropElement.drop(e);\r\n            }\r\n        }\r\n        delete this.helper;\r\n        delete this.mouseDownEvent;\r\n        delete dd_manager_1.DDManager.dragElement;\r\n        delete dd_manager_1.DDManager.dropElement;\r\n        delete dd_manager_1.DDManager.mouseHandled;\r\n        e.preventDefault();\r\n    }\r\n    /** @internal create a clone copy (or user defined method) of the original drag item if set */\r\n    _createHelper(event) {\r\n        let helper = this.el;\r\n        if (typeof this.option.helper === 'function') {\r\n            helper = this.option.helper(event);\r\n        }\r\n        else if (this.option.helper === 'clone') {\r\n            helper = utils_1.Utils.cloneNode(this.el);\r\n        }\r\n        if (!document.body.contains(helper)) {\r\n            utils_1.Utils.appendTo(helper, this.option.appendTo === 'parent' ? this.el.parentNode : this.option.appendTo);\r\n        }\r\n        if (helper === this.el) {\r\n            this.dragElementOriginStyle = DDDraggable.originStyleProp.map(prop => this.el.style[prop]);\r\n        }\r\n        return helper;\r\n    }\r\n    /** @internal set the fix position of the dragged item */\r\n    _setupHelperStyle(e) {\r\n        this.helper.classList.add('ui-draggable-dragging');\r\n        // TODO: set all at once with style.cssText += ... ? https://stackoverflow.com/questions/3968593\r\n        const style = this.helper.style;\r\n        style.pointerEvents = 'none'; // needed for over items to get enter/leave\r\n        // style.cursor = 'move'; //  TODO: can't set with pointerEvents=none ! (done in CSS as well)\r\n        style['min-width'] = 0; // since we no longer relative to our parent and we don't resize anyway (normally 100/#column %)\r\n        style.width = this.dragOffset.width + 'px';\r\n        style.height = this.dragOffset.height + 'px';\r\n        style.willChange = 'left, top';\r\n        style.position = 'fixed'; // let us drag between grids by not clipping as parent .grid-stack is position: 'relative'\r\n        this._dragFollow(e); // now position it\r\n        style.transition = 'none'; // show up instantly\r\n        setTimeout(() => {\r\n            if (this.helper) {\r\n                style.transition = null; // recover animation\r\n            }\r\n        }, 0);\r\n        return this;\r\n    }\r\n    /** @internal restore back the original style before dragging */\r\n    _removeHelperStyle() {\r\n        var _a;\r\n        this.helper.classList.remove('ui-draggable-dragging');\r\n        let node = (_a = this.helper) === null || _a === void 0 ? void 0 : _a.gridstackNode;\r\n        // don't bother restoring styles if we're gonna remove anyway...\r\n        if (!(node === null || node === void 0 ? void 0 : node._isAboutToRemove) && this.dragElementOriginStyle) {\r\n            let helper = this.helper;\r\n            // don't animate, otherwise we animate offseted when switching back to 'absolute' from 'fixed'.\r\n            // TODO: this also removes resizing animation which doesn't have this issue, but others.\r\n            // Ideally both would animate ('move' would immediately restore 'absolute' and adjust coordinate to match,\r\n            // then trigger a delay (repaint) to restore to final dest with animate) but then we need to make sure 'resizestop'\r\n            // is called AFTER 'transitionend' event is received (see https://github.com/gridstack/gridstack.js/issues/2033)\r\n            let transition = this.dragElementOriginStyle['transition'] || null;\r\n            helper.style.transition = this.dragElementOriginStyle['transition'] = 'none'; // can't be NULL #1973\r\n            DDDraggable.originStyleProp.forEach(prop => helper.style[prop] = this.dragElementOriginStyle[prop] || null);\r\n            setTimeout(() => helper.style.transition = transition, 50); // recover animation from saved vars after a pause (0 isn't enough #1973)\r\n        }\r\n        delete this.dragElementOriginStyle;\r\n        return this;\r\n    }\r\n    /** @internal updates the top/left position to follow the mouse */\r\n    _dragFollow(e) {\r\n        let containmentRect = { left: 0, top: 0 };\r\n        // if (this.helper.style.position === 'absolute') { // we use 'fixed'\r\n        //   const { left, top } = this.helperContainment.getBoundingClientRect();\r\n        //   containmentRect = { left, top };\r\n        // }\r\n        const style = this.helper.style;\r\n        const offset = this.dragOffset;\r\n        style.left = e.clientX + offset.offsetLeft - containmentRect.left + 'px';\r\n        style.top = e.clientY + offset.offsetTop - containmentRect.top + 'px';\r\n    }\r\n    /** @internal */\r\n    _setupHelperContainmentStyle() {\r\n        this.helperContainment = this.helper.parentElement;\r\n        if (this.helper.style.position !== 'fixed') {\r\n            this.parentOriginStylePosition = this.helperContainment.style.position;\r\n            if (window.getComputedStyle(this.helperContainment).position.match(/static/)) {\r\n                this.helperContainment.style.position = 'relative';\r\n            }\r\n        }\r\n        return this;\r\n    }\r\n    /** @internal */\r\n    _getDragOffset(event, el, parent) {\r\n        // in case ancestor has transform/perspective css properties that change the viewpoint\r\n        let xformOffsetX = 0;\r\n        let xformOffsetY = 0;\r\n        if (parent) {\r\n            const testEl = document.createElement('div');\r\n            utils_1.Utils.addElStyles(testEl, {\r\n                opacity: '0',\r\n                position: 'fixed',\r\n                top: 0 + 'px',\r\n                left: 0 + 'px',\r\n                width: '1px',\r\n                height: '1px',\r\n                zIndex: '-999999',\r\n            });\r\n            parent.appendChild(testEl);\r\n            const testElPosition = testEl.getBoundingClientRect();\r\n            parent.removeChild(testEl);\r\n            xformOffsetX = testElPosition.left;\r\n            xformOffsetY = testElPosition.top;\r\n            // TODO: scale ?\r\n        }\r\n        const targetOffset = el.getBoundingClientRect();\r\n        return {\r\n            left: targetOffset.left,\r\n            top: targetOffset.top,\r\n            offsetLeft: -event.clientX + targetOffset.left - xformOffsetX,\r\n            offsetTop: -event.clientY + targetOffset.top - xformOffsetY,\r\n            width: targetOffset.width,\r\n            height: targetOffset.height\r\n        };\r\n    }\r\n    /** @internal TODO: set to public as called by DDDroppable! */\r\n    ui() {\r\n        const containmentEl = this.el.parentElement;\r\n        const containmentRect = containmentEl.getBoundingClientRect();\r\n        const offset = this.helper.getBoundingClientRect();\r\n        return {\r\n            position: {\r\n                top: offset.top - containmentRect.top,\r\n                left: offset.left - containmentRect.left\r\n            }\r\n            /* not used by GridStack for now...\r\n            helper: [this.helper], //The object arr representing the helper that's being dragged.\r\n            offset: { top: offset.top, left: offset.left } // Current offset position of the helper as { top, left } object.\r\n            */\r\n        };\r\n    }\r\n}\r\nexports.DDDraggable = DDDraggable;\r\n/** @internal properties we change during dragging, and restore back */\r\nDDDraggable.originStyleProp = ['transition', 'pointerEvents', 'position', 'left', 'top', 'minWidth', 'willChange'];\r\n//# sourceMappingURL=dd-draggable.js.map","\"use strict\";\r\n/**\r\n * dd-droppable.ts 7.3.0\r\n * Copyright (c) 2021-2022 Alain Dumesny - see GridStack root license\r\n */\r\nObject.defineProperty(exports, \"__esModule\", { value: true });\r\nexports.DDDroppable = void 0;\r\nconst dd_manager_1 = require(\"./dd-manager\");\r\nconst dd_base_impl_1 = require(\"./dd-base-impl\");\r\nconst utils_1 = require(\"./utils\");\r\nconst dd_touch_1 = require(\"./dd-touch\");\r\n// let count = 0; // TEST\r\nclass DDDroppable extends dd_base_impl_1.DDBaseImplement {\r\n    constructor(el, opts = {}) {\r\n        super();\r\n        this.el = el;\r\n        this.option = opts;\r\n        // create var event binding so we can easily remove and still look like TS methods (unlike anonymous functions)\r\n        this._mouseEnter = this._mouseEnter.bind(this);\r\n        this._mouseLeave = this._mouseLeave.bind(this);\r\n        this.enable();\r\n        this._setupAccept();\r\n    }\r\n    on(event, callback) {\r\n        super.on(event, callback);\r\n    }\r\n    off(event) {\r\n        super.off(event);\r\n    }\r\n    enable() {\r\n        if (this.disabled === false)\r\n            return;\r\n        super.enable();\r\n        this.el.classList.add('ui-droppable');\r\n        this.el.classList.remove('ui-droppable-disabled');\r\n        this.el.addEventListener('mouseenter', this._mouseEnter);\r\n        this.el.addEventListener('mouseleave', this._mouseLeave);\r\n        if (dd_touch_1.isTouch) {\r\n            this.el.addEventListener('pointerenter', dd_touch_1.pointerenter);\r\n            this.el.addEventListener('pointerleave', dd_touch_1.pointerleave);\r\n        }\r\n    }\r\n    disable(forDestroy = false) {\r\n        if (this.disabled === true)\r\n            return;\r\n        super.disable();\r\n        this.el.classList.remove('ui-droppable');\r\n        if (!forDestroy)\r\n            this.el.classList.add('ui-droppable-disabled');\r\n        this.el.removeEventListener('mouseenter', this._mouseEnter);\r\n        this.el.removeEventListener('mouseleave', this._mouseLeave);\r\n        if (dd_touch_1.isTouch) {\r\n            this.el.removeEventListener('pointerenter', dd_touch_1.pointerenter);\r\n            this.el.removeEventListener('pointerleave', dd_touch_1.pointerleave);\r\n        }\r\n    }\r\n    destroy() {\r\n        this.disable(true);\r\n        this.el.classList.remove('ui-droppable');\r\n        this.el.classList.remove('ui-droppable-disabled');\r\n        super.destroy();\r\n    }\r\n    updateOption(opts) {\r\n        Object.keys(opts).forEach(key => this.option[key] = opts[key]);\r\n        this._setupAccept();\r\n        return this;\r\n    }\r\n    /** @internal called when the cursor enters our area - prepare for a possible drop and track leaving */\r\n    _mouseEnter(e) {\r\n        // console.log(`${count++} Enter ${this.el.id || (this.el as GridHTMLElement).gridstack.opts.id}`); // TEST\r\n        if (!dd_manager_1.DDManager.dragElement)\r\n            return;\r\n        if (!this._canDrop(dd_manager_1.DDManager.dragElement.el))\r\n            return;\r\n        e.preventDefault();\r\n        e.stopPropagation();\r\n        // make sure when we enter this, that the last one gets a leave FIRST to correctly cleanup as we don't always do\r\n        if (dd_manager_1.DDManager.dropElement && dd_manager_1.DDManager.dropElement !== this) {\r\n            dd_manager_1.DDManager.dropElement._mouseLeave(e);\r\n        }\r\n        dd_manager_1.DDManager.dropElement = this;\r\n        const ev = utils_1.Utils.initEvent(e, { target: this.el, type: 'dropover' });\r\n        if (this.option.over) {\r\n            this.option.over(ev, this._ui(dd_manager_1.DDManager.dragElement));\r\n        }\r\n        this.triggerEvent('dropover', ev);\r\n        this.el.classList.add('ui-droppable-over');\r\n        // console.log('tracking'); // TEST\r\n    }\r\n    /** @internal called when the item is leaving our area, stop tracking if we had moving item */\r\n    _mouseLeave(e) {\r\n        var _a;\r\n        // console.log(`${count++} Leave ${this.el.id || (this.el as GridHTMLElement).gridstack.opts.id}`); // TEST\r\n        if (!dd_manager_1.DDManager.dragElement || dd_manager_1.DDManager.dropElement !== this)\r\n            return;\r\n        e.preventDefault();\r\n        e.stopPropagation();\r\n        const ev = utils_1.Utils.initEvent(e, { target: this.el, type: 'dropout' });\r\n        if (this.option.out) {\r\n            this.option.out(ev, this._ui(dd_manager_1.DDManager.dragElement));\r\n        }\r\n        this.triggerEvent('dropout', ev);\r\n        if (dd_manager_1.DDManager.dropElement === this) {\r\n            delete dd_manager_1.DDManager.dropElement;\r\n            // console.log('not tracking'); // TEST\r\n            // if we're still over a parent droppable, send it an enter as we don't get one from leaving nested children\r\n            let parentDrop;\r\n            let parent = this.el.parentElement;\r\n            while (!parentDrop && parent) {\r\n                parentDrop = (_a = parent.ddElement) === null || _a === void 0 ? void 0 : _a.ddDroppable;\r\n                parent = parent.parentElement;\r\n            }\r\n            if (parentDrop) {\r\n                parentDrop._mouseEnter(e);\r\n            }\r\n        }\r\n    }\r\n    /** item is being dropped on us - called by the drag mouseup handler - this calls the client drop event */\r\n    drop(e) {\r\n        e.preventDefault();\r\n        const ev = utils_1.Utils.initEvent(e, { target: this.el, type: 'drop' });\r\n        if (this.option.drop) {\r\n            this.option.drop(ev, this._ui(dd_manager_1.DDManager.dragElement));\r\n        }\r\n        this.triggerEvent('drop', ev);\r\n    }\r\n    /** @internal true if element matches the string/method accept option */\r\n    _canDrop(el) {\r\n        return el && (!this.accept || this.accept(el));\r\n    }\r\n    /** @internal */\r\n    _setupAccept() {\r\n        if (!this.option.accept)\r\n            return this;\r\n        if (typeof this.option.accept === 'string') {\r\n            this.accept = (el) => el.matches(this.option.accept);\r\n        }\r\n        else {\r\n            this.accept = this.option.accept;\r\n        }\r\n        return this;\r\n    }\r\n    /** @internal */\r\n    _ui(drag) {\r\n        return Object.assign({ draggable: drag.el }, drag.ui());\r\n    }\r\n}\r\nexports.DDDroppable = DDDroppable;\r\n//# sourceMappingURL=dd-droppable.js.map","\"use strict\";\r\nvar __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {\r\n    if (k2 === undefined) k2 = k;\r\n    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });\r\n}) : (function(o, m, k, k2) {\r\n    if (k2 === undefined) k2 = k;\r\n    o[k2] = m[k];\r\n}));\r\nvar __exportStar = (this && this.__exportStar) || function(m, exports) {\r\n    for (var p in m) if (p !== \"default\" && !exports.hasOwnProperty(p)) __createBinding(exports, m, p);\r\n};\r\nObject.defineProperty(exports, \"__esModule\", { value: true });\r\nexports.GridStack = void 0;\r\n/*!\r\n * GridStack 7.3.0\r\n * https://gridstackjs.com/\r\n *\r\n * Copyright (c) 2021-2022 Alain Dumesny\r\n * see root license https://github.com/gridstack/gridstack.js/tree/master/LICENSE\r\n */\r\nconst gridstack_engine_1 = require(\"./gridstack-engine\");\r\nconst utils_1 = require(\"./utils\");\r\nconst types_1 = require(\"./types\");\r\n/*\r\n * and include D&D by default\r\n * TODO: while we could generate a gridstack-static.js at smaller size - saves about 31k (41k -> 72k)\r\n * I don't know how to generate the DD only code at the remaining 31k to delay load as code depends on Gridstack.ts\r\n * also it caused loading issues in prod - see https://github.com/gridstack/gridstack.js/issues/2039\r\n */\r\nconst dd_gridstack_1 = require(\"./dd-gridstack\");\r\nconst dd_touch_1 = require(\"./dd-touch\");\r\nconst dd_manager_1 = require(\"./dd-manager\");\r\n/** global instance */\r\nconst dd = new dd_gridstack_1.DDGridStack;\r\n// export all dependent file as well to make it easier for users to just import the main file\r\n__exportStar(require(\"./types\"), exports);\r\n__exportStar(require(\"./utils\"), exports);\r\n__exportStar(require(\"./gridstack-engine\"), exports);\r\n__exportStar(require(\"./dd-gridstack\"), exports);\r\n/**\r\n * Main gridstack class - you will need to call `GridStack.init()` first to initialize your grid.\r\n * Note: your grid elements MUST have the following classes for the CSS layout to work:\r\n * @example\r\n * <div class=\"grid-stack\">\r\n *   <div class=\"grid-stack-item\">\r\n *     <div class=\"grid-stack-item-content\">Item 1</div>\r\n *   </div>\r\n * </div>\r\n */\r\nclass GridStack {\r\n    /**\r\n     * Construct a grid item from the given element and options\r\n     * @param el\r\n     * @param opts\r\n     */\r\n    constructor(el, opts = {}) {\r\n        var _a, _b;\r\n        /** @internal */\r\n        this._gsEventHandler = {};\r\n        /** @internal extra row added when dragging at the bottom of the grid */\r\n        this._extraDragRow = 0;\r\n        this.el = el; // exposed HTML element to the user\r\n        opts = opts || {}; // handles null/undefined/0\r\n        if (!el.classList.contains('grid-stack')) {\r\n            this.el.classList.add('grid-stack');\r\n        }\r\n        // if row property exists, replace minRow and maxRow instead\r\n        if (opts.row) {\r\n            opts.minRow = opts.maxRow = opts.row;\r\n            delete opts.row;\r\n        }\r\n        let rowAttr = utils_1.Utils.toNumber(el.getAttribute('gs-row'));\r\n        // flag only valid in sub-grids (handled by parent, not here)\r\n        if (opts.column === 'auto') {\r\n            delete opts.column;\r\n        }\r\n        // 'minWidth' legacy support in 5.1\r\n        /* eslint-disable-next-line @typescript-eslint/no-explicit-any */\r\n        let anyOpts = opts;\r\n        if (anyOpts.minWidth !== undefined) {\r\n            opts.oneColumnSize = opts.oneColumnSize || anyOpts.minWidth;\r\n            delete anyOpts.minWidth;\r\n        }\r\n        // save original setting so we can restore on save\r\n        if (opts.alwaysShowResizeHandle !== undefined) {\r\n            opts._alwaysShowResizeHandle = opts.alwaysShowResizeHandle;\r\n        }\r\n        // elements DOM attributes override any passed options (like CSS style) - merge the two together\r\n        let defaults = Object.assign(Object.assign({}, utils_1.Utils.cloneDeep(types_1.gridDefaults)), { column: utils_1.Utils.toNumber(el.getAttribute('gs-column')) || types_1.gridDefaults.column, minRow: rowAttr ? rowAttr : utils_1.Utils.toNumber(el.getAttribute('gs-min-row')) || types_1.gridDefaults.minRow, maxRow: rowAttr ? rowAttr : utils_1.Utils.toNumber(el.getAttribute('gs-max-row')) || types_1.gridDefaults.maxRow, staticGrid: utils_1.Utils.toBool(el.getAttribute('gs-static')) || types_1.gridDefaults.staticGrid, draggable: {\r\n                handle: (opts.handleClass ? '.' + opts.handleClass : (opts.handle ? opts.handle : '')) || types_1.gridDefaults.draggable.handle,\r\n            }, removableOptions: {\r\n                accept: opts.itemClass ? '.' + opts.itemClass : types_1.gridDefaults.removableOptions.accept,\r\n            } });\r\n        if (el.getAttribute('gs-animate')) { // default to true, but if set to false use that instead\r\n            defaults.animate = utils_1.Utils.toBool(el.getAttribute('gs-animate'));\r\n        }\r\n        this.opts = utils_1.Utils.defaults(opts, defaults);\r\n        opts = null; // make sure we use this.opts instead\r\n        this._initMargin(); // part of settings defaults...\r\n        // Now check if we're loading into 1 column mode FIRST so we don't do un-necessary work (like cellHeight = width / 12 then go 1 column)\r\n        if (this.opts.column !== 1 && !this.opts.disableOneColumnMode && this._widthOrContainer() <= this.opts.oneColumnSize) {\r\n            this._prevColumn = this.getColumn();\r\n            this.opts.column = 1;\r\n        }\r\n        if (this.opts.rtl === 'auto') {\r\n            this.opts.rtl = (el.style.direction === 'rtl');\r\n        }\r\n        if (this.opts.rtl) {\r\n            this.el.classList.add('grid-stack-rtl');\r\n        }\r\n        // check if we're been nested, and if so update our style and keep pointer around (used during save)\r\n        let parentGridItem = (_a = utils_1.Utils.closestUpByClass(this.el, types_1.gridDefaults.itemClass)) === null || _a === void 0 ? void 0 : _a.gridstackNode;\r\n        if (parentGridItem) {\r\n            parentGridItem.subGrid = this;\r\n            this.parentGridItem = parentGridItem;\r\n            this.el.classList.add('grid-stack-nested');\r\n            parentGridItem.el.classList.add('grid-stack-sub-grid');\r\n        }\r\n        this._isAutoCellHeight = (this.opts.cellHeight === 'auto');\r\n        if (this._isAutoCellHeight || this.opts.cellHeight === 'initial') {\r\n            // make the cell content square initially (will use resize/column event to keep it square)\r\n            this.cellHeight(undefined, false);\r\n        }\r\n        else {\r\n            // append unit if any are set\r\n            if (typeof this.opts.cellHeight == 'number' && this.opts.cellHeightUnit && this.opts.cellHeightUnit !== types_1.gridDefaults.cellHeightUnit) {\r\n                this.opts.cellHeight = this.opts.cellHeight + this.opts.cellHeightUnit;\r\n                delete this.opts.cellHeightUnit;\r\n            }\r\n            this.cellHeight(this.opts.cellHeight, false);\r\n        }\r\n        // see if we need to adjust auto-hide\r\n        if (this.opts.alwaysShowResizeHandle === 'mobile') {\r\n            this.opts.alwaysShowResizeHandle = dd_touch_1.isTouch;\r\n        }\r\n        this._styleSheetClass = 'grid-stack-instance-' + gridstack_engine_1.GridStackEngine._idSeq++;\r\n        this.el.classList.add(this._styleSheetClass);\r\n        this._setStaticClass();\r\n        let engineClass = this.opts.engineClass || GridStack.engineClass || gridstack_engine_1.GridStackEngine;\r\n        this.engine = new engineClass({\r\n            column: this.getColumn(),\r\n            float: this.opts.float,\r\n            maxRow: this.opts.maxRow,\r\n            onChange: (cbNodes) => {\r\n                let maxH = 0;\r\n                this.engine.nodes.forEach(n => { maxH = Math.max(maxH, n.y + n.h); });\r\n                cbNodes.forEach(n => {\r\n                    let el = n.el;\r\n                    if (!el)\r\n                        return;\r\n                    if (n._removeDOM) {\r\n                        if (el)\r\n                            el.remove();\r\n                        delete n._removeDOM;\r\n                    }\r\n                    else {\r\n                        this._writePosAttr(el, n);\r\n                    }\r\n                });\r\n                this._updateStyles(false, maxH); // false = don't recreate, just append if need be\r\n            }\r\n        });\r\n        if (this.opts.auto) {\r\n            this.batchUpdate(); // prevent in between re-layout #1535 TODO: this only set float=true, need to prevent collision check...\r\n            this.getGridItems().forEach(el => this._prepareElement(el));\r\n            this.batchUpdate(false);\r\n        }\r\n        // load any passed in children as well, which overrides any DOM layout done above\r\n        if (this.opts.children) {\r\n            let children = this.opts.children;\r\n            delete this.opts.children;\r\n            if (children.length)\r\n                this.load(children); // don't load empty\r\n        }\r\n        this.setAnimation(this.opts.animate);\r\n        this._updateStyles();\r\n        if (this.opts.column != 12) {\r\n            this.el.classList.add('grid-stack-' + this.opts.column);\r\n        }\r\n        // legacy support to appear 'per grid` options when really global.\r\n        if (this.opts.dragIn)\r\n            GridStack.setupDragIn(this.opts.dragIn, this.opts.dragInOptions);\r\n        delete this.opts.dragIn;\r\n        delete this.opts.dragInOptions;\r\n        // dynamic grids require pausing during drag to detect over to nest vs push\r\n        if (this.opts.subGridDynamic && !dd_manager_1.DDManager.pauseDrag)\r\n            dd_manager_1.DDManager.pauseDrag = true;\r\n        if (((_b = this.opts.draggable) === null || _b === void 0 ? void 0 : _b.pause) !== undefined)\r\n            dd_manager_1.DDManager.pauseDrag = this.opts.draggable.pause;\r\n        this._setupRemoveDrop();\r\n        this._setupAcceptWidget();\r\n        this._updateWindowResizeEvent();\r\n    }\r\n    /**\r\n     * initializing the HTML element, or selector string, into a grid will return the grid. Calling it again will\r\n     * simply return the existing instance (ignore any passed options). There is also an initAll() version that support\r\n     * multiple grids initialization at once. Or you can use addGrid() to create the entire grid from JSON.\r\n     * @param options grid options (optional)\r\n     * @param elOrString element or CSS selector (first one used) to convert to a grid (default to '.grid-stack' class selector)\r\n     *\r\n     * @example\r\n     * let grid = GridStack.init();\r\n     *\r\n     * Note: the HTMLElement (of type GridHTMLElement) will store a `gridstack: GridStack` value that can be retrieve later\r\n     * let grid = document.querySelector('.grid-stack').gridstack;\r\n     */\r\n    static init(options = {}, elOrString = '.grid-stack') {\r\n        let el = GridStack.getGridElement(elOrString);\r\n        if (!el) {\r\n            if (typeof elOrString === 'string') {\r\n                console.error('GridStack.initAll() no grid was found with selector \"' + elOrString + '\" - element missing or wrong selector ?' +\r\n                    '\\nNote: \".grid-stack\" is required for proper CSS styling and drag/drop, and is the default selector.');\r\n            }\r\n            else {\r\n                console.error('GridStack.init() no grid element was passed.');\r\n            }\r\n            return null;\r\n        }\r\n        if (!el.gridstack) {\r\n            el.gridstack = new GridStack(el, utils_1.Utils.cloneDeep(options));\r\n        }\r\n        return el.gridstack;\r\n    }\r\n    /**\r\n     * Will initialize a list of elements (given a selector) and return an array of grids.\r\n     * @param options grid options (optional)\r\n     * @param selector elements selector to convert to grids (default to '.grid-stack' class selector)\r\n     *\r\n     * @example\r\n     * let grids = GridStack.initAll();\r\n     * grids.forEach(...)\r\n     */\r\n    static initAll(options = {}, selector = '.grid-stack') {\r\n        let grids = [];\r\n        GridStack.getGridElements(selector).forEach(el => {\r\n            if (!el.gridstack) {\r\n                el.gridstack = new GridStack(el, utils_1.Utils.cloneDeep(options));\r\n                delete options.dragIn;\r\n                delete options.dragInOptions; // only need to be done once (really a static global thing, not per grid)\r\n            }\r\n            grids.push(el.gridstack);\r\n        });\r\n        if (grids.length === 0) {\r\n            console.error('GridStack.initAll() no grid was found with selector \"' + selector + '\" - element missing or wrong selector ?' +\r\n                '\\nNote: \".grid-stack\" is required for proper CSS styling and drag/drop, and is the default selector.');\r\n        }\r\n        return grids;\r\n    }\r\n    /**\r\n     * call to create a grid with the given options, including loading any children from JSON structure. This will call GridStack.init(), then\r\n     * grid.load() on any passed children (recursively). Great alternative to calling init() if you want entire grid to come from\r\n     * JSON serialized data, including options.\r\n     * @param parent HTML element parent to the grid\r\n     * @param opt grids options used to initialize the grid, and list of children\r\n     */\r\n    static addGrid(parent, opt = {}) {\r\n        if (!parent)\r\n            return null;\r\n        // create the grid element, but check if the passed 'parent' already has grid styling and should be used instead\r\n        let el = parent;\r\n        const parentIsGrid = parent.classList.contains('grid-stack');\r\n        if (!parentIsGrid || opt.addRemoveCB) {\r\n            if (opt.addRemoveCB) {\r\n                el = opt.addRemoveCB(parent, opt, true, true);\r\n            }\r\n            else {\r\n                let doc = document.implementation.createHTMLDocument(''); // IE needs a param\r\n                doc.body.innerHTML = `<div class=\"grid-stack ${opt.class || ''}\"></div>`;\r\n                el = doc.body.children[0];\r\n                parent.appendChild(el);\r\n            }\r\n        }\r\n        // create grid class and load any children\r\n        let grid = GridStack.init(opt, el);\r\n        return grid;\r\n    }\r\n    /** call this method to register your engine instead of the default one.\r\n     * See instead `GridStackOptions.engineClass` if you only need to\r\n     * replace just one instance.\r\n     */\r\n    static registerEngine(engineClass) {\r\n        GridStack.engineClass = engineClass;\r\n    }\r\n    /** @internal create placeholder DIV as needed */\r\n    get placeholder() {\r\n        if (!this._placeholder) {\r\n            let placeholderChild = document.createElement('div'); // child so padding match item-content\r\n            placeholderChild.className = 'placeholder-content';\r\n            if (this.opts.placeholderText) {\r\n                placeholderChild.innerHTML = this.opts.placeholderText;\r\n            }\r\n            this._placeholder = document.createElement('div');\r\n            this._placeholder.classList.add(this.opts.placeholderClass, types_1.gridDefaults.itemClass, this.opts.itemClass);\r\n            this.placeholder.appendChild(placeholderChild);\r\n        }\r\n        return this._placeholder;\r\n    }\r\n    /**\r\n     * add a new widget and returns it.\r\n     *\r\n     * Widget will be always placed even if result height is more than actual grid height.\r\n     * You need to use `willItFit()` before calling addWidget for additional check.\r\n     * See also `makeWidget()`.\r\n     *\r\n     * @example\r\n     * let grid = GridStack.init();\r\n     * grid.addWidget({w: 3, content: 'hello'});\r\n     * grid.addWidget('<div class=\"grid-stack-item\"><div class=\"grid-stack-item-content\">hello</div></div>', {w: 3});\r\n     *\r\n     * @param el  GridStackWidget (which can have content string as well), html element, or string definition to add\r\n     * @param options widget position/size options (optional, and ignore if first param is already option) - see GridStackWidget\r\n     */\r\n    addWidget(els, options) {\r\n        function isGridStackWidget(w) {\r\n            return w.el !== undefined || w.x !== undefined || w.y !== undefined || w.w !== undefined || w.h !== undefined || w.content !== undefined ? true : false;\r\n        }\r\n        let el;\r\n        let node;\r\n        if (typeof els === 'string') {\r\n            let doc = document.implementation.createHTMLDocument(''); // IE needs a param\r\n            doc.body.innerHTML = els;\r\n            el = doc.body.children[0];\r\n        }\r\n        else if (arguments.length === 0 || arguments.length === 1 && isGridStackWidget(els)) {\r\n            node = options = els;\r\n            if (node === null || node === void 0 ? void 0 : node.el) {\r\n                el = node.el; // re-use element stored in the node\r\n            }\r\n            else if (this.opts.addRemoveCB) {\r\n                el = this.opts.addRemoveCB(this.el, options, true, false);\r\n            }\r\n            else {\r\n                let content = (options === null || options === void 0 ? void 0 : options.content) || '';\r\n                let doc = document.implementation.createHTMLDocument(''); // IE needs a param\r\n                doc.body.innerHTML = `<div class=\"grid-stack-item ${this.opts.itemClass || ''}\"><div class=\"grid-stack-item-content\">${content}</div></div>`;\r\n                el = doc.body.children[0];\r\n            }\r\n        }\r\n        else {\r\n            el = els;\r\n        }\r\n        if (!el)\r\n            return;\r\n        // Tempting to initialize the passed in opt with default and valid values, but this break knockout demos\r\n        // as the actual value are filled in when _prepareElement() calls el.getAttribute('gs-xyz') before adding the node.\r\n        // So make sure we load any DOM attributes that are not specified in passed in options (which override)\r\n        let domAttr = this._readAttr(el);\r\n        options = utils_1.Utils.cloneDeep(options) || {}; // make a copy before we modify in case caller re-uses it\r\n        utils_1.Utils.defaults(options, domAttr);\r\n        node = this.engine.prepareNode(options);\r\n        this._writeAttr(el, options);\r\n        if (this._insertNotAppend) {\r\n            this.el.prepend(el);\r\n        }\r\n        else {\r\n            this.el.appendChild(el);\r\n        }\r\n        // similar to makeWidget() that doesn't read attr again and worse re-create a new node and loose any _id\r\n        this._prepareElement(el, true, options);\r\n        this._updateContainerHeight();\r\n        // see if there is a sub-grid to create\r\n        if (node.subGrid) {\r\n            this.makeSubGrid(node.el, undefined, undefined, false); //node.subGrid will be used as option in method, no need to pass\r\n        }\r\n        // if we're adding an item into 1 column (_prevColumn is set only when going to 1) make sure\r\n        // we don't override the larger 12 column layout that was already saved. #1985\r\n        if (this._prevColumn && this.opts.column === 1) {\r\n            this._ignoreLayoutsNodeChange = true;\r\n        }\r\n        this._triggerAddEvent();\r\n        this._triggerChangeEvent();\r\n        delete this._ignoreLayoutsNodeChange;\r\n        return el;\r\n    }\r\n    /**\r\n     * Convert an existing gridItem element into a sub-grid with the given (optional) options, else inherit them\r\n     * from the parent's subGrid options.\r\n     * @param el gridItem element to convert\r\n     * @param ops (optional) sub-grid options, else default to node, then parent settings, else defaults\r\n     * @param nodeToAdd (optional) node to add to the newly created sub grid (used when dragging over existing regular item)\r\n     * @returns newly created grid\r\n     */\r\n    makeSubGrid(el, ops, nodeToAdd, saveContent = true) {\r\n        var _a, _b, _c;\r\n        let node = el.gridstackNode;\r\n        if (!node) {\r\n            node = this.makeWidget(el).gridstackNode;\r\n        }\r\n        if ((_a = node.subGrid) === null || _a === void 0 ? void 0 : _a.el)\r\n            return node.subGrid; // already done\r\n        // find the template subGrid stored on a parent as fallback...\r\n        let subGridTemplate; // eslint-disable-next-line @typescript-eslint/no-this-alias\r\n        let grid = this;\r\n        while (grid && !subGridTemplate) {\r\n            subGridTemplate = (_b = grid.opts) === null || _b === void 0 ? void 0 : _b.subGrid;\r\n            grid = (_c = grid.parentGridItem) === null || _c === void 0 ? void 0 : _c.grid;\r\n        }\r\n        //... and set the create options\r\n        ops = utils_1.Utils.cloneDeep(Object.assign(Object.assign(Object.assign({}, (subGridTemplate || {})), { children: undefined }), (ops || node.subGrid)));\r\n        node.subGrid = ops;\r\n        // if column special case it set, remember that flag and set default\r\n        let autoColumn;\r\n        if (ops.column === 'auto') {\r\n            autoColumn = true;\r\n            ops.column = Math.max(node.w || 1, (nodeToAdd === null || nodeToAdd === void 0 ? void 0 : nodeToAdd.w) || 1);\r\n            ops.disableOneColumnMode = true; // driven by parent\r\n        }\r\n        // if we're converting an existing full item, move over the content to be the first sub item in the new grid\r\n        let content = node.el.querySelector('.grid-stack-item-content');\r\n        let newItem;\r\n        let newItemOpt;\r\n        if (saveContent) {\r\n            this._removeDD(node.el); // remove D&D since it's set on content div\r\n            newItemOpt = Object.assign(Object.assign({}, node), { x: 0, y: 0 });\r\n            utils_1.Utils.removeInternalForSave(newItemOpt);\r\n            delete newItemOpt.subGrid;\r\n            if (node.content) {\r\n                newItemOpt.content = node.content;\r\n                delete node.content;\r\n            }\r\n            if (this.opts.addRemoveCB) {\r\n                newItem = this.opts.addRemoveCB(this.el, newItemOpt, true, false);\r\n            }\r\n            else {\r\n                let doc = document.implementation.createHTMLDocument(''); // IE needs a param\r\n                doc.body.innerHTML = `<div class=\"grid-stack-item\"></div>`;\r\n                newItem = doc.body.children[0];\r\n                newItem.appendChild(content);\r\n                doc.body.innerHTML = `<div class=\"grid-stack-item-content\"></div>`;\r\n                content = doc.body.children[0];\r\n                node.el.appendChild(content);\r\n            }\r\n            this._prepareDragDropByNode(node); // ... and restore original D&D\r\n        }\r\n        // if we're adding an additional item, make the container large enough to have them both\r\n        if (nodeToAdd) {\r\n            let w = autoColumn ? ops.column : node.w;\r\n            let h = node.h + nodeToAdd.h;\r\n            let style = node.el.style;\r\n            style.transition = 'none'; // show up instantly so we don't see scrollbar with nodeToAdd\r\n            this.update(node.el, { w, h });\r\n            setTimeout(() => style.transition = null); // recover animation\r\n        }\r\n        if (this.opts.addRemoveCB) {\r\n            ops.addRemoveCB = ops.addRemoveCB || this.opts.addRemoveCB;\r\n        }\r\n        let subGrid = node.subGrid = GridStack.addGrid(content, ops);\r\n        if (nodeToAdd === null || nodeToAdd === void 0 ? void 0 : nodeToAdd._moving)\r\n            subGrid._isTemp = true; // prevent re-nesting as we add over\r\n        if (autoColumn)\r\n            subGrid._autoColumn = true;\r\n        // add the original content back as a child of hte newly created grid\r\n        if (saveContent) {\r\n            subGrid.addWidget(newItem, newItemOpt);\r\n        }\r\n        // now add any additional node\r\n        if (nodeToAdd) {\r\n            if (nodeToAdd._moving) {\r\n                // create an artificial event even for the just created grid to receive this item\r\n                window.setTimeout(() => utils_1.Utils.simulateMouseEvent(nodeToAdd._event, 'mouseenter', subGrid.el), 0);\r\n            }\r\n            else {\r\n                subGrid.addWidget(node.el, node);\r\n            }\r\n        }\r\n        return subGrid;\r\n    }\r\n    /**\r\n     * called when an item was converted into a nested grid to accommodate a dragged over item, but then item leaves - return back\r\n     * to the original grid-item. Also called to remove empty sub-grids when last item is dragged out (since re-creating is simple)\r\n     */\r\n    removeAsSubGrid(nodeThatRemoved) {\r\n        var _a;\r\n        let pGrid = (_a = this.parentGridItem) === null || _a === void 0 ? void 0 : _a.grid;\r\n        if (!pGrid)\r\n            return;\r\n        pGrid.batchUpdate();\r\n        pGrid.removeWidget(this.parentGridItem.el, true, true);\r\n        this.engine.nodes.forEach(n => {\r\n            // migrate any children over and offsetting by our location\r\n            n.x += this.parentGridItem.x;\r\n            n.y += this.parentGridItem.y;\r\n            pGrid.addWidget(n.el, n);\r\n        });\r\n        pGrid.batchUpdate(false);\r\n        if (this.parentGridItem)\r\n            delete this.parentGridItem.subGrid;\r\n        delete this.parentGridItem;\r\n        // create an artificial event for the original grid now that this one is gone (got a leave, but won't get enter)\r\n        if (nodeThatRemoved) {\r\n            window.setTimeout(() => utils_1.Utils.simulateMouseEvent(nodeThatRemoved._event, 'mouseenter', pGrid.el), 0);\r\n        }\r\n    }\r\n    /**\r\n    /**\r\n     * saves the current layout returning a list of widgets for serialization which might include any nested grids.\r\n     * @param saveContent if true (default) the latest html inside .grid-stack-content will be saved to GridStackWidget.content field, else it will\r\n     * be removed.\r\n     * @param saveGridOpt if true (default false), save the grid options itself, so you can call the new GridStack.addGrid()\r\n     * to recreate everything from scratch. GridStackOptions.children would then contain the widget list instead.\r\n     * @returns list of widgets or full grid option, including .children list of widgets\r\n     */\r\n    save(saveContent = true, saveGridOpt = false) {\r\n        // return copied nodes we can modify at will...\r\n        let list = this.engine.save(saveContent);\r\n        // check for HTML content and nested grids\r\n        list.forEach(n => {\r\n            var _a;\r\n            if (saveContent && n.el && !n.subGrid) { // sub-grid are saved differently, not plain content\r\n                let sub = n.el.querySelector('.grid-stack-item-content');\r\n                n.content = sub ? sub.innerHTML : undefined;\r\n                if (!n.content)\r\n                    delete n.content;\r\n            }\r\n            else {\r\n                if (!saveContent) {\r\n                    delete n.content;\r\n                }\r\n                // check for nested grid\r\n                if ((_a = n.subGrid) === null || _a === void 0 ? void 0 : _a.el) {\r\n                    const listOrOpt = n.subGrid.save(saveContent, saveGridOpt);\r\n                    n.subGrid = (saveGridOpt ? listOrOpt : { children: listOrOpt });\r\n                }\r\n            }\r\n            delete n.el;\r\n        });\r\n        // check if save entire grid options (needed for recursive) + children...\r\n        if (saveGridOpt) {\r\n            let o = utils_1.Utils.cloneDeep(this.opts);\r\n            // delete default values that will be recreated on launch\r\n            if (o.marginBottom === o.marginTop && o.marginRight === o.marginLeft && o.marginTop === o.marginRight) {\r\n                o.margin = o.marginTop;\r\n                delete o.marginTop;\r\n                delete o.marginRight;\r\n                delete o.marginBottom;\r\n                delete o.marginLeft;\r\n            }\r\n            if (o.rtl === (this.el.style.direction === 'rtl')) {\r\n                o.rtl = 'auto';\r\n            }\r\n            if (this._isAutoCellHeight) {\r\n                o.cellHeight = 'auto';\r\n            }\r\n            if (this._autoColumn) {\r\n                o.column = 'auto';\r\n                delete o.disableOneColumnMode;\r\n            }\r\n            const origShow = o._alwaysShowResizeHandle;\r\n            delete o._alwaysShowResizeHandle;\r\n            if (origShow !== undefined) {\r\n                o.alwaysShowResizeHandle = origShow;\r\n            }\r\n            else {\r\n                delete o.alwaysShowResizeHandle;\r\n            }\r\n            utils_1.Utils.removeInternalAndSame(o, types_1.gridDefaults);\r\n            o.children = list;\r\n            return o;\r\n        }\r\n        return list;\r\n    }\r\n    /**\r\n     * load the widgets from a list. This will call update() on each (matching by id) or add/remove widgets that are not there.\r\n     *\r\n     * @param layout list of widgets definition to update/create\r\n     * @param addAndRemove boolean (default true) or callback method can be passed to control if and how missing widgets can be added/removed, giving\r\n     * the user control of insertion.\r\n     *\r\n     * @example\r\n     * see http://gridstackjs.com/demo/serialization.html\r\n     **/\r\n    load(layout, addRemove = this.opts.addRemoveCB || true) {\r\n        let items = GridStack.Utils.sort([...layout], -1, this._prevColumn || this.getColumn()); // make copy before we mod/sort\r\n        this._insertNotAppend = true; // since create in reverse order...\r\n        // if we're loading a layout into for example 1 column (_prevColumn is set only when going to 1) and items don't fit, make sure to save\r\n        // the original wanted layout so we can scale back up correctly #1471\r\n        if (this._prevColumn && this._prevColumn !== this.opts.column && items.some(n => (n.x + n.w) > this.opts.column)) {\r\n            this._ignoreLayoutsNodeChange = true; // skip layout update\r\n            this.engine.cacheLayout(items, this._prevColumn, true);\r\n        }\r\n        // if given a different callback, temporally set it as global option to creating will use it\r\n        const prevCB = this.opts.addRemoveCB;\r\n        if (typeof (addRemove) === 'function')\r\n            this.opts.addRemoveCB = addRemove;\r\n        let removed = [];\r\n        this.batchUpdate();\r\n        // see if any items are missing from new layout and need to be removed first\r\n        if (addRemove) {\r\n            let copyNodes = [...this.engine.nodes]; // don't loop through array you modify\r\n            copyNodes.forEach(n => {\r\n                let item = items.find(w => n.id === w.id);\r\n                if (!item) {\r\n                    if (this.opts.addRemoveCB)\r\n                        this.opts.addRemoveCB(this.el, n, false, false);\r\n                    removed.push(n); // batch keep track\r\n                    this.removeWidget(n.el, true, false);\r\n                }\r\n            });\r\n        }\r\n        // now add/update the widgets\r\n        items.forEach(w => {\r\n            let item = (w.id || w.id === 0) ? this.engine.nodes.find(n => n.id === w.id) : undefined;\r\n            if (item) {\r\n                this.update(item.el, w);\r\n                if (w.subGrid && w.subGrid.children) { // update any sub grid as well\r\n                    let sub = item.el.querySelector('.grid-stack');\r\n                    if (sub && sub.gridstack) {\r\n                        sub.gridstack.load(w.subGrid.children); // TODO: support updating grid options ?\r\n                        this._insertNotAppend = true; // got reset by above call\r\n                    }\r\n                }\r\n            }\r\n            else if (addRemove) {\r\n                this.addWidget(w);\r\n            }\r\n        });\r\n        this.engine.removedNodes = removed;\r\n        this.batchUpdate(false);\r\n        // after commit, clear that flag\r\n        delete this._ignoreLayoutsNodeChange;\r\n        delete this._insertNotAppend;\r\n        prevCB ? this.opts.addRemoveCB = prevCB : delete this.opts.addRemoveCB;\r\n        return this;\r\n    }\r\n    /**\r\n     * use before calling a bunch of `addWidget()` to prevent un-necessary relayouts in between (more efficient)\r\n     * and get a single event callback. You will see no changes until `batchUpdate(false)` is called.\r\n     */\r\n    batchUpdate(flag = true) {\r\n        this.engine.batchUpdate(flag);\r\n        if (!flag) {\r\n            this._triggerRemoveEvent();\r\n            this._triggerAddEvent();\r\n            this._triggerChangeEvent();\r\n        }\r\n        return this;\r\n    }\r\n    /**\r\n     * Gets current cell height.\r\n     */\r\n    getCellHeight(forcePixel = false) {\r\n        if (this.opts.cellHeight && this.opts.cellHeight !== 'auto' &&\r\n            (!forcePixel || !this.opts.cellHeightUnit || this.opts.cellHeightUnit === 'px')) {\r\n            return this.opts.cellHeight;\r\n        }\r\n        // else get first cell height\r\n        let el = this.el.querySelector('.' + this.opts.itemClass);\r\n        if (el) {\r\n            let height = utils_1.Utils.toNumber(el.getAttribute('gs-h'));\r\n            return Math.round(el.offsetHeight / height);\r\n        }\r\n        // else do entire grid and # of rows (but doesn't work if min-height is the actual constrain)\r\n        let rows = parseInt(this.el.getAttribute('gs-current-row'));\r\n        return rows ? Math.round(this.el.getBoundingClientRect().height / rows) : this.opts.cellHeight;\r\n    }\r\n    /**\r\n     * Update current cell height - see `GridStackOptions.cellHeight` for format.\r\n     * This method rebuilds an internal CSS style sheet.\r\n     * Note: You can expect performance issues if call this method too often.\r\n     *\r\n     * @param val the cell height. If not passed (undefined), cells content will be made square (match width minus margin),\r\n     * if pass 0 the CSS will be generated by the application instead.\r\n     * @param update (Optional) if false, styles will not be updated\r\n     *\r\n     * @example\r\n     * grid.cellHeight(100); // same as 100px\r\n     * grid.cellHeight('70px');\r\n     * grid.cellHeight(grid.cellWidth() * 1.2);\r\n     */\r\n    cellHeight(val, update = true) {\r\n        // if not called internally, check if we're changing mode\r\n        if (update && val !== undefined) {\r\n            if (this._isAutoCellHeight !== (val === 'auto')) {\r\n                this._isAutoCellHeight = (val === 'auto');\r\n                this._updateWindowResizeEvent();\r\n            }\r\n        }\r\n        if (val === 'initial' || val === 'auto') {\r\n            val = undefined;\r\n        }\r\n        // make item content be square\r\n        if (val === undefined) {\r\n            let marginDiff = -this.opts.marginRight - this.opts.marginLeft\r\n                + this.opts.marginTop + this.opts.marginBottom;\r\n            val = this.cellWidth() + marginDiff;\r\n        }\r\n        let data = utils_1.Utils.parseHeight(val);\r\n        if (this.opts.cellHeightUnit === data.unit && this.opts.cellHeight === data.h) {\r\n            return this;\r\n        }\r\n        this.opts.cellHeightUnit = data.unit;\r\n        this.opts.cellHeight = data.h;\r\n        if (update) {\r\n            this._updateStyles(true); // true = force re-create for current # of rows\r\n        }\r\n        return this;\r\n    }\r\n    /** Gets current cell width. */\r\n    cellWidth() {\r\n        return this._widthOrContainer() / this.getColumn();\r\n    }\r\n    /** return our expected width (or parent) for 1 column check */\r\n    _widthOrContainer() {\r\n        // use `offsetWidth` or `clientWidth` (no scrollbar) ?\r\n        // https://stackoverflow.com/questions/21064101/understanding-offsetwidth-clientwidth-scrollwidth-and-height-respectively\r\n        return (this.el.clientWidth || this.el.parentElement.clientWidth || window.innerWidth);\r\n    }\r\n    /** re-layout grid items to reclaim any empty space */\r\n    compact() {\r\n        this.engine.compact();\r\n        this._triggerChangeEvent();\r\n        return this;\r\n    }\r\n    /**\r\n     * set the number of columns in the grid. Will update existing widgets to conform to new number of columns,\r\n     * as well as cache the original layout so you can revert back to previous positions without loss.\r\n     * Requires `gridstack-extra.css` or `gridstack-extra.min.css` for [2-11],\r\n     * else you will need to generate correct CSS (see https://github.com/gridstack/gridstack.js#change-grid-columns)\r\n     * @param column - Integer > 0 (default 12).\r\n     * @param layout specify the type of re-layout that will happen (position, size, etc...).\r\n     * Note: items will never be outside of the current column boundaries. default (moveScale). Ignored for 1 column\r\n     */\r\n    column(column, layout = 'moveScale') {\r\n        if (column < 1 || this.opts.column === column)\r\n            return this;\r\n        let oldColumn = this.getColumn();\r\n        // if we go into 1 column mode (which happens if we're sized less than minW unless disableOneColumnMode is on)\r\n        // then remember the original columns so we can restore.\r\n        if (column === 1) {\r\n            this._prevColumn = oldColumn;\r\n        }\r\n        else {\r\n            delete this._prevColumn;\r\n        }\r\n        this.el.classList.remove('grid-stack-' + oldColumn);\r\n        this.el.classList.add('grid-stack-' + column);\r\n        this.opts.column = this.engine.column = column;\r\n        // update the items now - see if the dom order nodes should be passed instead (else default to current list)\r\n        let domNodes;\r\n        if (column === 1 && this.opts.oneColumnModeDomSort) {\r\n            domNodes = [];\r\n            this.getGridItems().forEach(el => {\r\n                if (el.gridstackNode) {\r\n                    domNodes.push(el.gridstackNode);\r\n                }\r\n            });\r\n            if (!domNodes.length) {\r\n                domNodes = undefined;\r\n            }\r\n        }\r\n        this.engine.updateNodeWidths(oldColumn, column, domNodes, layout);\r\n        if (this._isAutoCellHeight)\r\n            this.cellHeight();\r\n        // and trigger our event last...\r\n        this._ignoreLayoutsNodeChange = true; // skip layout update\r\n        this._triggerChangeEvent();\r\n        delete this._ignoreLayoutsNodeChange;\r\n        return this;\r\n    }\r\n    /**\r\n     * get the number of columns in the grid (default 12)\r\n     */\r\n    getColumn() {\r\n        return this.opts.column;\r\n    }\r\n    /** returns an array of grid HTML elements (no placeholder) - used to iterate through our children in DOM order */\r\n    getGridItems() {\r\n        return Array.from(this.el.children)\r\n            .filter((el) => el.matches('.' + this.opts.itemClass) && !el.matches('.' + this.opts.placeholderClass));\r\n    }\r\n    /**\r\n     * Destroys a grid instance. DO NOT CALL any methods or access any vars after this as it will free up members.\r\n     * @param removeDOM if `false` grid and items HTML elements will not be removed from the DOM (Optional. Default `true`).\r\n     */\r\n    destroy(removeDOM = true) {\r\n        if (!this.el)\r\n            return; // prevent multiple calls\r\n        this._updateWindowResizeEvent(true);\r\n        this.setStatic(true, false); // permanently removes DD but don't set CSS class (we're going away)\r\n        this.setAnimation(false);\r\n        if (!removeDOM) {\r\n            this.removeAll(removeDOM);\r\n            this.el.classList.remove(this._styleSheetClass);\r\n        }\r\n        else {\r\n            this.el.parentNode.removeChild(this.el);\r\n        }\r\n        this._removeStylesheet();\r\n        this.el.removeAttribute('gs-current-row');\r\n        if (this.parentGridItem)\r\n            delete this.parentGridItem.subGrid;\r\n        delete this.parentGridItem;\r\n        delete this.opts;\r\n        delete this._placeholder;\r\n        delete this.engine;\r\n        delete this.el.gridstack; // remove circular dependency that would prevent a freeing\r\n        delete this.el;\r\n        return this;\r\n    }\r\n    /**\r\n     * enable/disable floating widgets (default: `false`) See [example](http://gridstackjs.com/demo/float.html)\r\n     */\r\n    float(val) {\r\n        if (this.opts.float !== val) {\r\n            this.opts.float = this.engine.float = val;\r\n            this._triggerChangeEvent();\r\n        }\r\n        return this;\r\n    }\r\n    /**\r\n     * get the current float mode\r\n     */\r\n    getFloat() {\r\n        return this.engine.float;\r\n    }\r\n    /**\r\n     * Get the position of the cell under a pixel on screen.\r\n     * @param position the position of the pixel to resolve in\r\n     * absolute coordinates, as an object with top and left properties\r\n     * @param useDocRelative if true, value will be based on document position vs parent position (Optional. Default false).\r\n     * Useful when grid is within `position: relative` element\r\n     *\r\n     * Returns an object with properties `x` and `y` i.e. the column and row in the grid.\r\n     */\r\n    getCellFromPixel(position, useDocRelative = false) {\r\n        let box = this.el.getBoundingClientRect();\r\n        // console.log(`getBoundingClientRect left: ${box.left} top: ${box.top} w: ${box.w} h: ${box.h}`)\r\n        let containerPos;\r\n        if (useDocRelative) {\r\n            containerPos = { top: box.top + document.documentElement.scrollTop, left: box.left };\r\n            // console.log(`getCellFromPixel scrollTop: ${document.documentElement.scrollTop}`)\r\n        }\r\n        else {\r\n            containerPos = { top: this.el.offsetTop, left: this.el.offsetLeft };\r\n            // console.log(`getCellFromPixel offsetTop: ${containerPos.left} offsetLeft: ${containerPos.top}`)\r\n        }\r\n        let relativeLeft = position.left - containerPos.left;\r\n        let relativeTop = position.top - containerPos.top;\r\n        let columnWidth = (box.width / this.getColumn());\r\n        let rowHeight = (box.height / parseInt(this.el.getAttribute('gs-current-row')));\r\n        return { x: Math.floor(relativeLeft / columnWidth), y: Math.floor(relativeTop / rowHeight) };\r\n    }\r\n    /** returns the current number of rows, which will be at least `minRow` if set */\r\n    getRow() {\r\n        return Math.max(this.engine.getRow(), this.opts.minRow);\r\n    }\r\n    /**\r\n     * Checks if specified area is empty.\r\n     * @param x the position x.\r\n     * @param y the position y.\r\n     * @param w the width of to check\r\n     * @param h the height of to check\r\n     */\r\n    isAreaEmpty(x, y, w, h) {\r\n        return this.engine.isAreaEmpty(x, y, w, h);\r\n    }\r\n    /**\r\n     * If you add elements to your grid by hand, you have to tell gridstack afterwards to make them widgets.\r\n     * If you want gridstack to add the elements for you, use `addWidget()` instead.\r\n     * Makes the given element a widget and returns it.\r\n     * @param els widget or single selector to convert.\r\n     *\r\n     * @example\r\n     * let grid = GridStack.init();\r\n     * grid.el.appendChild('<div id=\"gsi-1\" gs-w=\"3\"></div>');\r\n     * grid.makeWidget('#gsi-1');\r\n     */\r\n    makeWidget(els) {\r\n        let el = GridStack.getElement(els);\r\n        this._prepareElement(el, true);\r\n        this._updateContainerHeight();\r\n        this._triggerAddEvent();\r\n        this._triggerChangeEvent();\r\n        return el;\r\n    }\r\n    /**\r\n     * Event handler that extracts our CustomEvent data out automatically for receiving custom\r\n     * notifications (see doc for supported events)\r\n     * @param name of the event (see possible values) or list of names space separated\r\n     * @param callback function called with event and optional second/third param\r\n     * (see README documentation for each signature).\r\n     *\r\n     * @example\r\n     * grid.on('added', function(e, items) { log('added ', items)} );\r\n     * or\r\n     * grid.on('added removed change', function(e, items) { log(e.type, items)} );\r\n     *\r\n     * Note: in some cases it is the same as calling native handler and parsing the event.\r\n     * grid.el.addEventListener('added', function(event) { log('added ', event.detail)} );\r\n     *\r\n     */\r\n    on(name, callback) {\r\n        // check for array of names being passed instead\r\n        if (name.indexOf(' ') !== -1) {\r\n            let names = name.split(' ');\r\n            names.forEach(name => this.on(name, callback));\r\n            return this;\r\n        }\r\n        if (name === 'change' || name === 'added' || name === 'removed' || name === 'enable' || name === 'disable') {\r\n            // native CustomEvent handlers - cash the generic handlers so we can easily remove\r\n            let noData = (name === 'enable' || name === 'disable');\r\n            if (noData) {\r\n                this._gsEventHandler[name] = (event) => callback(event);\r\n            }\r\n            else {\r\n                this._gsEventHandler[name] = (event) => callback(event, event.detail);\r\n            }\r\n            this.el.addEventListener(name, this._gsEventHandler[name]);\r\n        }\r\n        else if (name === 'drag' || name === 'dragstart' || name === 'dragstop' || name === 'resizestart' || name === 'resize' || name === 'resizestop' || name === 'dropped') {\r\n            // drag&drop stop events NEED to be call them AFTER we update node attributes so handle them ourself.\r\n            // do same for start event to make it easier...\r\n            this._gsEventHandler[name] = callback;\r\n        }\r\n        else {\r\n            console.log('GridStack.on(' + name + ') event not supported, but you can still use $(\".grid-stack\").on(...) while jquery-ui is still used internally.');\r\n        }\r\n        return this;\r\n    }\r\n    /**\r\n     * unsubscribe from the 'on' event below\r\n     * @param name of the event (see possible values)\r\n     */\r\n    off(name) {\r\n        // check for array of names being passed instead\r\n        if (name.indexOf(' ') !== -1) {\r\n            let names = name.split(' ');\r\n            names.forEach(name => this.off(name));\r\n            return this;\r\n        }\r\n        if (name === 'change' || name === 'added' || name === 'removed' || name === 'enable' || name === 'disable') {\r\n            // remove native CustomEvent handlers\r\n            if (this._gsEventHandler[name]) {\r\n                this.el.removeEventListener(name, this._gsEventHandler[name]);\r\n            }\r\n        }\r\n        delete this._gsEventHandler[name];\r\n        return this;\r\n    }\r\n    /**\r\n     * Removes widget from the grid.\r\n     * @param el  widget or selector to modify\r\n     * @param removeDOM if `false` DOM element won't be removed from the tree (Default? true).\r\n     * @param triggerEvent if `false` (quiet mode) element will not be added to removed list and no 'removed' callbacks will be called (Default? true).\r\n     */\r\n    removeWidget(els, removeDOM = true, triggerEvent = true) {\r\n        GridStack.getElements(els).forEach(el => {\r\n            if (el.parentElement && el.parentElement !== this.el)\r\n                return; // not our child!\r\n            let node = el.gridstackNode;\r\n            // For Meteor support: https://github.com/gridstack/gridstack.js/pull/272\r\n            if (!node) {\r\n                node = this.engine.nodes.find(n => el === n.el);\r\n            }\r\n            if (!node)\r\n                return;\r\n            // remove our DOM data (circular link) and drag&drop permanently\r\n            delete el.gridstackNode;\r\n            this._removeDD(el);\r\n            this.engine.removeNode(node, removeDOM, triggerEvent);\r\n            if (removeDOM && el.parentElement) {\r\n                el.remove(); // in batch mode engine.removeNode doesn't call back to remove DOM\r\n            }\r\n        });\r\n        if (triggerEvent) {\r\n            this._triggerRemoveEvent();\r\n            this._triggerChangeEvent();\r\n        }\r\n        return this;\r\n    }\r\n    /**\r\n     * Removes all widgets from the grid.\r\n     * @param removeDOM if `false` DOM elements won't be removed from the tree (Default? `true`).\r\n     */\r\n    removeAll(removeDOM = true) {\r\n        // always remove our DOM data (circular link) before list gets emptied and drag&drop permanently\r\n        this.engine.nodes.forEach(n => {\r\n            delete n.el.gridstackNode;\r\n            this._removeDD(n.el);\r\n        });\r\n        this.engine.removeAll(removeDOM);\r\n        this._triggerRemoveEvent();\r\n        return this;\r\n    }\r\n    /**\r\n     * Toggle the grid animation state.  Toggles the `grid-stack-animate` class.\r\n     * @param doAnimate if true the grid will animate.\r\n     */\r\n    setAnimation(doAnimate) {\r\n        if (doAnimate) {\r\n            this.el.classList.add('grid-stack-animate');\r\n        }\r\n        else {\r\n            this.el.classList.remove('grid-stack-animate');\r\n        }\r\n        return this;\r\n    }\r\n    /**\r\n     * Toggle the grid static state, which permanently removes/add Drag&Drop support, unlike disable()/enable() that just turns it off/on.\r\n     * Also toggle the grid-stack-static class.\r\n     * @param val if true the grid become static.\r\n     * @param updateClass true (default) if css class gets updated\r\n     * @param recurse true (default) if sub-grids also get updated\r\n     */\r\n    setStatic(val, updateClass = true, recurse = true) {\r\n        if (this.opts.staticGrid === val)\r\n            return this;\r\n        this.opts.staticGrid = val;\r\n        this._setupRemoveDrop();\r\n        this._setupAcceptWidget();\r\n        this.engine.nodes.forEach(n => {\r\n            this._prepareDragDropByNode(n); // either delete or init Drag&drop\r\n            if (n.subGrid && recurse)\r\n                n.subGrid.setStatic(val, updateClass, recurse);\r\n        });\r\n        if (updateClass) {\r\n            this._setStaticClass();\r\n        }\r\n        return this;\r\n    }\r\n    /**\r\n     * Updates widget position/size and other info. Note: if you need to call this on all nodes, use load() instead which will update what changed.\r\n     * @param els  widget or selector of objects to modify (note: setting the same x,y for multiple items will be indeterministic and likely unwanted)\r\n     * @param opt new widget options (x,y,w,h, etc..). Only those set will be updated.\r\n     */\r\n    update(els, opt) {\r\n        // support legacy call for now ?\r\n        if (arguments.length > 2) {\r\n            console.warn('gridstack.ts: `update(el, x, y, w, h)` is deprecated. Use `update(el, {x, w, content, ...})`. It will be removed soon');\r\n            // eslint-disable-next-line prefer-rest-params\r\n            let a = arguments, i = 1;\r\n            opt = { x: a[i++], y: a[i++], w: a[i++], h: a[i++] };\r\n            return this.update(els, opt);\r\n        }\r\n        GridStack.getElements(els).forEach(el => {\r\n            if (!el || !el.gridstackNode)\r\n                return;\r\n            let n = el.gridstackNode;\r\n            let w = utils_1.Utils.cloneDeep(opt); // make a copy we can modify in case they re-use it or multiple items\r\n            delete w.autoPosition;\r\n            // move/resize widget if anything changed\r\n            let keys = ['x', 'y', 'w', 'h'];\r\n            let m;\r\n            if (keys.some(k => w[k] !== undefined && w[k] !== n[k])) {\r\n                m = {};\r\n                keys.forEach(k => {\r\n                    m[k] = (w[k] !== undefined) ? w[k] : n[k];\r\n                    delete w[k];\r\n                });\r\n            }\r\n            // for a move as well IFF there is any min/max fields set\r\n            if (!m && (w.minW || w.minH || w.maxW || w.maxH)) {\r\n                m = {}; // will use node position but validate values\r\n            }\r\n            // check for content changing\r\n            if (w.content) {\r\n                let sub = el.querySelector('.grid-stack-item-content');\r\n                if (sub && sub.innerHTML !== w.content) {\r\n                    sub.innerHTML = w.content;\r\n                }\r\n                delete w.content;\r\n            }\r\n            // any remaining fields are assigned, but check for dragging changes, resize constrain\r\n            let changed = false;\r\n            let ddChanged = false;\r\n            for (const key in w) {\r\n                if (key[0] !== '_' && n[key] !== w[key]) {\r\n                    n[key] = w[key];\r\n                    changed = true;\r\n                    ddChanged = ddChanged || (!this.opts.staticGrid && (key === 'noResize' || key === 'noMove' || key === 'locked'));\r\n                }\r\n            }\r\n            // finally move the widget\r\n            if (m) {\r\n                this.engine.cleanNodes()\r\n                    .beginUpdate(n)\r\n                    .moveNode(n, m);\r\n                this._updateContainerHeight();\r\n                this._triggerChangeEvent();\r\n                this.engine.endUpdate();\r\n            }\r\n            if (changed) { // move will only update x,y,w,h so update the rest too\r\n                this._writeAttr(el, n);\r\n            }\r\n            if (ddChanged) {\r\n                this._prepareDragDropByNode(n);\r\n            }\r\n        });\r\n        return this;\r\n    }\r\n    /**\r\n     * Updates the margins which will set all 4 sides at once - see `GridStackOptions.margin` for format options (CSS string format of 1,2,4 values or single number).\r\n     * @param value margin value\r\n     */\r\n    margin(value) {\r\n        let isMultiValue = (typeof value === 'string' && value.split(' ').length > 1);\r\n        // check if we can skip re-creating our CSS file... won't check if multi values (too much hassle)\r\n        if (!isMultiValue) {\r\n            let data = utils_1.Utils.parseHeight(value);\r\n            if (this.opts.marginUnit === data.unit && this.opts.margin === data.h)\r\n                return;\r\n        }\r\n        // re-use existing margin handling\r\n        this.opts.margin = value;\r\n        this.opts.marginTop = this.opts.marginBottom = this.opts.marginLeft = this.opts.marginRight = undefined;\r\n        this._initMargin();\r\n        this._updateStyles(true); // true = force re-create\r\n        return this;\r\n    }\r\n    /** returns current margin number value (undefined if 4 sides don't match) */\r\n    getMargin() { return this.opts.margin; }\r\n    /**\r\n     * Returns true if the height of the grid will be less than the vertical\r\n     * constraint. Always returns true if grid doesn't have height constraint.\r\n     * @param node contains x,y,w,h,auto-position options\r\n     *\r\n     * @example\r\n     * if (grid.willItFit(newWidget)) {\r\n     *   grid.addWidget(newWidget);\r\n     * } else {\r\n     *   alert('Not enough free space to place the widget');\r\n     * }\r\n     */\r\n    willItFit(node) {\r\n        // support legacy call for now\r\n        if (arguments.length > 1) {\r\n            console.warn('gridstack.ts: `willItFit(x,y,w,h,autoPosition)` is deprecated. Use `willItFit({x, y,...})`. It will be removed soon');\r\n            // eslint-disable-next-line prefer-rest-params\r\n            let a = arguments, i = 0, w = { x: a[i++], y: a[i++], w: a[i++], h: a[i++], autoPosition: a[i++] };\r\n            return this.willItFit(w);\r\n        }\r\n        return this.engine.willItFit(node);\r\n    }\r\n    /** @internal */\r\n    _triggerChangeEvent() {\r\n        if (this.engine.batchMode)\r\n            return this;\r\n        let elements = this.engine.getDirtyNodes(true); // verify they really changed\r\n        if (elements && elements.length) {\r\n            if (!this._ignoreLayoutsNodeChange) {\r\n                this.engine.layoutsNodesChange(elements);\r\n            }\r\n            this._triggerEvent('change', elements);\r\n        }\r\n        this.engine.saveInitial(); // we called, now reset initial values & dirty flags\r\n        return this;\r\n    }\r\n    /** @internal */\r\n    _triggerAddEvent() {\r\n        if (this.engine.batchMode)\r\n            return this;\r\n        if (this.engine.addedNodes && this.engine.addedNodes.length > 0) {\r\n            if (!this._ignoreLayoutsNodeChange) {\r\n                this.engine.layoutsNodesChange(this.engine.addedNodes);\r\n            }\r\n            // prevent added nodes from also triggering 'change' event (which is called next)\r\n            this.engine.addedNodes.forEach(n => { delete n._dirty; });\r\n            this._triggerEvent('added', this.engine.addedNodes);\r\n            this.engine.addedNodes = [];\r\n        }\r\n        return this;\r\n    }\r\n    /** @internal */\r\n    _triggerRemoveEvent() {\r\n        if (this.engine.batchMode)\r\n            return this;\r\n        if (this.engine.removedNodes && this.engine.removedNodes.length > 0) {\r\n            this._triggerEvent('removed', this.engine.removedNodes);\r\n            this.engine.removedNodes = [];\r\n        }\r\n        return this;\r\n    }\r\n    /** @internal */\r\n    _triggerEvent(type, data) {\r\n        let event = data ? new CustomEvent(type, { bubbles: false, detail: data }) : new Event(type);\r\n        this.el.dispatchEvent(event);\r\n        return this;\r\n    }\r\n    /** @internal called to delete the current dynamic style sheet used for our layout */\r\n    _removeStylesheet() {\r\n        if (this._styles) {\r\n            utils_1.Utils.removeStylesheet(this._styleSheetClass);\r\n            delete this._styles;\r\n        }\r\n        return this;\r\n    }\r\n    /** @internal updated/create the CSS styles for row based layout and initial margin setting */\r\n    _updateStyles(forceUpdate = false, maxH) {\r\n        // call to delete existing one if we change cellHeight / margin\r\n        if (forceUpdate) {\r\n            this._removeStylesheet();\r\n        }\r\n        if (!maxH)\r\n            maxH = this.getRow();\r\n        this._updateContainerHeight();\r\n        // if user is telling us they will handle the CSS themselves by setting heights to 0. Do we need this opts really ??\r\n        if (this.opts.cellHeight === 0) {\r\n            return this;\r\n        }\r\n        let cellHeight = this.opts.cellHeight;\r\n        let cellHeightUnit = this.opts.cellHeightUnit;\r\n        let prefix = `.${this._styleSheetClass} > .${this.opts.itemClass}`;\r\n        // create one as needed\r\n        if (!this._styles) {\r\n            // insert style to parent (instead of 'head' by default) to support WebComponent\r\n            let styleLocation = this.opts.styleInHead ? undefined : this.el.parentNode;\r\n            this._styles = utils_1.Utils.createStylesheet(this._styleSheetClass, styleLocation, {\r\n                nonce: this.opts.nonce,\r\n            });\r\n            if (!this._styles)\r\n                return this;\r\n            this._styles._max = 0;\r\n            // these are done once only\r\n            utils_1.Utils.addCSSRule(this._styles, prefix, `min-height: ${cellHeight}${cellHeightUnit}`);\r\n            // content margins\r\n            let top = this.opts.marginTop + this.opts.marginUnit;\r\n            let bottom = this.opts.marginBottom + this.opts.marginUnit;\r\n            let right = this.opts.marginRight + this.opts.marginUnit;\r\n            let left = this.opts.marginLeft + this.opts.marginUnit;\r\n            let content = `${prefix} > .grid-stack-item-content`;\r\n            let placeholder = `.${this._styleSheetClass} > .grid-stack-placeholder > .placeholder-content`;\r\n            utils_1.Utils.addCSSRule(this._styles, content, `top: ${top}; right: ${right}; bottom: ${bottom}; left: ${left};`);\r\n            utils_1.Utils.addCSSRule(this._styles, placeholder, `top: ${top}; right: ${right}; bottom: ${bottom}; left: ${left};`);\r\n            // resize handles offset (to match margin)\r\n            utils_1.Utils.addCSSRule(this._styles, `${prefix} > .ui-resizable-ne`, `right: ${right}`);\r\n            utils_1.Utils.addCSSRule(this._styles, `${prefix} > .ui-resizable-e`, `right: ${right}`);\r\n            utils_1.Utils.addCSSRule(this._styles, `${prefix} > .ui-resizable-se`, `right: ${right}; bottom: ${bottom}`);\r\n            utils_1.Utils.addCSSRule(this._styles, `${prefix} > .ui-resizable-nw`, `left: ${left}`);\r\n            utils_1.Utils.addCSSRule(this._styles, `${prefix} > .ui-resizable-w`, `left: ${left}`);\r\n            utils_1.Utils.addCSSRule(this._styles, `${prefix} > .ui-resizable-sw`, `left: ${left}; bottom: ${bottom}`);\r\n        }\r\n        // now update the height specific fields\r\n        maxH = maxH || this._styles._max;\r\n        if (maxH > this._styles._max) {\r\n            let getHeight = (rows) => (cellHeight * rows) + cellHeightUnit;\r\n            for (let i = this._styles._max + 1; i <= maxH; i++) { // start at 1\r\n                let h = getHeight(i);\r\n                utils_1.Utils.addCSSRule(this._styles, `${prefix}[gs-y=\"${i - 1}\"]`, `top: ${getHeight(i - 1)}`); // start at 0\r\n                utils_1.Utils.addCSSRule(this._styles, `${prefix}[gs-h=\"${i}\"]`, `height: ${h}`);\r\n                utils_1.Utils.addCSSRule(this._styles, `${prefix}[gs-min-h=\"${i}\"]`, `min-height: ${h}`);\r\n                utils_1.Utils.addCSSRule(this._styles, `${prefix}[gs-max-h=\"${i}\"]`, `max-height: ${h}`);\r\n            }\r\n            this._styles._max = maxH;\r\n        }\r\n        return this;\r\n    }\r\n    /** @internal */\r\n    _updateContainerHeight() {\r\n        if (!this.engine || this.engine.batchMode)\r\n            return this;\r\n        let row = this.getRow() + this._extraDragRow; // checks for minRow already\r\n        // check for css min height\r\n        // Note: we don't handle %,rem correctly so comment out, beside we don't need need to create un-necessary\r\n        // rows as the CSS will make us bigger than our set height if needed... not sure why we had this.\r\n        // let cssMinHeight = parseInt(getComputedStyle(this.el)['min-height']);\r\n        // if (cssMinHeight > 0) {\r\n        //   let minRow = Math.round(cssMinHeight / this.getCellHeight(true));\r\n        //   if (row < minRow) {\r\n        //     row = minRow;\r\n        //   }\r\n        // }\r\n        this.el.setAttribute('gs-current-row', String(row));\r\n        if (row === 0) {\r\n            this.el.style.removeProperty('min-height');\r\n            return this;\r\n        }\r\n        let cellHeight = this.opts.cellHeight;\r\n        let unit = this.opts.cellHeightUnit;\r\n        if (!cellHeight)\r\n            return this;\r\n        this.el.style.minHeight = row * cellHeight + unit;\r\n        return this;\r\n    }\r\n    /** @internal */\r\n    _prepareElement(el, triggerAddEvent = false, node) {\r\n        el.classList.add(this.opts.itemClass);\r\n        node = node || this._readAttr(el);\r\n        el.gridstackNode = node;\r\n        node.el = el;\r\n        node.grid = this;\r\n        let copy = Object.assign({}, node);\r\n        node = this.engine.addNode(node, triggerAddEvent);\r\n        // write node attr back in case there was collision or we have to fix bad values during addNode()\r\n        if (!utils_1.Utils.same(node, copy)) {\r\n            this._writeAttr(el, node);\r\n        }\r\n        this._prepareDragDropByNode(node);\r\n        return this;\r\n    }\r\n    /** @internal call to write position x,y,w,h attributes back to element */\r\n    _writePosAttr(el, n) {\r\n        if (n.x !== undefined && n.x !== null) {\r\n            el.setAttribute('gs-x', String(n.x));\r\n        }\r\n        if (n.y !== undefined && n.y !== null) {\r\n            el.setAttribute('gs-y', String(n.y));\r\n        }\r\n        if (n.w) {\r\n            el.setAttribute('gs-w', String(n.w));\r\n        }\r\n        if (n.h) {\r\n            el.setAttribute('gs-h', String(n.h));\r\n        }\r\n        return this;\r\n    }\r\n    /** @internal call to write any default attributes back to element */\r\n    _writeAttr(el, node) {\r\n        if (!node)\r\n            return this;\r\n        this._writePosAttr(el, node);\r\n        let attrs /*: GridStackWidget but strings */ = {\r\n            autoPosition: 'gs-auto-position',\r\n            minW: 'gs-min-w',\r\n            minH: 'gs-min-h',\r\n            maxW: 'gs-max-w',\r\n            maxH: 'gs-max-h',\r\n            noResize: 'gs-no-resize',\r\n            noMove: 'gs-no-move',\r\n            locked: 'gs-locked',\r\n            id: 'gs-id',\r\n        };\r\n        for (const key in attrs) {\r\n            if (node[key]) { // 0 is valid for x,y only but done above already and not in list anyway\r\n                el.setAttribute(attrs[key], String(node[key]));\r\n            }\r\n            else {\r\n                el.removeAttribute(attrs[key]);\r\n            }\r\n        }\r\n        return this;\r\n    }\r\n    /** @internal call to read any default attributes from element */\r\n    _readAttr(el) {\r\n        let node = {};\r\n        node.x = utils_1.Utils.toNumber(el.getAttribute('gs-x'));\r\n        node.y = utils_1.Utils.toNumber(el.getAttribute('gs-y'));\r\n        node.w = utils_1.Utils.toNumber(el.getAttribute('gs-w'));\r\n        node.h = utils_1.Utils.toNumber(el.getAttribute('gs-h'));\r\n        node.maxW = utils_1.Utils.toNumber(el.getAttribute('gs-max-w'));\r\n        node.minW = utils_1.Utils.toNumber(el.getAttribute('gs-min-w'));\r\n        node.maxH = utils_1.Utils.toNumber(el.getAttribute('gs-max-h'));\r\n        node.minH = utils_1.Utils.toNumber(el.getAttribute('gs-min-h'));\r\n        node.autoPosition = utils_1.Utils.toBool(el.getAttribute('gs-auto-position'));\r\n        node.noResize = utils_1.Utils.toBool(el.getAttribute('gs-no-resize'));\r\n        node.noMove = utils_1.Utils.toBool(el.getAttribute('gs-no-move'));\r\n        node.locked = utils_1.Utils.toBool(el.getAttribute('gs-locked'));\r\n        node.id = el.getAttribute('gs-id');\r\n        // remove any key not found (null or false which is default)\r\n        for (const key in node) {\r\n            if (!node.hasOwnProperty(key))\r\n                return;\r\n            if (!node[key] && node[key] !== 0) { // 0 can be valid value (x,y only really)\r\n                delete node[key];\r\n            }\r\n        }\r\n        return node;\r\n    }\r\n    /** @internal */\r\n    _setStaticClass() {\r\n        let classes = ['grid-stack-static'];\r\n        if (this.opts.staticGrid) {\r\n            this.el.classList.add(...classes);\r\n            this.el.setAttribute('gs-static', 'true');\r\n        }\r\n        else {\r\n            this.el.classList.remove(...classes);\r\n            this.el.removeAttribute('gs-static');\r\n        }\r\n        return this;\r\n    }\r\n    /**\r\n     * called when we are being resized by the window - check if the one Column Mode needs to be turned on/off\r\n     * and remember the prev columns we used, or get our count from parent, as well as check for auto cell height (square)\r\n     */\r\n    onParentResize() {\r\n        if (!this.el || !this.el.clientWidth)\r\n            return; // return if we're gone or no size yet (will get called again)\r\n        let changedColumn = false;\r\n        // see if we're nested and take our column count from our parent....\r\n        if (this._autoColumn && this.parentGridItem) {\r\n            if (this.opts.column !== this.parentGridItem.w) {\r\n                changedColumn = true;\r\n                this.column(this.parentGridItem.w, 'none');\r\n            }\r\n        }\r\n        else {\r\n            // else check for 1 column in/out behavior\r\n            let oneColumn = !this.opts.disableOneColumnMode && this.el.clientWidth <= this.opts.oneColumnSize;\r\n            if ((this.opts.column === 1) !== oneColumn) {\r\n                changedColumn = true;\r\n                if (this.opts.animate) {\r\n                    this.setAnimation(false);\r\n                } // 1 <-> 12 is too radical, turn off animation\r\n                this.column(oneColumn ? 1 : this._prevColumn);\r\n                if (this.opts.animate) {\r\n                    this.setAnimation(true);\r\n                }\r\n            }\r\n        }\r\n        // make the cells content square again\r\n        if (this._isAutoCellHeight) {\r\n            if (!changedColumn && this.opts.cellHeightThrottle) {\r\n                if (!this._cellHeightThrottle) {\r\n                    this._cellHeightThrottle = utils_1.Utils.throttle(() => this.cellHeight(), this.opts.cellHeightThrottle);\r\n                }\r\n                this._cellHeightThrottle();\r\n            }\r\n            else {\r\n                // immediate update if we've changed column count or have no threshold\r\n                this.cellHeight();\r\n            }\r\n        }\r\n        // finally update any nested grids\r\n        this.engine.nodes.forEach(n => {\r\n            if (n.subGrid) {\r\n                n.subGrid.onParentResize();\r\n            }\r\n        });\r\n        return this;\r\n    }\r\n    /** add or remove the window size event handler */\r\n    _updateWindowResizeEvent(forceRemove = false) {\r\n        // only add event if we're not nested (parent will call us) and we're auto sizing cells or supporting oneColumn (i.e. doing work)\r\n        const workTodo = (this._isAutoCellHeight || !this.opts.disableOneColumnMode) && !this.parentGridItem;\r\n        if (!forceRemove && workTodo && !this._windowResizeBind) {\r\n            this._windowResizeBind = this.onParentResize.bind(this); // so we can properly remove later\r\n            window.addEventListener('resize', this._windowResizeBind);\r\n        }\r\n        else if ((forceRemove || !workTodo) && this._windowResizeBind) {\r\n            window.removeEventListener('resize', this._windowResizeBind);\r\n            delete this._windowResizeBind; // remove link to us so we can free\r\n        }\r\n        return this;\r\n    }\r\n    /** @internal convert a potential selector into actual element */\r\n    static getElement(els = '.grid-stack-item') { return utils_1.Utils.getElement(els); }\r\n    /** @internal */\r\n    static getElements(els = '.grid-stack-item') { return utils_1.Utils.getElements(els); }\r\n    /** @internal */\r\n    static getGridElement(els) { return GridStack.getElement(els); }\r\n    /** @internal */\r\n    static getGridElements(els) { return utils_1.Utils.getElements(els); }\r\n    /** @internal initialize margin top/bottom/left/right and units */\r\n    _initMargin() {\r\n        let data;\r\n        let margin = 0;\r\n        // support passing multiple values like CSS (ex: '5px 10px 0 20px')\r\n        let margins = [];\r\n        if (typeof this.opts.margin === 'string') {\r\n            margins = this.opts.margin.split(' ');\r\n        }\r\n        if (margins.length === 2) { // top/bot, left/right like CSS\r\n            this.opts.marginTop = this.opts.marginBottom = margins[0];\r\n            this.opts.marginLeft = this.opts.marginRight = margins[1];\r\n        }\r\n        else if (margins.length === 4) { // Clockwise like CSS\r\n            this.opts.marginTop = margins[0];\r\n            this.opts.marginRight = margins[1];\r\n            this.opts.marginBottom = margins[2];\r\n            this.opts.marginLeft = margins[3];\r\n        }\r\n        else {\r\n            data = utils_1.Utils.parseHeight(this.opts.margin);\r\n            this.opts.marginUnit = data.unit;\r\n            margin = this.opts.margin = data.h;\r\n        }\r\n        // see if top/bottom/left/right need to be set as well\r\n        if (this.opts.marginTop === undefined) {\r\n            this.opts.marginTop = margin;\r\n        }\r\n        else {\r\n            data = utils_1.Utils.parseHeight(this.opts.marginTop);\r\n            this.opts.marginTop = data.h;\r\n            delete this.opts.margin;\r\n        }\r\n        if (this.opts.marginBottom === undefined) {\r\n            this.opts.marginBottom = margin;\r\n        }\r\n        else {\r\n            data = utils_1.Utils.parseHeight(this.opts.marginBottom);\r\n            this.opts.marginBottom = data.h;\r\n            delete this.opts.margin;\r\n        }\r\n        if (this.opts.marginRight === undefined) {\r\n            this.opts.marginRight = margin;\r\n        }\r\n        else {\r\n            data = utils_1.Utils.parseHeight(this.opts.marginRight);\r\n            this.opts.marginRight = data.h;\r\n            delete this.opts.margin;\r\n        }\r\n        if (this.opts.marginLeft === undefined) {\r\n            this.opts.marginLeft = margin;\r\n        }\r\n        else {\r\n            data = utils_1.Utils.parseHeight(this.opts.marginLeft);\r\n            this.opts.marginLeft = data.h;\r\n            delete this.opts.margin;\r\n        }\r\n        this.opts.marginUnit = data.unit; // in case side were spelled out, use those units instead...\r\n        if (this.opts.marginTop === this.opts.marginBottom && this.opts.marginLeft === this.opts.marginRight && this.opts.marginTop === this.opts.marginRight) {\r\n            this.opts.margin = this.opts.marginTop; // makes it easier to check for no-ops in setMargin()\r\n        }\r\n        return this;\r\n    }\r\n    /* ===========================================================================================\r\n     * drag&drop methods that used to be stubbed out and implemented in dd-gridstack.ts\r\n     * but caused loading issues in prod - see https://github.com/gridstack/gridstack.js/issues/2039\r\n     * ===========================================================================================\r\n     */\r\n    /** get the global (but static to this code) DD implementation */\r\n    static getDD() {\r\n        return dd;\r\n    }\r\n    /**\r\n     * call to setup dragging in from the outside (say toolbar), by specifying the class selection and options.\r\n     * Called during GridStack.init() as options, but can also be called directly (last param are used) in case the toolbar\r\n     * is dynamically create and needs to be set later.\r\n     * @param dragIn string selector (ex: '.sidebar .grid-stack-item')\r\n     * @param dragInOptions options - see DDDragInOpt. (default: {handle: '.grid-stack-item-content', appendTo: 'body'}\r\n     **/\r\n    static setupDragIn(dragIn, dragInOptions) {\r\n        if ((dragInOptions === null || dragInOptions === void 0 ? void 0 : dragInOptions.pause) !== undefined) {\r\n            dd_manager_1.DDManager.pauseDrag = dragInOptions.pause;\r\n        }\r\n        if (typeof dragIn === 'string') {\r\n            dragInOptions = Object.assign(Object.assign({}, types_1.dragInDefaultOptions), (dragInOptions || {}));\r\n            utils_1.Utils.getElements(dragIn).forEach(el => {\r\n                if (!dd.isDraggable(el))\r\n                    dd.dragIn(el, dragInOptions);\r\n            });\r\n        }\r\n    }\r\n    /**\r\n     * Enables/Disables dragging by the user of specific grid element. If you want all items, and have it affect future items, use enableMove() instead. No-op for static grids.\r\n     * IF you are looking to prevent an item from moving (due to being pushed around by another during collision) use locked property instead.\r\n     * @param els widget or selector to modify.\r\n     * @param val if true widget will be draggable.\r\n     */\r\n    movable(els, val) {\r\n        if (this.opts.staticGrid)\r\n            return this; // can't move a static grid!\r\n        GridStack.getElements(els).forEach(el => {\r\n            let node = el.gridstackNode;\r\n            if (!node)\r\n                return;\r\n            if (val)\r\n                delete node.noMove;\r\n            else\r\n                node.noMove = true;\r\n            this._prepareDragDropByNode(node); // init DD if need be, and adjust\r\n        });\r\n        return this;\r\n    }\r\n    /**\r\n     * Enables/Disables user resizing of specific grid element. If you want all items, and have it affect future items, use enableResize() instead. No-op for static grids.\r\n     * @param els  widget or selector to modify\r\n     * @param val  if true widget will be resizable.\r\n     */\r\n    resizable(els, val) {\r\n        if (this.opts.staticGrid)\r\n            return this; // can't resize a static grid!\r\n        GridStack.getElements(els).forEach(el => {\r\n            let node = el.gridstackNode;\r\n            if (!node)\r\n                return;\r\n            if (val)\r\n                delete node.noResize;\r\n            else\r\n                node.noResize = true;\r\n            this._prepareDragDropByNode(node); // init DD if need be, and adjust\r\n        });\r\n        return this;\r\n    }\r\n    /**\r\n     * Temporarily disables widgets moving/resizing.\r\n     * If you want a more permanent way (which freezes up resources) use `setStatic(true)` instead.\r\n     * Note: no-op for static grid\r\n     * This is a shortcut for:\r\n     * @example\r\n     *  grid.enableMove(false);\r\n     *  grid.enableResize(false);\r\n     * @param recurse true (default) if sub-grids also get updated\r\n     */\r\n    disable(recurse = true) {\r\n        if (this.opts.staticGrid)\r\n            return;\r\n        this.enableMove(false, recurse);\r\n        this.enableResize(false, recurse); // @ts-ignore\r\n        this._triggerEvent('disable');\r\n        return this;\r\n    }\r\n    /**\r\n     * Re-enables widgets moving/resizing - see disable().\r\n     * Note: no-op for static grid.\r\n     * This is a shortcut for:\r\n     * @example\r\n     *  grid.enableMove(true);\r\n     *  grid.enableResize(true);\r\n     * @param recurse true (default) if sub-grids also get updated\r\n     */\r\n    enable(recurse = true) {\r\n        if (this.opts.staticGrid)\r\n            return;\r\n        this.enableMove(true, recurse);\r\n        this.enableResize(true, recurse); // @ts-ignore\r\n        this._triggerEvent('enable');\r\n        return this;\r\n    }\r\n    /**\r\n     * Enables/disables widget moving. No-op for static grids.\r\n     * @param recurse true (default) if sub-grids also get updated\r\n     */\r\n    enableMove(doEnable, recurse = true) {\r\n        if (this.opts.staticGrid)\r\n            return this; // can't move a static grid!\r\n        this.opts.disableDrag = !doEnable; // FIRST before we update children as grid overrides #1658\r\n        this.engine.nodes.forEach(n => {\r\n            this.movable(n.el, doEnable);\r\n            if (n.subGrid && recurse)\r\n                n.subGrid.enableMove(doEnable, recurse);\r\n        });\r\n        return this;\r\n    }\r\n    /**\r\n     * Enables/disables widget resizing. No-op for static grids.\r\n     * @param recurse true (default) if sub-grids also get updated\r\n     */\r\n    enableResize(doEnable, recurse = true) {\r\n        if (this.opts.staticGrid)\r\n            return this; // can't size a static grid!\r\n        this.opts.disableResize = !doEnable; // FIRST before we update children as grid overrides #1658\r\n        this.engine.nodes.forEach(n => {\r\n            this.resizable(n.el, doEnable);\r\n            if (n.subGrid && recurse)\r\n                n.subGrid.enableResize(doEnable, recurse);\r\n        });\r\n        return this;\r\n    }\r\n    /** @internal removes any drag&drop present (called during destroy) */\r\n    _removeDD(el) {\r\n        dd.draggable(el, 'destroy').resizable(el, 'destroy');\r\n        if (el.gridstackNode) {\r\n            delete el.gridstackNode._initDD; // reset our DD init flag\r\n        }\r\n        delete el.ddElement;\r\n        return this;\r\n    }\r\n    /** @internal called to add drag over to support widgets being added externally */\r\n    _setupAcceptWidget() {\r\n        // check if we need to disable things\r\n        if (this.opts.staticGrid || (!this.opts.acceptWidgets && !this.opts.removable)) {\r\n            dd.droppable(this.el, 'destroy');\r\n            return this;\r\n        }\r\n        // vars shared across all methods\r\n        let cellHeight, cellWidth;\r\n        let onDrag = (event, el, helper) => {\r\n            let node = el.gridstackNode;\r\n            if (!node)\r\n                return;\r\n            helper = helper || el;\r\n            let parent = this.el.getBoundingClientRect();\r\n            let { top, left } = helper.getBoundingClientRect();\r\n            left -= parent.left;\r\n            top -= parent.top;\r\n            let ui = { position: { top, left } };\r\n            if (node._temporaryRemoved) {\r\n                node.x = Math.max(0, Math.round(left / cellWidth));\r\n                node.y = Math.max(0, Math.round(top / cellHeight));\r\n                delete node.autoPosition;\r\n                this.engine.nodeBoundFix(node);\r\n                // don't accept *initial* location if doesn't fit #1419 (locked drop region, or can't grow), but maybe try if it will go somewhere\r\n                if (!this.engine.willItFit(node)) {\r\n                    node.autoPosition = true; // ignore x,y and try for any slot...\r\n                    if (!this.engine.willItFit(node)) {\r\n                        dd.off(el, 'drag'); // stop calling us\r\n                        return; // full grid or can't grow\r\n                    }\r\n                    if (node._willFitPos) {\r\n                        // use the auto position instead #1687\r\n                        utils_1.Utils.copyPos(node, node._willFitPos);\r\n                        delete node._willFitPos;\r\n                    }\r\n                }\r\n                // re-use the existing node dragging method\r\n                this._onStartMoving(helper, event, ui, node, cellWidth, cellHeight);\r\n            }\r\n            else {\r\n                // re-use the existing node dragging that does so much of the collision detection\r\n                this._dragOrResize(helper, event, ui, node, cellWidth, cellHeight);\r\n            }\r\n        };\r\n        dd.droppable(this.el, {\r\n            accept: (el) => {\r\n                let node = el.gridstackNode;\r\n                // set accept drop to true on ourself (which we ignore) so we don't get \"can't drop\" icon in HTML5 mode while moving\r\n                if ((node === null || node === void 0 ? void 0 : node.grid) === this)\r\n                    return true;\r\n                if (!this.opts.acceptWidgets)\r\n                    return false;\r\n                // check for accept method or class matching\r\n                let canAccept = true;\r\n                if (typeof this.opts.acceptWidgets === 'function') {\r\n                    canAccept = this.opts.acceptWidgets(el);\r\n                }\r\n                else {\r\n                    let selector = (this.opts.acceptWidgets === true ? '.grid-stack-item' : this.opts.acceptWidgets);\r\n                    canAccept = el.matches(selector);\r\n                }\r\n                // finally check to make sure we actually have space left #1571\r\n                if (canAccept && node && this.opts.maxRow) {\r\n                    let n = { w: node.w, h: node.h, minW: node.minW, minH: node.minH }; // only width/height matters and autoPosition\r\n                    canAccept = this.engine.willItFit(n);\r\n                }\r\n                return canAccept;\r\n            }\r\n        })\r\n            /**\r\n             * entering our grid area\r\n             */\r\n            .on(this.el, 'dropover', (event, el, helper) => {\r\n            // console.log(`over ${this.el.gridstack.opts.id} ${count++}`); // TEST\r\n            let node = el.gridstackNode;\r\n            // ignore drop enter on ourself (unless we temporarily removed) which happens on a simple drag of our item\r\n            if ((node === null || node === void 0 ? void 0 : node.grid) === this && !node._temporaryRemoved) {\r\n                // delete node._added; // reset this to track placeholder again in case we were over other grid #1484 (dropout doesn't always clear)\r\n                return false; // prevent parent from receiving msg (which may be a grid as well)\r\n            }\r\n            // fix #1578 when dragging fast, we may not get a leave on the previous grid so force one now\r\n            if ((node === null || node === void 0 ? void 0 : node.grid) && node.grid !== this && !node._temporaryRemoved) {\r\n                // console.log('dropover without leave'); // TEST\r\n                let otherGrid = node.grid;\r\n                otherGrid._leave(el, helper);\r\n            }\r\n            // cache cell dimensions (which don't change), position can animate if we removed an item in otherGrid that affects us...\r\n            cellWidth = this.cellWidth();\r\n            cellHeight = this.getCellHeight(true);\r\n            // load any element attributes if we don't have a node\r\n            if (!node) { // @ts-ignore private read only on ourself\r\n                node = this._readAttr(el);\r\n            }\r\n            if (!node.grid) {\r\n                node._isExternal = true;\r\n                el.gridstackNode = node;\r\n            }\r\n            // calculate the grid size based on element outer size\r\n            helper = helper || el;\r\n            let w = node.w || Math.round(helper.offsetWidth / cellWidth) || 1;\r\n            let h = node.h || Math.round(helper.offsetHeight / cellHeight) || 1;\r\n            // if the item came from another grid, make a copy and save the original info in case we go back there\r\n            if (node.grid && node.grid !== this) {\r\n                // copy the node original values (min/max/id/etc...) but override width/height/other flags which are this grid specific\r\n                // console.log('dropover cloning node'); // TEST\r\n                if (!el._gridstackNodeOrig)\r\n                    el._gridstackNodeOrig = node; // shouldn't have multiple nested!\r\n                el.gridstackNode = node = Object.assign(Object.assign({}, node), { w, h, grid: this });\r\n                this.engine.cleanupNode(node)\r\n                    .nodeBoundFix(node);\r\n                // restore some internal fields we need after clearing them all\r\n                node._initDD =\r\n                    node._isExternal = // DOM needs to be re-parented on a drop\r\n                        node._temporaryRemoved = true; // so it can be inserted onDrag below\r\n            }\r\n            else {\r\n                node.w = w;\r\n                node.h = h;\r\n                node._temporaryRemoved = true; // so we can insert it\r\n            }\r\n            // clear any marked for complete removal (Note: don't check _isAboutToRemove as that is cleared above - just do it)\r\n            this._itemRemoving(node.el, false);\r\n            dd.on(el, 'drag', onDrag);\r\n            // make sure this is called at least once when going fast #1578\r\n            onDrag(event, el, helper);\r\n            return false; // prevent parent from receiving msg (which may be a grid as well)\r\n        })\r\n            /**\r\n             * Leaving our grid area...\r\n             */\r\n            .on(this.el, 'dropout', (event, el, helper) => {\r\n            // console.log(`out ${this.el.gridstack.opts.id} ${count++}`); // TEST\r\n            let node = el.gridstackNode;\r\n            if (!node)\r\n                return false;\r\n            // fix #1578 when dragging fast, we might get leave after other grid gets enter (which calls us to clean)\r\n            // so skip this one if we're not the active grid really..\r\n            if (!node.grid || node.grid === this) {\r\n                this._leave(el, helper);\r\n                // if we were created as temporary nested grid, go back to before state\r\n                if (this._isTemp) {\r\n                    this.removeAsSubGrid(node);\r\n                }\r\n            }\r\n            return false; // prevent parent from receiving msg (which may be grid as well)\r\n        })\r\n            /**\r\n             * end - releasing the mouse\r\n             */\r\n            .on(this.el, 'drop', (event, el, helper) => {\r\n            var _a, _b;\r\n            let node = el.gridstackNode;\r\n            // ignore drop on ourself from ourself that didn't come from the outside - dragend will handle the simple move instead\r\n            if ((node === null || node === void 0 ? void 0 : node.grid) === this && !node._isExternal)\r\n                return false;\r\n            let wasAdded = !!this.placeholder.parentElement; // skip items not actually added to us because of constrains, but do cleanup #1419\r\n            this.placeholder.remove();\r\n            // notify previous grid of removal\r\n            // console.log('drop delete _gridstackNodeOrig') // TEST\r\n            let origNode = el._gridstackNodeOrig;\r\n            delete el._gridstackNodeOrig;\r\n            if (wasAdded && (origNode === null || origNode === void 0 ? void 0 : origNode.grid) && origNode.grid !== this) {\r\n                let oGrid = origNode.grid;\r\n                oGrid.engine.removedNodes.push(origNode);\r\n                oGrid._triggerRemoveEvent()._triggerChangeEvent();\r\n                // if it's an empty sub-grid that got auto-created, nuke it\r\n                if (oGrid.parentGridItem && !oGrid.engine.nodes.length && oGrid.opts.subGridDynamic) {\r\n                    oGrid.removeAsSubGrid();\r\n                }\r\n            }\r\n            if (!node)\r\n                return false;\r\n            // use existing placeholder node as it's already in our list with drop location\r\n            if (wasAdded) {\r\n                this.engine.cleanupNode(node); // removes all internal _xyz values\r\n                node.grid = this;\r\n            }\r\n            dd.off(el, 'drag');\r\n            // if we made a copy ('helper' which is temp) of the original node then insert a copy, else we move the original node (#1102)\r\n            // as the helper will be nuked by jquery-ui otherwise. TODO: update old code path\r\n            if (helper !== el) {\r\n                helper.remove();\r\n                el.gridstackNode = origNode; // original item (left behind) is re-stored to pre dragging as the node now has drop info\r\n                if (wasAdded) {\r\n                    el = el.cloneNode(true);\r\n                }\r\n            }\r\n            else {\r\n                el.remove(); // reduce flicker as we change depth here, and size further down\r\n                this._removeDD(el);\r\n            }\r\n            if (!wasAdded)\r\n                return false;\r\n            el.gridstackNode = node;\r\n            node.el = el;\r\n            let subGrid = (_b = (_a = node.subGrid) === null || _a === void 0 ? void 0 : _a.el) === null || _b === void 0 ? void 0 : _b.gridstack; // set when actual sub-grid present\r\n            // @ts-ignore\r\n            utils_1.Utils.copyPos(node, this._readAttr(this.placeholder)); // placeholder values as moving VERY fast can throw things off #1578\r\n            utils_1.Utils.removePositioningStyles(el); // @ts-ignore\r\n            this._writeAttr(el, node);\r\n            el.classList.add(types_1.gridDefaults.itemClass, this.opts.itemClass);\r\n            this.el.appendChild(el); // @ts-ignore // TODO: now would be ideal time to _removeHelperStyle() overriding floating styles (native only)\r\n            if (subGrid) {\r\n                subGrid.parentGridItem = node;\r\n                if (!subGrid.opts.styleInHead)\r\n                    subGrid._updateStyles(true); // re-create sub-grid styles now that we've moved\r\n            }\r\n            this._updateContainerHeight();\r\n            this.engine.addedNodes.push(node); // @ts-ignore\r\n            this._triggerAddEvent(); // @ts-ignore\r\n            this._triggerChangeEvent();\r\n            this.engine.endUpdate();\r\n            if (this._gsEventHandler['dropped']) {\r\n                this._gsEventHandler['dropped'](Object.assign(Object.assign({}, event), { type: 'dropped' }), origNode && origNode.grid ? origNode : undefined, node);\r\n            }\r\n            // wait till we return out of the drag callback to set the new drag&resize handler or they may get messed up\r\n            window.setTimeout(() => {\r\n                // IFF we are still there (some application will use as placeholder and insert their real widget instead and better call makeWidget())\r\n                if (node.el && node.el.parentElement) {\r\n                    this._prepareDragDropByNode(node);\r\n                }\r\n                else {\r\n                    this.engine.removeNode(node);\r\n                }\r\n                delete node.grid._isTemp;\r\n            });\r\n            return false; // prevent parent from receiving msg (which may be grid as well)\r\n        });\r\n        return this;\r\n    }\r\n    /** @internal mark item for removal */\r\n    _itemRemoving(el, remove) {\r\n        let node = el ? el.gridstackNode : undefined;\r\n        if (!node || !node.grid)\r\n            return;\r\n        remove ? node._isAboutToRemove = true : delete node._isAboutToRemove;\r\n        remove ? el.classList.add('grid-stack-item-removing') : el.classList.remove('grid-stack-item-removing');\r\n    }\r\n    /** @internal called to setup a trash drop zone if the user specifies it */\r\n    _setupRemoveDrop() {\r\n        if (!this.opts.staticGrid && typeof this.opts.removable === 'string') {\r\n            let trashEl = document.querySelector(this.opts.removable);\r\n            if (!trashEl)\r\n                return this;\r\n            // only register ONE drop-over/dropout callback for the 'trash', and it will\r\n            // update the passed in item and parent grid because the 'trash' is a shared resource anyway,\r\n            // and Native DD only has 1 event CB (having a list and technically a per grid removableOptions complicates things greatly)\r\n            if (!dd.isDroppable(trashEl)) {\r\n                dd.droppable(trashEl, this.opts.removableOptions)\r\n                    .on(trashEl, 'dropover', (event, el) => this._itemRemoving(el, true))\r\n                    .on(trashEl, 'dropout', (event, el) => this._itemRemoving(el, false));\r\n            }\r\n        }\r\n        return this;\r\n    }\r\n    /** @internal prepares the element for drag&drop **/\r\n    _prepareDragDropByNode(node) {\r\n        let el = node.el;\r\n        const noMove = node.noMove || this.opts.disableDrag;\r\n        const noResize = node.noResize || this.opts.disableResize;\r\n        // check for disabled grid first\r\n        if (this.opts.staticGrid || (noMove && noResize)) {\r\n            if (node._initDD) {\r\n                this._removeDD(el); // nukes everything instead of just disable, will add some styles back next\r\n                delete node._initDD;\r\n            }\r\n            el.classList.add('ui-draggable-disabled', 'ui-resizable-disabled'); // add styles one might depend on #1435\r\n            return this;\r\n        }\r\n        if (!node._initDD) {\r\n            // variables used/cashed between the 3 start/move/end methods, in addition to node passed above\r\n            let cellWidth;\r\n            let cellHeight;\r\n            /** called when item starts moving/resizing */\r\n            let onStartMoving = (event, ui) => {\r\n                // trigger any 'dragstart' / 'resizestart' manually\r\n                if (this._gsEventHandler[event.type]) {\r\n                    this._gsEventHandler[event.type](event, event.target);\r\n                }\r\n                cellWidth = this.cellWidth();\r\n                cellHeight = this.getCellHeight(true); // force pixels for calculations\r\n                this._onStartMoving(el, event, ui, node, cellWidth, cellHeight);\r\n            };\r\n            /** called when item is being dragged/resized */\r\n            let dragOrResize = (event, ui) => {\r\n                this._dragOrResize(el, event, ui, node, cellWidth, cellHeight);\r\n            };\r\n            /** called when the item stops moving/resizing */\r\n            let onEndMoving = (event) => {\r\n                this.placeholder.remove();\r\n                delete node._moving;\r\n                delete node._event;\r\n                delete node._lastTried;\r\n                // if the item has moved to another grid, we're done here\r\n                let target = event.target;\r\n                if (!target.gridstackNode || target.gridstackNode.grid !== this)\r\n                    return;\r\n                node.el = target;\r\n                if (node._isAboutToRemove) {\r\n                    let gridToNotify = el.gridstackNode.grid;\r\n                    if (gridToNotify._gsEventHandler[event.type]) {\r\n                        gridToNotify._gsEventHandler[event.type](event, target);\r\n                    }\r\n                    this._removeDD(el);\r\n                    gridToNotify.engine.removedNodes.push(node);\r\n                    gridToNotify._triggerRemoveEvent();\r\n                    // break circular links and remove DOM\r\n                    delete el.gridstackNode;\r\n                    delete node.el;\r\n                    el.remove();\r\n                }\r\n                else {\r\n                    utils_1.Utils.removePositioningStyles(target);\r\n                    if (node._temporaryRemoved) {\r\n                        // got removed - restore item back to before dragging position\r\n                        utils_1.Utils.copyPos(node, node._orig); // @ts-ignore\r\n                        this._writePosAttr(target, node);\r\n                        this.engine.addNode(node);\r\n                    }\r\n                    else {\r\n                        // move to new placeholder location\r\n                        this._writePosAttr(target, node);\r\n                    }\r\n                    if (this._gsEventHandler[event.type]) {\r\n                        this._gsEventHandler[event.type](event, target);\r\n                    }\r\n                }\r\n                // @ts-ignore\r\n                this._extraDragRow = 0; // @ts-ignore\r\n                this._updateContainerHeight(); // @ts-ignore\r\n                this._triggerChangeEvent();\r\n                this.engine.endUpdate();\r\n            };\r\n            dd.draggable(el, {\r\n                start: onStartMoving,\r\n                stop: onEndMoving,\r\n                drag: dragOrResize\r\n            }).resizable(el, {\r\n                start: onStartMoving,\r\n                stop: onEndMoving,\r\n                resize: dragOrResize\r\n            });\r\n            node._initDD = true; // we've set DD support now\r\n        }\r\n        // finally fine tune move vs resize by disabling any part...\r\n        dd.draggable(el, noMove ? 'disable' : 'enable')\r\n            .resizable(el, noResize ? 'disable' : 'enable');\r\n        return this;\r\n    }\r\n    /** @internal handles actual drag/resize start **/\r\n    _onStartMoving(el, event, ui, node, cellWidth, cellHeight) {\r\n        this.engine.cleanNodes()\r\n            .beginUpdate(node);\r\n        // @ts-ignore\r\n        this._writePosAttr(this.placeholder, node);\r\n        this.el.appendChild(this.placeholder);\r\n        // console.log('_onStartMoving placeholder') // TEST\r\n        node.el = this.placeholder;\r\n        node._lastUiPosition = ui.position;\r\n        node._prevYPix = ui.position.top;\r\n        node._moving = (event.type === 'dragstart'); // 'dropover' are not initially moving so they can go exactly where they enter (will push stuff out of the way)\r\n        delete node._lastTried;\r\n        if (event.type === 'dropover' && node._temporaryRemoved) {\r\n            // console.log('engine.addNode x=' + node.x); // TEST\r\n            this.engine.addNode(node); // will add, fix collisions, update attr and clear _temporaryRemoved\r\n            node._moving = true; // AFTER, mark as moving object (wanted fix location before)\r\n        }\r\n        // set the min/max resize info\r\n        this.engine.cacheRects(cellWidth, cellHeight, this.opts.marginTop, this.opts.marginRight, this.opts.marginBottom, this.opts.marginLeft);\r\n        if (event.type === 'resizestart') {\r\n            dd.resizable(el, 'option', 'minWidth', cellWidth * (node.minW || 1))\r\n                .resizable(el, 'option', 'minHeight', cellHeight * (node.minH || 1));\r\n            if (node.maxW) {\r\n                dd.resizable(el, 'option', 'maxWidth', cellWidth * node.maxW);\r\n            }\r\n            if (node.maxH) {\r\n                dd.resizable(el, 'option', 'maxHeight', cellHeight * node.maxH);\r\n            }\r\n        }\r\n    }\r\n    /** @internal handles actual drag/resize **/\r\n    _dragOrResize(el, event, ui, node, cellWidth, cellHeight) {\r\n        let p = Object.assign({}, node._orig); // could be undefined (_isExternal) which is ok (drag only set x,y and w,h will default to node value)\r\n        let resizing;\r\n        let mLeft = this.opts.marginLeft, mRight = this.opts.marginRight, mTop = this.opts.marginTop, mBottom = this.opts.marginBottom;\r\n        // if margins (which are used to pass mid point by) are large relative to cell height/width, reduce them down #1855\r\n        let mHeight = Math.round(cellHeight * 0.1), mWidth = Math.round(cellWidth * 0.1);\r\n        mLeft = Math.min(mLeft, mWidth);\r\n        mRight = Math.min(mRight, mWidth);\r\n        mTop = Math.min(mTop, mHeight);\r\n        mBottom = Math.min(mBottom, mHeight);\r\n        if (event.type === 'drag') {\r\n            if (node._temporaryRemoved)\r\n                return; // handled by dropover\r\n            let distance = ui.position.top - node._prevYPix;\r\n            node._prevYPix = ui.position.top;\r\n            if (this.opts.draggable.scroll !== false) {\r\n                utils_1.Utils.updateScrollPosition(el, ui.position, distance);\r\n            }\r\n            // get new position taking into account the margin in the direction we are moving! (need to pass mid point by margin)\r\n            let left = ui.position.left + (ui.position.left > node._lastUiPosition.left ? -mRight : mLeft);\r\n            let top = ui.position.top + (ui.position.top > node._lastUiPosition.top ? -mBottom : mTop);\r\n            p.x = Math.round(left / cellWidth);\r\n            p.y = Math.round(top / cellHeight);\r\n            // @ts-ignore// if we're at the bottom hitting something else, grow the grid so cursor doesn't leave when trying to place below others\r\n            let prev = this._extraDragRow;\r\n            if (this.engine.collide(node, p)) {\r\n                let row = this.getRow();\r\n                let extra = Math.max(0, (p.y + node.h) - row);\r\n                if (this.opts.maxRow && row + extra > this.opts.maxRow) {\r\n                    extra = Math.max(0, this.opts.maxRow - row);\r\n                } // @ts-ignore\r\n                this._extraDragRow = extra; // @ts-ignore\r\n            }\r\n            else\r\n                this._extraDragRow = 0; // @ts-ignore\r\n            if (this._extraDragRow !== prev)\r\n                this._updateContainerHeight();\r\n            if (node.x === p.x && node.y === p.y)\r\n                return; // skip same\r\n            // DON'T skip one we tried as we might have failed because of coverage <50% before\r\n            // if (node._lastTried && node._lastTried.x === x && node._lastTried.y === y) return;\r\n        }\r\n        else if (event.type === 'resize') {\r\n            if (p.x < 0)\r\n                return;\r\n            // Scrolling page if needed\r\n            utils_1.Utils.updateScrollResize(event, el, cellHeight);\r\n            // get new size\r\n            p.w = Math.round((ui.size.width - mLeft) / cellWidth);\r\n            p.h = Math.round((ui.size.height - mTop) / cellHeight);\r\n            if (node.w === p.w && node.h === p.h)\r\n                return;\r\n            if (node._lastTried && node._lastTried.w === p.w && node._lastTried.h === p.h)\r\n                return; // skip one we tried (but failed)\r\n            // if we size on left/top side this might move us, so get possible new position as well\r\n            let left = ui.position.left + mLeft;\r\n            let top = ui.position.top + mTop;\r\n            p.x = Math.round(left / cellWidth);\r\n            p.y = Math.round(top / cellHeight);\r\n            resizing = true;\r\n        }\r\n        node._event = event;\r\n        node._lastTried = p; // set as last tried (will nuke if we go there)\r\n        let rect = {\r\n            x: ui.position.left + mLeft,\r\n            y: ui.position.top + mTop,\r\n            w: (ui.size ? ui.size.width : node.w * cellWidth) - mLeft - mRight,\r\n            h: (ui.size ? ui.size.height : node.h * cellHeight) - mTop - mBottom\r\n        };\r\n        if (this.engine.moveNodeCheck(node, Object.assign(Object.assign({}, p), { cellWidth, cellHeight, rect, resizing }))) {\r\n            node._lastUiPosition = ui.position;\r\n            this.engine.cacheRects(cellWidth, cellHeight, mTop, mRight, mBottom, mLeft);\r\n            delete node._skipDown;\r\n            if (resizing && node.subGrid) {\r\n                node.subGrid.onParentResize();\r\n            } // @ts-ignore\r\n            this._extraDragRow = 0; // @ts-ignore\r\n            this._updateContainerHeight();\r\n            let target = event.target; // @ts-ignore\r\n            this._writePosAttr(target, node);\r\n            if (this._gsEventHandler[event.type]) {\r\n                this._gsEventHandler[event.type](event, target);\r\n            }\r\n        }\r\n    }\r\n    /** @internal called when item leaving our area by either cursor dropout event\r\n     * or shape is outside our boundaries. remove it from us, and mark temporary if this was\r\n     * our item to start with else restore prev node values from prev grid it came from.\r\n     **/\r\n    _leave(el, helper) {\r\n        let node = el.gridstackNode;\r\n        if (!node)\r\n            return;\r\n        dd.off(el, 'drag'); // no need to track while being outside\r\n        // this gets called when cursor leaves and shape is outside, so only do this once\r\n        if (node._temporaryRemoved)\r\n            return;\r\n        node._temporaryRemoved = true;\r\n        this.engine.removeNode(node); // remove placeholder as well, otherwise it's a sign node is not in our list, which is a bigger issue\r\n        node.el = node._isExternal && helper ? helper : el; // point back to real item being dragged\r\n        if (this.opts.removable === true) { // boolean vs a class string\r\n            // item leaving us and we are supposed to remove on leave (no need to drag onto trash) mark it so\r\n            this._itemRemoving(el, true);\r\n        }\r\n        // finally if item originally came from another grid, but left us, restore things back to prev info\r\n        if (el._gridstackNodeOrig) {\r\n            // console.log('leave delete _gridstackNodeOrig') // TEST\r\n            el.gridstackNode = el._gridstackNodeOrig;\r\n            delete el._gridstackNodeOrig;\r\n        }\r\n        else if (node._isExternal) {\r\n            // item came from outside (like a toolbar) so nuke any node info\r\n            delete node.el;\r\n            delete el.gridstackNode;\r\n            // and restore all nodes back to original\r\n            this.engine.restoreInitial();\r\n        }\r\n    }\r\n    // legacy method removed\r\n    commit() { utils_1.obsolete(this, this.batchUpdate(false), 'commit', 'batchUpdate', '5.2'); return this; }\r\n}\r\nexports.GridStack = GridStack;\r\n/** scoping so users can call GridStack.Utils.sort() for example */\r\nGridStack.Utils = utils_1.Utils;\r\n/** scoping so users can call new GridStack.Engine(12) for example */\r\nGridStack.Engine = gridstack_engine_1.GridStackEngine;\r\nGridStack.GDRev = '7.3.0';\r\n//# sourceMappingURL=gridstack.js.map","\"use strict\";\r\n/**\r\n * dd-resizable-handle.ts 7.3.0\r\n * Copyright (c) 2021-2022 Alain Dumesny - see GridStack root license\r\n */\r\nObject.defineProperty(exports, \"__esModule\", { value: true });\r\nexports.DDResizableHandle = void 0;\r\nconst dd_touch_1 = require(\"./dd-touch\");\r\nclass DDResizableHandle {\r\n    constructor(host, direction, option) {\r\n        /** @internal true after we've moved enough pixels to start a resize */\r\n        this.moving = false;\r\n        this.host = host;\r\n        this.dir = direction;\r\n        this.option = option;\r\n        // create var event binding so we can easily remove and still look like TS methods (unlike anonymous functions)\r\n        this._mouseDown = this._mouseDown.bind(this);\r\n        this._mouseMove = this._mouseMove.bind(this);\r\n        this._mouseUp = this._mouseUp.bind(this);\r\n        this._init();\r\n    }\r\n    /** @internal */\r\n    _init() {\r\n        const el = document.createElement('div');\r\n        el.classList.add('ui-resizable-handle');\r\n        el.classList.add(`${DDResizableHandle.prefix}${this.dir}`);\r\n        el.style.zIndex = '100';\r\n        el.style.userSelect = 'none';\r\n        this.el = el;\r\n        this.host.appendChild(this.el);\r\n        this.el.addEventListener('mousedown', this._mouseDown);\r\n        if (dd_touch_1.isTouch) {\r\n            this.el.addEventListener('touchstart', dd_touch_1.touchstart);\r\n            this.el.addEventListener('pointerdown', dd_touch_1.pointerdown);\r\n            // this.el.style.touchAction = 'none'; // not needed unlike pointerdown doc comment\r\n        }\r\n        return this;\r\n    }\r\n    /** call this when resize handle needs to be removed and cleaned up */\r\n    destroy() {\r\n        if (this.moving)\r\n            this._mouseUp(this.mouseDownEvent);\r\n        this.el.removeEventListener('mousedown', this._mouseDown);\r\n        if (dd_touch_1.isTouch) {\r\n            this.el.removeEventListener('touchstart', dd_touch_1.touchstart);\r\n            this.el.removeEventListener('pointerdown', dd_touch_1.pointerdown);\r\n        }\r\n        this.host.removeChild(this.el);\r\n        delete this.el;\r\n        delete this.host;\r\n        return this;\r\n    }\r\n    /** @internal called on mouse down on us: capture move on the entire document (mouse might not stay on us) until we release the mouse */\r\n    _mouseDown(e) {\r\n        this.mouseDownEvent = e;\r\n        document.addEventListener('mousemove', this._mouseMove, true); // capture, not bubble\r\n        document.addEventListener('mouseup', this._mouseUp, true);\r\n        if (dd_touch_1.isTouch) {\r\n            this.el.addEventListener('touchmove', dd_touch_1.touchmove);\r\n            this.el.addEventListener('touchend', dd_touch_1.touchend);\r\n        }\r\n        e.stopPropagation();\r\n        e.preventDefault();\r\n    }\r\n    /** @internal */\r\n    _mouseMove(e) {\r\n        let s = this.mouseDownEvent;\r\n        if (this.moving) {\r\n            this._triggerEvent('move', e);\r\n        }\r\n        else if (Math.abs(e.x - s.x) + Math.abs(e.y - s.y) > 2) {\r\n            // don't start unless we've moved at least 3 pixels\r\n            this.moving = true;\r\n            this._triggerEvent('start', this.mouseDownEvent);\r\n            this._triggerEvent('move', e);\r\n        }\r\n        e.stopPropagation();\r\n        e.preventDefault();\r\n    }\r\n    /** @internal */\r\n    _mouseUp(e) {\r\n        if (this.moving) {\r\n            this._triggerEvent('stop', e);\r\n        }\r\n        document.removeEventListener('mousemove', this._mouseMove, true);\r\n        document.removeEventListener('mouseup', this._mouseUp, true);\r\n        if (dd_touch_1.isTouch) {\r\n            this.el.removeEventListener('touchmove', dd_touch_1.touchmove);\r\n            this.el.removeEventListener('touchend', dd_touch_1.touchend);\r\n        }\r\n        delete this.moving;\r\n        delete this.mouseDownEvent;\r\n        e.stopPropagation();\r\n        e.preventDefault();\r\n    }\r\n    /** @internal */\r\n    _triggerEvent(name, event) {\r\n        if (this.option[name])\r\n            this.option[name](event);\r\n        return this;\r\n    }\r\n}\r\nexports.DDResizableHandle = DDResizableHandle;\r\n/** @internal */\r\nDDResizableHandle.prefix = 'ui-resizable-';\r\n//# sourceMappingURL=dd-resizable-handle.js.map","\"use strict\";\r\n/**\r\n * dd-resizable.ts 7.3.0\r\n * Copyright (c) 2021-2022 Alain Dumesny - see GridStack root license\r\n */\r\nObject.defineProperty(exports, \"__esModule\", { value: true });\r\nexports.DDResizable = void 0;\r\nconst dd_resizable_handle_1 = require(\"./dd-resizable-handle\");\r\nconst dd_base_impl_1 = require(\"./dd-base-impl\");\r\nconst utils_1 = require(\"./utils\");\r\nconst dd_manager_1 = require(\"./dd-manager\");\r\nclass DDResizable extends dd_base_impl_1.DDBaseImplement {\r\n    constructor(el, opts = {}) {\r\n        super();\r\n        /** @internal */\r\n        this._ui = () => {\r\n            const containmentEl = this.el.parentElement;\r\n            const containmentRect = containmentEl.getBoundingClientRect();\r\n            const newRect = {\r\n                width: this.originalRect.width,\r\n                height: this.originalRect.height + this.scrolled,\r\n                left: this.originalRect.left,\r\n                top: this.originalRect.top - this.scrolled\r\n            };\r\n            const rect = this.temporalRect || newRect;\r\n            return {\r\n                position: {\r\n                    left: rect.left - containmentRect.left,\r\n                    top: rect.top - containmentRect.top\r\n                },\r\n                size: {\r\n                    width: rect.width,\r\n                    height: rect.height\r\n                }\r\n                /* Gridstack ONLY needs position set above... keep around in case.\r\n                element: [this.el], // The object representing the element to be resized\r\n                helper: [], // TODO: not support yet - The object representing the helper that's being resized\r\n                originalElement: [this.el],// we don't wrap here, so simplify as this.el //The object representing the original element before it is wrapped\r\n                originalPosition: { // The position represented as { left, top } before the resizable is resized\r\n                  left: this.originalRect.left - containmentRect.left,\r\n                  top: this.originalRect.top - containmentRect.top\r\n                },\r\n                originalSize: { // The size represented as { width, height } before the resizable is resized\r\n                  width: this.originalRect.width,\r\n                  height: this.originalRect.height\r\n                }\r\n                */\r\n            };\r\n        };\r\n        this.el = el;\r\n        this.option = opts;\r\n        // create var event binding so we can easily remove and still look like TS methods (unlike anonymous functions)\r\n        this._mouseOver = this._mouseOver.bind(this);\r\n        this._mouseOut = this._mouseOut.bind(this);\r\n        this.enable();\r\n        this._setupAutoHide(this.option.autoHide);\r\n        this._setupHandlers();\r\n    }\r\n    on(event, callback) {\r\n        super.on(event, callback);\r\n    }\r\n    off(event) {\r\n        super.off(event);\r\n    }\r\n    enable() {\r\n        super.enable();\r\n        this.el.classList.add('ui-resizable');\r\n        this.el.classList.remove('ui-resizable-disabled');\r\n        this._setupAutoHide(this.option.autoHide);\r\n    }\r\n    disable() {\r\n        super.disable();\r\n        this.el.classList.add('ui-resizable-disabled');\r\n        this.el.classList.remove('ui-resizable');\r\n        this._setupAutoHide(false);\r\n    }\r\n    destroy() {\r\n        this._removeHandlers();\r\n        this._setupAutoHide(false);\r\n        this.el.classList.remove('ui-resizable');\r\n        delete this.el;\r\n        super.destroy();\r\n    }\r\n    updateOption(opts) {\r\n        let updateHandles = (opts.handles && opts.handles !== this.option.handles);\r\n        let updateAutoHide = (opts.autoHide && opts.autoHide !== this.option.autoHide);\r\n        Object.keys(opts).forEach(key => this.option[key] = opts[key]);\r\n        if (updateHandles) {\r\n            this._removeHandlers();\r\n            this._setupHandlers();\r\n        }\r\n        if (updateAutoHide) {\r\n            this._setupAutoHide(this.option.autoHide);\r\n        }\r\n        return this;\r\n    }\r\n    /** @internal turns auto hide on/off */\r\n    _setupAutoHide(auto) {\r\n        if (auto) {\r\n            this.el.classList.add('ui-resizable-autohide');\r\n            // use mouseover and not mouseenter to get better performance and track for nested cases\r\n            this.el.addEventListener('mouseover', this._mouseOver);\r\n            this.el.addEventListener('mouseout', this._mouseOut);\r\n        }\r\n        else {\r\n            this.el.classList.remove('ui-resizable-autohide');\r\n            this.el.removeEventListener('mouseover', this._mouseOver);\r\n            this.el.removeEventListener('mouseout', this._mouseOut);\r\n            if (dd_manager_1.DDManager.overResizeElement === this) {\r\n                delete dd_manager_1.DDManager.overResizeElement;\r\n            }\r\n        }\r\n        return this;\r\n    }\r\n    /** @internal */\r\n    // eslint-disable-next-line @typescript-eslint/no-unused-vars\r\n    _mouseOver(e) {\r\n        // console.log(`${count++} pre-enter ${(this.el as GridItemHTMLElement).gridstackNode._id}`)\r\n        // already over a child, ignore. Ideally we just call e.stopPropagation() but see https://github.com/gridstack/gridstack.js/issues/2018\r\n        if (dd_manager_1.DDManager.overResizeElement || dd_manager_1.DDManager.dragElement)\r\n            return;\r\n        dd_manager_1.DDManager.overResizeElement = this;\r\n        // console.log(`${count++} enter ${(this.el as GridItemHTMLElement).gridstackNode._id}`)\r\n        this.el.classList.remove('ui-resizable-autohide');\r\n    }\r\n    /** @internal */\r\n    // eslint-disable-next-line @typescript-eslint/no-unused-vars\r\n    _mouseOut(e) {\r\n        // console.log(`${count++} pre-leave ${(this.el as GridItemHTMLElement).gridstackNode._id}`)\r\n        if (dd_manager_1.DDManager.overResizeElement !== this)\r\n            return;\r\n        delete dd_manager_1.DDManager.overResizeElement;\r\n        // console.log(`${count++} leave ${(this.el as GridItemHTMLElement).gridstackNode._id}`)\r\n        this.el.classList.add('ui-resizable-autohide');\r\n    }\r\n    /** @internal */\r\n    _setupHandlers() {\r\n        let handlerDirection = this.option.handles || 'e,s,se';\r\n        if (handlerDirection === 'all') {\r\n            handlerDirection = 'n,e,s,w,se,sw,ne,nw';\r\n        }\r\n        this.handlers = handlerDirection.split(',')\r\n            .map(dir => dir.trim())\r\n            .map(dir => new dd_resizable_handle_1.DDResizableHandle(this.el, dir, {\r\n            start: (event) => {\r\n                this._resizeStart(event);\r\n            },\r\n            stop: (event) => {\r\n                this._resizeStop(event);\r\n            },\r\n            move: (event) => {\r\n                this._resizing(event, dir);\r\n            }\r\n        }));\r\n        return this;\r\n    }\r\n    /** @internal */\r\n    _resizeStart(event) {\r\n        this.originalRect = this.el.getBoundingClientRect();\r\n        this.scrollEl = utils_1.Utils.getScrollElement(this.el);\r\n        this.scrollY = this.scrollEl.scrollTop;\r\n        this.scrolled = 0;\r\n        this.startEvent = event;\r\n        this._setupHelper();\r\n        this._applyChange();\r\n        const ev = utils_1.Utils.initEvent(event, { type: 'resizestart', target: this.el });\r\n        if (this.option.start) {\r\n            this.option.start(ev, this._ui());\r\n        }\r\n        this.el.classList.add('ui-resizable-resizing');\r\n        this.triggerEvent('resizestart', ev);\r\n        return this;\r\n    }\r\n    /** @internal */\r\n    _resizing(event, dir) {\r\n        this.scrolled = this.scrollEl.scrollTop - this.scrollY;\r\n        this.temporalRect = this._getChange(event, dir);\r\n        this._applyChange();\r\n        const ev = utils_1.Utils.initEvent(event, { type: 'resize', target: this.el });\r\n        if (this.option.resize) {\r\n            this.option.resize(ev, this._ui());\r\n        }\r\n        this.triggerEvent('resize', ev);\r\n        return this;\r\n    }\r\n    /** @internal */\r\n    _resizeStop(event) {\r\n        const ev = utils_1.Utils.initEvent(event, { type: 'resizestop', target: this.el });\r\n        if (this.option.stop) {\r\n            this.option.stop(ev); // Note: ui() not used by gridstack so don't pass\r\n        }\r\n        this.el.classList.remove('ui-resizable-resizing');\r\n        this.triggerEvent('resizestop', ev);\r\n        this._cleanHelper();\r\n        delete this.startEvent;\r\n        delete this.originalRect;\r\n        delete this.temporalRect;\r\n        delete this.scrollY;\r\n        delete this.scrolled;\r\n        return this;\r\n    }\r\n    /** @internal */\r\n    _setupHelper() {\r\n        this.elOriginStyleVal = DDResizable._originStyleProp.map(prop => this.el.style[prop]);\r\n        this.parentOriginStylePosition = this.el.parentElement.style.position;\r\n        if (window.getComputedStyle(this.el.parentElement).position.match(/static/)) {\r\n            this.el.parentElement.style.position = 'relative';\r\n        }\r\n        this.el.style.position = 'absolute';\r\n        this.el.style.opacity = '0.8';\r\n        return this;\r\n    }\r\n    /** @internal */\r\n    _cleanHelper() {\r\n        DDResizable._originStyleProp.forEach((prop, i) => {\r\n            this.el.style[prop] = this.elOriginStyleVal[i] || null;\r\n        });\r\n        this.el.parentElement.style.position = this.parentOriginStylePosition || null;\r\n        return this;\r\n    }\r\n    /** @internal */\r\n    _getChange(event, dir) {\r\n        const oEvent = this.startEvent;\r\n        const newRect = {\r\n            width: this.originalRect.width,\r\n            height: this.originalRect.height + this.scrolled,\r\n            left: this.originalRect.left,\r\n            top: this.originalRect.top - this.scrolled\r\n        };\r\n        const offsetX = event.clientX - oEvent.clientX;\r\n        const offsetY = event.clientY - oEvent.clientY;\r\n        if (dir.indexOf('e') > -1) {\r\n            newRect.width += offsetX;\r\n        }\r\n        else if (dir.indexOf('w') > -1) {\r\n            newRect.width -= offsetX;\r\n            newRect.left += offsetX;\r\n        }\r\n        if (dir.indexOf('s') > -1) {\r\n            newRect.height += offsetY;\r\n        }\r\n        else if (dir.indexOf('n') > -1) {\r\n            newRect.height -= offsetY;\r\n            newRect.top += offsetY;\r\n        }\r\n        const constrain = this._constrainSize(newRect.width, newRect.height);\r\n        if (Math.round(newRect.width) !== Math.round(constrain.width)) { // round to ignore slight round-off errors\r\n            if (dir.indexOf('w') > -1) {\r\n                newRect.left += newRect.width - constrain.width;\r\n            }\r\n            newRect.width = constrain.width;\r\n        }\r\n        if (Math.round(newRect.height) !== Math.round(constrain.height)) {\r\n            if (dir.indexOf('n') > -1) {\r\n                newRect.top += newRect.height - constrain.height;\r\n            }\r\n            newRect.height = constrain.height;\r\n        }\r\n        return newRect;\r\n    }\r\n    /** @internal constrain the size to the set min/max values */\r\n    _constrainSize(oWidth, oHeight) {\r\n        const maxWidth = this.option.maxWidth || Number.MAX_SAFE_INTEGER;\r\n        const minWidth = this.option.minWidth || oWidth;\r\n        const maxHeight = this.option.maxHeight || Number.MAX_SAFE_INTEGER;\r\n        const minHeight = this.option.minHeight || oHeight;\r\n        const width = Math.min(maxWidth, Math.max(minWidth, oWidth));\r\n        const height = Math.min(maxHeight, Math.max(minHeight, oHeight));\r\n        return { width, height };\r\n    }\r\n    /** @internal */\r\n    _applyChange() {\r\n        let containmentRect = { left: 0, top: 0, width: 0, height: 0 };\r\n        if (this.el.style.position === 'absolute') {\r\n            const containmentEl = this.el.parentElement;\r\n            const { left, top } = containmentEl.getBoundingClientRect();\r\n            containmentRect = { left, top, width: 0, height: 0 };\r\n        }\r\n        if (!this.temporalRect)\r\n            return this;\r\n        Object.keys(this.temporalRect).forEach(key => {\r\n            const value = this.temporalRect[key];\r\n            this.el.style[key] = value - containmentRect[key] + 'px';\r\n        });\r\n        return this;\r\n    }\r\n    /** @internal */\r\n    _removeHandlers() {\r\n        this.handlers.forEach(handle => handle.destroy());\r\n        delete this.handlers;\r\n        return this;\r\n    }\r\n}\r\nexports.DDResizable = DDResizable;\r\n/** @internal */\r\nDDResizable._originStyleProp = ['width', 'height', 'position', 'left', 'top', 'opacity', 'zIndex'];\r\n//# sourceMappingURL=dd-resizable.js.map","// Imports\nvar ___CSS_LOADER_API_IMPORT___ = require(\"../../css-loader/dist/runtime/api.js\");\nexports = ___CSS_LOADER_API_IMPORT___(false);\n// Module\nexports.push([module.id, \":root .grid-stack-item>.ui-resizable-handle{filter:none}.grid-stack{position:relative}.grid-stack.grid-stack-rtl{direction:ltr}.grid-stack.grid-stack-rtl>.grid-stack-item{direction:rtl}.grid-stack .grid-stack-placeholder>.placeholder-content{background-color:rgba(0,0,0,.1);margin:0;position:absolute;width:auto;z-index:0!important;text-align:center}.grid-stack>.grid-stack-item{min-width:8.3333333333%;position:absolute;padding:0}.grid-stack>.grid-stack-item>.grid-stack-item-content{margin:0;position:absolute;width:auto;overflow-x:hidden;overflow-y:auto}.grid-stack>.grid-stack-item>.ui-resizable-handle{position:absolute;font-size:.1px;display:block;-ms-touch-action:none;touch-action:none}.grid-stack>.grid-stack-item.ui-resizable-autohide>.ui-resizable-handle,.grid-stack>.grid-stack-item.ui-resizable-disabled>.ui-resizable-handle{display:none}.grid-stack>.grid-stack-item>.ui-resizable-se,.grid-stack>.grid-stack-item>.ui-resizable-sw{background-image:url(data:image/svg+xml;base64,PD94bWwgdmVyc2lvbj0iMS4wIiBlbmNvZGluZz0iaXNvLTg4NTktMSI/Pgo8IS0tIEdlbmVyYXRvcjogQWRvYmUgSWxsdXN0cmF0b3IgMTYuMC4wLCBTVkcgRXhwb3J0IFBsdWctSW4gLiBTVkcgVmVyc2lvbjogNi4wMCBCdWlsZCAwKSAgLS0+CjwhRE9DVFlQRSBzdmcgUFVCTElDICItLy9XM0MvL0RURCBTVkcgMS4xLy9FTiIgImh0dHA6Ly93d3cudzMub3JnL0dyYXBoaWNzL1NWRy8xLjEvRFREL3N2ZzExLmR0ZCI+CjxzdmcgeG1sbnM9Imh0dHA6Ly93d3cudzMub3JnLzIwMDAvc3ZnIiB4bWxuczp4bGluaz0iaHR0cDovL3d3dy53My5vcmcvMTk5OS94bGluayIgdmVyc2lvbj0iMS4xIiBpZD0iQ2FwYV8xIiB4PSIwcHgiIHk9IjBweCIgd2lkdGg9IjE2cHgiIGhlaWdodD0iMTZweCIgdmlld0JveD0iMCAwIDUxMS42MjYgNTExLjYyNyIgc3R5bGU9ImVuYWJsZS1iYWNrZ3JvdW5kOm5ldyAwIDAgNTExLjYyNiA1MTEuNjI3OyIgeG1sOnNwYWNlPSJwcmVzZXJ2ZSI+CjxnPgoJPHBhdGggZD0iTTMyOC45MDYsNDAxLjk5NGgtMzYuNTUzVjEwOS42MzZoMzYuNTUzYzQuOTQ4LDAsOS4yMzYtMS44MDksMTIuODQ3LTUuNDI2YzMuNjEzLTMuNjE1LDUuNDIxLTcuODk4LDUuNDIxLTEyLjg0NSAgIGMwLTQuOTQ5LTEuODAxLTkuMjMxLTUuNDI4LTEyLjg1MWwtNzMuMDg3LTczLjA5QzI2NS4wNDQsMS44MDksMjYwLjc2LDAsMjU1LjgxMywwYy00Ljk0OCwwLTkuMjI5LDEuODA5LTEyLjg0Nyw1LjQyNCAgIGwtNzMuMDg4LDczLjA5Yy0zLjYxOCwzLjYxOS01LjQyNCw3LjkwMi01LjQyNCwxMi44NTFjMCw0Ljk0NiwxLjgwNyw5LjIyOSw1LjQyNCwxMi44NDVjMy42MTksMy42MTcsNy45MDEsNS40MjYsMTIuODUsNS40MjYgICBoMzYuNTQ1djI5Mi4zNThoLTM2LjU0MmMtNC45NTIsMC05LjIzNSwxLjgwOC0xMi44NSw1LjQyMWMtMy42MTcsMy42MjEtNS40MjQsNy45MDUtNS40MjQsMTIuODU0ICAgYzAsNC45NDUsMS44MDcsOS4yMjcsNS40MjQsMTIuODQ3bDczLjA4OSw3My4wODhjMy42MTcsMy42MTcsNy44OTgsNS40MjQsMTIuODQ3LDUuNDI0YzQuOTUsMCw5LjIzNC0xLjgwNywxMi44NDktNS40MjQgICBsNzMuMDg3LTczLjA4OGMzLjYxMy0zLjYyLDUuNDIxLTcuOTAxLDUuNDIxLTEyLjg0N2MwLTQuOTQ4LTEuODA4LTkuMjMyLTUuNDIxLTEyLjg1NCAgIEMzMzguMTQyLDQwMy44MDIsMzMzLjg1Nyw0MDEuOTk0LDMyOC45MDYsNDAxLjk5NHoiIGZpbGw9IiM2NjY2NjYiLz4KPC9nPgo8Zz4KPC9nPgo8Zz4KPC9nPgo8Zz4KPC9nPgo8Zz4KPC9nPgo8Zz4KPC9nPgo8Zz4KPC9nPgo8Zz4KPC9nPgo8Zz4KPC9nPgo8Zz4KPC9nPgo8Zz4KPC9nPgo8Zz4KPC9nPgo8Zz4KPC9nPgo8Zz4KPC9nPgo8Zz4KPC9nPgo8Zz4KPC9nPgo8L3N2Zz4K);background-repeat:no-repeat;background-position:center;-webkit-transform:rotate(45deg);-moz-transform:rotate(45deg);-ms-transform:rotate(45deg);-o-transform:rotate(45deg);transform:rotate(45deg)}.grid-stack>.grid-stack-item>.ui-resizable-se{-webkit-transform:rotate(-45deg);-moz-transform:rotate(-45deg);-ms-transform:rotate(-45deg);-o-transform:rotate(-45deg);transform:rotate(-45deg)}.grid-stack>.grid-stack-item>.ui-resizable-nw{cursor:nw-resize;width:20px;height:20px;top:0}.grid-stack>.grid-stack-item>.ui-resizable-n{cursor:n-resize;height:10px;top:0;left:25px;right:25px}.grid-stack>.grid-stack-item>.ui-resizable-ne{cursor:ne-resize;width:20px;height:20px;top:0}.grid-stack>.grid-stack-item>.ui-resizable-e{cursor:e-resize;width:10px;top:15px;bottom:15px}.grid-stack>.grid-stack-item>.ui-resizable-se{cursor:se-resize;width:20px;height:20px}.grid-stack>.grid-stack-item>.ui-resizable-s{cursor:s-resize;height:10px;left:25px;bottom:0;right:25px}.grid-stack>.grid-stack-item>.ui-resizable-sw{cursor:sw-resize;width:20px;height:20px}.grid-stack>.grid-stack-item>.ui-resizable-w{cursor:w-resize;width:10px;top:15px;bottom:15px}.grid-stack>.grid-stack-item.ui-draggable-dragging>.ui-resizable-handle{display:none!important}.grid-stack>.grid-stack-item[gs-w=\\\"0\\\"]{width:0%}.grid-stack>.grid-stack-item[gs-x=\\\"0\\\"]{left:0}.grid-stack>.grid-stack-item[gs-min-w=\\\"0\\\"]{min-width:0}.grid-stack>.grid-stack-item[gs-max-w=\\\"0\\\"]{max-width:0%}.grid-stack>.grid-stack-item[gs-w=\\\"1\\\"]{width:8.3333333333%}.grid-stack>.grid-stack-item[gs-x=\\\"1\\\"]{left:8.3333333333%}.grid-stack>.grid-stack-item[gs-min-w=\\\"1\\\"]{min-width:8.3333333333%}.grid-stack>.grid-stack-item[gs-max-w=\\\"1\\\"]{max-width:8.3333333333%}.grid-stack>.grid-stack-item[gs-w=\\\"2\\\"]{width:16.6666666667%}.grid-stack>.grid-stack-item[gs-x=\\\"2\\\"]{left:16.6666666667%}.grid-stack>.grid-stack-item[gs-min-w=\\\"2\\\"]{min-width:16.6666666667%}.grid-stack>.grid-stack-item[gs-max-w=\\\"2\\\"]{max-width:16.6666666667%}.grid-stack>.grid-stack-item[gs-w=\\\"3\\\"]{width:25%}.grid-stack>.grid-stack-item[gs-x=\\\"3\\\"]{left:25%}.grid-stack>.grid-stack-item[gs-min-w=\\\"3\\\"]{min-width:25%}.grid-stack>.grid-stack-item[gs-max-w=\\\"3\\\"]{max-width:25%}.grid-stack>.grid-stack-item[gs-w=\\\"4\\\"]{width:33.3333333333%}.grid-stack>.grid-stack-item[gs-x=\\\"4\\\"]{left:33.3333333333%}.grid-stack>.grid-stack-item[gs-min-w=\\\"4\\\"]{min-width:33.3333333333%}.grid-stack>.grid-stack-item[gs-max-w=\\\"4\\\"]{max-width:33.3333333333%}.grid-stack>.grid-stack-item[gs-w=\\\"5\\\"]{width:41.6666666667%}.grid-stack>.grid-stack-item[gs-x=\\\"5\\\"]{left:41.6666666667%}.grid-stack>.grid-stack-item[gs-min-w=\\\"5\\\"]{min-width:41.6666666667%}.grid-stack>.grid-stack-item[gs-max-w=\\\"5\\\"]{max-width:41.6666666667%}.grid-stack>.grid-stack-item[gs-w=\\\"6\\\"]{width:50%}.grid-stack>.grid-stack-item[gs-x=\\\"6\\\"]{left:50%}.grid-stack>.grid-stack-item[gs-min-w=\\\"6\\\"]{min-width:50%}.grid-stack>.grid-stack-item[gs-max-w=\\\"6\\\"]{max-width:50%}.grid-stack>.grid-stack-item[gs-w=\\\"7\\\"]{width:58.3333333333%}.grid-stack>.grid-stack-item[gs-x=\\\"7\\\"]{left:58.3333333333%}.grid-stack>.grid-stack-item[gs-min-w=\\\"7\\\"]{min-width:58.3333333333%}.grid-stack>.grid-stack-item[gs-max-w=\\\"7\\\"]{max-width:58.3333333333%}.grid-stack>.grid-stack-item[gs-w=\\\"8\\\"]{width:66.6666666667%}.grid-stack>.grid-stack-item[gs-x=\\\"8\\\"]{left:66.6666666667%}.grid-stack>.grid-stack-item[gs-min-w=\\\"8\\\"]{min-width:66.6666666667%}.grid-stack>.grid-stack-item[gs-max-w=\\\"8\\\"]{max-width:66.6666666667%}.grid-stack>.grid-stack-item[gs-w=\\\"9\\\"]{width:75%}.grid-stack>.grid-stack-item[gs-x=\\\"9\\\"]{left:75%}.grid-stack>.grid-stack-item[gs-min-w=\\\"9\\\"]{min-width:75%}.grid-stack>.grid-stack-item[gs-max-w=\\\"9\\\"]{max-width:75%}.grid-stack>.grid-stack-item[gs-w=\\\"10\\\"]{width:83.3333333333%}.grid-stack>.grid-stack-item[gs-x=\\\"10\\\"]{left:83.3333333333%}.grid-stack>.grid-stack-item[gs-min-w=\\\"10\\\"]{min-width:83.3333333333%}.grid-stack>.grid-stack-item[gs-max-w=\\\"10\\\"]{max-width:83.3333333333%}.grid-stack>.grid-stack-item[gs-w=\\\"11\\\"]{width:91.6666666667%}.grid-stack>.grid-stack-item[gs-x=\\\"11\\\"]{left:91.6666666667%}.grid-stack>.grid-stack-item[gs-min-w=\\\"11\\\"]{min-width:91.6666666667%}.grid-stack>.grid-stack-item[gs-max-w=\\\"11\\\"]{max-width:91.6666666667%}.grid-stack>.grid-stack-item[gs-w=\\\"12\\\"]{width:100%}.grid-stack>.grid-stack-item[gs-x=\\\"12\\\"]{left:100%}.grid-stack>.grid-stack-item[gs-min-w=\\\"12\\\"]{min-width:100%}.grid-stack>.grid-stack-item[gs-max-w=\\\"12\\\"]{max-width:100%}.grid-stack.grid-stack-1>.grid-stack-item{min-width:100%}.grid-stack.grid-stack-1>.grid-stack-item[gs-w=\\\"1\\\"]{width:100%}.grid-stack.grid-stack-1>.grid-stack-item[gs-x=\\\"1\\\"]{left:100%}.grid-stack.grid-stack-1>.grid-stack-item[gs-min-w=\\\"1\\\"]{min-width:100%}.grid-stack.grid-stack-1>.grid-stack-item[gs-max-w=\\\"1\\\"]{max-width:100%}.grid-stack.grid-stack-animate,.grid-stack.grid-stack-animate .grid-stack-item{-webkit-transition:left .3s,top .3s,height .3s,width .3s;-moz-transition:left .3s,top .3s,height .3s,width .3s;-ms-transition:left .3s,top .3s,height .3s,width .3s;-o-transition:left .3s,top .3s,height .3s,width .3s;transition:left .3s,top .3s,height .3s,width .3s}.grid-stack.grid-stack-animate .grid-stack-item.grid-stack-placeholder,.grid-stack.grid-stack-animate .grid-stack-item.ui-draggable-dragging,.grid-stack.grid-stack-animate .grid-stack-item.ui-resizable-resizing{-webkit-transition:left 0s,top 0s,height 0s,width 0s;-moz-transition:left 0s,top 0s,height 0s,width 0s;-ms-transition:left 0s,top 0s,height 0s,width 0s;-o-transition:left 0s,top 0s,height 0s,width 0s;transition:left 0s,top 0s,height 0s,width 0s}.ui-draggable-dragging,.ui-resizable-resizing{z-index:100}.ui-draggable-dragging>.grid-stack-item-content,.ui-resizable-resizing>.grid-stack-item-content{box-shadow:1px 4px 6px rgba(0,0,0,.2);opacity:.8}.ui-draggable-dragging{will-change:left,top;cursor:move}.ui-resizable-resizing{will-change:width,height}\", \"\"]);\n// Exports\nmodule.exports = exports;\n","\"use strict\";\r\n/**\r\n * touch.ts 7.3.0\r\n * Copyright (c) 2021 Alain Dumesny - see GridStack root license\r\n */\r\nObject.defineProperty(exports, \"__esModule\", { value: true });\r\nexports.pointerleave = exports.pointerenter = exports.pointerdown = exports.touchend = exports.touchmove = exports.touchstart = exports.isTouch = void 0;\r\nconst dd_manager_1 = require(\"./dd-manager\");\r\n/**\r\n * Detect touch support - Windows Surface devices and other touch devices\r\n * should we use this instead ? (what we had for always showing resize handles)\r\n * /Android|webOS|iPhone|iPad|iPod|BlackBerry|IEMobile|Opera Mini/i.test(navigator.userAgent)\r\n */\r\nexports.isTouch = typeof window !== 'undefined' && typeof document !== 'undefined' &&\r\n    ('ontouchstart' in document\r\n        || 'ontouchstart' in window\r\n        // || !!window.TouchEvent // true on Windows 10 Chrome desktop so don't use this\r\n        // eslint-disable-next-line @typescript-eslint/no-explicit-any\r\n        || (window.DocumentTouch && document instanceof window.DocumentTouch)\r\n        || navigator.maxTouchPoints > 0\r\n        // eslint-disable-next-line @typescript-eslint/no-explicit-any\r\n        || navigator.msMaxTouchPoints > 0);\r\n// interface TouchCoord {x: number, y: number};\r\nclass DDTouch {\r\n}\r\n/**\r\n* Get the x,y position of a touch event\r\n*/\r\n// function getTouchCoords(e: TouchEvent): TouchCoord {\r\n//   return {\r\n//     x: e.changedTouches[0].pageX,\r\n//     y: e.changedTouches[0].pageY\r\n//   };\r\n// }\r\n/**\r\n * Simulate a mouse event based on a corresponding touch event\r\n * @param {Object} e A touch event\r\n * @param {String} simulatedType The corresponding mouse event\r\n */\r\nfunction simulateMouseEvent(e, simulatedType) {\r\n    // Ignore multi-touch events\r\n    if (e.touches.length > 1)\r\n        return;\r\n    // Prevent \"Ignored attempt to cancel a touchmove event with cancelable=false\" errors\r\n    if (e.cancelable)\r\n        e.preventDefault();\r\n    const touch = e.changedTouches[0], simulatedEvent = document.createEvent('MouseEvents');\r\n    // Initialize the simulated mouse event using the touch event's coordinates\r\n    simulatedEvent.initMouseEvent(simulatedType, // type\r\n    true, // bubbles\r\n    true, // cancelable\r\n    window, // view\r\n    1, // detail\r\n    touch.screenX, // screenX\r\n    touch.screenY, // screenY\r\n    touch.clientX, // clientX\r\n    touch.clientY, // clientY\r\n    false, // ctrlKey\r\n    false, // altKey\r\n    false, // shiftKey\r\n    false, // metaKey\r\n    0, // button\r\n    null // relatedTarget\r\n    );\r\n    // Dispatch the simulated event to the target element\r\n    e.target.dispatchEvent(simulatedEvent);\r\n}\r\n/**\r\n * Simulate a mouse event based on a corresponding Pointer event\r\n * @param {Object} e A pointer event\r\n * @param {String} simulatedType The corresponding mouse event\r\n */\r\nfunction simulatePointerMouseEvent(e, simulatedType) {\r\n    // Prevent \"Ignored attempt to cancel a touchmove event with cancelable=false\" errors\r\n    if (e.cancelable)\r\n        e.preventDefault();\r\n    const simulatedEvent = document.createEvent('MouseEvents');\r\n    // Initialize the simulated mouse event using the touch event's coordinates\r\n    simulatedEvent.initMouseEvent(simulatedType, // type\r\n    true, // bubbles\r\n    true, // cancelable\r\n    window, // view\r\n    1, // detail\r\n    e.screenX, // screenX\r\n    e.screenY, // screenY\r\n    e.clientX, // clientX\r\n    e.clientY, // clientY\r\n    false, // ctrlKey\r\n    false, // altKey\r\n    false, // shiftKey\r\n    false, // metaKey\r\n    0, // button\r\n    null // relatedTarget\r\n    );\r\n    // Dispatch the simulated event to the target element\r\n    e.target.dispatchEvent(simulatedEvent);\r\n}\r\n/**\r\n * Handle the touchstart events\r\n * @param {Object} e The widget element's touchstart event\r\n */\r\nfunction touchstart(e) {\r\n    // Ignore the event if another widget is already being handled\r\n    if (DDTouch.touchHandled)\r\n        return;\r\n    DDTouch.touchHandled = true;\r\n    // Simulate the mouse events\r\n    // simulateMouseEvent(e, 'mouseover');\r\n    // simulateMouseEvent(e, 'mousemove');\r\n    simulateMouseEvent(e, 'mousedown');\r\n}\r\nexports.touchstart = touchstart;\r\n/**\r\n * Handle the touchmove events\r\n * @param {Object} e The document's touchmove event\r\n */\r\nfunction touchmove(e) {\r\n    // Ignore event if not handled by us\r\n    if (!DDTouch.touchHandled)\r\n        return;\r\n    simulateMouseEvent(e, 'mousemove');\r\n}\r\nexports.touchmove = touchmove;\r\n/**\r\n * Handle the touchend events\r\n * @param {Object} e The document's touchend event\r\n */\r\nfunction touchend(e) {\r\n    // Ignore event if not handled\r\n    if (!DDTouch.touchHandled)\r\n        return;\r\n    // cancel delayed leave event when we release on ourself which happens BEFORE we get this!\r\n    if (DDTouch.pointerLeaveTimeout) {\r\n        window.clearTimeout(DDTouch.pointerLeaveTimeout);\r\n        delete DDTouch.pointerLeaveTimeout;\r\n    }\r\n    const wasDragging = !!dd_manager_1.DDManager.dragElement;\r\n    // Simulate the mouseup event\r\n    simulateMouseEvent(e, 'mouseup');\r\n    // simulateMouseEvent(event, 'mouseout');\r\n    // If the touch interaction did not move, it should trigger a click\r\n    if (!wasDragging) {\r\n        simulateMouseEvent(e, 'click');\r\n    }\r\n    // Unset the flag to allow other widgets to inherit the touch event\r\n    DDTouch.touchHandled = false;\r\n}\r\nexports.touchend = touchend;\r\n/**\r\n * Note we don't get touchenter/touchleave (which are deprecated)\r\n * see https://stackoverflow.com/questions/27908339/js-touch-equivalent-for-mouseenter\r\n * so instead of PointerEvent to still get enter/leave and send the matching mouse event.\r\n */\r\nfunction pointerdown(e) {\r\n    // console.log(\"pointer down\")\r\n    e.target.releasePointerCapture(e.pointerId); // <- Important!\r\n}\r\nexports.pointerdown = pointerdown;\r\nfunction pointerenter(e) {\r\n    // ignore the initial one we get on pointerdown on ourself\r\n    if (!dd_manager_1.DDManager.dragElement) {\r\n        // console.log('pointerenter ignored');\r\n        return;\r\n    }\r\n    // console.log('pointerenter');\r\n    simulatePointerMouseEvent(e, 'mouseenter');\r\n}\r\nexports.pointerenter = pointerenter;\r\nfunction pointerleave(e) {\r\n    // ignore the leave on ourself we get before releasing the mouse over ourself\r\n    // by delaying sending the event and having the up event cancel us\r\n    if (!dd_manager_1.DDManager.dragElement) {\r\n        // console.log('pointerleave ignored');\r\n        return;\r\n    }\r\n    DDTouch.pointerLeaveTimeout = window.setTimeout(() => {\r\n        delete DDTouch.pointerLeaveTimeout;\r\n        // console.log('pointerleave delayed');\r\n        simulatePointerMouseEvent(e, 'mouseleave');\r\n    }, 10);\r\n}\r\nexports.pointerleave = pointerleave;\r\n//# sourceMappingURL=dd-touch.js.map","\"use strict\";\r\n/**\r\n * dd-base-impl.ts 7.3.0\r\n * Copyright (c) 2021-2022 Alain Dumesny - see GridStack root license\r\n */\r\nObject.defineProperty(exports, \"__esModule\", { value: true });\r\nexports.DDBaseImplement = void 0;\r\nclass DDBaseImplement {\r\n    constructor() {\r\n        /** @internal */\r\n        this._eventRegister = {};\r\n    }\r\n    /** returns the enable state, but you have to call enable()/disable() to change (as other things need to happen) */\r\n    get disabled() { return this._disabled; }\r\n    on(event, callback) {\r\n        this._eventRegister[event] = callback;\r\n    }\r\n    off(event) {\r\n        delete this._eventRegister[event];\r\n    }\r\n    enable() {\r\n        this._disabled = false;\r\n    }\r\n    disable() {\r\n        this._disabled = true;\r\n    }\r\n    destroy() {\r\n        delete this._eventRegister;\r\n    }\r\n    triggerEvent(eventName, event) {\r\n        if (!this.disabled && this._eventRegister && this._eventRegister[eventName])\r\n            return this._eventRegister[eventName](event);\r\n    }\r\n}\r\nexports.DDBaseImplement = DDBaseImplement;\r\n//# sourceMappingURL=dd-base-impl.js.map","\"use strict\";\r\n/**\r\n * dd-elements.ts 7.3.0\r\n * Copyright (c) 2021 Alain Dumesny - see GridStack root license\r\n */\r\nObject.defineProperty(exports, \"__esModule\", { value: true });\r\nexports.DDElement = void 0;\r\nconst dd_resizable_1 = require(\"./dd-resizable\");\r\nconst dd_draggable_1 = require(\"./dd-draggable\");\r\nconst dd_droppable_1 = require(\"./dd-droppable\");\r\nclass DDElement {\r\n    constructor(el) {\r\n        this.el = el;\r\n    }\r\n    static init(el) {\r\n        if (!el.ddElement) {\r\n            el.ddElement = new DDElement(el);\r\n        }\r\n        return el.ddElement;\r\n    }\r\n    on(eventName, callback) {\r\n        if (this.ddDraggable && ['drag', 'dragstart', 'dragstop'].indexOf(eventName) > -1) {\r\n            this.ddDraggable.on(eventName, callback);\r\n        }\r\n        else if (this.ddDroppable && ['drop', 'dropover', 'dropout'].indexOf(eventName) > -1) {\r\n            this.ddDroppable.on(eventName, callback);\r\n        }\r\n        else if (this.ddResizable && ['resizestart', 'resize', 'resizestop'].indexOf(eventName) > -1) {\r\n            this.ddResizable.on(eventName, callback);\r\n        }\r\n        return this;\r\n    }\r\n    off(eventName) {\r\n        if (this.ddDraggable && ['drag', 'dragstart', 'dragstop'].indexOf(eventName) > -1) {\r\n            this.ddDraggable.off(eventName);\r\n        }\r\n        else if (this.ddDroppable && ['drop', 'dropover', 'dropout'].indexOf(eventName) > -1) {\r\n            this.ddDroppable.off(eventName);\r\n        }\r\n        else if (this.ddResizable && ['resizestart', 'resize', 'resizestop'].indexOf(eventName) > -1) {\r\n            this.ddResizable.off(eventName);\r\n        }\r\n        return this;\r\n    }\r\n    setupDraggable(opts) {\r\n        if (!this.ddDraggable) {\r\n            this.ddDraggable = new dd_draggable_1.DDDraggable(this.el, opts);\r\n        }\r\n        else {\r\n            this.ddDraggable.updateOption(opts);\r\n        }\r\n        return this;\r\n    }\r\n    cleanDraggable() {\r\n        if (this.ddDraggable) {\r\n            this.ddDraggable.destroy();\r\n            delete this.ddDraggable;\r\n        }\r\n        return this;\r\n    }\r\n    setupResizable(opts) {\r\n        if (!this.ddResizable) {\r\n            this.ddResizable = new dd_resizable_1.DDResizable(this.el, opts);\r\n        }\r\n        else {\r\n            this.ddResizable.updateOption(opts);\r\n        }\r\n        return this;\r\n    }\r\n    cleanResizable() {\r\n        if (this.ddResizable) {\r\n            this.ddResizable.destroy();\r\n            delete this.ddResizable;\r\n        }\r\n        return this;\r\n    }\r\n    setupDroppable(opts) {\r\n        if (!this.ddDroppable) {\r\n            this.ddDroppable = new dd_droppable_1.DDDroppable(this.el, opts);\r\n        }\r\n        else {\r\n            this.ddDroppable.updateOption(opts);\r\n        }\r\n        return this;\r\n    }\r\n    cleanDroppable() {\r\n        if (this.ddDroppable) {\r\n            this.ddDroppable.destroy();\r\n            delete this.ddDroppable;\r\n        }\r\n        return this;\r\n    }\r\n}\r\nexports.DDElement = DDElement;\r\n//# sourceMappingURL=dd-element.js.map","\"use strict\";\r\n/**\r\n * utils.ts 7.3.0\r\n * Copyright (c) 2021 Alain Dumesny - see GridStack root license\r\n */\r\nObject.defineProperty(exports, \"__esModule\", { value: true });\r\nexports.Utils = exports.obsoleteAttr = exports.obsoleteOptsDel = exports.obsoleteOpts = exports.obsolete = void 0;\r\n/** checks for obsolete method names */\r\n// eslint-disable-next-line\r\nfunction obsolete(self, f, oldName, newName, rev) {\r\n    let wrapper = (...args) => {\r\n        console.warn('gridstack.js: Function `' + oldName + '` is deprecated in ' + rev + ' and has been replaced ' +\r\n            'with `' + newName + '`. It will be **removed** in a future release');\r\n        return f.apply(self, args);\r\n    };\r\n    wrapper.prototype = f.prototype;\r\n    return wrapper;\r\n}\r\nexports.obsolete = obsolete;\r\n/** checks for obsolete grid options (can be used for any fields, but msg is about options) */\r\nfunction obsoleteOpts(opts, oldName, newName, rev) {\r\n    if (opts[oldName] !== undefined) {\r\n        opts[newName] = opts[oldName];\r\n        console.warn('gridstack.js: Option `' + oldName + '` is deprecated in ' + rev + ' and has been replaced with `' +\r\n            newName + '`. It will be **removed** in a future release');\r\n    }\r\n}\r\nexports.obsoleteOpts = obsoleteOpts;\r\n/** checks for obsolete grid options which are gone */\r\nfunction obsoleteOptsDel(opts, oldName, rev, info) {\r\n    if (opts[oldName] !== undefined) {\r\n        console.warn('gridstack.js: Option `' + oldName + '` is deprecated in ' + rev + info);\r\n    }\r\n}\r\nexports.obsoleteOptsDel = obsoleteOptsDel;\r\n/** checks for obsolete Jquery element attributes */\r\nfunction obsoleteAttr(el, oldName, newName, rev) {\r\n    let oldAttr = el.getAttribute(oldName);\r\n    if (oldAttr !== null) {\r\n        el.setAttribute(newName, oldAttr);\r\n        console.warn('gridstack.js: attribute `' + oldName + '`=' + oldAttr + ' is deprecated on this object in ' + rev + ' and has been replaced with `' +\r\n            newName + '`. It will be **removed** in a future release');\r\n    }\r\n}\r\nexports.obsoleteAttr = obsoleteAttr;\r\n/**\r\n * Utility methods\r\n */\r\nclass Utils {\r\n    /** convert a potential selector into actual list of html elements */\r\n    static getElements(els) {\r\n        if (typeof els === 'string') {\r\n            let list = document.querySelectorAll(els);\r\n            if (!list.length && els[0] !== '.' && els[0] !== '#') {\r\n                list = document.querySelectorAll('.' + els);\r\n                if (!list.length) {\r\n                    list = document.querySelectorAll('#' + els);\r\n                }\r\n            }\r\n            return Array.from(list);\r\n        }\r\n        return [els];\r\n    }\r\n    /** convert a potential selector into actual single element */\r\n    static getElement(els) {\r\n        if (typeof els === 'string') {\r\n            if (!els.length)\r\n                return null;\r\n            if (els[0] === '#') {\r\n                return document.getElementById(els.substring(1));\r\n            }\r\n            if (els[0] === '.' || els[0] === '[') {\r\n                return document.querySelector(els);\r\n            }\r\n            // if we start with a digit, assume it's an id (error calling querySelector('#1')) as class are not valid CSS\r\n            if (!isNaN(+els[0])) { // start with digit\r\n                return document.getElementById(els);\r\n            }\r\n            // finally try string, then id then class\r\n            let el = document.querySelector(els);\r\n            if (!el) {\r\n                el = document.getElementById(els);\r\n            }\r\n            if (!el) {\r\n                el = document.querySelector('.' + els);\r\n            }\r\n            return el;\r\n        }\r\n        return els;\r\n    }\r\n    /** returns true if a and b overlap */\r\n    static isIntercepted(a, b) {\r\n        return !(a.y >= b.y + b.h || a.y + a.h <= b.y || a.x + a.w <= b.x || a.x >= b.x + b.w);\r\n    }\r\n    /** returns true if a and b touch edges or corners */\r\n    static isTouching(a, b) {\r\n        return Utils.isIntercepted(a, { x: b.x - 0.5, y: b.y - 0.5, w: b.w + 1, h: b.h + 1 });\r\n    }\r\n    /** returns the area a and b overlap */\r\n    static areaIntercept(a, b) {\r\n        let x0 = (a.x > b.x) ? a.x : b.x;\r\n        let x1 = (a.x + a.w < b.x + b.w) ? a.x + a.w : b.x + b.w;\r\n        if (x1 <= x0)\r\n            return 0; // no overlap\r\n        let y0 = (a.y > b.y) ? a.y : b.y;\r\n        let y1 = (a.y + a.h < b.y + b.h) ? a.y + a.h : b.y + b.h;\r\n        if (y1 <= y0)\r\n            return 0; // no overlap\r\n        return (x1 - x0) * (y1 - y0);\r\n    }\r\n    /** returns the area */\r\n    static area(a) {\r\n        return a.w * a.h;\r\n    }\r\n    /**\r\n     * Sorts array of nodes\r\n     * @param nodes array to sort\r\n     * @param dir 1 for asc, -1 for desc (optional)\r\n     * @param width width of the grid. If undefined the width will be calculated automatically (optional).\r\n     **/\r\n    static sort(nodes, dir, column) {\r\n        column = column || nodes.reduce((col, n) => Math.max(n.x + n.w, col), 0) || 12;\r\n        if (dir === -1)\r\n            return nodes.sort((a, b) => (b.x + b.y * column) - (a.x + a.y * column));\r\n        else\r\n            return nodes.sort((b, a) => (b.x + b.y * column) - (a.x + a.y * column));\r\n    }\r\n    /**\r\n     * creates a style sheet with style id under given parent\r\n     * @param id will set the 'gs-style-id' attribute to that id\r\n     * @param parent to insert the stylesheet as first child,\r\n     * if none supplied it will be appended to the document head instead.\r\n     */\r\n    static createStylesheet(id, parent, options) {\r\n        let style = document.createElement('style');\r\n        const nonce = options === null || options === void 0 ? void 0 : options.nonce;\r\n        if (nonce)\r\n            style.nonce = nonce;\r\n        style.setAttribute('type', 'text/css');\r\n        style.setAttribute('gs-style-id', id);\r\n        // eslint-disable-next-line @typescript-eslint/no-explicit-any\r\n        if (style.styleSheet) { // TODO: only CSSImportRule have that and different beast ??\r\n            // eslint-disable-next-line @typescript-eslint/no-explicit-any\r\n            style.styleSheet.cssText = '';\r\n        }\r\n        else {\r\n            style.appendChild(document.createTextNode('')); // WebKit hack\r\n        }\r\n        if (!parent) {\r\n            // default to head\r\n            parent = document.getElementsByTagName('head')[0];\r\n            parent.appendChild(style);\r\n        }\r\n        else {\r\n            parent.insertBefore(style, parent.firstChild);\r\n        }\r\n        return style.sheet;\r\n    }\r\n    /** removed the given stylesheet id */\r\n    static removeStylesheet(id) {\r\n        let el = document.querySelector('STYLE[gs-style-id=' + id + ']');\r\n        if (el && el.parentNode)\r\n            el.remove();\r\n    }\r\n    /** inserts a CSS rule */\r\n    static addCSSRule(sheet, selector, rules) {\r\n        if (typeof sheet.addRule === 'function') {\r\n            sheet.addRule(selector, rules);\r\n        }\r\n        else if (typeof sheet.insertRule === 'function') {\r\n            sheet.insertRule(`${selector}{${rules}}`);\r\n        }\r\n    }\r\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\r\n    static toBool(v) {\r\n        if (typeof v === 'boolean') {\r\n            return v;\r\n        }\r\n        if (typeof v === 'string') {\r\n            v = v.toLowerCase();\r\n            return !(v === '' || v === 'no' || v === 'false' || v === '0');\r\n        }\r\n        return Boolean(v);\r\n    }\r\n    static toNumber(value) {\r\n        return (value === null || value.length === 0) ? undefined : Number(value);\r\n    }\r\n    static parseHeight(val) {\r\n        let h;\r\n        let unit = 'px';\r\n        if (typeof val === 'string') {\r\n            let match = val.match(/^(-[0-9]+\\.[0-9]+|[0-9]*\\.[0-9]+|-[0-9]+|[0-9]+)(px|em|rem|vh|vw|%)?$/);\r\n            if (!match) {\r\n                throw new Error('Invalid height');\r\n            }\r\n            unit = match[2] || 'px';\r\n            h = parseFloat(match[1]);\r\n        }\r\n        else {\r\n            h = val;\r\n        }\r\n        return { h, unit };\r\n    }\r\n    /** copies unset fields in target to use the given default sources values */\r\n    // eslint-disable-next-line\r\n    static defaults(target, ...sources) {\r\n        sources.forEach(source => {\r\n            for (const key in source) {\r\n                if (!source.hasOwnProperty(key))\r\n                    return;\r\n                if (target[key] === null || target[key] === undefined) {\r\n                    target[key] = source[key];\r\n                }\r\n                else if (typeof source[key] === 'object' && typeof target[key] === 'object') {\r\n                    // property is an object, recursively add it's field over... #1373\r\n                    this.defaults(target[key], source[key]);\r\n                }\r\n            }\r\n        });\r\n        return target;\r\n    }\r\n    /** given 2 objects return true if they have the same values. Checks for Object {} having same fields and values (just 1 level down) */\r\n    static same(a, b) {\r\n        if (typeof a !== 'object')\r\n            return a == b;\r\n        if (typeof a !== typeof b)\r\n            return false;\r\n        // else we have object, check just 1 level deep for being same things...\r\n        if (Object.keys(a).length !== Object.keys(b).length)\r\n            return false;\r\n        for (const key in a) {\r\n            if (a[key] !== b[key])\r\n                return false;\r\n        }\r\n        return true;\r\n    }\r\n    /** copies over b size & position (GridStackPosition), and optionally min/max as well */\r\n    static copyPos(a, b, doMinMax = false) {\r\n        a.x = b.x;\r\n        a.y = b.y;\r\n        a.w = b.w;\r\n        a.h = b.h;\r\n        if (doMinMax) {\r\n            if (b.minW)\r\n                a.minW = b.minW;\r\n            if (b.minH)\r\n                a.minH = b.minH;\r\n            if (b.maxW)\r\n                a.maxW = b.maxW;\r\n            if (b.maxH)\r\n                a.maxH = b.maxH;\r\n        }\r\n        return a;\r\n    }\r\n    /** true if a and b has same size & position */\r\n    static samePos(a, b) {\r\n        return a && b && a.x === b.x && a.y === b.y && a.w === b.w && a.h === b.h;\r\n    }\r\n    /** removes field from the first object if same as the second objects (like diffing) and internal '_' for saving */\r\n    static removeInternalAndSame(a, b) {\r\n        if (typeof a !== 'object' || typeof b !== 'object')\r\n            return;\r\n        for (let key in a) {\r\n            let val = a[key];\r\n            if (key[0] === '_' || val === b[key]) {\r\n                delete a[key];\r\n            }\r\n            else if (val && typeof val === 'object' && b[key] !== undefined) {\r\n                for (let i in val) {\r\n                    if (val[i] === b[key][i] || i[0] === '_') {\r\n                        delete val[i];\r\n                    }\r\n                }\r\n                if (!Object.keys(val).length) {\r\n                    delete a[key];\r\n                }\r\n            }\r\n        }\r\n    }\r\n    /** removes internal fields '_' and default values for saving */\r\n    static removeInternalForSave(n, removeEl = true) {\r\n        for (let key in n) {\r\n            if (key[0] === '_' || n[key] === null || n[key] === undefined)\r\n                delete n[key];\r\n        }\r\n        delete n.grid;\r\n        if (removeEl)\r\n            delete n.el;\r\n        // delete default values (will be re-created on read)\r\n        if (!n.autoPosition)\r\n            delete n.autoPosition;\r\n        if (!n.noResize)\r\n            delete n.noResize;\r\n        if (!n.noMove)\r\n            delete n.noMove;\r\n        if (!n.locked)\r\n            delete n.locked;\r\n        if (n.w === 1 || n.w === n.minW)\r\n            delete n.w;\r\n        if (n.h === 1 || n.h === n.minH)\r\n            delete n.h;\r\n    }\r\n    /** return the closest parent (or itself) matching the given class */\r\n    static closestUpByClass(el, name) {\r\n        while (el) {\r\n            if (el.classList.contains(name))\r\n                return el;\r\n            el = el.parentElement;\r\n        }\r\n        return null;\r\n    }\r\n    /** delay calling the given function for given delay, preventing new calls from happening while waiting */\r\n    static throttle(func, delay) {\r\n        let isWaiting = false;\r\n        return (...args) => {\r\n            if (!isWaiting) {\r\n                isWaiting = true;\r\n                setTimeout(() => { func(...args); isWaiting = false; }, delay);\r\n            }\r\n        };\r\n    }\r\n    static removePositioningStyles(el) {\r\n        let style = el.style;\r\n        if (style.position) {\r\n            style.removeProperty('position');\r\n        }\r\n        if (style.left) {\r\n            style.removeProperty('left');\r\n        }\r\n        if (style.top) {\r\n            style.removeProperty('top');\r\n        }\r\n        if (style.width) {\r\n            style.removeProperty('width');\r\n        }\r\n        if (style.height) {\r\n            style.removeProperty('height');\r\n        }\r\n    }\r\n    /** @internal returns the passed element if scrollable, else the closest parent that will, up to the entire document scrolling element */\r\n    static getScrollElement(el) {\r\n        if (!el)\r\n            return document.scrollingElement || document.documentElement; // IE support\r\n        const style = getComputedStyle(el);\r\n        const overflowRegex = /(auto|scroll)/;\r\n        if (overflowRegex.test(style.overflow + style.overflowY)) {\r\n            return el;\r\n        }\r\n        else {\r\n            return this.getScrollElement(el.parentElement);\r\n        }\r\n    }\r\n    /** @internal */\r\n    static updateScrollPosition(el, position, distance) {\r\n        // is widget in view?\r\n        let rect = el.getBoundingClientRect();\r\n        let innerHeightOrClientHeight = (window.innerHeight || document.documentElement.clientHeight);\r\n        if (rect.top < 0 ||\r\n            rect.bottom > innerHeightOrClientHeight) {\r\n            // set scrollTop of first parent that scrolls\r\n            // if parent is larger than el, set as low as possible\r\n            // to get entire widget on screen\r\n            let offsetDiffDown = rect.bottom - innerHeightOrClientHeight;\r\n            let offsetDiffUp = rect.top;\r\n            let scrollEl = this.getScrollElement(el);\r\n            if (scrollEl !== null) {\r\n                let prevScroll = scrollEl.scrollTop;\r\n                if (rect.top < 0 && distance < 0) {\r\n                    // moving up\r\n                    if (el.offsetHeight > innerHeightOrClientHeight) {\r\n                        scrollEl.scrollTop += distance;\r\n                    }\r\n                    else {\r\n                        scrollEl.scrollTop += Math.abs(offsetDiffUp) > Math.abs(distance) ? distance : offsetDiffUp;\r\n                    }\r\n                }\r\n                else if (distance > 0) {\r\n                    // moving down\r\n                    if (el.offsetHeight > innerHeightOrClientHeight) {\r\n                        scrollEl.scrollTop += distance;\r\n                    }\r\n                    else {\r\n                        scrollEl.scrollTop += offsetDiffDown > distance ? distance : offsetDiffDown;\r\n                    }\r\n                }\r\n                // move widget y by amount scrolled\r\n                position.top += scrollEl.scrollTop - prevScroll;\r\n            }\r\n        }\r\n    }\r\n    /**\r\n     * @internal Function used to scroll the page.\r\n     *\r\n     * @param event `MouseEvent` that triggers the resize\r\n     * @param el `HTMLElement` that's being resized\r\n     * @param distance Distance from the V edges to start scrolling\r\n     */\r\n    static updateScrollResize(event, el, distance) {\r\n        const scrollEl = this.getScrollElement(el);\r\n        const height = scrollEl.clientHeight;\r\n        // #1727 event.clientY is relative to viewport, so must compare this against position of scrollEl getBoundingClientRect().top\r\n        // #1745 Special situation if scrollEl is document 'html': here browser spec states that\r\n        // clientHeight is height of viewport, but getBoundingClientRect() is rectangle of html element;\r\n        // this discrepancy arises because in reality scrollbar is attached to viewport, not html element itself.\r\n        const offsetTop = (scrollEl === this.getScrollElement()) ? 0 : scrollEl.getBoundingClientRect().top;\r\n        const pointerPosY = event.clientY - offsetTop;\r\n        const top = pointerPosY < distance;\r\n        const bottom = pointerPosY > height - distance;\r\n        if (top) {\r\n            // This also can be done with a timeout to keep scrolling while the mouse is\r\n            // in the scrolling zone. (will have smoother behavior)\r\n            scrollEl.scrollBy({ behavior: 'smooth', top: pointerPosY - distance });\r\n        }\r\n        else if (bottom) {\r\n            scrollEl.scrollBy({ behavior: 'smooth', top: distance - (height - pointerPosY) });\r\n        }\r\n    }\r\n    /** single level clone, returning a new object with same top fields. This will share sub objects and arrays */\r\n    static clone(obj) {\r\n        if (obj === null || obj === undefined || typeof (obj) !== 'object') {\r\n            return obj;\r\n        }\r\n        // return Object.assign({}, obj);\r\n        if (obj instanceof Array) {\r\n            // eslint-disable-next-line @typescript-eslint/no-explicit-any\r\n            return [...obj];\r\n        }\r\n        return Object.assign({}, obj);\r\n    }\r\n    /**\r\n     * Recursive clone version that returns a full copy, checking for nested objects and arrays ONLY.\r\n     * Note: this will use as-is any key starting with double __ (and not copy inside) some lib have circular dependencies.\r\n     */\r\n    static cloneDeep(obj) {\r\n        // list of fields we will skip during cloneDeep (nested objects, other internal)\r\n        const skipFields = ['parentGrid', 'el', 'grid', 'subGrid', 'engine'];\r\n        // return JSON.parse(JSON.stringify(obj)); // doesn't work with date format ?\r\n        const ret = Utils.clone(obj);\r\n        for (const key in ret) {\r\n            // NOTE: we don't support function/circular dependencies so skip those properties for now...\r\n            if (ret.hasOwnProperty(key) && typeof (ret[key]) === 'object' && key.substring(0, 2) !== '__' && !skipFields.find(k => k === key)) {\r\n                ret[key] = Utils.cloneDeep(obj[key]);\r\n            }\r\n        }\r\n        return ret;\r\n    }\r\n    /** deep clone the given HTML node, removing teh unique id field */\r\n    static cloneNode(el) {\r\n        const node = el.cloneNode(true);\r\n        node.removeAttribute('id');\r\n        return node;\r\n    }\r\n    static appendTo(el, parent) {\r\n        let parentNode;\r\n        if (typeof parent === 'string') {\r\n            parentNode = document.querySelector(parent);\r\n        }\r\n        else {\r\n            parentNode = parent;\r\n        }\r\n        if (parentNode) {\r\n            parentNode.appendChild(el);\r\n        }\r\n    }\r\n    // public static setPositionRelative(el: HTMLElement): void {\r\n    //   if (!(/^(?:r|a|f)/).test(window.getComputedStyle(el).position)) {\r\n    //     el.style.position = \"relative\";\r\n    //   }\r\n    // }\r\n    static addElStyles(el, styles) {\r\n        if (styles instanceof Object) {\r\n            for (const s in styles) {\r\n                if (styles.hasOwnProperty(s)) {\r\n                    if (Array.isArray(styles[s])) {\r\n                        // support fallback value\r\n                        styles[s].forEach(val => {\r\n                            el.style[s] = val;\r\n                        });\r\n                    }\r\n                    else {\r\n                        el.style[s] = styles[s];\r\n                    }\r\n                }\r\n            }\r\n        }\r\n    }\r\n    static initEvent(e, info) {\r\n        const evt = { type: info.type };\r\n        const obj = {\r\n            button: 0,\r\n            which: 0,\r\n            buttons: 1,\r\n            bubbles: true,\r\n            cancelable: true,\r\n            target: info.target ? info.target : e.target\r\n        };\r\n        // don't check for `instanceof DragEvent` as Safari use MouseEvent #1540\r\n        if (e.dataTransfer) {\r\n            evt['dataTransfer'] = e.dataTransfer; // workaround 'readonly' field.\r\n        }\r\n        ['altKey', 'ctrlKey', 'metaKey', 'shiftKey'].forEach(p => evt[p] = e[p]); // keys\r\n        ['pageX', 'pageY', 'clientX', 'clientY', 'screenX', 'screenY'].forEach(p => evt[p] = e[p]); // point info\r\n        return Object.assign(Object.assign({}, evt), obj);\r\n    }\r\n    /** copies the MouseEvent properties and sends it as another event to the given target */\r\n    static simulateMouseEvent(e, simulatedType, target) {\r\n        const simulatedEvent = document.createEvent('MouseEvents');\r\n        simulatedEvent.initMouseEvent(simulatedType, // type\r\n        true, // bubbles\r\n        true, // cancelable\r\n        window, // view\r\n        1, // detail\r\n        e.screenX, // screenX\r\n        e.screenY, // screenY\r\n        e.clientX, // clientX\r\n        e.clientY, // clientY\r\n        e.ctrlKey, // ctrlKey\r\n        e.altKey, // altKey\r\n        e.shiftKey, // shiftKey\r\n        e.metaKey, // metaKey\r\n        0, // button\r\n        e.target // relatedTarget\r\n        );\r\n        (target || e.target).dispatchEvent(simulatedEvent);\r\n    }\r\n}\r\nexports.Utils = Utils;\r\n//# sourceMappingURL=utils.js.map","\"use strict\";\r\n/**\r\n * dd-manager.ts 7.3.0\r\n * Copyright (c) 2021 Alain Dumesny - see GridStack root license\r\n */\r\nObject.defineProperty(exports, \"__esModule\", { value: true });\r\nexports.DDManager = void 0;\r\n/**\r\n * globals that are shared across Drag & Drop instances\r\n */\r\nclass DDManager {\r\n}\r\nexports.DDManager = DDManager;\r\n//# sourceMappingURL=dd-manager.js.map"],"sourceRoot":""}