{"version":3,"sources":["webpack://GridStack/webpack/universalModuleDefinition","webpack://GridStack/./src/gridstack-dd.ts","webpack://GridStack/./src/gridstack-ddi.ts","webpack://GridStack/./src/gridstack-engine.ts","webpack://GridStack/./src/gridstack-h5.ts","webpack://GridStack/./src/gridstack.ts","webpack://GridStack/./src/h5/dd-base-impl.ts","webpack://GridStack/./src/h5/dd-draggable.ts","webpack://GridStack/./src/h5/dd-droppable.ts","webpack://GridStack/./src/h5/dd-element.ts","webpack://GridStack/./src/h5/dd-manager.ts","webpack://GridStack/./src/h5/dd-resizable-handle.ts","webpack://GridStack/./src/h5/dd-resizable.ts","webpack://GridStack/./src/h5/dd-utils.ts","webpack://GridStack/./src/h5/gridstack-dd-native.ts","webpack://GridStack/./src/utils.ts","webpack://GridStack/webpack/bootstrap","webpack://GridStack/webpack/startup"],"names":["root","factory","exports","module","define","amd","self","GridStackDD","GridStackDDI","get","el","this","draggable","resizable","gridstackNode","_initDD","_itemRemoving","remove","node","undefined","grid","_isAboutToRemove","classList","add","GridStack","prototype","_setupAcceptWidget","opts","staticGrid","acceptWidgets","removable","droppable","cellHeight","cellWidth","onDrag","event","helper","parent","getBoundingClientRect","top","left","ui","position","_temporaryRemoved","x","Math","max","round","y","autoPosition","engine","nodeBoundFix","willItFit","off","_willFitPos","Utils","copyPos","_onStartMoving","_dragOrResize","accept","subGrid","canAccept","selector","matches","maxRow","n","w","h","minW","minH","on","_leave","getCellHeight","_readAttr","_isExternal","offsetWidth","offsetHeight","_gridstackNodeOrig","cleanupNode","wasAdded","placeholder","parentElement","origNode","oGrid","removedNodes","push","_triggerRemoveEvent","cloneNode","removePositioningStyles","_writeAttr","appendChild","_updateContainerHeight","addedNodes","_triggerAddEvent","_triggerChangeEvent","endUpdate","_gsEventHandler","type","window","setTimeout","_prepareDragDropByNode","removeNode","_setupRemoveDrop","trashEl","document","querySelector","isDroppable","removableOptions","setupDragIn","_dragIn","_dragInOptions","dragIn","dragInOptions","revert","handle","scroll","appendTo","dd","getElements","forEach","isDraggable","noMove","disableDrag","noResize","disableResize","onStartMoving","target","dragOrResize","onEndMoving","_moving","_lastTried","gridToNotify","_orig","_writePosAttr","addNode","_extraDragRow","start","stop","drag","resize","cleanNodes","beginUpdate","_lastUiPosition","_prevYPix","cacheRects","marginTop","marginRight","marginBottom","marginLeft","maxW","maxH","restoreInitial","resizing","p","mLeft","mRight","mTop","mBottom","mHeight","mWidth","min","distance","updateScrollPosition","prev","collide","row","getRow","extra","updateScrollResize","size","width","height","rect","moveNodeCheck","_skipDown","onParentResize","movable","els","val","disable","enableMove","enableResize","_triggerEvent","enable","doEnable","nodes","pluginClass","ddi","registerPlugin","GridStackEngine","column","_float","float","onChange","batchMode","_prevFloat","saveInitial","_packNodes","_notify","nn","_hasLocked","opt","sortNodes","nested","swap","area","_useEntireRowArea","skip","didMove","newOpt","pack","moved","locked","moveNode","skip2","find","isIntercepted","filter","o","collides","_rect","r0","r","r2","yOver","Number","MAX_VALUE","xOver","overMax","over","right","bottom","a","b","_doSwap","_dirty","touching","isTouching","t","length","batchUpdate","copyNodes","commit","dir","sort","_updating","newY","i","_id","_idSeq","defaults","isNaN","before","_inColumnResize","cacheOneLayout","samePos","verify","dirtyNodes","concat","getDirtyNodes","some","triggerAddEvent","dup","prepareNode","_removeDOM","floor","box","_fixCollisions","removeDOM","triggerEvent","_layouts","changedPosConstrain","clonedNode","clone","map","canMove","c","content","prevPos","collideAll","needToMove","collideCoverage","reduce","saveElement","len","layout","list","wl","l","key","ratio","prevColumn","cacheLayout","newNodes","domOrder","cacheNodes","lastIndex","cacheNode","j","findIndex","splice","move","scale","clear","copy","index","prop","GridDefaults","minRow","itemClass","placeholderClass","placeholderText","handleClass","styleInHead","cellHeightThrottle","margin","auto","oneColumnSize","animate","alwaysShowResizeHandle","autoHide","handles","rtl","marginUnit","cellHeightUnit","disableOneColumnMode","oneColumnModeDomSort","rowAttr","toNumber","getAttribute","anyOpts","minWidth","cloneDeep","toBool","_styleSheetClass","random","toFixed","_initMargin","_widthOrContainer","_prevColumn","getColumn","style","direction","parentGridItemEl","closestByClass","_isNested","_isAutoCellHeight","_setStaticClass","engineClass","cbNodes","_updateStyles","elements","getGridItems","parseInt","e","_prepareElement","setAnimation","_updateWindowResizeEvent","options","elOrString","getGridElement","gridstack","console","error","grids","getGridElements","contains","doc","implementation","createHTMLDocument","body","innerHTML","class","children","init","load","_placeholder","placeholderChild","createElement","className","arguments","warn","id","addWidget","domAttr","_insertNotAppend","prepend","autoColumn","ops","addGrid","_autoColumn","saveContent","saveGridOpt","save","sub","removeInternalAndSame","addAndRemove","items","_ignoreLayoutsNodeChange","removed","removeWidget","item","update","forcePixel","rows","marginDiff","data","parseHeight","unit","clientWidth","innerWidth","compact","domNodes","oldColumn","updateNodeWidths","Array","from","setStatic","parentNode","removeChild","removeAll","_removeStylesheet","removeAttribute","useDocRelative","containerPos","documentElement","scrollTop","offsetTop","offsetLeft","relativeLeft","relativeTop","columnWidth","rowHeight","isAreaEmpty","getElement","name","callback","indexOf","split","noData","detail","addEventListener","log","removeEventListener","doAnimate","updateClass","m","keys","k","changed","ddChanged","value","layoutsNodesChange","CustomEvent","bubbles","Event","dispatchEvent","_styles","removeStylesheet","forceUpdate","prefix","styleLocation","createStylesheet","_max","addCSSRule","getHeight","setAttribute","String","removeProperty","same","attrs","resizeHandles","hasOwnProperty","classes","changedColumn","oneColumn","_cellHeightThrottle","throttle","forceRemove","workTodo","_windowResizeBind","bind","margins","Engine","_disabled","_eventRegister","eventName","disabled","DDDraggable","DDBaseImplement","option","super","dragging","containmentRect","offset","substring","dragEl","_dragStart","_drag","_dragEnd","forDestroy","destroy","Object","DDManager","dragElement","_createHelper","_setupHelperContainmentStyle","dragOffset","_getDragOffset","helperContainment","ev","DDUtils","initEvent","_setupDragFollowNodeNotifyStart","_dragFollow","dragFollowTimer","_cancelDragGhost","_setupHelperStyle","dragEventListenerOption","preventDefault","clearTimeout","paintTimer","cancelAnimationFrame","parentOriginStylePosition","_removeHelperStyle","dragElementOriginStyle","originStyleProp","rec","pointerEvents","willChange","transition","requestAnimationFrame","clientX","clientY","getComputedStyle","match","img","dataTransfer","setDragImage","stopPropagation","xformOffsetX","xformOffsetY","testEl","addElStyles","opacity","zIndex","testElPosition","targetOffset","DDDroppable","_dragEnter","_dragOver","_dragLeave","_drop","_setupAccept","_removeLeaveCallbacks","_canDrop","moving","_ui","lastActive","forceLeave","onChild","inside","out","drop","DDElement","ddElement","ddDraggable","ddDroppable","ddResizable","updateOption","DDResizable","DDResizableHandle","host","_mouseDown","_mouseMove","_mouseUp","_init","userSelect","mouseDownEvent","s","abs","_showHandlers","_hideHandlers","newRect","originalRect","scrolled","temporalRect","_setupAutoHide","_setupHandlers","_removeHandlers","updateHandles","updateAutoHide","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","minHeight","containmentEl","test","styles","isArray","info","evt","obj","button","which","buttons","cancelable","relatedTarget","fromElement","isEventSupportPassiveOption","supportsPassive","passiveTest","GridStackDDNative","_getDDElements","dEl","cleanResizable","setupResizable","cleanDraggable","setupDraggable","containment","dragOut","_accept","cleanDroppable","setupDroppable","create","hosts","d","f","oldName","newName","rev","wrapper","args","apply","oldAttr","querySelectorAll","getElementById","col","styleSheet","cssText","createTextNode","insertBefore","firstChild","getElementsByTagName","sheet","rules","addRule","insertRule","v","toLowerCase","Boolean","Error","parseFloat","sources","source","doMinMax","func","delay","isWaiting","scrollingElement","overflow","overflowY","innerHeightOrClientHeight","innerHeight","clientHeight","offsetDiffDown","offsetDiffUp","prevScroll","pointerPosY","scrollBy","behavior","ret","skipFields","__webpack_module_cache__","__webpack_exports__","__webpack_require__","moduleId","cachedModule","__webpack_modules__","call"],"mappings":"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","file":"gridstack-h5.js","sourcesContent":["(function webpackUniversalModuleDefinition(root, factory) {\n\tif(typeof exports === 'object' && typeof module === 'object')\n\t\tmodule.exports = factory();\n\telse if(typeof define === 'function' && define.amd)\n\t\tdefine([], factory);\n\telse if(typeof exports === 'object')\n\t\texports[\"GridStack\"] = factory();\n\telse\n\t\troot[\"GridStack\"] = factory();\n})(self, function() {\nreturn ","/**\r\n * gridstack-dd.ts 5.1.1\r\n * Copyright (c) 2021 Alain Dumesny - see GridStack root license\r\n */\r\n\r\n/* eslint-disable @typescript-eslint/no-unused-vars */\r\nimport { GridStackDDI } from './gridstack-ddi';\r\nimport { GridItemHTMLElement, GridStackNode, GridStackElement, DDUIData, DDDragInOpt, GridStackPosition } from './types';\r\nimport { GridStack, MousePosition } from './gridstack';\r\nimport { Utils } from './utils';\r\n\r\n/** Drag&Drop drop options */\r\nexport type DDDropOpt = {\r\n  /** function or class type that this grid will accept as dropped items (see GridStackOptions.acceptWidgets) */\r\n  accept?: (el: GridItemHTMLElement) => boolean;\r\n}\r\n\r\n/** drag&drop options currently called from the main code, but others can be passed in grid options */\r\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\r\nexport type DDOpts = 'enable' | 'disable' | 'destroy' | 'option' | string | any;\r\nexport type DDKey = 'minWidth' | 'minHeight' | 'maxWidth' | 'maxHeight';\r\nexport type DDValue = number | string;\r\n\r\n/** drag&drop events callbacks */\r\nexport type DDCallback = (event: Event, arg2: GridItemHTMLElement, helper?: GridItemHTMLElement) => void;\r\n\r\n// TEST let count = 0;\r\n\r\n/**\r\n * Base class implementing common Grid drag'n'drop functionality, with domain specific subclass (h5 vs jq subclasses)\r\n */\r\nexport abstract class GridStackDD extends GridStackDDI {\r\n\r\n  /** override to cast to correct type */\r\n  static get(): GridStackDD {\r\n    return GridStackDDI.get() as GridStackDD;\r\n  }\r\n\r\n  /** removes any drag&drop present (called during destroy) */\r\n  public remove(el: GridItemHTMLElement): GridStackDD {\r\n    this.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    return this;\r\n  }\r\n\r\n  // APIs that must be implemented by subclasses to do actual darg/drop/resize called by GridStack code below\r\n\r\n  public abstract resizable(el: GridItemHTMLElement, opts: DDOpts, key?: DDKey, value?: DDValue): GridStackDD;\r\n\r\n  public abstract isResizable(el: HTMLElement): boolean;\r\n\r\n  public abstract draggable(el: GridItemHTMLElement, opts: DDOpts, key?: DDKey, value?: DDValue): GridStackDD;\r\n\r\n  public abstract dragIn(el: GridStackElement, opts: DDDragInOpt): GridStackDD;\r\n\r\n  public abstract isDraggable(el: HTMLElement): boolean;\r\n\r\n  public abstract droppable(el: GridItemHTMLElement, opts: DDOpts | DDDropOpt, key?: DDKey, value?: DDValue): GridStackDD;\r\n\r\n  public abstract isDroppable(el: HTMLElement): boolean;\r\n\r\n  public abstract on(el: GridItemHTMLElement, eventName: string, callback: DDCallback): GridStackDD;\r\n\r\n  public abstract off(el: GridItemHTMLElement, eventName: string): GridStackDD;\r\n}\r\n\r\n/********************************************************************************\r\n * GridStack code that is doing drag&drop extracted here so main class is smaller\r\n * for static grid that don't do any of this work anyway. Saves about 10k.\r\n * https://www.typescriptlang.org/docs/handbook/declaration-merging.html\r\n * https://www.typescriptlang.org/docs/handbook/mixins.html\r\n ********************************************************************************/\r\n\r\n/** @internal called to add drag over to support widgets being added externally */\r\nGridStack.prototype._setupAcceptWidget = function(this: GridStack): GridStack {\r\n\r\n  // check if we need to disable things\r\n  if (this.opts.staticGrid || (!this.opts.acceptWidgets && !this.opts.removable)) {\r\n    GridStackDD.get().droppable(this.el, 'destroy');\r\n    return this;\r\n  }\r\n\r\n  // vars shared across all methods\r\n  let cellHeight: number, cellWidth: number;\r\n\r\n  let onDrag = (event: DragEvent, el: GridItemHTMLElement, helper: GridItemHTMLElement) => {\r\n    let node = el.gridstackNode;\r\n    if (!node) return;\r\n\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: DDUIData = {position: {top, left}};\r\n\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\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          GridStackDD.get().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.copyPos(node, node._willFitPos);\r\n          delete node._willFitPos;\r\n        }\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    } 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\r\n  GridStackDD.get()\r\n    .droppable(this.el, {\r\n      accept: (el: GridItemHTMLElement) => {\r\n        let node: GridStackNode = 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?.grid === this) return true;\r\n        if (!this.opts.acceptWidgets) return false;\r\n        // prevent deeper nesting until rest of 992 can be fixed\r\n        if (node?.subGrid) 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        } else {\r\n          let selector = (this.opts.acceptWidgets === true ? '.grid-stack-item' : this.opts.acceptWidgets as string);\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: Event, el: GridItemHTMLElement, helper: GridItemHTMLElement) => {\r\n      // TEST console.log(`over ${this.el.gridstack.opts.id} ${count++}`);\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?.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\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?.grid && node.grid !== this && !node._temporaryRemoved) {\r\n        // TEST console.log('dropover without leave');\r\n        let otherGrid = node.grid;\r\n        otherGrid._leave(el, helper);\r\n      }\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\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\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\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        // TEST console.log('dropover cloning node');\r\n        if (!el._gridstackNodeOrig) el._gridstackNodeOrig = node; // shouldn't have multiple nested!\r\n        el.gridstackNode = node = {...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      } else {\r\n        node.w = w; node.h = h;\r\n        node._temporaryRemoved = true; // so we can insert it\r\n      }\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      _itemRemoving(node.el, false);\r\n\r\n      GridStackDD.get().on(el, 'drag', onDrag);\r\n      // make sure this is called at least once when going fast #1578\r\n      onDrag(event as DragEvent, 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: GridItemHTMLElement, helper: GridItemHTMLElement) => {\r\n      // TEST console.log(`out ${this.el.gridstack.opts.id} ${count++}`);\r\n      let node = el.gridstackNode;\r\n      if (!node) 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      }\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: GridItemHTMLElement, helper: GridItemHTMLElement) => {\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?.grid === this && !node._isExternal) return false;\r\n\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\r\n      // notify previous grid of removal\r\n      // TEST console.log('drop delete _gridstackNodeOrig')\r\n      let origNode = el._gridstackNodeOrig;\r\n      delete el._gridstackNodeOrig;\r\n      if (wasAdded && origNode && origNode.grid && origNode.grid !== this) {\r\n        let oGrid = origNode.grid;\r\n        oGrid.engine.removedNodes.push(origNode);\r\n        oGrid._triggerRemoveEvent();\r\n      }\r\n\r\n      if (!node) return false;\r\n\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      GridStackDD.get().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\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) as GridItemHTMLElement;\r\n        }\r\n      } else {\r\n        el.remove(); // reduce flicker as we change depth here, and size further down\r\n        GridStackDD.get().remove(el);\r\n      }\r\n      if (!wasAdded) return false;\r\n      el.gridstackNode = node;\r\n      node.el = el;\r\n      // @ts-ignore\r\n      Utils.copyPos(node, this._readAttr(this.placeholder)); // placeholder values as moving VERY fast can throw things off #1578\r\n      Utils.removePositioningStyles(el);// @ts-ignore\r\n      this._writeAttr(el, node);\r\n      this.el.appendChild(el);// @ts-ignore\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\r\n      this.engine.endUpdate();\r\n      if (this._gsEventHandler['dropped']) {\r\n        this._gsEventHandler['dropped']({...event, type: 'dropped'}, origNode && origNode.grid ? origNode : undefined, node);\r\n      }\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        } else {\r\n          this.engine.removeNode(node);\r\n        }\r\n      });\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\r\n/** @internal mark item for removal */\r\nfunction _itemRemoving(el: GridItemHTMLElement, remove: boolean) {\r\n  let node = el ? el.gridstackNode : undefined;\r\n  if (!node || !node.grid) 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\r\n/** @internal called to setup a trash drop zone if the user specifies it */\r\nGridStack.prototype._setupRemoveDrop = function(this: GridStack): GridStack {\r\n  if (!this.opts.staticGrid && typeof this.opts.removable === 'string') {\r\n    let trashEl = document.querySelector(this.opts.removable) as HTMLElement;\r\n    if (!trashEl) 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 (!GridStackDD.get().isDroppable(trashEl)) {\r\n      GridStackDD.get().droppable(trashEl, this.opts.removableOptions)\r\n        .on(trashEl, 'dropover', (event, el) => _itemRemoving(el, true))\r\n        .on(trashEl, 'dropout',  (event, el) => _itemRemoving(el, false));\r\n    }\r\n  }\r\n  return this;\r\n}\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 cached) in case the toolbar\r\n * is dynamically create and needs to change later.\r\n **/\r\nGridStack.setupDragIn = function(this: GridStack, _dragIn?: string, _dragInOptions?: DDDragInOpt) {\r\n  let dragIn: string;\r\n  let dragInOptions: DDDragInOpt;\r\n  const dragInDefaultOptions: DDDragInOpt = {\r\n    revert: 'invalid',\r\n    handle: '.grid-stack-item-content',\r\n    scroll: false,\r\n    appendTo: 'body'\r\n  };\r\n\r\n  // cache in the passed in values (form grid init?) so they don't have to resend them each time\r\n  if (_dragIn) {\r\n    dragIn = _dragIn;\r\n    dragInOptions = {...dragInDefaultOptions, ...(_dragInOptions || {})};\r\n  }\r\n  if (typeof dragIn !== 'string') return;\r\n  let dd = GridStackDD.get();\r\n  Utils.getElements(dragIn).forEach(el => {\r\n    if (!dd.isDraggable(el)) dd.dragIn(el, dragInOptions);\r\n  });\r\n}\r\n\r\n/** @internal prepares the element for drag&drop **/\r\nGridStack.prototype._prepareDragDropByNode = function(this: GridStack, node: GridStackNode): GridStack {\r\n  let el = node.el;\r\n  let dd = GridStackDD.get();\r\n\r\n  // check for disabled grid first\r\n  if (this.opts.staticGrid || ((node.noMove || this.opts.disableDrag) && (node.noResize || this.opts.disableResize))) {\r\n    if (node._initDD) {\r\n      dd.remove(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\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: number;\r\n    let cellHeight: number;\r\n\r\n    /** called when item starts moving/resizing */\r\n    let onStartMoving = (event: Event, ui: DDUIData) => {\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\r\n      this._onStartMoving(el, event, ui, node, cellWidth, cellHeight);\r\n    }\r\n\r\n    /** called when item is being dragged/resized */\r\n    let dragOrResize = (event: Event, ui: DDUIData) => {\r\n      this._dragOrResize(el, event, ui, node, cellWidth, cellHeight);\r\n    }\r\n\r\n    /** called when the item stops moving/resizing */\r\n    let onEndMoving = (event: Event) => {\r\n      this.placeholder.remove();\r\n      delete node._moving;\r\n      delete node._lastTried;\r\n\r\n      // if the item has moved to another grid, we're done here\r\n      let target: GridItemHTMLElement = event.target as GridItemHTMLElement;\r\n      if (!target.gridstackNode || target.gridstackNode.grid !== this) return;\r\n\r\n      node.el = target;\r\n\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        dd.remove(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      } else {\r\n        if (!node._temporaryRemoved) {\r\n          // move to new placeholder location\r\n          Utils.removePositioningStyles(target);// @ts-ignore\r\n          this._writePosAttr(target, node);\r\n        } else {\r\n          // got removed - restore item back to before dragging position\r\n          Utils.removePositioningStyles(target);\r\n          Utils.copyPos(node, node._orig);// @ts-ignore\r\n          this._writePosAttr(target, node);\r\n          this.engine.addNode(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\r\n      this.engine.endUpdate();\r\n    }\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\r\n  // finally fine tune move vs resize by disabling any part...\r\n  if (node.noMove || this.opts.disableDrag) {\r\n    dd.draggable(el, 'disable');\r\n    el.classList.add('ui-draggable-disabled');\r\n  } else {\r\n    dd.draggable(el, 'enable');\r\n    el.classList.remove('ui-draggable-disabled');\r\n  }\r\n  if (node.noResize || this.opts.disableResize) {\r\n    dd.resizable(el, 'disable');\r\n    el.classList.add('ui-resizable-disabled');\r\n  } else {\r\n    dd.resizable(el, 'enable');\r\n    el.classList.remove('ui-resizable-disabled');\r\n  }\r\n\r\n  return this;\r\n}\r\n\r\n/** @internal called when item is starting a drag/resize */\r\nGridStack.prototype._onStartMoving = function(this: GridStack, el: GridItemHTMLElement, event: Event, ui: DDUIData, node: GridStackNode, cellWidth: number, cellHeight: number) {\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  // TEST console.log('_onStartMoving placeholder')\r\n\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\r\n  if (event.type === 'dropover' && node._temporaryRemoved) {\r\n    // TEST console.log('engine.addNode x=' + node.x);\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\r\n  // set the min/max resize info\r\n  this.engine.cacheRects(cellWidth, cellHeight, this.opts.marginTop as number, this.opts.marginRight as number, this.opts.marginBottom as number, this.opts.marginLeft as number);\r\n  if (event.type === 'resizestart') {\r\n    let dd = GridStackDD.get()\r\n      .resizable(el, 'option', 'minWidth', cellWidth * (node.minW || 1))\r\n      .resizable(el, 'option', 'minHeight', cellHeight * (node.minH || 1));\r\n    if (node.maxW) { dd.resizable(el, 'option', 'maxWidth', cellWidth * node.maxW); }\r\n    if (node.maxH) { dd.resizable(el, 'option', 'maxHeight', cellHeight * node.maxH); }\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\nGridStack.prototype._leave = function(this: GridStack, el: GridItemHTMLElement, helper?: GridItemHTMLElement)  {\r\n  let node = el.gridstackNode;\r\n  if (!node) return;\r\n\r\n  GridStackDD.get().off(el, 'drag'); // no need to track while being outside\r\n\r\n  // this gets called when cursor leaves and shape is outside, so only do this once\r\n  if (node._temporaryRemoved) return;\r\n  node._temporaryRemoved = true;\r\n\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\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    _itemRemoving(el, true);\r\n  }\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    // TEST console.log('leave delete _gridstackNodeOrig')\r\n    el.gridstackNode = el._gridstackNodeOrig;\r\n    delete el._gridstackNodeOrig;\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\r\n/** @internal called when item is being dragged/resized */\r\nGridStack.prototype._dragOrResize = function(this: GridStack, el: GridItemHTMLElement, event: Event, ui: DDUIData, node: GridStackNode, cellWidth: number, cellHeight: number)  {\r\n  let p = {...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: boolean;\r\n  let mLeft = this.opts.marginLeft as number,\r\n    mRight = this.opts.marginRight as number,\r\n    mTop = this.opts.marginTop as number,\r\n    mBottom = this.opts.marginBottom as number;\r\n\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),\r\n    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\r\n  if (event.type === 'drag') {\r\n    if (node._temporaryRemoved) return; // handled by dropover\r\n    let distance = ui.position.top - node._prevYPix;\r\n    node._prevYPix = ui.position.top;\r\n    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\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    } else this._extraDragRow = 0;// @ts-ignore\r\n    if (this._extraDragRow !== prev) this._updateContainerHeight();\r\n\r\n    if (node.x === p.x && node.y === p.y) 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  } else if (event.type === 'resize')  {\r\n    if (p.x < 0) return;\r\n    // Scrolling page if needed\r\n    Utils.updateScrollResize(event as MouseEvent, el, cellHeight);\r\n\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) return;\r\n    if (node._lastTried && node._lastTried.w === p.w && node._lastTried.h === p.h) return; // skip one we tried (but failed)\r\n\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\r\n    resizing = true;\r\n  }\r\n\r\n  node._lastTried = p; // set as last tried (will nuke if we go there)\r\n  let rect: GridStackPosition = { // screen pix of the dragged box\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, {...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) { (node.subGrid as GridStack).onParentResize(); }// @ts-ignore\r\n    this._extraDragRow = 0;// @ts-ignore\r\n    this._updateContainerHeight();\r\n\r\n    let target = event.target as GridItemHTMLElement;// @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\r\n/**\r\n * Enables/Disables moving.\r\n * @param els widget or selector to modify.\r\n * @param val if true widget will be draggable.\r\n */\r\nGridStack.prototype.movable = function(this: GridStack, els: GridStackElement, val: boolean): GridStack {\r\n  if (this.opts.staticGrid) 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) return;\r\n    if (val) delete node.noMove; else 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/**\r\n * Enables/Disables resizing.\r\n * @param els  widget or selector to modify\r\n * @param val  if true widget will be resizable.\r\n */\r\nGridStack.prototype.resizable = function(this: GridStack, els: GridStackElement, val: boolean): GridStack {\r\n  if (this.opts.staticGrid) 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) return;\r\n    if (val) delete node.noResize; else 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\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  */\r\nGridStack.prototype.disable = function(this: GridStack): GridStack {\r\n  if (this.opts.staticGrid) return;\r\n  this.enableMove(false);\r\n  this.enableResize(false);// @ts-ignore\r\n  this._triggerEvent('disable');\r\n  return this;\r\n}\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  */\r\nGridStack.prototype.enable = function(this: GridStack): GridStack {\r\n  if (this.opts.staticGrid) return;\r\n  this.enableMove(true);\r\n  this.enableResize(true);// @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\nGridStack.prototype.enableMove = function(this: GridStack, doEnable: boolean): GridStack {\r\n  if (this.opts.staticGrid) 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 => this.movable(n.el, doEnable));\r\n  return this;\r\n}\r\n\r\n/** Enables/disables widget resizing. No-op for static grids. */\r\nGridStack.prototype.enableResize = function(this: GridStack, doEnable: boolean): GridStack {\r\n  if (this.opts.staticGrid) 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 => this.resizable(n.el, doEnable));\r\n  return this;\r\n}\r\n","/**\r\n * gridstack-ddi.ts 5.1.1\r\n * Copyright (c) 2021 Alain Dumesny - see GridStack root license\r\n */\r\n\r\nimport { GridItemHTMLElement } from './types';\r\n\r\n/**\r\n * Abstract Partial Interface API for drag'n'drop plugin - look at GridStackDD and HTML5 / Jquery implementation versions\r\n */\r\nexport class GridStackDDI {\r\n\r\n  protected static ddi: GridStackDDI;\r\n\r\n  /** call this method to register your plugin instead of the default no-op one */\r\n  static registerPlugin(pluginClass: typeof GridStackDDI): GridStackDDI {\r\n    GridStackDDI.ddi = new pluginClass();\r\n    return GridStackDDI.ddi;\r\n  }\r\n\r\n  /** get the current registered plugin to use */\r\n  static get(): GridStackDDI {\r\n    return GridStackDDI.ddi || GridStackDDI.registerPlugin(GridStackDDI);\r\n  }\r\n\r\n  /** removes any drag&drop present (called during destroy) */\r\n  /* eslint-disable-next-line @typescript-eslint/no-unused-vars */\r\n  public remove(el: GridItemHTMLElement): GridStackDDI {\r\n    return this; // no-op for static grids\r\n  }\r\n}\r\n","/**\n * gridstack-engine.ts 5.1.1\n * Copyright (c) 2021-2022 Alain Dumesny - see GridStack root license\n */\n\nimport { Utils } from './utils';\nimport { GridStackNode, ColumnOptions, GridStackPosition, GridStackMoveOpts } from './types';\n\n/** callback to update the DOM attributes since this class is generic (no HTML or other info) for items that changed - see _notify() */\ntype OnChangeCB = (nodes: GridStackNode[]) => void;\n\n/** options used during creation - similar to GridStackOptions */\nexport interface GridStackEngineOptions {\n  column?: number;\n  maxRow?: number;\n  float?: boolean;\n  nodes?: GridStackNode[];\n  onChange?: OnChangeCB;\n}\n\n/**\n * Defines the GridStack engine that does most no DOM grid manipulation.\n * See GridStack methods and vars for descriptions.\n *\n * NOTE: values should not be modified directly - call the main GridStack API instead\n */\nexport class GridStackEngine {\n  public column: number;\n  public maxRow: number;\n  public nodes: GridStackNode[];\n  public addedNodes: GridStackNode[] = [];\n  public removedNodes: GridStackNode[] = [];\n  public batchMode: boolean;\n  /** @internal callback to update the DOM attributes */\n  protected onChange: OnChangeCB;\n  /** @internal */\n  protected _float: boolean;\n  /** @internal */\n  protected _prevFloat: boolean;\n  /** @internal cached layouts of difference column count so we can restore ack (eg 12 -> 1 -> 12) */\n  protected _layouts?: GridStackNode[][]; // maps column # to array of values nodes\n  /** @internal true while we are resizing widgets during column resize to skip certain parts */\n  protected _inColumnResize: boolean;\n  /** @internal true if we have some items locked */\n  protected _hasLocked: boolean;\n  /** @internal unique global internal _id counter NOT starting at 0 */\n  protected static _idSeq = 1;\n\n  public constructor(opts: GridStackEngineOptions = {}) {\n    this.column = opts.column || 12;\n    this.maxRow = opts.maxRow;\n    this._float = opts.float;\n    this.nodes = opts.nodes || [];\n    this.onChange = opts.onChange;\n  }\n\n  public batchUpdate(): GridStackEngine {\n    if (this.batchMode) return this;\n    this.batchMode = true;\n    this._prevFloat = this._float;\n    this._float = true; // let things go anywhere for now... commit() will restore and possibly reposition\n    return this.saveInitial(); // since begin update (which is called multiple times) won't do this\n  }\n\n  public commit(): GridStackEngine {\n    if (!this.batchMode) return this;\n    this.batchMode = false;\n    this._float = this._prevFloat;\n    delete this._prevFloat;\n    return this._packNodes()\n      ._notify();\n  }\n\n  // use entire row for hitting area (will use bottom reverse sorted first) if we not actively moving DOWN and didn't already skip\n  protected _useEntireRowArea(node: GridStackNode, nn: GridStackPosition): boolean {\n    return !this.float && !this._hasLocked && (!node._moving || node._skipDown || nn.y <= node.y);\n  }\n\n  /** @internal fix collision on given 'node', going to given new location 'nn', with optional 'collide' node already found.\n   * return true if we moved. */\n  protected _fixCollisions(node: GridStackNode, nn = node, collide?: GridStackNode, opt: GridStackMoveOpts = {}): boolean {\n    this.sortNodes(-1); // from last to first, so recursive collision move items in the right order\n\n    collide = collide || this.collide(node, nn); // REAL area collide for swap and skip if none...\n    if (!collide) return false;\n\n    // swap check: if we're actively moving in gravity mode, see if we collide with an object the same size\n    if (node._moving && !opt.nested && !this.float) {\n      if (this.swap(node, collide)) return true;\n    }\n\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)\n    let area = nn;\n    if (this._useEntireRowArea(node, nn)) {\n      area = {x: 0, w: this.column, y: nn.y, h: nn.h};\n      collide = this.collide(node, area, opt.skip); // force new hit\n    }\n\n    let didMove = false;\n    let newOpt: GridStackMoveOpts = {nested: true, pack: false};\n    while (collide = collide || this.collide(node, area, opt.skip)) { // could collide with more than 1 item... so repeat for each\n      let moved: boolean;\n      // if colliding with a locked item OR moving down with top gravity (and collide could move up) -> skip past the collide,\n      // but remember that skip down so we only do this once (and push others otherwise).\n      if (collide.locked || node._moving && !node._skipDown && nn.y > node.y && !this.float &&\n        // can take space we had, or before where we're going\n        (!this.collide(collide, {...collide, y: node.y}, node) || !this.collide(collide, {...collide, y: nn.y - collide.h}, node))) {\n        node._skipDown = (node._skipDown || nn.y > node.y);\n        moved = this.moveNode(node, {...nn, y: collide.y + collide.h, ...newOpt});\n        if (collide.locked && moved) {\n          Utils.copyPos(nn, node); // moving after lock become our new desired location\n        } else if (!collide.locked && moved && opt.pack) {\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\n          this._packNodes();\n          nn.y = collide.y + collide.h;\n          Utils.copyPos(node, nn);\n        }\n        didMove = didMove || moved;\n      } else {\n        // move collide down *after* where we will be, ignoring where we are now (don't collide with us)\n        moved = this.moveNode(collide, {...collide, y: nn.y + nn.h, skip: node, ...newOpt});\n      }\n      if (!moved) { return didMove; } // break inf loop if we couldn't move after all (ex: maxRow, fixed)\n      collide = undefined;\n    }\n    return didMove;\n  }\n\n  /** return the nodes that intercept the given node. Optionally a different area can be used, as well as a second node to skip */\n  public collide(skip: GridStackNode, area = skip, skip2?: GridStackNode): GridStackNode {\n    return this.nodes.find(n => n !== skip && n !== skip2 && Utils.isIntercepted(n, area));\n  }\n  public collideAll(skip: GridStackNode, area = skip, skip2?: GridStackNode): GridStackNode[] {\n    return this.nodes.filter(n => n !== skip && n !== skip2 && Utils.isIntercepted(n, area));\n  }\n\n  /** does a pixel coverage collision, returning the node that has the most coverage that is >50% mid line */\n  public collideCoverage(node: GridStackNode, o: GridStackMoveOpts, collides: GridStackNode[]): GridStackNode {\n    if (!o.rect || !node._rect) return;\n    let r0 = node._rect; // where started\n    let r = {...o.rect}; // where we are\n\n    // update dragged rect to show where it's coming from (above or below, etc...)\n    if (r.y > r0.y) {\n      r.h += r.y - r0.y;\n      r.y = r0.y;\n    } else {\n      r.h += r0.y - r.y;\n    }\n    if (r.x > r0.x) {\n      r.w += r.x - r0.x;\n      r.x = r0.x;\n    } else {\n      r.w += r0.x - r.x;\n    }\n\n    let collide: GridStackNode;\n    collides.forEach(n => {\n      if (n.locked || !n._rect) return;\n      let r2 = n._rect; // overlapping target\n      let yOver = Number.MAX_VALUE, xOver = Number.MAX_VALUE, overMax = 0.5; // need >50%\n      // depending on which side we started from, compute the overlap % of coverage\n      // (ex: from above/below we only compute the max horizontal line coverage)\n      if (r0.y < r2.y) { // from above\n        yOver = ((r.y + r.h) - r2.y) / r2.h;\n      } else if (r0.y+r0.h > r2.y+r2.h) { // from below\n        yOver = ((r2.y + r2.h) - r.y) / r2.h;\n      }\n      if (r0.x < r2.x) { // from the left\n        xOver = ((r.x + r.w) - r2.x) / r2.w;\n      } else if (r0.x+r0.w > r2.x+r2.w) { // from the right\n        xOver = ((r2.x + r2.w) - r.x) / r2.w;\n      }\n      let over = Math.min(xOver, yOver);\n      if (over > overMax) {\n        overMax = over;\n        collide = n;\n      }\n    });\n    return collide;\n  }\n\n  /** called to cache the nodes pixel rectangles used for collision detection during drag */\n  public cacheRects(w: number, h: number, top: number, right: number, bottom: number, left: number): GridStackEngine\n  {\n    this.nodes.forEach(n =>\n      n._rect = {\n        y: n.y * h + top,\n        x: n.x * w + left,\n        w: n.w * w - left - right,\n        h: n.h * h - top - bottom\n      }\n    );\n    return this;\n  }\n\n  /** called to possibly swap between 2 nodes (same size or column, not locked, touching), returning true if successful */\n  public swap(a: GridStackNode, b: GridStackNode): boolean {\n    if (!b || b.locked || !a || a.locked) return false;\n\n    function _doSwap(): true { // assumes a is before b IFF they have different height (put after rather than exact swap)\n      let x = b.x, y = b.y;\n      b.x = a.x; b.y = a.y; // b -> a position\n      if (a.h != b.h) {\n        a.x = x; a.y = b.y + b.h; // a -> goes after b\n      } else if (a.w != b.w) {\n        a.x = b.x + b.w; a.y = y; // a -> goes after b\n      } else {\n        a.x = x; a.y = y; // a -> old b position\n      }\n      a._dirty = b._dirty = true;\n      return true;\n    }\n    let touching: boolean; // remember if we called it (vs undefined)\n\n    // same size and same row or column, and touching\n    if (a.w === b.w && a.h === b.h && (a.x === b.x || a.y === b.y) && (touching = Utils.isTouching(a, b)))\n      return _doSwap();\n    if (touching === false) return; // IFF ran test and fail, bail out\n\n    // check for taking same columns (but different height) and touching\n    if (a.w === b.w && a.x === b.x && (touching || (touching = Utils.isTouching(a, b)))) {\n      if (b.y < a.y) { let t = a; a = b; b = t; } // swap a <-> b vars so a is first\n      return _doSwap();\n    }\n    if (touching === false) return;\n\n    // check if taking same row (but different width) and touching\n    if (a.h === b.h && a.y === b.y && (touching || (touching = Utils.isTouching(a, b)))) {\n      if (b.x < a.x) { let t = a; a = b; b = t; } // swap a <-> b vars so a is first\n      return _doSwap();\n    }\n    return false;\n  }\n\n  public isAreaEmpty(x: number, y: number, w: number, h: number): boolean {\n    let nn: GridStackNode = {x: x || 0, y: y || 0, w: w || 1, h: h || 1};\n    return !this.collide(nn);\n  }\n\n  /** re-layout grid items to reclaim any empty space */\n  public compact(): GridStackEngine {\n    if (this.nodes.length === 0) return this;\n    this.batchUpdate()\n      .sortNodes();\n    let copyNodes = this.nodes;\n    this.nodes = []; // pretend we have no nodes to conflict layout to start with...\n    copyNodes.forEach(node => {\n      if (!node.locked) {\n        node.autoPosition = true;\n      }\n      this.addNode(node, false); // 'false' for add event trigger\n      node._dirty = true; // will force attr update\n    });\n    return this.commit();\n  }\n\n  /** enable/disable floating widgets (default: `false`) See [example](http://gridstackjs.com/demo/float.html) */\n  public set float(val: boolean) {\n    if (this._float === val) return;\n    this._float = val || false;\n    if (!val) {\n      this._packNodes()._notify();\n    }\n  }\n\n  /** float getter method */\n  public get float(): boolean { return this._float || false; }\n\n  /** sort the nodes array from first to last, or reverse. Called during collision/placement to force an order */\n  public sortNodes(dir?: -1 | 1): GridStackEngine {\n    this.nodes = Utils.sort(this.nodes, dir, this.column);\n    return this;\n  }\n\n  /** @internal called to top gravity pack the items back OR revert back to original Y positions when floating */\n  protected _packNodes(): GridStackEngine {\n    if (this.batchMode) { return this; }\n    this.sortNodes(); // first to last\n\n    if (this.float) {\n      // restore original Y pos\n      this.nodes.forEach(n => {\n        if (n._updating || n._orig === undefined || n.y === n._orig.y) return;\n        let newY = n.y;\n        while (newY > n._orig.y) {\n          --newY;\n          let collide = this.collide(n, {x: n.x, y: newY, w: n.w, h: n.h});\n          if (!collide) {\n            n._dirty = true;\n            n.y = newY;\n          }\n        }\n      });\n    } else {\n      // top gravity pack\n      this.nodes.forEach((n, i) => {\n        if (n.locked) return;\n        while (n.y > 0) {\n          let newY = i === 0 ? 0 : n.y - 1;\n          let canBeMoved = i === 0 || !this.collide(n, {x: n.x, y: newY, w: n.w, h: n.h});\n          if (!canBeMoved) break;\n          // Note: must be dirty (from last position) for GridStack::OnChange CB to update positions\n          // and move items back. The user 'change' CB should detect changes from the original\n          // starting position instead.\n          n._dirty = (n.y !== newY);\n          n.y = newY;\n        }\n      });\n    }\n    return this;\n  }\n\n  /**\n   * given a random node, makes sure it's coordinates/values are valid in the current grid\n   * @param node to adjust\n   * @param resizing if out of bound, resize down or move into the grid to fit ?\n   */\n  public prepareNode(node: GridStackNode, resizing?: boolean): GridStackNode {\n    node = node || {};\n    node._id = node._id || GridStackEngine._idSeq++;\n\n    // if we're missing position, have the grid position us automatically (before we set them to 0,0)\n    if (node.x === undefined || node.y === undefined || node.x === null || node.y === null) {\n      node.autoPosition = true;\n    }\n\n    // assign defaults for missing required fields\n    let defaults: GridStackNode = { x: 0, y: 0, w: 1, h: 1};\n    Utils.defaults(node, defaults);\n\n    if (!node.autoPosition) { delete node.autoPosition; }\n    if (!node.noResize) { delete node.noResize; }\n    if (!node.noMove) { delete node.noMove; }\n\n    // check for NaN (in case messed up strings were passed. can't do parseInt() || defaults.x above as 0 is valid #)\n    if (typeof node.x == 'string')      { node.x = Number(node.x); }\n    if (typeof node.y == 'string')      { node.y = Number(node.y); }\n    if (typeof node.w == 'string')  { node.w = Number(node.w); }\n    if (typeof node.h == 'string') { node.h = Number(node.h); }\n    if (isNaN(node.x))      { node.x = defaults.x; node.autoPosition = true; }\n    if (isNaN(node.y))      { node.y = defaults.y; node.autoPosition = true; }\n    if (isNaN(node.w))  { node.w = defaults.w; }\n    if (isNaN(node.h)) { node.h = defaults.h; }\n\n    return this.nodeBoundFix(node, resizing);\n  }\n\n  /** part2 of preparing a node to fit inside our grid - checks  for x,y from grid dimensions */\n  public nodeBoundFix(node: GridStackNode, resizing?: boolean): GridStackNode {\n\n    let before = node._orig || Utils.copyPos({}, node);\n\n    if (node.maxW) { node.w = Math.min(node.w, node.maxW); }\n    if (node.maxH) { node.h = Math.min(node.h, node.maxH); }\n    if (node.minW && node.minW <= this.column) { node.w = Math.max(node.w, node.minW); }\n    if (node.minH) { node.h = Math.max(node.h, node.minH); }\n\n    if (node.w > this.column) {\n      // if user loaded a larger than allowed widget for current # of columns,\n      // remember it's full width so we can restore back (1 -> 12 column) #1655\n      // IFF we're not in the middle of column resizing!\n      if (this.column < 12 && !this._inColumnResize) {\n        node.w = Math.min(12, node.w);\n        this.cacheOneLayout(node, 12);\n      }\n      node.w = this.column;\n    } else if (node.w < 1) {\n      node.w = 1;\n    }\n\n    if (this.maxRow && node.h > this.maxRow) {\n      node.h = this.maxRow;\n    } else if (node.h < 1) {\n      node.h = 1;\n    }\n\n    if (node.x < 0) {\n      node.x = 0;\n    }\n    if (node.y < 0) {\n      node.y = 0;\n    }\n\n    if (node.x + node.w > this.column) {\n      if (resizing) {\n        node.w = this.column - node.x;\n      } else {\n        node.x = this.column - node.w;\n      }\n    }\n    if (this.maxRow && node.y + node.h > this.maxRow) {\n      if (resizing) {\n        node.h = this.maxRow - node.y;\n      } else {\n        node.y = this.maxRow - node.h;\n      }\n    }\n\n    if (!Utils.samePos(node, before)) {\n      node._dirty = true;\n    }\n\n    return node;\n  }\n\n  /** returns a list of modified nodes from their original values */\n  public getDirtyNodes(verify?: boolean): GridStackNode[] {\n    // compare original x,y,w,h instead as _dirty can be a temporary state\n    if (verify) {\n      return this.nodes.filter(n => n._dirty && !Utils.samePos(n, n._orig));\n    }\n    return this.nodes.filter(n => n._dirty);\n  }\n\n  /** @internal call this to call onChange callback with dirty nodes so DOM can be updated */\n  protected _notify(removedNodes?: GridStackNode[]): GridStackEngine {\n    if (this.batchMode || !this.onChange) return this;\n    let dirtyNodes = (removedNodes || []).concat(this.getDirtyNodes());\n    this.onChange(dirtyNodes);\n    return this;\n  }\n\n  /** @internal remove dirty and last tried info */\n  public cleanNodes(): GridStackEngine {\n    if (this.batchMode) return this;\n    this.nodes.forEach(n => {\n      delete n._dirty;\n      delete n._lastTried;\n    });\n    return this;\n  }\n\n  /** @internal called to save initial position/size to track real dirty state.\n   * Note: should be called right after we call change event (so next API is can detect changes)\n   * as well as right before we start move/resize/enter (so we can restore items to prev values) */\n  public saveInitial(): GridStackEngine {\n    this.nodes.forEach(n => {\n      n._orig = Utils.copyPos({}, n);\n      delete n._dirty;\n    });\n    this._hasLocked = this.nodes.some(n => n.locked);\n    return this;\n  }\n\n  /** @internal restore all the nodes back to initial values (called when we leave) */\n  public restoreInitial(): GridStackEngine {\n    this.nodes.forEach(n => {\n      if (Utils.samePos(n, n._orig)) return;\n      Utils.copyPos(n, n._orig);\n      n._dirty = true;\n    });\n    this._notify();\n    return this;\n  }\n\n  /** call to add the given node to our list, fixing collision and re-packing */\n  public addNode(node: GridStackNode, triggerAddEvent = false): GridStackNode {\n    let dup = this.nodes.find(n => n._id === node._id);\n    if (dup) return dup; // prevent inserting twice! return it instead.\n\n    // skip prepareNode if we're in middle of column resize (not new) but do check for bounds!\n    node = this._inColumnResize ? this.nodeBoundFix(node) : this.prepareNode(node);\n    delete node._temporaryRemoved;\n    delete node._removeDOM;\n\n    if (node.autoPosition) {\n      this.sortNodes();\n\n      for (let i = 0;; ++i) {\n        let x = i % this.column;\n        let y = Math.floor(i / this.column);\n        if (x + node.w > this.column) {\n          continue;\n        }\n        let box = {x, y, w: node.w, h: node.h};\n        if (!this.nodes.find(n => Utils.isIntercepted(box, n))) {\n          node.x = x;\n          node.y = y;\n          delete node.autoPosition; // found our slot\n          break;\n        }\n      }\n    }\n\n    this.nodes.push(node);\n    if (triggerAddEvent) { this.addedNodes.push(node); }\n\n    this._fixCollisions(node);\n    if (!this.batchMode) { this._packNodes()._notify(); }\n    return node;\n  }\n\n  public removeNode(node: GridStackNode, removeDOM = true, triggerEvent = false): GridStackEngine {\n    if (!this.nodes.find(n => n === node)) {\n      // TEST console.log(`Error: GridStackEngine.removeNode() node._id=${node._id} not found!`)\n      return this;\n    }\n    if (triggerEvent) { // we wait until final drop to manually track removed items (rather than during drag)\n      this.removedNodes.push(node);\n    }\n    if (removeDOM) node._removeDOM = true; // let CB remove actual HTML (used to set _id to null, but then we loose layout info)\n    // don't use 'faster' .splice(findIndex(),1) in case node isn't in our list, or in multiple times.\n    this.nodes = this.nodes.filter(n => n !== node);\n    return this._packNodes()\n      ._notify([node]);\n  }\n\n  public removeAll(removeDOM = true): GridStackEngine {\n    delete this._layouts;\n    if (this.nodes.length === 0) return this;\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)\n    this.removedNodes = this.nodes;\n    this.nodes = [];\n    return this._notify(this.removedNodes);\n  }\n\n  /** checks if item can be moved (layout constrain) vs moveNode(), returning true if was able to move.\n   * In more complicated cases (maxRow) it will attempt at moving the item and fixing\n   * others in a clone first, then apply those changes if still within specs. */\n  public moveNodeCheck(node: GridStackNode, o: GridStackMoveOpts): boolean {\n    // if (node.locked) return false;\n    if (!this.changedPosConstrain(node, o)) return false;\n    o.pack = true;\n\n    // simpler case: move item directly...\n    if (!this.maxRow) {\n      return this.moveNode(node, o);\n    }\n\n    // complex case: create a clone with NO maxRow (will check for out of bounds at the end)\n    let clonedNode: GridStackNode;\n    let clone = new GridStackEngine({\n      column: this.column,\n      float: this.float,\n      nodes: this.nodes.map(n => {\n        if (n === node) {\n          clonedNode = {...n};\n          return clonedNode;\n        }\n        return {...n};\n      })\n    });\n    if (!clonedNode) return false;\n\n    // make sure we are still valid size\n    let canMove = clone.moveNode(clonedNode, o) && clone.getRow() <= this.maxRow;\n    // turns out we can't grow, then see if we can swap instead (ex: full grid) if we're not resizing\n    if (!canMove && !o.resizing) {\n      let collide = this.collide(node, o);\n      if (collide && this.swap(node, collide)) {\n        this._notify();\n        return true;\n      }\n    }\n    if (!canMove) return false;\n\n    // if clone was able to move, copy those mods over to us now instead of caller trying to do this all over!\n    // Note: we can't use the list directly as elements and other parts point to actual node, so copy content\n    clone.nodes.filter(n => n._dirty).forEach(c => {\n      let n = this.nodes.find(a => a._id === c._id);\n      if (!n) return;\n      Utils.copyPos(n, c);\n      n._dirty = true;\n    });\n    this._notify();\n    return true;\n  }\n\n  /** return true if can fit in grid height constrain only (always true if no maxRow) */\n  public willItFit(node: GridStackNode): boolean {\n    delete node._willFitPos;\n    if (!this.maxRow) return true;\n    // create a clone with NO maxRow and check if still within size\n    let clone = new GridStackEngine({\n      column: this.column,\n      float: this.float,\n      nodes: this.nodes.map(n => {return {...n}})\n    });\n    let n = {...node}; // clone node so we don't mod any settings on it but have full autoPosition and min/max as well! #1687\n    this.cleanupNode(n);\n    delete n.el; delete n._id; delete n.content; delete n.grid;\n    clone.addNode(n);\n    if (clone.getRow() <= this.maxRow) {\n      node._willFitPos = Utils.copyPos({}, n);\n      return true;\n    }\n    return false;\n  }\n\n  /** true if x,y or w,h are different after clamping to min/max */\n  public changedPosConstrain(node: GridStackNode, p: GridStackPosition): boolean {\n    // first make sure w,h are set for caller\n    p.w = p.w || node.w;\n    p.h = p.h || node.h;\n    if (node.x !== p.x || node.y !== p.y) return true;\n    // check constrained w,h\n    if (node.maxW) { p.w = Math.min(p.w, node.maxW); }\n    if (node.maxH) { p.h = Math.min(p.h, node.maxH); }\n    if (node.minW) { p.w = Math.max(p.w, node.minW); }\n    if (node.minH) { p.h = Math.max(p.h, node.minH); }\n    return (node.w !== p.w || node.h !== p.h);\n  }\n\n  /** return true if the passed in node was actually moved (checks for no-op and locked) */\n  public moveNode(node: GridStackNode, o: GridStackMoveOpts): boolean {\n    if (!node || /*node.locked ||*/ !o) return false;\n    if (o.pack === undefined) o.pack = true;\n\n    // constrain the passed in values and check if we're still changing our node\n    if (typeof o.x !== 'number') { o.x = node.x; }\n    if (typeof o.y !== 'number') { o.y = node.y; }\n    if (typeof o.w !== 'number') { o.w = node.w; }\n    if (typeof o.h !== 'number') { o.h = node.h; }\n    let resizing = (node.w !== o.w || node.h !== o.h);\n    let nn: GridStackNode = Utils.copyPos({}, node, true); // get min/max out first, then opt positions next\n    Utils.copyPos(nn, o);\n    nn = this.nodeBoundFix(nn, resizing);\n    Utils.copyPos(o, nn);\n\n    if (Utils.samePos(node, o)) return false;\n    let prevPos: GridStackPosition = Utils.copyPos({}, node);\n\n    // check if we will need to fix collision at our new location\n    let collides = this.collideAll(node, nn, o.skip);\n    let needToMove = true;\n    if (collides.length) {\n      // now check to make sure we actually collided over 50% surface area while dragging\n      let collide = node._moving && !o.nested ? this.collideCoverage(node, o, collides) : collides[0];\n      if (collide) {\n        needToMove = !this._fixCollisions(node, nn, collide, o); // check if already moved...\n      } else {\n        needToMove = false; // we didn't cover >50% for a move, skip...\n      }\n    }\n\n    // now move (to the original ask vs the collision version which might differ) and repack things\n    if (needToMove) {\n      node._dirty = true;\n      Utils.copyPos(node, nn);\n    }\n    if (o.pack) {\n      this._packNodes()\n        ._notify();\n    }\n    return !Utils.samePos(node, prevPos); // pack might have moved things back\n  }\n\n  public getRow(): number {\n    return this.nodes.reduce((row, n) => Math.max(row, n.y + n.h), 0);\n  }\n\n  public beginUpdate(node: GridStackNode): GridStackEngine {\n    if (!node._updating) {\n      node._updating = true;\n      delete node._skipDown;\n      if (!this.batchMode) this.saveInitial();\n    }\n    return this;\n  }\n\n  public endUpdate(): GridStackEngine {\n    let n = this.nodes.find(n => n._updating);\n    if (n) {\n      delete n._updating;\n      delete n._skipDown;\n    }\n    return this;\n  }\n\n  /** saves a copy of the largest column layout (eg 12 even when rendering oneColumnMode, so we don't loose orig layout),\n   * returning a list of widgets for serialization */\n  public save(saveElement = true): GridStackNode[] {\n    // use the highest layout for any saved info so we can have full detail on reload #1849\n    let len = this._layouts?.length;\n    let layout = len && this.column !== (len - 1) ? this._layouts[len - 1] : null;\n    let list: GridStackNode[] = [];\n    this.sortNodes();\n    this.nodes.forEach(n => {\n      let wl = layout?.find(l => l._id === n._id);\n      let w: GridStackNode = {...n};\n      // use layout info instead if set\n      if (wl) { w.x = wl.x; w.y = wl.y; w.w = wl.w; }\n      // delete internals\n      for (let key in w) { if (key[0] === '_' || w[key] === null || w[key] === undefined ) delete w[key]; }\n      delete w.grid;\n      if (!saveElement) delete w.el;\n      // delete default values (will be re-created on read)\n      if (!w.autoPosition) delete w.autoPosition;\n      if (!w.noResize) delete w.noResize;\n      if (!w.noMove) delete w.noMove;\n      if (!w.locked) delete w.locked;\n      list.push(w);\n    });\n    return list;\n  }\n\n  /** @internal called whenever a node is added or moved - updates the cached layouts */\n  public layoutsNodesChange(nodes: GridStackNode[]): GridStackEngine {\n    if (!this._layouts || this._inColumnResize) return this;\n    // remove smaller layouts - we will re-generate those on the fly... larger ones need to update\n    this._layouts.forEach((layout, column) => {\n      if (!layout || column === this.column) return this;\n      if (column < this.column) {\n        this._layouts[column] = undefined;\n      }\n      else {\n        // we save the original x,y,w (h isn't cached) to see what actually changed to propagate better.\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\n        let ratio = column / this.column;\n        nodes.forEach(node => {\n          if (!node._orig) return; // didn't change (newly added ?)\n          let n = layout.find(l => l._id === node._id);\n          if (!n) return; // no cache for new nodes. Will use those values.\n          // Y changed, push down same amount\n          // TODO: detect doing item 'swaps' will help instead of move (especially in 1 column mode)\n          if (node.y !== node._orig.y) {\n            n.y += (node.y - node._orig.y);\n          }\n          // X changed, scale from new position\n          if (node.x !== node._orig.x) {\n            n.x = Math.round(node.x * ratio);\n          }\n          // width changed, scale from new width\n          if (node.w !== node._orig.w) {\n            n.w = Math.round(node.w * ratio);\n          }\n          // ...height always carries over from cache\n        });\n      }\n    });\n    return this;\n  }\n\n  /**\n   * @internal Called to scale the widget width & position up/down based on the column change.\n   * Note we store previous layouts (especially original ones) to make it possible to go\n   * from say 12 -> 1 -> 12 and get back to where we were.\n   *\n   * @param prevColumn previous number of columns\n   * @param column  new column number\n   * @param nodes different sorted list (ex: DOM order) instead of current list\n   * @param layout specify the type of re-layout that will happen (position, size, etc...).\n   * Note: items will never be outside of the current column boundaries. default (moveScale). Ignored for 1 column\n   */\n  public updateNodeWidths(prevColumn: number, column: number, nodes: GridStackNode[], layout: ColumnOptions = 'moveScale'): GridStackEngine {\n    if (!this.nodes.length || !column || prevColumn === column) return this;\n\n    // cache the current layout in case they want to go back (like 12 -> 1 -> 12) as it requires original data\n    this.cacheLayout(this.nodes, prevColumn);\n    this.batchUpdate(); // do this EARLY as it will call saveInitial() so we can detect where we started for _dirty and collision\n    let newNodes: GridStackNode[] = [];\n\n    // if we're going to 1 column and using DOM order rather than default sorting, then generate that layout\n    let domOrder = false;\n    if (column === 1 && nodes?.length) {\n      domOrder = true;\n      let top = 0;\n      nodes.forEach(n => {\n        n.x = 0;\n        n.w = 1;\n        n.y = Math.max(n.y, top);\n        top = n.y + n.h;\n      });\n      newNodes = nodes;\n      nodes = [];\n    } else {\n      nodes = Utils.sort(this.nodes, -1, prevColumn); // current column reverse sorting so we can insert last to front (limit collision)\n    }\n\n    // see if we have cached previous layout IFF we are going up in size (restore) otherwise always\n    // generate next size down from where we are (looks more natural as you gradually size down).\n    let cacheNodes: GridStackNode[] = [];\n    if (column > prevColumn) {\n      cacheNodes = this._layouts[column] || [];\n      // ...if not, start with the largest layout (if not already there) as down-scaling is more accurate\n      // by pretending we came from that larger column by assigning those values as starting point\n      let lastIndex = this._layouts.length - 1;\n      if (!cacheNodes.length && prevColumn !== lastIndex && this._layouts[lastIndex]?.length) {\n        prevColumn = lastIndex;\n        this._layouts[lastIndex].forEach(cacheNode => {\n          let n = nodes.find(n => n._id === cacheNode._id);\n          if (n) {\n            // still current, use cache info positions\n            n.x = cacheNode.x;\n            n.y = cacheNode.y;\n            n.w = cacheNode.w;\n          }\n        });\n      }\n    }\n\n    // if we found cache re-use those nodes that are still current\n    cacheNodes.forEach(cacheNode => {\n      let j = nodes.findIndex(n => n._id === cacheNode._id);\n      if (j !== -1) {\n        // still current, use cache info positions\n        nodes[j].x = cacheNode.x;\n        nodes[j].y = cacheNode.y;\n        nodes[j].w = cacheNode.w;\n        newNodes.push(nodes[j]);\n        nodes.splice(j, 1);\n      }\n    });\n    // ...and add any extra non-cached ones\n    if (nodes.length) {\n      if (typeof layout === 'function') {\n        layout(column, prevColumn, newNodes, nodes);\n      } else if (!domOrder) {\n        let ratio = column / prevColumn;\n        let move = (layout === 'move' || layout === 'moveScale');\n        let scale = (layout === 'scale' || layout === 'moveScale');\n        nodes.forEach(node => {\n          // NOTE: x + w could be outside of the grid, but addNode() below will handle that\n          node.x = (column === 1 ? 0 : (move ? Math.round(node.x * ratio) : Math.min(node.x, column - 1)));\n          node.w = ((column === 1 || prevColumn === 1) ? 1 :\n            scale ? (Math.round(node.w * ratio) || 1) : (Math.min(node.w, column)));\n          newNodes.push(node);\n        });\n        nodes = [];\n      }\n    }\n\n    // finally re-layout them in reverse order (to get correct placement)\n    newNodes = Utils.sort(newNodes, -1, column);\n    this._inColumnResize = true; // prevent cache update\n    this.nodes = []; // pretend we have no nodes to start with (add() will use same structures) to simplify layout\n    newNodes.forEach(node => {\n      this.addNode(node, false); // 'false' for add event trigger\n      delete node._orig; // make sure the commit doesn't try to restore things back to original\n    });\n    this.commit();\n    delete this._inColumnResize;\n    return this;\n  }\n\n  /**\n   * call to cache the given layout internally to the given location so we can restore back when column changes size\n   * @param nodes list of nodes\n   * @param column corresponding column index to save it under\n   * @param clear if true, will force other caches to be removed (default false)\n   */\n  public cacheLayout(nodes: GridStackNode[], column: number, clear = false): GridStackEngine {\n    let copy: GridStackNode[] = [];\n    nodes.forEach((n, i) => {\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\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\n    });\n    this._layouts = clear ? [] : this._layouts || []; // use array to find larger quick\n    this._layouts[column] = copy;\n    return this;\n  }\n\n  /**\n   * call to cache the given node layout internally to the given location so we can restore back when column changes size\n   * @param node single node to cache\n   * @param column corresponding column index to save it under\n   */\n  public cacheOneLayout(n: GridStackNode, column: number): GridStackEngine {\n    n._id = n._id || GridStackEngine._idSeq++;\n    let layout: GridStackNode = {x: n.x, y: n.y, w: n.w, _id: n._id}\n    this._layouts = this._layouts || [];\n    this._layouts[column] = this._layouts[column] || [];\n    let index = this._layouts[column].findIndex(l => l._id === n._id);\n    index === -1 ? this._layouts[column].push(layout) : this._layouts[column][index] = layout;\n    return this;\n  }\n\n\n  /** called to remove all internal values but the _id */\n  public cleanupNode(node: GridStackNode): GridStackEngine {\n    for (let prop in node) {\n      if (prop[0] === '_' && prop !== '_id') delete node[prop];\n    }\n    return this;\n  }\n}\n","/**\r\n * index-h5.ts 5.1.1 - everything you need for a Grid that uses HTML5 native drag&drop\r\n * Copyright (c) 2021 Alain Dumesny - see GridStack root license\r\n */\r\n\r\nexport * from './types';\r\nexport * from './utils';\r\nexport * from './gridstack-engine';\r\nexport * from './gridstack-ddi';\r\nexport * from './gridstack';\r\n\r\nexport * from './h5/gridstack-dd-native';\r\n\r\n// declare module 'gridstack'; for umd ?\r\n","/*!\r\n * GridStack 5.1.1\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\nimport { GridStackEngine } from './gridstack-engine';\r\nimport { Utils, HeightData } from './utils';\r\nimport { ColumnOptions, GridItemHTMLElement, GridStackElement, GridStackEventHandlerCallback,\r\n  GridStackNode, GridStackOptions, GridStackWidget, numberOrString, DDUIData, DDDragInOpt, GridStackPosition } from './types';\r\nimport { GridStackDDI } from './gridstack-ddi';\r\n\r\n// export all dependent file as well to make it easier for users to just import the main file\r\nexport * from './types';\r\nexport * from './utils';\r\nexport * from './gridstack-engine';\r\nexport * from './gridstack-ddi';\r\n\r\nexport interface GridHTMLElement extends HTMLElement {\r\n  gridstack?: GridStack; // grid's parent DOM element points back to grid class\r\n}\r\n/** list of possible events, or space separated list of them */\r\nexport type GridStackEvent = 'added' | 'change' | 'disable' | 'drag' | 'dragstart' | 'dragstop' | 'dropped' |\r\n  'enable' | 'removed' | 'resize' | 'resizestart' | 'resizestop' | string;\r\n\r\n/** Defines the coordinates of an object */\r\nexport interface MousePosition {\r\n  top: number;\r\n  left: number;\r\n}\r\n\r\n/** Defines the position of a cell inside the grid*/\r\nexport interface CellPosition {\r\n  x: number;\r\n  y: number;\r\n}\r\n\r\ninterface GridCSSStyleSheet extends CSSStyleSheet {\r\n  _id?: string; // random id we will use to style us\r\n  _max?: number; // internal tracker of the max # of rows we created\\\r\n}\r\n\r\n// default values for grid options - used during init and when saving out\r\nconst GridDefaults: GridStackOptions = {\r\n  column: 12,\r\n  minRow: 0,\r\n  maxRow: 0,\r\n  itemClass: 'grid-stack-item',\r\n  placeholderClass: 'grid-stack-placeholder',\r\n  placeholderText: '',\r\n  handle: '.grid-stack-item-content',\r\n  handleClass: null,\r\n  styleInHead: false,\r\n  cellHeight: 'auto',\r\n  cellHeightThrottle: 100,\r\n  margin: 10,\r\n  auto: true,\r\n  oneColumnSize: 768,\r\n  float: false,\r\n  staticGrid: false,\r\n  animate: true,\r\n  alwaysShowResizeHandle: false,\r\n  resizable: {\r\n    autoHide: true,\r\n    handles: 'se'\r\n  },\r\n  draggable: {\r\n    handle: '.grid-stack-item-content',\r\n    scroll: false,\r\n    appendTo: 'body'\r\n  },\r\n  disableDrag: false,\r\n  disableResize: false,\r\n  rtl: 'auto',\r\n  removable: false,\r\n  removableOptions: {\r\n    accept: '.grid-stack-item'\r\n  },\r\n  marginUnit: 'px',\r\n  cellHeightUnit: 'px',\r\n  disableOneColumnMode: false,\r\n  oneColumnModeDomSort: false\r\n};\r\n\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\nexport class GridStack {\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  public static init(options: GridStackOptions = {}, elOrString: GridStackElement = '.grid-stack'): GridStack {\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      } 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.cloneDeep(options));\r\n    }\r\n    return el.gridstack\r\n  }\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  public static initAll(options: GridStackOptions = {}, selector = '.grid-stack'): GridStack[] {\r\n    let grids: GridStack[] = [];\r\n    GridStack.getGridElements(selector).forEach(el => {\r\n      if (!el.gridstack) {\r\n        el.gridstack = new GridStack(el, Utils.cloneDeep(options));\r\n        delete options.dragIn; 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  /**\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  public static addGrid(parent: HTMLElement, opt: GridStackOptions = {}): GridStack {\r\n    if (!parent) return null;\r\n\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    if (!parent.classList.contains('grid-stack')) {\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] as HTMLElement;\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    if (grid.opts.children) {\r\n      let children = grid.opts.children;\r\n      delete grid.opts.children;\r\n      grid.load(children);\r\n    }\r\n    return grid;\r\n  }\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: typeof GridStackEngine): void {\r\n    GridStack.engineClass = engineClass;\r\n  }\r\n\r\n  /** scoping so users can call GridStack.Utils.sort() for example */\r\n  public static Utils = Utils;\r\n\r\n  /** scoping so users can call new GridStack.Engine(12) for example */\r\n  public static Engine = GridStackEngine;\r\n\r\n  /** the HTML element tied to this grid after it's been initialized */\r\n  public el: GridHTMLElement;\r\n\r\n  /** engine used to implement non DOM grid functionality */\r\n  public engine: GridStackEngine;\r\n\r\n  /** grid options - public for classes to access, but use methods to modify! */\r\n  public opts: GridStackOptions;\r\n\r\n  protected static engineClass: typeof GridStackEngine;\r\n\r\n  /** @internal create placeholder DIV as needed */\r\n  public get placeholder(): HTMLElement {\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, GridDefaults.itemClass, this.opts.itemClass);\r\n      this.placeholder.appendChild(placeholderChild);\r\n    }\r\n    return this._placeholder;\r\n  }\r\n  /** @internal */\r\n  protected _placeholder: HTMLElement;\r\n  /** @internal */\r\n  protected _prevColumn: number;\r\n  /** @internal */\r\n  protected _ignoreLayoutsNodeChange: boolean;\r\n  /** @internal */\r\n  public _gsEventHandler = {};\r\n  /** @internal */\r\n  protected _styles: GridCSSStyleSheet;\r\n  /** @internal flag to keep cells square during resize */\r\n  protected _isAutoCellHeight: boolean;\r\n  /** @internal track event binding to window resize so we can remove */\r\n  protected _windowResizeBind: () => void;\r\n  /** @internal limit auto cell resizing method */\r\n  protected _cellHeightThrottle: () => void;\r\n  /** @internal true when loading items to insert first rather than append */\r\n  protected _insertNotAppend: boolean;\r\n  /** @internal extra row added when dragging at the bottom of the grid */\r\n  protected _extraDragRow = 0;\r\n  /** @internal true if nested grid should get column count from our width */\r\n  protected _autoColumn?: boolean;\r\n\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  public constructor(el: GridHTMLElement, opts: GridStackOptions = {}) {\r\n    this.el = el; // exposed HTML element to the user\r\n    opts = opts || {}; // handles null/undefined/0\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.toNumber(el.getAttribute('gs-row'));\r\n\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 as any;\r\n    if (anyOpts.minWidth !== undefined) {\r\n      opts.oneColumnSize = opts.oneColumnSize || anyOpts.minWidth;\r\n      delete anyOpts.minWidth;\r\n    }\r\n\r\n    // elements attributes override any passed options (like CSS style) - merge the two together\r\n    let defaults: GridStackOptions = {...Utils.cloneDeep(GridDefaults),\r\n      column: Utils.toNumber(el.getAttribute('gs-column')) || 12,\r\n      minRow: rowAttr ? rowAttr : Utils.toNumber(el.getAttribute('gs-min-row')) || 0,\r\n      maxRow: rowAttr ? rowAttr : Utils.toNumber(el.getAttribute('gs-max-row')) || 0,\r\n      staticGrid: Utils.toBool(el.getAttribute('gs-static')) || false,\r\n      _styleSheetClass: 'grid-stack-instance-' + (Math.random() * 10000).toFixed(0),\r\n      alwaysShowResizeHandle: opts.alwaysShowResizeHandle || false,\r\n      resizable: {\r\n        autoHide: !(opts.alwaysShowResizeHandle || false),\r\n        handles: 'se'\r\n      },\r\n      draggable: {\r\n        handle: (opts.handleClass ? '.' + opts.handleClass : (opts.handle ? opts.handle : '')) || '.grid-stack-item-content',\r\n        scroll: false,\r\n        appendTo: 'body'\r\n      },\r\n      removableOptions: {\r\n        accept: '.' + (opts.itemClass || 'grid-stack-item')\r\n      },\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.toBool(el.getAttribute('gs-animate'))\r\n    }\r\n\r\n    this.opts = 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\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\r\n    if (this.opts.rtl === 'auto') {\r\n      this.opts.rtl = (el.style.direction === 'rtl');\r\n    }\r\n\r\n    if (this.opts.rtl) {\r\n      this.el.classList.add('grid-stack-rtl');\r\n    }\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 parentGridItemEl = Utils.closestByClass(this.el, GridDefaults.itemClass) as GridItemHTMLElement;\r\n    if (parentGridItemEl && parentGridItemEl.gridstackNode) {\r\n      this.opts._isNested = parentGridItemEl.gridstackNode;\r\n      this.opts._isNested.subGrid = this;\r\n      parentGridItemEl.classList.add('grid-stack-nested');\r\n      this.el.classList.add('grid-stack-nested');\r\n    }\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    } else {\r\n      // append unit if any are set\r\n      if (typeof this.opts.cellHeight == 'number' && this.opts.cellHeightUnit && this.opts.cellHeightUnit !== 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\r\n    this.el.classList.add(this.opts._styleSheetClass);\r\n\r\n    this._setStaticClass();\r\n\r\n    let engineClass = this.opts.engineClass || GridStack.engineClass || 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) return;\r\n          if (n._removeDOM) {\r\n            if (el) el.remove();\r\n            delete n._removeDOM;\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\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      let elements: {el: HTMLElement; i: number}[] = [];\r\n      this.getGridItems().forEach(el => { // get dom elements (not nodes yet)\r\n        let x = parseInt(el.getAttribute('gs-x'));\r\n        let y = parseInt(el.getAttribute('gs-y'));\r\n        elements.push({\r\n          el,\r\n          // if x,y are missing (autoPosition) add them to end of list - but keep their respective DOM order\r\n          i: (Number.isNaN(x) ? 1000 : x) + (Number.isNaN(y) ? 1000 : y) * this.getColumn()\r\n        });\r\n      });\r\n      elements.sort((a, b) => a.i - b.i).forEach(e => this._prepareElement(e.el));\r\n      this.commit();\r\n    }\r\n\r\n    this.setAnimation(this.opts.animate);\r\n\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\r\n    // legacy support to appear 'per grid` options when really global.\r\n    if (this.opts.dragIn) GridStack.setupDragIn(this.opts.dragIn, this.opts.dragInOptions);\r\n    delete this.opts.dragIn;\r\n    delete this.opts.dragInOptions;\r\n\r\n    this._setupRemoveDrop();\r\n    this._setupAcceptWidget();\r\n    this._updateWindowResizeEvent();\r\n  }\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  public addWidget(els?: GridStackWidget | GridStackElement, options?: GridStackWidget): GridItemHTMLElement {\r\n\r\n    // support legacy call for now ?\r\n    if (arguments.length > 2) {\r\n      console.warn('gridstack.ts: `addWidget(el, x, y, width...)` is deprecated. Use `addWidget({x, y, 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: GridStackWidget = { x:a[i++], y:a[i++], w:a[i++], h:a[i++], autoPosition:a[i++],\r\n          minW:a[i++], maxW:a[i++], minH:a[i++], maxH:a[i++], id:a[i++] };\r\n      return this.addWidget(els, opt);\r\n    }\r\n\r\n    function isGridStackWidget(w: GridStackWidget): w is GridStackWidget { // https://medium.com/ovrsea/checking-the-type-of-an-object-in-typescript-the-type-guards-24d98d9119b0\r\n      return w.x !== undefined || w.y !== undefined || w.w !== undefined || w.h !== undefined || w.content !== undefined ? true : false;\r\n    }\r\n\r\n    let el: HTMLElement;\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] as HTMLElement;\r\n    } else if (arguments.length === 0 || arguments.length === 1 && isGridStackWidget(els)) {\r\n      let content = els ? (els as GridStackWidget).content || '' : '';\r\n      options = els;\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] as HTMLElement;\r\n    } else {\r\n      el = els as HTMLElement;\r\n    }\r\n\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.cloneDeep(options) || {};  // make a copy before we modify in case caller re-uses it\r\n    Utils.defaults(options, domAttr);\r\n    let node = this.engine.prepareNode(options);\r\n    this._writeAttr(el, options);\r\n\r\n    if (this._insertNotAppend) {\r\n      this.el.prepend(el);\r\n    } else {\r\n      this.el.appendChild(el);\r\n    }\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\r\n    // check if nested grid definition is present\r\n    if (node.subGrid && !(node.subGrid as GridStack).el) { // see if there is a sub-grid to create too\r\n      // if column special case it set, remember that flag and set default\r\n      let autoColumn: boolean;\r\n      let ops = node.subGrid as GridStackOptions;\r\n      if (ops.column === 'auto') {\r\n        ops.column = node.w;\r\n        ops.disableOneColumnMode = true; // driven by parent\r\n        autoColumn = true;\r\n      }\r\n      let content = node.el.querySelector('.grid-stack-item-content') as HTMLElement;\r\n      node.subGrid = GridStack.addGrid(content, node.subGrid as GridStackOptions);\r\n      if (autoColumn) { node.subGrid._autoColumn = true; }\r\n    }\r\n\r\n    this._triggerAddEvent();\r\n    this._triggerChangeEvent();\r\n\r\n    return el;\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  public save(saveContent = true, saveGridOpt = false): GridStackWidget[] | GridStackOptions {\r\n    // return copied nodes we can modify at will...\r\n    let list = this.engine.save(saveContent);\r\n\r\n    // check for HTML content and nested grids\r\n    list.forEach(n => {\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) delete n.content;\r\n      } else {\r\n        if (!saveContent) { delete n.content; }\r\n        // check for nested grid\r\n        if (n.subGrid) {\r\n          n.subGrid = (n.subGrid as GridStack).save(saveContent, true) as GridStackOptions;\r\n        }\r\n      }\r\n      delete n.el;\r\n    });\r\n\r\n    // check if save entire grid options (needed for recursive) + children...\r\n    if (saveGridOpt) {\r\n      let o: GridStackOptions = 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; delete o.marginRight; delete o.marginBottom; delete o.marginLeft;\r\n      }\r\n      if (o.rtl === (this.el.style.direction === 'rtl')) { o.rtl = 'auto' }\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      Utils.removeInternalAndSame(o, GridDefaults);\r\n      o.children = list;\r\n      return o;\r\n    }\r\n\r\n    return list;\r\n  }\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  public load(layout: GridStackWidget[], addAndRemove: boolean | ((g: GridStack, w: GridStackWidget, add: boolean) => GridItemHTMLElement)  = true): GridStack {\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\r\n    // if we're loading a layout into 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\r\n    let removed: GridStackNode[] = [];\r\n    this.batchUpdate();\r\n\r\n    // see if any items are missing from new layout and need to be removed first\r\n    if (addAndRemove) {\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 (typeof(addAndRemove) === 'function') {\r\n            addAndRemove(this, n, false);\r\n          } else {\r\n            removed.push(n); // batch keep track\r\n            this.removeWidget(n.el, true, false);\r\n          }\r\n        }\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 as GridStackOptions).children) { // update any sub grid as well\r\n          let sub = item.el.querySelector('.grid-stack') as GridHTMLElement;\r\n          if (sub && sub.gridstack) {\r\n            sub.gridstack.load((w.subGrid as GridStackOptions).children); // TODO: support updating grid options ?\r\n            this._insertNotAppend = true; // got reset by above call\r\n          }\r\n        }\r\n      } else if (addAndRemove) {\r\n        if (typeof(addAndRemove) === 'function') {\r\n          w = addAndRemove(this, w, true).gridstackNode;\r\n        } else {\r\n          w = this.addWidget(w).gridstackNode;\r\n        }\r\n      }\r\n    });\r\n\r\n    this.engine.removedNodes = removed;\r\n    this.commit();\r\n\r\n    // after commit, clear that flag\r\n    delete this._ignoreLayoutsNodeChange;\r\n    delete this._insertNotAppend;\r\n    return this;\r\n  }\r\n\r\n  /**\r\n   * Initializes batch updates. You will see no changes until `commit()` method is called.\r\n   */\r\n  public batchUpdate(): GridStack {\r\n    this.engine.batchUpdate();\r\n    return this;\r\n  }\r\n\r\n  /**\r\n   * Gets current cell height.\r\n   */\r\n  public getCellHeight(forcePixel = false): number {\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 as number;\r\n    }\r\n    // else get first cell height\r\n    let el = this.el.querySelector('.' + this.opts.itemClass) as HTMLElement;\r\n    if (el) {\r\n      let height = 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 as number;\r\n  }\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  public cellHeight(val?: numberOrString, update = true): GridStack {\r\n\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') { val = undefined; }\r\n\r\n    // make item content be square\r\n    if (val === undefined) {\r\n      let marginDiff = - (this.opts.marginRight as number) - (this.opts.marginLeft as number)\r\n        + (this.opts.marginTop as number) + (this.opts.marginBottom as number);\r\n      val = this.cellWidth() + marginDiff;\r\n    }\r\n\r\n    let data = 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\r\n    if (update) {\r\n      this._updateStyles(true, this.getRow()); // true = force re-create, for that # of rows\r\n    }\r\n    return this;\r\n  }\r\n\r\n  /** Gets current cell width. */\r\n  public cellWidth(): number {\r\n    return this._widthOrContainer() / this.getColumn();\r\n  }\r\n  /** return our expected width (or parent) for 1 column check */\r\n  protected _widthOrContainer(): number {\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\r\n  /**\r\n   * Finishes batch updates. Updates DOM nodes. You must call it after batchUpdate.\r\n   */\r\n  public commit(): GridStack {\r\n    this.engine.commit();\r\n    this._triggerRemoveEvent();\r\n    this._triggerAddEvent();\r\n    this._triggerChangeEvent();\r\n    return this;\r\n  }\r\n\r\n  /** re-layout grid items to reclaim any empty space */\r\n  public compact(): GridStack {\r\n    this.engine.compact();\r\n    this._triggerChangeEvent();\r\n    return this;\r\n  }\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  public column(column: number, layout: ColumnOptions = 'moveScale'): GridStack {\r\n    if (column < 1 || this.opts.column === column) return this;\r\n    let oldColumn = this.getColumn();\r\n\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    } else {\r\n      delete this._prevColumn;\r\n    }\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\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: GridStackNode[];\r\n    if (column === 1 && this.opts.oneColumnModeDomSort) {\r\n      domNodes = [];\r\n      this.getGridItems().forEach(el => { // get dom elements in order\r\n        if (el.gridstackNode) { domNodes.push(el.gridstackNode); }\r\n      });\r\n      if (!domNodes.length) { domNodes = undefined; }\r\n    }\r\n    this.engine.updateNodeWidths(oldColumn, column, domNodes, layout);\r\n    if (this._isAutoCellHeight) this.cellHeight();\r\n\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\r\n    return this;\r\n  }\r\n\r\n  /**\r\n   * get the number of columns in the grid (default 12)\r\n   */\r\n  public getColumn(): number {\r\n    return this.opts.column as number;\r\n  }\r\n\r\n  /** returns an array of grid HTML elements (no placeholder) - used to iterate through our children in DOM order */\r\n  public getGridItems(): GridItemHTMLElement[] {\r\n    return Array.from(this.el.children)\r\n      .filter((el: HTMLElement) => el.matches('.' + this.opts.itemClass) && !el.matches('.' + this.opts.placeholderClass)) as GridItemHTMLElement[];\r\n  }\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  public destroy(removeDOM = true): GridStack {\r\n    if (!this.el) 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.opts._styleSheetClass);\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    delete this.opts._isNested;\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  /**\r\n   * enable/disable floating widgets (default: `false`) See [example](http://gridstackjs.com/demo/float.html)\r\n   */\r\n  public float(val: boolean): GridStack {\r\n    this.engine.float = val;\r\n    this._triggerChangeEvent();\r\n    return this;\r\n  }\r\n\r\n  /**\r\n   * get the current float mode\r\n   */\r\n  public getFloat(): boolean {\r\n    return this.engine.float;\r\n  }\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  public getCellFromPixel(position: MousePosition, useDocRelative = false): CellPosition {\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: {top: number, left: number};\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    } 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\r\n    let columnWidth = (box.width / this.getColumn());\r\n    let rowHeight = (box.height / parseInt(this.el.getAttribute('gs-current-row')));\r\n\r\n    return {x: Math.floor(relativeLeft / columnWidth), y: Math.floor(relativeTop / rowHeight)};\r\n  }\r\n\r\n  /** returns the current number of rows, which will be at least `minRow` if set */\r\n  public getRow(): number {\r\n    return Math.max(this.engine.getRow(), this.opts.minRow);\r\n  }\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  public isAreaEmpty(x: number, y: number, w: number, h: number): boolean {\r\n    return this.engine.isAreaEmpty(x, y, w, h);\r\n  }\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  public makeWidget(els: GridStackElement): GridItemHTMLElement {\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  /**\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  public on(name: GridStackEvent, callback: GridStackEventHandlerCallback): GridStack {\r\n    // check for array of names being passed instead\r\n    if (name.indexOf(' ') !== -1) {\r\n      let names = name.split(' ') as GridStackEvent[];\r\n      names.forEach(name => this.on(name, callback));\r\n      return this;\r\n    }\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: Event) => callback(event);\r\n      } else {\r\n        this._gsEventHandler[name] = (event: CustomEvent) => callback(event, event.detail);\r\n      }\r\n      this.el.addEventListener(name, this._gsEventHandler[name]);\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    } 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  /**\r\n   * unsubscribe from the 'on' event below\r\n   * @param name of the event (see possible values)\r\n   */\r\n  public off(name: GridStackEvent): GridStack {\r\n    // check for array of names being passed instead\r\n    if (name.indexOf(' ') !== -1) {\r\n      let names = name.split(' ') as GridStackEvent[];\r\n      names.forEach(name => this.off(name));\r\n      return this;\r\n    }\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\r\n    return this;\r\n  }\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  public removeWidget(els: GridStackElement, removeDOM = true, triggerEvent = true): GridStack {\r\n    GridStack.getElements(els).forEach(el => {\r\n      if (el.parentElement !== this.el) 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) return;\r\n\r\n      // remove our DOM data (circular link) and drag&drop permanently\r\n      delete el.gridstackNode;\r\n      GridStackDDI.get().remove(el);\r\n\r\n      this.engine.removeNode(node, removeDOM, triggerEvent);\r\n\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  /**\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  public removeAll(removeDOM = true): GridStack {\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      GridStackDDI.get().remove(n.el);\r\n    });\r\n    this.engine.removeAll(removeDOM);\r\n    this._triggerRemoveEvent();\r\n    return this;\r\n  }\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  public setAnimation(doAnimate: boolean): GridStack {\r\n    if (doAnimate) {\r\n      this.el.classList.add('grid-stack-animate');\r\n    } else {\r\n      this.el.classList.remove('grid-stack-animate');\r\n    }\r\n    return this;\r\n  }\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   */\r\n  public setStatic(val: boolean, updateClass = true): GridStack {\r\n    if (this.opts.staticGrid === val) return this;\r\n    this.opts.staticGrid = val;\r\n    this._setupRemoveDrop();\r\n    this._setupAcceptWidget();\r\n    this.engine.nodes.forEach(n => this._prepareDragDropByNode(n)); // either delete or init Drag&drop\r\n    if (updateClass) { this._setStaticClass(); }\r\n    return this;\r\n  }\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  public update(els: GridStackElement, opt: GridStackWidget): GridStack {\r\n\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\r\n    GridStack.getElements(els).forEach(el => {\r\n      if (!el || !el.gridstackNode) return;\r\n      let n = el.gridstackNode;\r\n      let w = 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\r\n      // move/resize widget if anything changed\r\n      let keys = ['x', 'y', 'w', 'h'];\r\n      let m: GridStackWidget;\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\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\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\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  /**\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  public margin(value: numberOrString): GridStack {\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.parseHeight(value);\r\n      if (this.opts.marginUnit === data.unit && this.opts.margin === data.h) 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\r\n    this._updateStyles(true); // true = force re-create\r\n\r\n    return this;\r\n  }\r\n\r\n  /** returns current margin number value (undefined if 4 sides don't match) */\r\n  public getMargin(): number { return this.opts.margin as number; }\r\n\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  public willItFit(node: GridStackWidget): boolean {\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,\r\n        w: GridStackWidget = { 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\r\n  /** @internal */\r\n  protected _triggerChangeEvent(): GridStack {\r\n    if (this.engine.batchMode) 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\r\n  /** @internal */\r\n  protected _triggerAddEvent(): GridStack {\r\n    if (this.engine.batchMode) 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\r\n  /** @internal */\r\n  public _triggerRemoveEvent(): GridStack {\r\n    if (this.engine.batchMode) 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\r\n  /** @internal */\r\n  protected _triggerEvent(name: string, data?: GridStackNode[]): GridStack {\r\n    let event = data ? new CustomEvent(name, {bubbles: false, detail: data}) : new Event(name);\r\n    this.el.dispatchEvent(event);\r\n    return this;\r\n  }\r\n\r\n  /** @internal called to delete the current dynamic style sheet used for our layout */\r\n  protected _removeStylesheet(): GridStack {\r\n\r\n    if (this._styles) {\r\n      Utils.removeStylesheet(this._styles._id);\r\n      delete this._styles;\r\n    }\r\n    return this;\r\n  }\r\n\r\n  /** @internal updated/create the CSS styles for row based layout and initial margin setting */\r\n  protected _updateStyles(forceUpdate = false, maxH?: number): GridStack {\r\n    // call to delete existing one if we change cellHeight / margin\r\n    if (forceUpdate) {\r\n      this._removeStylesheet();\r\n    }\r\n\r\n    this._updateContainerHeight();\r\n\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\r\n    let cellHeight = this.opts.cellHeight as number;\r\n    let cellHeightUnit = this.opts.cellHeightUnit;\r\n    let prefix = `.${this.opts._styleSheetClass} > .${this.opts.itemClass}`;\r\n\r\n    // create one as needed\r\n    if (!this._styles) {\r\n      let id = 'gridstack-style-' + (Math.random() * 100000).toFixed();\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 as HTMLElement;\r\n      this._styles = Utils.createStylesheet(id, styleLocation);\r\n      if (!this._styles) return this;\r\n      this._styles._id = id;\r\n      this._styles._max = 0;\r\n\r\n      // these are done once only\r\n      Utils.addCSSRule(this._styles, prefix, `min-height: ${cellHeight}${cellHeightUnit}`);\r\n      // content margins\r\n      let top: string = this.opts.marginTop + this.opts.marginUnit;\r\n      let bottom: string = this.opts.marginBottom + this.opts.marginUnit;\r\n      let right: string = this.opts.marginRight + this.opts.marginUnit;\r\n      let left: string = this.opts.marginLeft + this.opts.marginUnit;\r\n      let content = `${prefix} > .grid-stack-item-content`;\r\n      let placeholder = `.${this.opts._styleSheetClass} > .grid-stack-placeholder > .placeholder-content`;\r\n      Utils.addCSSRule(this._styles, content, `top: ${top}; right: ${right}; bottom: ${bottom}; left: ${left};`);\r\n      Utils.addCSSRule(this._styles, placeholder, `top: ${top}; right: ${right}; bottom: ${bottom}; left: ${left};`);\r\n      // resize handles offset (to match margin)\r\n      Utils.addCSSRule(this._styles, `${prefix} > .ui-resizable-ne`, `right: ${right}`);\r\n      Utils.addCSSRule(this._styles, `${prefix} > .ui-resizable-e`, `right: ${right}`);\r\n      Utils.addCSSRule(this._styles, `${prefix} > .ui-resizable-se`, `right: ${right}; bottom: ${bottom}`);\r\n      Utils.addCSSRule(this._styles, `${prefix} > .ui-resizable-nw`, `left: ${left}`);\r\n      Utils.addCSSRule(this._styles, `${prefix} > .ui-resizable-w`, `left: ${left}`);\r\n      Utils.addCSSRule(this._styles, `${prefix} > .ui-resizable-sw`, `left: ${left}; bottom: ${bottom}`);\r\n    }\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: number): string => (cellHeight * rows) + cellHeightUnit;\r\n      for (let i = this._styles._max + 1; i <= maxH; i++) { // start at 1\r\n        let h: string = getHeight(i);\r\n        Utils.addCSSRule(this._styles, `${prefix}[gs-y=\"${i-1}\"]`,   `top: ${getHeight(i-1)}`); // start at 0\r\n        Utils.addCSSRule(this._styles, `${prefix}[gs-h=\"${i}\"]`,     `height: ${h}`);\r\n        Utils.addCSSRule(this._styles, `${prefix}[gs-min-h=\"${i}\"]`, `min-height: ${h}`);\r\n        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\r\n  /** @internal */\r\n  protected _updateContainerHeight(): GridStack {\r\n    if (!this.engine || this.engine.batchMode) 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('height');\r\n      return this;\r\n    }\r\n    let cellHeight = this.opts.cellHeight as number;\r\n    let unit = this.opts.cellHeightUnit;\r\n    if (!cellHeight) return this;\r\n    this.el.style.height = row * cellHeight + unit;\r\n    return this;\r\n  }\r\n\r\n  /** @internal */\r\n  protected _prepareElement(el: GridItemHTMLElement, triggerAddEvent = false, node?: GridStackNode): GridStack {\r\n    if (!node) {\r\n      el.classList.add(this.opts.itemClass);\r\n      node = this._readAttr(el);\r\n    }\r\n    el.gridstackNode = node;\r\n    node.el = el;\r\n    node.grid = this;\r\n    let copy = {...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.same(node, copy)) {\r\n      this._writeAttr(el, node);\r\n    }\r\n    this._prepareDragDropByNode(node);\r\n    return this;\r\n  }\r\n\r\n  /** @internal call to write position x,y,w,h attributes back to element */\r\n  protected _writePosAttr(el: HTMLElement, n: GridStackPosition): GridStack {\r\n    if (n.x !== undefined && n.x !== null) { el.setAttribute('gs-x', String(n.x)); }\r\n    if (n.y !== undefined && n.y !== null) { el.setAttribute('gs-y', String(n.y)); }\r\n    if (n.w) { el.setAttribute('gs-w', String(n.w)); }\r\n    if (n.h) { el.setAttribute('gs-h', String(n.h)); }\r\n    return this;\r\n  }\r\n\r\n  /** @internal call to write any default attributes back to element */\r\n  protected _writeAttr(el: HTMLElement, node: GridStackWidget): GridStack {\r\n    if (!node) return this;\r\n    this._writePosAttr(el, node);\r\n\r\n    let attrs /*: GridStackWidget but strings */ = { // remaining attributes\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      resizeHandles: 'gs-resize-handles'\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      } else {\r\n        el.removeAttribute(attrs[key]);\r\n      }\r\n    }\r\n    return this;\r\n  }\r\n\r\n  /** @internal call to read any default attributes from element */\r\n  protected _readAttr(el: HTMLElement): GridStackWidget {\r\n    let node: GridStackNode = {};\r\n    node.x = Utils.toNumber(el.getAttribute('gs-x'));\r\n    node.y = Utils.toNumber(el.getAttribute('gs-y'));\r\n    node.w = Utils.toNumber(el.getAttribute('gs-w'));\r\n    node.h = Utils.toNumber(el.getAttribute('gs-h'));\r\n    node.maxW = Utils.toNumber(el.getAttribute('gs-max-w'));\r\n    node.minW = Utils.toNumber(el.getAttribute('gs-min-w'));\r\n    node.maxH = Utils.toNumber(el.getAttribute('gs-max-h'));\r\n    node.minH = Utils.toNumber(el.getAttribute('gs-min-h'));\r\n    node.autoPosition = Utils.toBool(el.getAttribute('gs-auto-position'));\r\n    node.noResize = Utils.toBool(el.getAttribute('gs-no-resize'));\r\n    node.noMove = Utils.toBool(el.getAttribute('gs-no-move'));\r\n    node.locked = Utils.toBool(el.getAttribute('gs-locked'));\r\n    node.resizeHandles = el.getAttribute('gs-resize-handles');\r\n    node.id = el.getAttribute('gs-id');\r\n\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)) 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\r\n    return node;\r\n  }\r\n\r\n  /** @internal */\r\n  protected _setStaticClass(): GridStack {\r\n    let classes = ['grid-stack-static'];\r\n\r\n    if (this.opts.staticGrid) {\r\n      this.el.classList.add(...classes);\r\n      this.el.setAttribute('gs-static', 'true');\r\n    } else {\r\n      this.el.classList.remove(...classes);\r\n      this.el.removeAttribute('gs-static');\r\n\r\n    }\r\n    return this;\r\n  }\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  public onParentResize(): GridStack {\r\n    if (!this.el || !this.el.clientWidth) return; // return if we're gone or no size yet (will get called again)\r\n    let changedColumn = false;\r\n\r\n    // see if we're nested and take our column count from our parent....\r\n    if (this._autoColumn && this.opts._isNested) {\r\n      if (this.opts.column !== this.opts._isNested.w) {\r\n        changedColumn = true;\r\n        this.column(this.opts._isNested.w, 'none');\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) { this.setAnimation(false); } // 1 <-> 12 is too radical, turn off animation\r\n        this.column(oneColumn ? 1 : this._prevColumn);\r\n        if (this.opts.animate) { 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.throttle(() => this.cellHeight(), this.opts.cellHeightThrottle);\r\n        }\r\n        this._cellHeightThrottle();\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\r\n    // finally update any nested grids\r\n    this.engine.nodes.forEach(n => {\r\n      if (n.subGrid) {(n.subGrid as GridStack).onParentResize()}\r\n    });\r\n\r\n    return this;\r\n  }\r\n\r\n  /** add or remove the window size event handler */\r\n  protected _updateWindowResizeEvent(forceRemove = false): GridStack {\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.opts._isNested;\r\n\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    } 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\r\n    return this;\r\n  }\r\n\r\n  /** @internal convert a potential selector into actual element */\r\n  public static getElement(els: GridStackElement = '.grid-stack-item'): GridItemHTMLElement { return Utils.getElement(els) }\r\n  /** @internal */\r\n  public static getElements(els: GridStackElement = '.grid-stack-item'): GridItemHTMLElement[] { return Utils.getElements(els) }\r\n  /** @internal */\r\n  public static getGridElement(els: GridStackElement): GridHTMLElement { return GridStack.getElement(els) }\r\n  /** @internal */\r\n  public static getGridElements(els: string): GridHTMLElement[] { return Utils.getElements(els) }\r\n\r\n  /** @internal initialize margin top/bottom/left/right and units */\r\n  protected _initMargin(): GridStack {\r\n\r\n    let data: HeightData;\r\n    let margin = 0;\r\n\r\n    // support passing multiple values like CSS (ex: '5px 10px 0 20px')\r\n    let margins: string[] = [];\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    } 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    } else {\r\n      data = Utils.parseHeight(this.opts.margin);\r\n      this.opts.marginUnit = data.unit;\r\n      margin = this.opts.margin = data.h;\r\n    }\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    } else {\r\n      data = Utils.parseHeight(this.opts.marginTop);\r\n      this.opts.marginTop = data.h;\r\n      delete this.opts.margin;\r\n    }\r\n\r\n    if (this.opts.marginBottom === undefined) {\r\n      this.opts.marginBottom = margin;\r\n    } else {\r\n      data = Utils.parseHeight(this.opts.marginBottom);\r\n      this.opts.marginBottom = data.h;\r\n      delete this.opts.margin;\r\n    }\r\n\r\n    if (this.opts.marginRight === undefined) {\r\n      this.opts.marginRight = margin;\r\n    } else {\r\n      data = Utils.parseHeight(this.opts.marginRight);\r\n      this.opts.marginRight = data.h;\r\n      delete this.opts.margin;\r\n    }\r\n\r\n    if (this.opts.marginLeft === undefined) {\r\n      this.opts.marginLeft = margin;\r\n    } else {\r\n      data = 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  /*\r\n   * drag&drop empty stubs that will be implemented in gridstack-dd.ts for non static grid\r\n   * so we don't incur the load unless needed.\r\n   * NOTE: had to make those methods public in order to define them else as\r\n   *   GridStack.prototype._setupAcceptWidget = function()\r\n   * maybe there is a better way ????\r\n   */\r\n  /* eslint-disable @typescript-eslint/no-unused-vars */\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 cached) in case the toolbar\r\n   * is dynamically create and needs to change later.\r\n   * @param dragIn string selector (ex: '.sidebar .grid-stack-item')\r\n   * @param dragInOptions options - see DDDragInOpt. (default: {revert: 'invalid', handle: '.grid-stack-item-content', scroll: false, appendTo: 'body'}\r\n   **/\r\n  public static setupDragIn(dragIn?: string, dragInOptions?: DDDragInOpt): void { /* implemented in gridstack-dd.ts */ }\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  public movable(els: GridStackElement, val: boolean): GridStack { return this }\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  public resizable(els: GridStackElement, val: boolean): GridStack { return this }\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   */\r\n  public disable(): GridStack { return this }\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   */\r\n  public enable(): GridStack { return this }\r\n  /**\r\n   * Enables/disables widget moving. No-op for static grids.\r\n   */\r\n  public enableMove(doEnable: boolean): GridStack { return this }\r\n  /**\r\n   * Enables/disables widget resizing. No-op for static grids.\r\n   */\r\n  public enableResize(doEnable: boolean): GridStack { return this }\r\n\r\n  /** @internal called to add drag over support to support widgets */\r\n  public _setupAcceptWidget(): GridStack { return this }\r\n  /** @internal called to setup a trash drop zone if the user specifies it */\r\n  public _setupRemoveDrop(): GridStack { return this }\r\n  /** @internal prepares the element for drag&drop **/\r\n  public _prepareDragDropByNode(node: GridStackNode): GridStack { return this }\r\n  /** @internal handles actual drag/resize start **/\r\n  public _onStartMoving(el: GridItemHTMLElement, event: Event, ui: DDUIData, node: GridStackNode, cellWidth: number, cellHeight: number): void { return }\r\n  /** @internal handles actual drag/resize **/\r\n  public _dragOrResize(el: GridItemHTMLElement, event: Event, ui: DDUIData, node: GridStackNode, cellWidth: number, cellHeight: number): void { return }\r\n  /** @internal called when a node leaves our area (mouse out or shape outside) **/\r\n  public _leave(el: GridItemHTMLElement, helper?: GridItemHTMLElement): void { return }\r\n}\r\n","/**\n * dd-base-impl.ts 5.1.1\n * Copyright (c) 2021-2022 Alain Dumesny - see GridStack root license\n */\n\nexport type EventCallback = (event: Event) => boolean|void;\nexport abstract class DDBaseImplement {\n  /** returns the enable state, but you have to call enable()/disable() to change (as other things need to happen) */\n  public get disabled(): boolean   { return this._disabled; }\n\n  /** @internal */\n  protected _disabled = false;\n  /** @internal */\n  protected _eventRegister: {\n    [eventName: string]: EventCallback;\n  } = {};\n\n  public on(event: string, callback: EventCallback): void {\n    this._eventRegister[event] = callback;\n  }\n\n  public off(event: string): void {\n    delete this._eventRegister[event];\n  }\n\n  public enable(): void {\n    this._disabled = false;\n  }\n\n  public disable(): void {\n    this._disabled = true;\n  }\n\n  public destroy(): void {\n    delete this._eventRegister;\n  }\n\n  public triggerEvent(eventName: string, event: Event): boolean|void {\n    if (!this.disabled && this._eventRegister && this._eventRegister[eventName])\n      return this._eventRegister[eventName](event);\n  }\n}\n\nexport interface HTMLElementExtendOpt<T> {\n  el: HTMLElement;\n  option: T;\n  updateOption(T): DDBaseImplement;\n}\n","/**\n * dd-draggable.ts 5.1.1\n * Copyright (c) 2021-2022 Alain Dumesny - see GridStack root license\n */\n\nimport { DDManager } from './dd-manager';\nimport { DDUtils } from './dd-utils';\nimport { DDBaseImplement, HTMLElementExtendOpt } from './dd-base-impl';\nimport { GridItemHTMLElement, DDUIData } from '../types';\n\n// TODO: merge with DDDragOpt ?\nexport interface DDDraggableOpt {\n  appendTo?: string | HTMLElement;\n  containment?: string | HTMLElement; // TODO: not implemented yet\n  handle?: string;\n  revert?: string | boolean | unknown; // TODO: not implemented yet\n  scroll?: boolean; // nature support by HTML5 drag drop, can't be switch to off actually\n  helper?: string | HTMLElement | ((event: Event) => HTMLElement);\n  start?: (event: Event, ui: DDUIData) => void;\n  stop?: (event: Event) => void;\n  drag?: (event: Event, ui: DDUIData) => void;\n}\n\ninterface DragOffset {\n  left: number;\n  top: number;\n  width: number;\n  height: number;\n  offsetLeft: number;\n  offsetTop: number;\n}\n\nexport class DDDraggable extends DDBaseImplement implements HTMLElementExtendOpt<DDDraggableOpt> {\n  public el: HTMLElement;\n  public option: DDDraggableOpt;\n  public helper: HTMLElement; // used by GridStackDDNative\n\n  /** @internal */\n  protected dragOffset: DragOffset;\n  /** @internal */\n  protected dragElementOriginStyle: Array<string>;\n  /** @internal */\n  protected dragFollowTimer: number;\n  /** @internal */\n  protected dragEl: HTMLElement;\n  /** @internal */\n  protected dragging = false;\n  /** @internal */\n  protected paintTimer: number;\n  /** @internal */\n  protected parentOriginStylePosition: string;\n  /** @internal */\n  protected helperContainment: HTMLElement;\n  /** @internal #1541 can't have {passive: true} on Safari as otherwise it reverts animate back to old location on drop */\n  protected static dragEventListenerOption = true; // DDUtils.isEventSupportPassiveOption ? { capture: true, passive: true } : true;\n  /** @internal properties we change during dragging, and restore back */\n  protected static originStyleProp = ['transition', 'pointerEvents', 'position',\n    'left', 'top', 'opacity', 'zIndex', 'width', 'height', 'willChange', 'min-width'];\n\n  constructor(el: HTMLElement, option: DDDraggableOpt = {}) {\n    super();\n    this.el = el;\n    this.option = option;\n    // get the element that is actually supposed to be dragged by\n    let className = option.handle.substring(1);\n    this.dragEl = el.classList.contains(className) ? el : el.querySelector(option.handle) || el;\n    // create var event binding so we can easily remove and still look like TS methods (unlike anonymous functions)\n    this._dragStart = this._dragStart.bind(this);\n    this._drag = this._drag.bind(this);\n    this._dragEnd = this._dragEnd.bind(this);\n    this.enable();\n  }\n\n  public on(event: 'drag' | 'dragstart' | 'dragstop', callback: (event: DragEvent) => void): void {\n    super.on(event, callback);\n  }\n\n  public off(event: 'drag' | 'dragstart' | 'dragstop'): void {\n    super.off(event);\n  }\n\n  public enable(): void {\n    super.enable();\n    this.dragEl.draggable = true;\n    this.dragEl.addEventListener('dragstart', this._dragStart);\n    this.el.classList.remove('ui-draggable-disabled');\n    this.el.classList.add('ui-draggable');\n  }\n\n  public disable(forDestroy = false): void {\n    super.disable();\n    this.dragEl.removeAttribute('draggable');\n    this.dragEl.removeEventListener('dragstart', this._dragStart);\n    this.el.classList.remove('ui-draggable');\n    if (!forDestroy) this.el.classList.add('ui-draggable-disabled');\n  }\n\n  public destroy(): void {\n    if (this.dragging) {\n      // Destroy while dragging should remove dragend listener and manually trigger\n      // dragend, otherwise dragEnd can't perform dragstop because eventRegistry is\n      // destroyed.\n      this._dragEnd({} as DragEvent);\n    }\n    this.disable(true);\n    delete this.el;\n    delete this.helper;\n    delete this.option;\n    super.destroy();\n  }\n\n  public updateOption(opts: DDDraggableOpt): DDDraggable {\n    Object.keys(opts).forEach(key => this.option[key] = opts[key]);\n    return this;\n  }\n\n  /** @internal */\n  protected _dragStart(event: DragEvent): void {\n    DDManager.dragElement = this;\n    this.helper = this._createHelper(event);\n    this._setupHelperContainmentStyle();\n    this.dragOffset = this._getDragOffset(event, this.el, this.helperContainment);\n    const ev = DDUtils.initEvent<DragEvent>(event, { target: this.el, type: 'dragstart' });\n    if (this.helper !== this.el) {\n      this._setupDragFollowNodeNotifyStart(ev);\n      // immediately set external helper initial position to avoid flickering behavior and unnecessary looping in `_packNodes()`\n      this._dragFollow(event);\n    } else {\n      this.dragFollowTimer = window.setTimeout(() => {\n        delete this.dragFollowTimer;\n        this._setupDragFollowNodeNotifyStart(ev);\n      }, 0);\n    }\n    this._cancelDragGhost(event);\n  }\n\n  /** @internal */\n  protected _setupDragFollowNodeNotifyStart(ev: Event): DDDraggable {\n    this._setupHelperStyle();\n    document.addEventListener('dragover', this._drag, DDDraggable.dragEventListenerOption);\n    this.dragEl.addEventListener('dragend', this._dragEnd);\n    if (this.option.start) {\n      this.option.start(ev, this.ui());\n    }\n    this.dragging = true;\n    this.helper.classList.add('ui-draggable-dragging');\n    this.triggerEvent('dragstart', ev);\n    return this;\n  }\n\n  /** @internal */\n  protected _drag(event: DragEvent): void {\n    // Safari: prevent default to allow drop to happen instead of reverting back (with animation) and delaying dragend #1541\n    // https://stackoverflow.com/questions/61760755/how-to-fire-dragend-event-immediately\n    event.preventDefault();\n    this._dragFollow(event);\n    const ev = DDUtils.initEvent<DragEvent>(event, { target: this.el, type: 'drag' });\n    if (this.option.drag) {\n      this.option.drag(ev, this.ui());\n    }\n    this.triggerEvent('drag', ev);\n  }\n\n  /** @internal */\n  protected _dragEnd(event: DragEvent): void {\n    if (this.dragFollowTimer) {\n      clearTimeout(this.dragFollowTimer);\n      delete this.dragFollowTimer;\n      return;\n    } else {\n      if (this.paintTimer) {\n        cancelAnimationFrame(this.paintTimer);\n      }\n      document.removeEventListener('dragover', this._drag, DDDraggable.dragEventListenerOption);\n      this.dragEl.removeEventListener('dragend', this._dragEnd);\n    }\n    this.dragging = false;\n    this.helper.classList.remove('ui-draggable-dragging');\n    this.helperContainment.style.position = this.parentOriginStylePosition || null;\n    if (this.helper === this.el) {\n      this._removeHelperStyle();\n    } else {\n      this.helper.remove();\n    }\n    const ev = DDUtils.initEvent<DragEvent>(event, { target: this.el, type: 'dragstop' });\n    if (this.option.stop) {\n      this.option.stop(ev); // Note: ui() not used by gridstack so don't pass\n    }\n    this.triggerEvent('dragstop', ev);\n    delete DDManager.dragElement;\n    delete this.helper;\n  }\n\n  /** @internal create a clone copy (or user defined method) of the original drag item if set */\n  protected _createHelper(event: DragEvent): HTMLElement {\n    let helper = this.el;\n    if (typeof this.option.helper === 'function') {\n      helper = this.option.helper(event);\n    } else if (this.option.helper === 'clone') {\n      helper = DDUtils.clone(this.el);\n    }\n    if (!document.body.contains(helper)) {\n      DDUtils.appendTo(helper, this.option.appendTo === 'parent' ? this.el.parentNode : this.option.appendTo);\n    }\n    if (helper === this.el) {\n      this.dragElementOriginStyle = DDDraggable.originStyleProp.map(prop => this.el.style[prop]);\n    }\n    return helper;\n  }\n\n  /** @internal */\n  protected _setupHelperStyle(): DDDraggable {\n    // TODO: set all at once with style.cssText += ... ? https://stackoverflow.com/questions/3968593\n    const rec = this.helper.getBoundingClientRect();\n    const style = this.helper.style;\n    style.pointerEvents = 'none';\n    style['min-width'] = 0; // since we no longer relative to our parent and we don't resize anyway (normally 100/#column %)\n    style.width = this.dragOffset.width + 'px';\n    style.height = this.dragOffset.height + 'px';\n    style.willChange = 'left, top';\n    style.position = 'fixed'; // let us drag between grids by not clipping as parent .grid-stack is position: 'relative'\n    style.left = rec.left + 'px';\n    style.top = rec.top + 'px';\n    style.transition = 'none'; // show up instantly\n    setTimeout(() => {\n      if (this.helper) {\n        style.transition = null; // recover animation\n      }\n    }, 0);\n    return this;\n  }\n\n  /** @internal */\n  protected _removeHelperStyle(): DDDraggable {\n    let node = (this.helper as GridItemHTMLElement)?.gridstackNode;\n    // don't bother restoring styles if we're gonna remove anyway...\n    if (this.dragElementOriginStyle && (!node || !node._isAboutToRemove)) {\n      let helper = this.helper;\n      // don't animate, otherwise we animate offseted when switching back to 'absolute' from 'fixed' \n      let transition = this.dragElementOriginStyle['transition'] || null;\n      helper.style.transition = this.dragElementOriginStyle['transition'] = 'none';\n      DDDraggable.originStyleProp.forEach(prop => helper.style[prop] = this.dragElementOriginStyle[prop] || null);\n      setTimeout(() => helper.style.transition = transition, 50); // recover animation from saved vars after a pause (0 isn't enough #1973)\n    }\n    delete this.dragElementOriginStyle;\n    return this;\n  }\n\n  /** @internal */\n  protected _dragFollow(event: DragEvent): void {\n    if (this.paintTimer) {\n      cancelAnimationFrame(this.paintTimer);\n    }\n    this.paintTimer = requestAnimationFrame(() => {\n      delete this.paintTimer;\n      const offset = this.dragOffset;\n      let containmentRect = { left: 0, top: 0 };\n      if (this.helper.style.position === 'absolute') {\n        const { left, top } = this.helperContainment.getBoundingClientRect();\n        containmentRect = { left, top };\n      }\n      this.helper.style.left = event.clientX + offset.offsetLeft - containmentRect.left + 'px';\n      this.helper.style.top = event.clientY + offset.offsetTop - containmentRect.top + 'px';\n    });\n  }\n\n  /** @internal */\n  protected _setupHelperContainmentStyle(): DDDraggable {\n    this.helperContainment = this.helper.parentElement;\n    if (this.helper.style.position !== 'fixed') {\n      this.parentOriginStylePosition = this.helperContainment.style.position;\n      if (window.getComputedStyle(this.helperContainment).position.match(/static/)) {\n        this.helperContainment.style.position = 'relative';\n      }\n    }\n    return this;\n  }\n\n  /** @internal prevent the default ghost image to be created (which has wrong as we move the helper/element instead\n   * (legacy jquery UI code updates the top/left of the item).\n   * TODO: maybe use mouse event instead of HTML5 drag as we have to work around it anyway, or change code to not update\n   * the actual grid-item but move the ghost image around (and special case jq version) ?\n   **/\n  protected _cancelDragGhost(e: DragEvent): DDDraggable {\n    /* doesn't seem to do anything...\n    let t = e.dataTransfer;\n    t.effectAllowed = 'none';\n    t.dropEffect = 'none';\n    t.setData('text', '');\n    */\n\n    // NOTE: according to spec (and required by Safari see #1540) the image has to be visible in the browser (in dom and not hidden) so make it a 1px div\n    let img = document.createElement('div');\n    img.style.width = '1px';\n    img.style.height = '1px';\n    img.style.position = 'fixed'; // prevent unwanted scrollbar\n    document.body.appendChild(img);\n    e.dataTransfer.setDragImage(img, 0, 0);\n    setTimeout(() => document.body.removeChild(img)); // nuke once drag had a chance to grab this 'image'\n\n    e.stopPropagation();\n    return this;\n  }\n\n  /** @internal */\n  protected _getDragOffset(event: DragEvent, el: HTMLElement, parent: HTMLElement): DragOffset {\n\n    // in case ancestor has transform/perspective css properties that change the viewpoint\n    let xformOffsetX = 0;\n    let xformOffsetY = 0;\n    if (parent) {\n      const testEl = document.createElement('div');\n      DDUtils.addElStyles(testEl, {\n        opacity: '0',\n        position: 'fixed',\n        top: 0 + 'px',\n        left: 0 + 'px',\n        width: '1px',\n        height: '1px',\n        zIndex: '-999999',\n      });\n      parent.appendChild(testEl);\n      const testElPosition = testEl.getBoundingClientRect();\n      parent.removeChild(testEl);\n      xformOffsetX = testElPosition.left;\n      xformOffsetY = testElPosition.top;\n      // TODO: scale ?\n    }\n\n    const targetOffset = el.getBoundingClientRect();\n    return {\n      left: targetOffset.left,\n      top: targetOffset.top,\n      offsetLeft: - event.clientX + targetOffset.left - xformOffsetX,\n      offsetTop: - event.clientY + targetOffset.top - xformOffsetY,\n      width: targetOffset.width,\n      height: targetOffset.height\n    };\n  }\n\n  /** @internal TODO: set to public as called by DDDroppable! */\n  public ui = (): DDUIData => {\n    const containmentEl = this.el.parentElement;\n    const containmentRect = containmentEl.getBoundingClientRect();\n    const offset = this.helper.getBoundingClientRect();\n    return {\n      position: { //Current CSS position of the helper as { top, left } object\n        top: offset.top - containmentRect.top,\n        left: offset.left - containmentRect.left\n      }\n      /* not used by GridStack for now...\n      helper: [this.helper], //The object arr representing the helper that's being dragged.\n      offset: { top: offset.top, left: offset.left } // Current offset position of the helper as { top, left } object.\n      */\n    };\n  }\n}\n\n\n","/**\n * dd-droppable.ts 5.1.1\n * Copyright (c) 2021-2022 Alain Dumesny - see GridStack root license\n */\n\nimport { DDDraggable } from './dd-draggable';\nimport { DDManager } from './dd-manager';\nimport { DDBaseImplement, HTMLElementExtendOpt } from './dd-base-impl';\nimport { DDUtils } from './dd-utils';\nimport { GridHTMLElement, GridStack } from '../gridstack';\nimport { GridItemHTMLElement } from '../types';\n\nexport interface DDDroppableOpt {\n  accept?: string | ((el: HTMLElement) => boolean);\n  drop?: (event: DragEvent, ui) => void;\n  over?: (event: DragEvent, ui) => void;\n  out?: (event: DragEvent, ui) => void;\n}\n\n// TEST let count = 0;\n\nexport class DDDroppable extends DDBaseImplement implements HTMLElementExtendOpt<DDDroppableOpt> {\n\n  public accept: (el: HTMLElement) => boolean;\n  public el: HTMLElement;\n  public option: DDDroppableOpt;\n\n  /** @internal */\n  protected moving: boolean;\n  protected static lastActive: DDDroppable;\n\n  constructor(el: HTMLElement, opts: DDDroppableOpt = {}) {\n    super();\n    this.el = el;\n    this.option = opts;\n    // create var event binding so we can easily remove and still look like TS methods (unlike anonymous functions)\n    this._dragEnter = this._dragEnter.bind(this);\n    this._dragOver = this._dragOver.bind(this);\n    this._dragLeave = this._dragLeave.bind(this);\n    this._drop = this._drop.bind(this);\n\n    this.el.classList.add('ui-droppable');\n    this.el.addEventListener('dragenter', this._dragEnter);\n    this._setupAccept();\n  }\n\n  public on(event: 'drop' | 'dropover' | 'dropout', callback: (event: DragEvent) => void): void {\n    super.on(event, callback);\n  }\n\n  public off(event: 'drop' | 'dropover' | 'dropout'): void {\n    super.off(event);\n  }\n\n  public enable(): void {\n    if (!this.disabled) return;\n    super.enable();\n    this.el.classList.remove('ui-droppable-disabled');\n    this.el.addEventListener('dragenter', this._dragEnter);\n  }\n\n  public disable(forDestroy=false): void {\n    if (this.disabled) return;\n    super.disable();\n    if (!forDestroy) this.el.classList.add('ui-droppable-disabled');\n    this.el.removeEventListener('dragenter', this._dragEnter);\n  }\n\n  public destroy(): void {\n    this._removeLeaveCallbacks();\n    this.disable(true);\n    this.el.classList.remove('ui-droppable');\n    this.el.classList.remove('ui-droppable-disabled');\n    super.destroy();\n  }\n\n  public updateOption(opts: DDDroppableOpt): DDDroppable {\n    Object.keys(opts).forEach(key => this.option[key] = opts[key]);\n    this._setupAccept();\n    return this;\n  }\n\n  /** @internal called when the cursor enters our area - prepare for a possible drop and track leaving */\n  protected _dragEnter(event: DragEvent): void {\n    // TEST console.log(`${count++} Enter ${(this.el as GridHTMLElement).gridstack.opts.id}`);\n    if (!this._canDrop()) return;\n    event.preventDefault();\n    event.stopPropagation();\n\n    // ignore multiple 'dragenter' as we go over existing items\n    if (this.moving) return;\n    this.moving = true;\n\n    const ev = DDUtils.initEvent<DragEvent>(event, { target: this.el, type: 'dropover' });\n    if (this.option.over) {\n      this.option.over(ev, this._ui(DDManager.dragElement))\n    }\n    this.triggerEvent('dropover', ev);\n    this.el.addEventListener('dragover', this._dragOver);\n    this.el.addEventListener('drop', this._drop);\n    this.el.addEventListener('dragleave', this._dragLeave);\n    // Update: removed that as it causes nested grids to no receive dragenter events when parent drags and sets this for #992. not seeing cursor flicker (chrome).\n    // this.el.classList.add('ui-droppable-over');\n\n    // make sure when we enter this, that the last one gets a leave to correctly cleanup as we don't always do\n    if (DDDroppable.lastActive && DDDroppable.lastActive !== this) {\n      DDDroppable.lastActive._dragLeave(event, true);\n    }\n    DDDroppable.lastActive = this;\n  }\n\n  /** @internal called when an moving to drop item is being dragged over - do nothing but eat the event */\n  protected _dragOver(event: DragEvent): void {\n    event.preventDefault();\n    event.stopPropagation();\n  }\n\n  /** @internal called when the item is leaving our area, stop tracking if we had moving item */\n  protected _dragLeave(event: DragEvent, forceLeave?: boolean): void {\n    // TEST console.log(`${count++} Leave ${(this.el as GridHTMLElement).gridstack.opts.id}`);\n    event.preventDefault();\n    event.stopPropagation();\n\n    // ignore leave events on our children (we get them when starting to drag our items)\n    // but exclude nested grids since we would still be leaving ourself, \n    // but don't handle leave if we're dragging a nested grid around\n    if (!forceLeave) {\n      let onChild = DDUtils.inside(event, this.el);\n      let drag: GridItemHTMLElement = DDManager.dragElement.el;\n      if (onChild && !drag.gridstackNode?.subGrid) { // dragging a nested grid ?\n        let nestedEl = (this.el as GridHTMLElement).gridstack.engine.nodes.filter(n => n.subGrid).map(n => (n.subGrid as GridStack).el);\n        onChild = !nestedEl.some(el => DDUtils.inside(event, el));\n      }\n      if (onChild) return;\n    }\n\n    if (this.moving) {\n      const ev = DDUtils.initEvent<DragEvent>(event, { target: this.el, type: 'dropout' });\n      if (this.option.out) {\n        this.option.out(ev, this._ui(DDManager.dragElement))\n      }\n      this.triggerEvent('dropout', ev);\n    }\n    this._removeLeaveCallbacks();\n\n    if (DDDroppable.lastActive === this) {\n      delete DDDroppable.lastActive;\n    }\n  }\n\n  /** @internal item is being dropped on us - call the client drop event */\n  protected _drop(event: DragEvent): void {\n    if (!this.moving) return; // should not have received event...\n    event.preventDefault();\n    const ev = DDUtils.initEvent<DragEvent>(event, { target: this.el, type: 'drop' });\n    if (this.option.drop) {\n      this.option.drop(ev, this._ui(DDManager.dragElement))\n    }\n    this.triggerEvent('drop', ev);\n    this._removeLeaveCallbacks();\n  }\n\n  /** @internal called to remove callbacks when leaving or dropping */\n  protected _removeLeaveCallbacks() {\n    if (!this.moving) { return; }\n    delete this.moving;\n    this.el.removeEventListener('dragover', this._dragOver);\n    this.el.removeEventListener('drop', this._drop);\n    this.el.removeEventListener('dragleave', this._dragLeave);\n    // Update: removed that as it causes nested grids to no receive dragenter events when parent drags and sets this for #992. not seeing cursor flicker (chrome).\n    // this.el.classList.remove('ui-droppable-over');\n  }\n\n  /** @internal */\n  protected _canDrop(): boolean {\n    return DDManager.dragElement && (!this.accept || this.accept(DDManager.dragElement.el));\n  }\n\n  /** @internal */\n  protected _setupAccept(): DDDroppable {\n    if (this.option.accept && typeof this.option.accept === 'string') {\n      this.accept = (el: HTMLElement) => {\n        return el.matches(this.option.accept as string)\n      }\n    } else {\n      this.accept = this.option.accept as ((el: HTMLElement) => boolean);\n    }\n    return this;\n  }\n\n  /** @internal */\n  protected _ui(drag: DDDraggable) {\n    return {\n      draggable: drag.el,\n      ...drag.ui()\n    };\n  }\n}\n\n","/**\n * dd-elements.ts 5.1.1\n * Copyright (c) 2021 Alain Dumesny - see GridStack root license\n */\n\nimport { DDResizable, DDResizableOpt } from './dd-resizable';\nimport { GridItemHTMLElement } from './../types';\nimport { DDDraggable, DDDraggableOpt } from './dd-draggable';\nimport { DDDroppable, DDDroppableOpt } from './dd-droppable';\n\nexport interface DDElementHost extends GridItemHTMLElement {\n  ddElement?: DDElement;\n}\n\nexport class DDElement {\n\n  static init(el: DDElementHost): DDElement {\n    if (!el.ddElement) { el.ddElement = new DDElement(el); }\n    return el.ddElement;\n  }\n\n  public el: DDElementHost;\n  public ddDraggable?: DDDraggable;\n  public ddDroppable?: DDDroppable;\n  public ddResizable?: DDResizable;\n\n  constructor(el: DDElementHost) {\n    this.el = el;\n  }\n\n  public on(eventName: string, callback: (event: MouseEvent) => void): DDElement {\n    if (this.ddDraggable && ['drag', 'dragstart', 'dragstop'].indexOf(eventName) > -1) {\n      this.ddDraggable.on(eventName as 'drag' | 'dragstart' | 'dragstop', callback);\n    } else if (this.ddDroppable && ['drop', 'dropover', 'dropout'].indexOf(eventName) > -1) {\n      this.ddDroppable.on(eventName as 'drop' | 'dropover' | 'dropout', callback);\n    } else if (this.ddResizable && ['resizestart', 'resize', 'resizestop'].indexOf(eventName) > -1) {\n      this.ddResizable.on(eventName as 'resizestart' | 'resize' | 'resizestop', callback);\n    }\n    return this;\n  }\n\n  public off(eventName: string): DDElement {\n    if (this.ddDraggable && ['drag', 'dragstart', 'dragstop'].indexOf(eventName) > -1) {\n      this.ddDraggable.off(eventName as 'drag' | 'dragstart' | 'dragstop');\n    } else if (this.ddDroppable && ['drop', 'dropover', 'dropout'].indexOf(eventName) > -1) {\n      this.ddDroppable.off(eventName as 'drop' | 'dropover' | 'dropout');\n    } else if (this.ddResizable && ['resizestart', 'resize', 'resizestop'].indexOf(eventName) > -1) {\n      this.ddResizable.off(eventName as 'resizestart' | 'resize' | 'resizestop');\n    }\n    return this;\n  }\n\n  public setupDraggable(opts: DDDraggableOpt): DDElement {\n    if (!this.ddDraggable) {\n      this.ddDraggable = new DDDraggable(this.el, opts);\n    } else {\n      this.ddDraggable.updateOption(opts);\n    }\n    return this;\n  }\n\n  public cleanDraggable(): DDElement {\n    if (this.ddDraggable) {\n      this.ddDraggable.destroy();\n      delete this.ddDraggable;\n    }\n    return this;\n  }\n\n  public setupResizable(opts: DDResizableOpt): DDElement {\n    if (!this.ddResizable) {\n      this.ddResizable = new DDResizable(this.el, opts);\n    } else {\n      this.ddResizable.updateOption(opts);\n    }\n    return this;\n  }\n\n  public cleanResizable(): DDElement {\n    if (this.ddResizable) {\n      this.ddResizable.destroy();\n      delete this.ddResizable;\n    }\n    return this;\n  }\n\n  public setupDroppable(opts: DDDroppableOpt): DDElement {\n    if (!this.ddDroppable) {\n      this.ddDroppable = new DDDroppable(this.el, opts);\n    } else {\n      this.ddDroppable.updateOption(opts);\n    }\n    return this;\n  }\n\n  public cleanDroppable(): DDElement {\n    if (this.ddDroppable) {\n      this.ddDroppable.destroy();\n      delete this.ddDroppable;\n    }\n    return this;\n  }\n}\n","/**\n * dd-manager.ts 5.1.1\n * Copyright (c) 2021 Alain Dumesny - see GridStack root license\n */\n\nimport { DDDraggable } from './dd-draggable';\n\nexport class DDManager {\n  static dragElement: DDDraggable;\n}\n","/**\n * dd-resizable-handle.ts 5.1.1\n * Copyright (c) 2021-2022 Alain Dumesny - see GridStack root license\n */\n\nexport interface DDResizableHandleOpt {\n  start?: (event) => void;\n  move?: (event) => void;\n  stop?: (event) => void;\n}\n\nexport class DDResizableHandle {\n  /** @internal */\n  protected el: HTMLElement;\n  /** @internal */\n  protected host: HTMLElement;\n  /** @internal */\n  protected option: DDResizableHandleOpt;\n  /** @internal */\n  protected dir: string;\n  /** @internal true after we've moved enough pixels to start a resize */\n  protected moving = false;\n  /** @internal */\n  protected mouseDownEvent: MouseEvent;\n  /** @internal */\n  protected static prefix = 'ui-resizable-';\n\n  constructor(host: HTMLElement, direction: string, option: DDResizableHandleOpt) {\n    this.host = host;\n    this.dir = direction;\n    this.option = option;\n    // create var event binding so we can easily remove and still look like TS methods (unlike anonymous functions)\n    this._mouseDown = this._mouseDown.bind(this);\n    this._mouseMove = this._mouseMove.bind(this);\n    this._mouseUp = this._mouseUp.bind(this);\n\n    this._init();\n  }\n\n  /** @internal */\n  protected _init(): DDResizableHandle {\n    const el = document.createElement('div');\n    el.classList.add('ui-resizable-handle');\n    el.classList.add(`${DDResizableHandle.prefix}${this.dir}`);\n    el.style.zIndex = '100';\n    el.style.userSelect = 'none';\n    this.el = el;\n    this.host.appendChild(this.el);\n    this.el.addEventListener('mousedown', this._mouseDown);\n    return this;\n  }\n\n  /** call this when resize handle needs to be removed and cleaned up */\n  public destroy(): DDResizableHandle {\n    if (this.moving) this._mouseUp(this.mouseDownEvent);\n    this.el.removeEventListener('mousedown', this._mouseDown);\n    this.host.removeChild(this.el);\n    delete this.el;\n    delete this.host;\n    return this;\n  }\n\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 */\n  protected _mouseDown(e: MouseEvent): void {\n    e.preventDefault();\n    this.mouseDownEvent = e;\n    document.addEventListener('mousemove', this._mouseMove, true); // capture, not bubble\n    document.addEventListener('mouseup', this._mouseUp);\n  }\n\n  /** @internal */\n  protected _mouseMove(e: MouseEvent): void {\n    let s = this.mouseDownEvent;\n    // don't start unless we've moved at least 3 pixels\n    if (!this.moving && Math.abs(e.x - s.x) + Math.abs(e.y - s.y) > 2) {\n      this.moving = true;\n      this._triggerEvent('start', this.mouseDownEvent);\n    } else if (this.moving) {\n      this._triggerEvent('move', e);\n    }\n  }\n\n  /** @internal */\n  protected _mouseUp(e: MouseEvent): void {\n    if (this.moving) {\n      this._triggerEvent('stop', e);\n    }\n    document.removeEventListener('mousemove', this._mouseMove, true);\n    document.removeEventListener('mouseup', this._mouseUp);\n    delete this.moving;\n    delete this.mouseDownEvent;\n  }\n\n  /** @internal */\n  protected _triggerEvent(name: string, event: MouseEvent): DDResizableHandle {\n    if (this.option[name]) this.option[name](event);\n    return this;\n  }\n}\n","/**\n * dd-resizable.ts 5.1.1\n * Copyright (c) 2021-2022 Alain Dumesny - see GridStack root license\n */\n\nimport { DDResizableHandle } from './dd-resizable-handle';\nimport { DDBaseImplement, HTMLElementExtendOpt } from './dd-base-impl';\nimport { DDUtils } from './dd-utils';\nimport { Utils } from '../utils';\nimport { DDUIData, Rect, Size } from '../types';\n\n// TODO: merge with DDDragOpt\nexport interface DDResizableOpt {\n  autoHide?: boolean;\n  handles?: string;\n  maxHeight?: number;\n  maxWidth?: number;\n  minHeight?: number;\n  minWidth?: number;\n  start?: (event: Event, ui: DDUIData) => void;\n  stop?: (event: Event) => void;\n  resize?: (event: Event, ui: DDUIData) => void;\n}\n\nexport class DDResizable extends DDBaseImplement implements HTMLElementExtendOpt<DDResizableOpt> {\n\n  // have to be public else complains for HTMLElementExtendOpt ?\n  public el: HTMLElement;\n  public option: DDResizableOpt;\n\n  /** @internal */\n  protected handlers: DDResizableHandle[];\n  /** @internal */\n  protected originalRect: Rect;\n  /** @internal */\n  protected temporalRect: Rect;\n  /** @internal */\n  protected scrollY: number;\n  /** @internal */\n  protected scrolled: number;\n  /** @internal */\n  protected scrollEl: HTMLElement;\n  /** @internal */\n  protected startEvent: MouseEvent;\n  /** @internal value saved in the same order as _originStyleProp[] */\n  protected elOriginStyleVal: string[];\n  /** @internal */\n  protected parentOriginStylePosition: string;\n  /** @internal */\n  protected static _originStyleProp = ['width', 'height', 'position', 'left', 'top', 'opacity', 'zIndex'];\n\n  constructor(el: HTMLElement, opts: DDResizableOpt = {}) {\n    super();\n    this.el = el;\n    this.option = opts;\n    this.enable();\n    this._setupAutoHide();\n    this._setupHandlers();\n  }\n\n  public on(event: 'resizestart' | 'resize' | 'resizestop', callback: (event: DragEvent) => void): void {\n    super.on(event, callback);\n  }\n\n  public off(event: 'resizestart' | 'resize' | 'resizestop'): void {\n    super.off(event);\n  }\n\n  public enable(): void {\n    super.enable();\n    this.el.classList.add('ui-resizable');\n    this.el.classList.remove('ui-resizable-disabled');\n  }\n\n  public disable(): void {\n    super.disable();\n    this.el.classList.add('ui-resizable-disabled');\n    this.el.classList.remove('ui-resizable');\n  }\n\n  public destroy(): void {\n    this._removeHandlers();\n    if (this.option.autoHide) {\n      this.el.removeEventListener('mouseover', this._showHandlers);\n      this.el.removeEventListener('mouseout', this._hideHandlers);\n    }\n    this.el.classList.remove('ui-resizable');\n    delete this.el;\n    super.destroy();\n  }\n\n  public updateOption(opts: DDResizableOpt): DDResizable {\n    let updateHandles = (opts.handles && opts.handles !== this.option.handles);\n    let updateAutoHide = (opts.autoHide && opts.autoHide !== this.option.autoHide);\n    Object.keys(opts).forEach(key => this.option[key] = opts[key]);\n    if (updateHandles) {\n      this._removeHandlers();\n      this._setupHandlers();\n    }\n    if (updateAutoHide) {\n      this._setupAutoHide();\n    }\n    return this;\n  }\n\n  /** @internal */\n  protected _setupAutoHide(): DDResizable {\n    if (this.option.autoHide) {\n      this.el.classList.add('ui-resizable-autohide');\n      // use mouseover/mouseout instead of mouseenter/mouseleave to get better performance;\n      this.el.addEventListener('mouseover', this._showHandlers);\n      this.el.addEventListener('mouseout', this._hideHandlers);\n    } else {\n      this.el.classList.remove('ui-resizable-autohide');\n      this.el.removeEventListener('mouseover', this._showHandlers);\n      this.el.removeEventListener('mouseout', this._hideHandlers);\n    }\n    return this;\n  }\n\n  /** @internal */\n  protected _showHandlers = () => {\n    this.el.classList.remove('ui-resizable-autohide');\n  }\n\n  /** @internal */\n  protected _hideHandlers = () => {\n    this.el.classList.add('ui-resizable-autohide');\n  }\n\n  /** @internal */\n  protected _setupHandlers(): DDResizable {\n    let handlerDirection = this.option.handles || 'e,s,se';\n    if (handlerDirection === 'all') {\n      handlerDirection = 'n,e,s,w,se,sw,ne,nw';\n    }\n    this.handlers = handlerDirection.split(',')\n      .map(dir => dir.trim())\n      .map(dir => new DDResizableHandle(this.el, dir, {\n        start: (event: MouseEvent) => {\n          this._resizeStart(event);\n        },\n        stop: (event: MouseEvent) => {\n          this._resizeStop(event);\n        },\n        move: (event: MouseEvent) => {\n          this._resizing(event, dir);\n        }\n      }));\n    return this;\n  }\n\n  /** @internal */\n  protected _resizeStart(event: MouseEvent): DDResizable {\n    this.originalRect = this.el.getBoundingClientRect();\n    this.scrollEl = Utils.getScrollElement(this.el);\n    this.scrollY = this.scrollEl.scrollTop;\n    this.scrolled = 0;\n    this.startEvent = event;\n    this._setupHelper();\n    this._applyChange();\n    const ev = DDUtils.initEvent<MouseEvent>(event, { type: 'resizestart', target: this.el });\n    if (this.option.start) {\n      this.option.start(ev, this._ui());\n    }\n    this.el.classList.add('ui-resizable-resizing');\n    this.triggerEvent('resizestart', ev);\n    return this;\n  }\n\n  /** @internal */\n  protected _resizing(event: MouseEvent, dir: string): DDResizable {\n    this.scrolled = this.scrollEl.scrollTop - this.scrollY;\n    this.temporalRect = this._getChange(event, dir);\n    this._applyChange();\n    const ev = DDUtils.initEvent<MouseEvent>(event, { type: 'resize', target: this.el });\n    if (this.option.resize) {\n      this.option.resize(ev, this._ui());\n    }\n    this.triggerEvent('resize', ev);\n    return this;\n  }\n\n  /** @internal */\n  protected _resizeStop(event: MouseEvent): DDResizable {\n    const ev = DDUtils.initEvent<MouseEvent>(event, { type: 'resizestop', target: this.el });\n    if (this.option.stop) {\n      this.option.stop(ev); // Note: ui() not used by gridstack so don't pass\n    }\n    this.el.classList.remove('ui-resizable-resizing');\n    this.triggerEvent('resizestop', ev);\n    this._cleanHelper();\n    delete this.startEvent;\n    delete this.originalRect;\n    delete this.temporalRect;\n    delete this.scrollY;\n    delete this.scrolled;\n    return this;\n  }\n\n  /** @internal */\n  protected _setupHelper(): DDResizable {\n    this.elOriginStyleVal = DDResizable._originStyleProp.map(prop => this.el.style[prop]);\n    this.parentOriginStylePosition = this.el.parentElement.style.position;\n    if (window.getComputedStyle(this.el.parentElement).position.match(/static/)) {\n      this.el.parentElement.style.position = 'relative';\n    }\n    this.el.style.position = 'absolute';\n    this.el.style.opacity = '0.8';\n    return this;\n  }\n\n  /** @internal */\n  protected _cleanHelper(): DDResizable {\n    DDResizable._originStyleProp.forEach((prop, i) => {\n      this.el.style[prop] = this.elOriginStyleVal[i] || null;\n    });\n    this.el.parentElement.style.position = this.parentOriginStylePosition || null;\n    return this;\n  }\n\n  /** @internal */\n  protected _getChange(event: MouseEvent, dir: string): Rect {\n    const oEvent = this.startEvent;\n    const newRect = { // Note: originalRect is a complex object, not a simple Rect, so copy out.\n      width: this.originalRect.width,\n      height: this.originalRect.height + this.scrolled,\n      left: this.originalRect.left,\n      top: this.originalRect.top - this.scrolled\n    };\n    \n    const offsetX = event.clientX - oEvent.clientX;\n    const offsetY = event.clientY - oEvent.clientY;\n\n    if (dir.indexOf('e') > -1) {\n      newRect.width += offsetX;\n    } else if (dir.indexOf('w') > -1) {\n      newRect.width -= offsetX;\n      newRect.left += offsetX;\n    }\n    if (dir.indexOf('s') > -1) {\n      newRect.height += offsetY;\n    } else if (dir.indexOf('n') > -1) {\n      newRect.height -= offsetY;\n      newRect.top += offsetY\n    }\n    const constrain = this._constrainSize(newRect.width, newRect.height);\n    if (Math.round(newRect.width) !== Math.round(constrain.width)) { // round to ignore slight round-off errors\n      if (dir.indexOf('w') > -1) {\n        newRect.left += newRect.width - constrain.width;\n      }\n      newRect.width = constrain.width;\n    }\n    if (Math.round(newRect.height) !== Math.round(constrain.height)) {\n      if (dir.indexOf('n') > -1) {\n        newRect.top += newRect.height - constrain.height;\n      }\n      newRect.height = constrain.height;\n    }\n    return newRect;\n  }\n\n  /** @internal constrain the size to the set min/max values */\n  protected _constrainSize(oWidth: number, oHeight: number): Size {\n    const maxWidth = this.option.maxWidth || Number.MAX_SAFE_INTEGER;\n    const minWidth = this.option.minWidth || oWidth;\n    const maxHeight = this.option.maxHeight || Number.MAX_SAFE_INTEGER;\n    const minHeight = this.option.minHeight || oHeight;\n    const width = Math.min(maxWidth, Math.max(minWidth, oWidth));\n    const height = Math.min(maxHeight, Math.max(minHeight, oHeight));\n    return { width, height };\n  }\n\n  /** @internal */\n  protected _applyChange(): DDResizable {\n    let containmentRect = { left: 0, top: 0, width: 0, height: 0 };\n    if (this.el.style.position === 'absolute') {\n      const containmentEl = this.el.parentElement;\n      const { left, top } = containmentEl.getBoundingClientRect();\n      containmentRect = { left, top, width: 0, height: 0 };\n    }\n    if (!this.temporalRect) return this;\n    Object.keys(this.temporalRect).forEach(key => {\n      const value = this.temporalRect[key];\n      this.el.style[key] = value - containmentRect[key] + 'px';\n    });\n    return this;\n  }\n\n  /** @internal */\n  protected _removeHandlers(): DDResizable {\n    this.handlers.forEach(handle => handle.destroy());\n    delete this.handlers;\n    return this;\n  }\n\n  /** @internal */\n  protected _ui = (): DDUIData => {\n    const containmentEl = this.el.parentElement;\n    const containmentRect = containmentEl.getBoundingClientRect();\n    const newRect = { // Note: originalRect is a complex object, not a simple Rect, so copy out.\n      width: this.originalRect.width,\n      height: this.originalRect.height + this.scrolled,\n      left: this.originalRect.left,\n      top: this.originalRect.top - this.scrolled\n    };\n    const rect = this.temporalRect || newRect;\n    return {\n      position: {\n        left: rect.left - containmentRect.left,\n        top: rect.top - containmentRect.top\n      },\n      size: {\n        width: rect.width,\n        height: rect.height\n      }\n      /* Gridstack ONLY needs position set above... keep around in case.\n      element: [this.el], // The object representing the element to be resized\n      helper: [], // TODO: not support yet - The object representing the helper that's being resized\n      originalElement: [this.el],// we don't wrap here, so simplify as this.el //The object representing the original element before it is wrapped\n      originalPosition: { // The position represented as { left, top } before the resizable is resized\n        left: this.originalRect.left - containmentRect.left,\n        top: this.originalRect.top - containmentRect.top\n      },\n      originalSize: { // The size represented as { width, height } before the resizable is resized\n        width: this.originalRect.width,\n        height: this.originalRect.height\n      }\n      */\n    };\n  }\n}\n","/**\n * dd-utils.ts 5.1.1\n * Copyright (c) 2021 Alain Dumesny - see GridStack root license\n */\nexport class DDUtils {\n\n  public static isEventSupportPassiveOption = ((() => {\n    let supportsPassive = false;\n    let passiveTest = () => {\n      // do nothing\n    };\n    document.addEventListener('test', passiveTest, {\n      get passive() {\n        supportsPassive = true;\n        return true;\n      }\n    });\n    document.removeEventListener('test', passiveTest);\n    return supportsPassive;\n  })());\n\n  public static clone(el: HTMLElement): HTMLElement {\n    const node = el.cloneNode(true) as HTMLElement;\n    node.removeAttribute('id');\n    return node;\n  }\n\n  public static appendTo(el: HTMLElement, parent: string | HTMLElement | Node): void {\n    let parentNode: HTMLElement;\n    if (typeof parent === 'string') {\n      parentNode = document.querySelector(parent as string);\n    } else {\n      parentNode = parent as HTMLElement;\n    }\n    if (parentNode) {\n      parentNode.appendChild(el);\n    }\n  }\n\n  public static setPositionRelative(el: HTMLElement): void {\n    if (!(/^(?:r|a|f)/).test(window.getComputedStyle(el).position)) {\n      el.style.position = \"relative\";\n    }\n  }\n\n  public static addElStyles(el: HTMLElement, styles: { [prop: string]: string | string[] }): void {\n    if (styles instanceof Object) {\n      for (const s in styles) {\n        if (styles.hasOwnProperty(s)) {\n          if (Array.isArray(styles[s])) {\n            // support fallback value\n            (styles[s] as string[]).forEach(val => {\n              el.style[s] = val;\n            });\n          } else {\n            el.style[s] = styles[s];\n          }\n        }\n      }\n    }\n  }\n\n  public static initEvent<T>(e: DragEvent | MouseEvent, info: { type: string; target?: EventTarget }): T {\n    const evt = { type: info.type };\n    const obj = {\n      button: 0,\n      which: 0,\n      buttons: 1,\n      bubbles: true,\n      cancelable: true,\n      target: info.target ? info.target : e.target\n    };\n    // don't check for `instanceof DragEvent` as Safari use MouseEvent #1540\n    if ((e as DragEvent).dataTransfer) {\n      evt['dataTransfer'] = (e as DragEvent).dataTransfer; // workaround 'readonly' field.\n    }\n    ['altKey','ctrlKey','metaKey','shiftKey'].forEach(p => evt[p] = e[p]); // keys\n    ['pageX','pageY','clientX','clientY','screenX','screenY'].forEach(p => evt[p] = e[p]); // point info\n    return {...evt, ...obj} as unknown as T;\n  }\n\n  /** returns true if event is inside the given element rectangle */\n  // Note: Safari Mac has null event.relatedTarget which causes #1684 so check if DragEvent is inside the coordinates instead\n  //    this.el.contains(event.relatedTarget as HTMLElement)\n  public static inside(e: MouseEvent, el: HTMLElement): boolean {\n    // srcElement, toElement, target: all set to placeholder when leaving simple grid, so we can't use that (Chrome)\n    let target: HTMLElement = e.relatedTarget || (e as any).fromElement;\n    if (!target) {\n      const { bottom, left, right, top } = el.getBoundingClientRect();\n      return (e.x < right && e.x > left && e.y < bottom && e.y > top);\n    }\n    return el.contains(target);\n  }\n}","/**\n * gridstack-dd-native.ts 5.1.1\n * Copyright (c) 2021-2022 Alain Dumesny - see GridStack root license\n */\n\nimport { DDManager } from './dd-manager';\nimport { DDElement, DDElementHost } from './dd-element';\n\nimport { GridStackElement } from '../gridstack';\nimport { GridStackDD, DDOpts, DDKey, DDDropOpt, DDCallback, DDValue } from '../gridstack-dd';\nimport { GridItemHTMLElement, DDDragInOpt } from '../types';\nimport { Utils } from '../utils';\n\n// export our base class (what user should use) and all associated types\nexport * from '../gridstack-dd';\n\n/**\n * HTML 5 Native DragDrop based drag'n'drop plugin.\n */\nexport class GridStackDDNative extends GridStackDD {\n\n  public resizable(el: GridItemHTMLElement, opts: DDOpts, key?: DDKey, value?: DDValue): GridStackDDNative {\n    this._getDDElements(el).forEach(dEl => {\n      if (opts === 'disable' || opts === 'enable') {\n        dEl.ddResizable && dEl.ddResizable[opts](); // can't create DD as it requires options for setupResizable()\n      } else if (opts === 'destroy') {\n        dEl.ddResizable && dEl.cleanResizable();\n      } else if (opts === 'option') {\n        dEl.setupResizable({ [key]: value });\n      } else {\n        const grid = dEl.el.gridstackNode.grid;\n        let handles = dEl.el.getAttribute('gs-resize-handles') ? dEl.el.getAttribute('gs-resize-handles') : grid.opts.resizable.handles;\n        dEl.setupResizable({\n          ...grid.opts.resizable,\n          ...{ handles: handles },\n          ...{\n            start: opts.start,\n            stop: opts.stop,\n            resize: opts.resize\n          }\n        });\n      }\n    });\n    return this;\n  }\n\n  public draggable(el: GridItemHTMLElement, opts: DDOpts, key?: DDKey, value?: DDValue): GridStackDDNative {\n    this._getDDElements(el).forEach(dEl => {\n      if (opts === 'disable' || opts === 'enable') {\n        dEl.ddDraggable && dEl.ddDraggable[opts](); // can't create DD as it requires options for setupDraggable()\n      } else if (opts === 'destroy') {\n        dEl.ddDraggable && dEl.cleanDraggable();\n      } else if (opts === 'option') {\n        dEl.setupDraggable({ [key]: value });\n      } else {\n        const grid = dEl.el.gridstackNode.grid;\n        dEl.setupDraggable({\n          ...grid.opts.draggable,\n          ...{\n            containment: (grid.opts._isNested && !grid.opts.dragOut)\n              ? grid.el.parentElement\n              : (grid.opts.draggable.containment || null),\n            start: opts.start,\n            stop: opts.stop,\n            drag: opts.drag\n          }\n        });\n      }\n    });\n    return this;\n  }\n\n  public dragIn(el: GridStackElement, opts: DDDragInOpt): GridStackDDNative {\n    this._getDDElements(el).forEach(dEl => dEl.setupDraggable(opts));\n    return this;\n  }\n\n  public droppable(el: GridItemHTMLElement, opts: DDOpts | DDDropOpt, key?: DDKey, value?: DDValue): GridStackDDNative {\n    if (typeof opts.accept === 'function' && !opts._accept) {\n      opts._accept = opts.accept;\n      opts.accept = (el) => opts._accept(el);\n    }\n    this._getDDElements(el).forEach(dEl => {\n      if (opts === 'disable' || opts === 'enable') {\n        dEl.ddDroppable && dEl.ddDroppable[opts]();\n      } else if (opts === 'destroy') {\n        if (dEl.ddDroppable) { // error to call destroy if not there\n          dEl.cleanDroppable();\n        }\n      } else if (opts === 'option') {\n        dEl.setupDroppable({ [key]: value });\n      } else {\n        dEl.setupDroppable(opts);\n      }\n    });\n    return this;\n  }\n\n  /** true if element is droppable */\n  public isDroppable(el: DDElementHost): boolean {\n    return !!(el && el.ddElement && el.ddElement.ddDroppable && !el.ddElement.ddDroppable.disabled);\n  }\n\n  /** true if element is draggable */\n  public isDraggable(el: DDElementHost): boolean {\n    return !!(el && el.ddElement && el.ddElement.ddDraggable && !el.ddElement.ddDraggable.disabled);\n  }\n\n  /** true if element is draggable */\n  public isResizable(el: DDElementHost): boolean {\n    return !!(el && el.ddElement && el.ddElement.ddResizable && !el.ddElement.ddResizable.disabled);\n  }\n\n  public on(el: GridItemHTMLElement, name: string, callback: DDCallback): GridStackDDNative {\n    this._getDDElements(el).forEach(dEl =>\n      dEl.on(name, (event: Event) => {\n        callback(\n          event,\n          DDManager.dragElement ? DDManager.dragElement.el : event.target as GridItemHTMLElement,\n          DDManager.dragElement ? DDManager.dragElement.helper : null)\n      })\n    );\n    return this;\n  }\n\n  public off(el: GridItemHTMLElement, name: string): GridStackDD {\n    this._getDDElements(el).forEach(dEl => dEl.off(name));\n    return this;\n  }\n\n  /** @internal returns a list of DD elements, creating them on the fly by default */\n  protected _getDDElements(els: GridStackElement, create = true): DDElement[] {\n    let hosts = Utils.getElements(els) as DDElementHost[];\n    if (!hosts.length) return [];\n    let list = hosts.map(e => e.ddElement || (create ? DDElement.init(e) : null));\n    if (!create) { list.filter(d => d); } // remove nulls\n    return list;\n  }\n}\n\n// finally register ourself\nGridStackDD.registerPlugin(GridStackDDNative);\n","/**\r\n * utils.ts 5.1.1\r\n * Copyright (c) 2021 Alain Dumesny - see GridStack root license\r\n */\r\n\r\nimport { GridStackElement, GridStackNode, GridStackOptions, numberOrString, GridStackPosition, GridStackWidget } from './types';\r\n\r\nexport interface HeightData {\r\n  h: number;\r\n  unit: string;\r\n}\r\n\r\n/** checks for obsolete method names */\r\n// eslint-disable-next-line\r\nexport function obsolete(self, f, oldName: string, newName: string, rev: string): (...args: any[]) => any {\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 **completely** removed in v1.0');\r\n    return f.apply(self, args);\r\n  }\r\n  wrapper.prototype = f.prototype;\r\n  return wrapper;\r\n}\r\n\r\n/** checks for obsolete grid options (can be used for any fields, but msg is about options) */\r\nexport function obsoleteOpts(opts: GridStackOptions, oldName: string, newName: string, rev: string): void {\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 **completely** removed in v1.0');\r\n  }\r\n}\r\n\r\n/** checks for obsolete grid options which are gone */\r\nexport function obsoleteOptsDel(opts: GridStackOptions, oldName: string, rev: string, info: string): void {\r\n  if (opts[oldName] !== undefined) {\r\n    console.warn('gridstack.js: Option `' + oldName + '` is deprecated in ' + rev + info);\r\n  }\r\n}\r\n\r\n/** checks for obsolete Jquery element attributes */\r\nexport function obsoleteAttr(el: HTMLElement, oldName: string, newName: string, rev: string): void {\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 **completely** removed in v1.0');\r\n  }\r\n}\r\n\r\n/**\r\n * Utility methods\r\n */\r\nexport class Utils {\r\n\r\n  /** convert a potential selector into actual list of html elements */\r\n  static getElements(els: GridStackElement): HTMLElement[] {\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) { list = document.querySelectorAll('#' + els) }\r\n      }\r\n      return Array.from(list) as HTMLElement[];\r\n    }\r\n    return [els];\r\n  }\r\n\r\n  /** convert a potential selector into actual single element */\r\n  static getElement(els: GridStackElement): HTMLElement {\r\n    if (typeof els === 'string') {\r\n      if (!els.length) 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\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\r\n      // finally try string, then id then class\r\n      let el = document.querySelector(els);\r\n      if (!el) { el = document.getElementById(els) }\r\n      if (!el) { el = document.querySelector('.' + els) }\r\n      return el as HTMLElement;\r\n    }\r\n    return els;\r\n  }\r\n\r\n  /** returns true if a and b overlap */\r\n  static isIntercepted(a: GridStackPosition, b: GridStackPosition): boolean {\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\r\n  /** returns true if a and b touch edges or corners */\r\n  static isTouching(a: GridStackPosition, b: GridStackPosition): boolean {\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  /**\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: GridStackNode[], dir?: -1 | 1, column?: number): GridStackNode[] {\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  /**\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: string, parent?: HTMLElement): CSSStyleSheet {\r\n    let style: HTMLStyleElement = document.createElement('style');\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 as any).styleSheet) { // TODO: only CSSImportRule have that and different beast ??\r\n      // eslint-disable-next-line @typescript-eslint/no-explicit-any\r\n      (style as any).styleSheet.cssText = '';\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    } else {\r\n      parent.insertBefore(style, parent.firstChild);\r\n    }\r\n    return style.sheet as CSSStyleSheet;\r\n  }\r\n\r\n  /** removed the given stylesheet id */\r\n  static removeStylesheet(id: string): void {\r\n    let el = document.querySelector('STYLE[gs-style-id=' + id + ']');\r\n    if (el && el.parentNode) el.remove();\r\n  }\r\n\r\n  /** inserts a CSS rule */\r\n  static addCSSRule(sheet: CSSStyleSheet, selector: string, rules: string): void {\r\n    if (typeof sheet.addRule === 'function') {\r\n      sheet.addRule(selector, rules);\r\n    } else if (typeof sheet.insertRule === 'function') {\r\n      sheet.insertRule(`${selector}{${rules}}`);\r\n    }\r\n  }\r\n\r\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\r\n  static toBool(v: unknown): boolean {\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\r\n  static toNumber(value: null | string): number {\r\n    return (value === null || value.length === 0) ? undefined : Number(value);\r\n  }\r\n\r\n  static parseHeight(val: numberOrString): HeightData {\r\n    let h: number;\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    } else {\r\n      h = val;\r\n    }\r\n    return { h, unit };\r\n  }\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\r\n    sources.forEach(source => {\r\n      for (const key in source) {\r\n        if (!source.hasOwnProperty(key)) return;\r\n        if (target[key] === null || target[key] === undefined) {\r\n          target[key] = source[key];\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\r\n    return target;\r\n  }\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: unknown, b: unknown): boolean {\r\n    if (typeof a !== 'object')  return a == b;\r\n    if (typeof a !== typeof b) 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) return false;\r\n    for (const key in a) {\r\n      if (a[key] !== b[key]) return false;\r\n    }\r\n    return true;\r\n  }\r\n\r\n  /** copies over b size & position (GridStackPosition), and possibly min/max as well */\r\n  static copyPos(a: GridStackWidget, b: GridStackWidget, doMinMax = false): GridStackWidget {\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) a.minW = b.minW;\r\n      if (b.minH) a.minH = b.minH;\r\n      if (b.maxW) a.maxW = b.maxW;\r\n      if (b.maxH) a.maxH = b.maxH;\r\n    }\r\n    return a;\r\n  }\r\n\r\n  /** true if a and b has same size & position */\r\n  static samePos(a: GridStackPosition, b: GridStackPosition): boolean {\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\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: unknown, b: unknown):void {\r\n    if (typeof a !== 'object' || typeof b !== 'object') 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      } 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] === '_') { delete val[i] }\r\n        }\r\n        if (!Object.keys(val).length) { delete a[key] }\r\n      }\r\n    }\r\n  }\r\n\r\n  /** return the closest parent (or itself) matching the given class */\r\n  static closestByClass(el: HTMLElement, name: string): HTMLElement {\r\n    while (el) {\r\n      if (el.classList.contains(name)) return el;\r\n      el = el.parentElement\r\n    }\r\n    return null;\r\n  }\r\n\r\n  /** delay calling the given function for given delay, preventing new calls from happening while waiting */\r\n  static throttle(func: () => void, delay: number): () => void {\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\r\n  static removePositioningStyles(el: HTMLElement): void {\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\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?: HTMLElement): HTMLElement {\r\n    if (!el) return document.scrollingElement as HTMLElement || document.documentElement; // IE support\r\n    const style = getComputedStyle(el);\r\n    const overflowRegex = /(auto|scroll)/;\r\n\r\n    if (overflowRegex.test(style.overflow + style.overflowY)) {\r\n      return el;\r\n    } else {\r\n      return this.getScrollElement(el.parentElement);\r\n    }\r\n  }\r\n\r\n  /** @internal */\r\n  static updateScrollPosition(el: HTMLElement, position: {top: number}, distance: number): void {\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    ) {\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          } else {\r\n            scrollEl.scrollTop += Math.abs(offsetDiffUp) > Math.abs(distance) ? distance : offsetDiffUp;\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          } 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  /**\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: MouseEvent, el: HTMLElement, distance: number): void {\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\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    } else if (bottom) {\r\n      scrollEl.scrollBy({ behavior: 'smooth', top: distance - (height - pointerPosY)});\r\n    }\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<T>(obj: T): T {\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] as any;\r\n    }\r\n    return {...obj};\r\n  }\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<T>(obj: T): T {\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}\r\n\r\n// list of fields we will skip during cloneDeep (nested objects, other internal)\r\nconst skipFields = ['_isNested', 'el', 'grid', 'subGrid', 'engine'];\r\n","// The module cache\nvar __webpack_module_cache__ = {};\n\n// The require function\nfunction __webpack_require__(moduleId) {\n\t// Check if module is in cache\n\tvar cachedModule = __webpack_module_cache__[moduleId];\n\tif (cachedModule !== undefined) {\n\t\treturn cachedModule.exports;\n\t}\n\t// Create a new module (and put it into the cache)\n\tvar module = __webpack_module_cache__[moduleId] = {\n\t\t// no module.id needed\n\t\t// no module.loaded needed\n\t\texports: {}\n\t};\n\n\t// Execute the module function\n\t__webpack_modules__[moduleId].call(module.exports, module, module.exports, __webpack_require__);\n\n\t// Return the exports of the module\n\treturn module.exports;\n}\n\n","// startup\n// Load entry module and return exports\n// This entry module is referenced by other modules so it can't be inlined\nvar __webpack_exports__ = __webpack_require__(930);\n"],"sourceRoot":""}