{"version":3,"sources":["webpack://GridStack/webpack/universalModuleDefinition","webpack://GridStack/./src/dd-base-impl.ts","webpack://GridStack/./src/dd-draggable.ts","webpack://GridStack/./src/dd-droppable.ts","webpack://GridStack/./src/dd-element.ts","webpack://GridStack/./src/dd-gridstack.ts","webpack://GridStack/./src/dd-manager.ts","webpack://GridStack/./src/dd-resizable-handle.ts","webpack://GridStack/./src/dd-resizable.ts","webpack://GridStack/./src/dd-touch.ts","webpack://GridStack/./src/gridstack-engine.ts","webpack://GridStack/./src/gridstack.ts","webpack://GridStack/./src/types.ts","webpack://GridStack/./src/utils.ts","webpack://GridStack/webpack/bootstrap","webpack://GridStack/webpack/startup"],"names":["root","factory","exports","module","define","amd","self","_eventRegister","disabled","this","_disabled","on","event","callback","off","enable","disable","destroy","triggerEvent","eventName","DDDraggable","DDBaseImplement","constructor","el","option","super","className","handle","substring","dragEl","classList","contains","querySelector","_mouseDown","bind","_mouseMove","_mouseUp","addEventListener","isTouch","touchstart","pointerdown","remove","add","forDestroy","removeEventListener","dragging","mouseDownEvent","helper","updateOption","opts","Object","keys","forEach","key","e","DDManager","mouseHandled","button","name","target","nodeName","toLowerCase","find","skip","dragElement","dropElement","document","touchmove","touchend","preventDefault","s","_dragFollow","ev","Utils","initEvent","type","drag","ui","Math","abs","x","y","grid","gridstackNode","ddElement","ddDroppable","_createHelper","_setupHelperContainmentStyle","dragOffset","_getDragOffset","helperContainment","_setupHelperStyle","start","parentElement","style","position","parentOriginStylePosition","_removeHelperStyle","stop","drop","cloneNode","body","appendTo","parentNode","dragElementOriginStyle","originStyleProp","map","prop","pointerEvents","width","height","willChange","transition","setTimeout","node","_isAboutToRemove","offset","left","clientX","offsetLeft","top","clientY","offsetTop","window","getComputedStyle","match","parent","xformOffsetX","xformOffsetY","testEl","createElement","addElStyles","opacity","zIndex","appendChild","testElPosition","getBoundingClientRect","removeChild","targetOffset","containmentRect","DDDroppable","_mouseEnter","_mouseLeave","_setupAccept","pointerenter","pointerleave","_canDrop","stopPropagation","over","_ui","out","parentDrop","accept","matches","draggable","DDElement","static","ddDraggable","indexOf","ddResizable","setupDraggable","cleanDraggable","setupResizable","DDResizable","cleanResizable","setupDroppable","cleanDroppable","DDGridStack","dd","resizable","value","_getDDElements","dEl","handles","getAttribute","autoHide","alwaysShowResizeHandle","resize","dragIn","droppable","_accept","isDroppable","isDraggable","isResizable","els","create","hosts","getElements","length","list","init","filter","d","_itemRemoving","undefined","GridStack","prototype","_setupAcceptWidget","staticGrid","acceptWidgets","removable","cellHeight","cellWidth","onDrag","_temporaryRemoved","max","round","autoPosition","engine","nodeBoundFix","willItFit","_willFitPos","copyPos","_onStartMoving","_dragOrResize","subGrid","canAccept","selector","maxRow","n","w","h","minW","minH","_leave","getCellHeight","_readAttr","_isExternal","offsetWidth","offsetHeight","_gridstackNodeOrig","cleanupNode","_initDD","wasAdded","placeholder","origNode","oGrid","removedNodes","push","_triggerRemoveEvent","_removeDD","removePositioningStyles","_writeAttr","_updateContainerHeight","addedNodes","_triggerAddEvent","_triggerChangeEvent","endUpdate","_gsEventHandler","_prepareDragDropByNode","removeNode","_setupRemoveDrop","trashEl","removableOptions","setupDragIn","_dragIn","_dragInOptions","dragInOptions","noMove","disableDrag","noResize","disableResize","onStartMoving","dragOrResize","onEndMoving","_moving","_lastTried","gridToNotify","_orig","_writePosAttr","addNode","_extraDragRow","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","rect","moveNodeCheck","_skipDown","onParentResize","movable","val","enableMove","enableResize","_triggerEvent","doEnable","nodes","DDResizableHandle","host","direction","moving","dir","_init","prefix","userSelect","newRect","originalRect","scrolled","temporalRect","_mouseOver","_mouseOut","_setupAutoHide","_setupHandlers","_removeHandlers","updateHandles","updateAutoHide","auto","overResizeElement","handlerDirection","handlers","split","trim","_resizeStart","_resizeStop","move","_resizing","scrollEl","getScrollElement","scrollY","scrollTop","startEvent","_setupHelper","_applyChange","_getChange","_cleanHelper","elOriginStyleVal","_originStyleProp","i","oEvent","offsetX","offsetY","constrain","_constrainSize","oWidth","oHeight","maxWidth","Number","MAX_SAFE_INTEGER","minWidth","maxHeight","minHeight","containmentEl","DocumentTouch","navigator","maxTouchPoints","msMaxTouchPoints","DDTouch","simulateMouseEvent","simulatedType","touches","cancelable","touch","changedTouches","simulatedEvent","createEvent","initMouseEvent","screenX","screenY","dispatchEvent","simulatePointerMouseEvent","touchHandled","pointerLeaveTimeout","clearTimeout","wasDragging","releasePointerCapture","pointerId","GridStackEngine","column","_float","float","onChange","batchUpdate","flag","batchMode","_prevFloat","saveInitial","_packNodes","_notify","_useEntireRowArea","nn","_hasLocked","_fixCollisions","opt","sortNodes","nested","swap","area","didMove","newOpt","pack","moved","locked","moveNode","skip2","isIntercepted","collideAll","collideCoverage","o","collides","_rect","r0","r","r2","yOver","MAX_VALUE","xOver","overMax","right","bottom","a","b","_doSwap","_dirty","touching","isTouching","t","isAreaEmpty","compact","copyNodes","sort","_updating","newY","prepareNode","_id","_idSeq","defaults","isNaN","before","_inColumnResize","cacheOneLayout","samePos","getDirtyNodes","verify","dirtyNodes","concat","some","triggerAddEvent","dup","_removeDOM","floor","box","removeDOM","removeAll","_layouts","changedPosConstrain","clonedNode","clone","canMove","c","content","prevPos","needToMove","reduce","save","saveElement","len","layout","wl","l","layoutsNodesChange","ratio","updateNodeWidths","prevColumn","cacheLayout","newNodes","domOrder","cacheNodes","lastIndex","cacheNode","j","findIndex","splice","scale","clear","copy","index","minRow","rowAttr","toNumber","anyOpts","oneColumnSize","_alwaysShowResizeHandle","cloneDeep","GridDefaults","toBool","handleClass","itemClass","animate","_initMargin","disableOneColumnMode","_widthOrContainer","_prevColumn","getColumn","rtl","parentGridItemEl","closestByClass","_isNested","_isAutoCellHeight","cellHeightUnit","_styleSheetClass","random","toFixed","_setStaticClass","engineClass","cbNodes","_updateStyles","elements","getGridItems","parseInt","_prepareElement","setAnimation","_updateWindowResizeEvent","options","elOrString","getGridElement","gridstack","console","error","grids","getGridElements","doc","implementation","createHTMLDocument","innerHTML","class","children","load","_placeholder","placeholderChild","placeholderText","placeholderClass","addWidget","arguments","warn","id","domAttr","_insertNotAppend","prepend","autoColumn","ops","addGrid","_autoColumn","saveContent","saveGridOpt","sub","margin","origShow","removeInternalAndSame","addAndRemove","items","_ignoreLayoutsNodeChange","removed","removeWidget","item","update","forcePixel","rows","marginDiff","data","parseHeight","unit","clientWidth","innerWidth","domNodes","oldColumn","oneColumnModeDomSort","Array","from","setStatic","_removeStylesheet","removeAttribute","getFloat","getCellFromPixel","useDocRelative","containerPos","documentElement","relativeLeft","relativeTop","columnWidth","rowHeight","makeWidget","getElement","noData","detail","log","doAnimate","updateClass","m","k","changed","ddChanged","marginUnit","getMargin","CustomEvent","bubbles","Event","_styles","removeStylesheet","forceUpdate","styleLocation","styleInHead","createStylesheet","_max","addCSSRule","getHeight","setAttribute","String","removeProperty","same","attrs","resizeHandles","hasOwnProperty","classes","changedColumn","oneColumn","cellHeightThrottle","_cellHeightThrottle","throttle","forceRemove","workTodo","_windowResizeBind","margins","commit","obsolete","Engine","GDRev","f","oldName","newName","rev","wrapper","args","apply","info","oldAttr","querySelectorAll","getElementById","col","styleSheet","cssText","createTextNode","insertBefore","firstChild","getElementsByTagName","sheet","rules","addRule","insertRule","v","Boolean","Error","parseFloat","sources","source","doMinMax","func","delay","isWaiting","scrollingElement","test","overflow","overflowY","innerHeightOrClientHeight","innerHeight","clientHeight","offsetDiffDown","offsetDiffUp","prevScroll","pointerPosY","scrollBy","behavior","obj","skipFields","ret","styles","isArray","evt","which","buttons","dataTransfer","__webpack_module_cache__","__webpack_exports__","__webpack_require__","moduleId","cachedModule","__webpack_modules__","call"],"mappings":"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","file":"gridstack-all.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 ","/**\n * dd-base-impl.ts 6.0.3\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: boolean; // initial state to differentiate from 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 6.0.3\n * Copyright (c) 2021-2022 Alain Dumesny - see GridStack root license\n */\n\nimport { DDManager } from './dd-manager';\nimport { Utils } from './utils';\nimport { DDBaseImplement, HTMLElementExtendOpt } from './dd-base-impl';\nimport { GridItemHTMLElement, DDUIData } from './types';\nimport { DDElementHost } from './dd-element';\nimport { isTouch, touchend, touchmove, touchstart, pointerdown } from './dd-touch';\n\n// TODO: merge with DDDragOpt ?\nexport interface DDDraggableOpt {\n  appendTo?: string | HTMLElement;\n  handle?: string;\n  helper?: string | HTMLElement | ((event: Event) => HTMLElement);\n  // containment?: string | HTMLElement; // TODO: not implemented yet\n  // revert?: string | boolean | unknown; // TODO: not implemented yet\n  // scroll?: boolean; // native support by HTML5 drag drop, can't be switch to off actually\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\ntype DDDragEvent = 'drag' | 'dragstart' | 'dragstop';\n\n// let count = 0; // TEST\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 mouseDownEvent: MouseEvent;\n  /** @internal */\n  protected dragOffset: DragOffset;\n  /** @internal */\n  protected dragElementOriginStyle: Array<string>;\n  /** @internal */\n  protected dragEl: HTMLElement;\n  /** @internal true while we are dragging an item around */\n  protected dragging: boolean;\n  /** @internal */\n  protected parentOriginStylePosition: string;\n  /** @internal */\n  protected helperContainment: HTMLElement;\n  /** @internal properties we change during dragging, and restore back */\n  protected static originStyleProp = ['transition', 'pointerEvents', 'position', 'left', 'top'];\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._mouseDown = this._mouseDown.bind(this);\n    this._mouseMove = this._mouseMove.bind(this);\n    this._mouseUp = this._mouseUp.bind(this);\n    this.enable();\n  }\n\n  public on(event: DDDragEvent, callback: (event: DragEvent) => void): void {\n    super.on(event, callback);\n  }\n\n  public off(event: DDDragEvent): void {\n    super.off(event);\n  }\n\n  public enable(): void {\n    if (this.disabled === false) return;\n    super.enable();\n    this.dragEl.addEventListener('mousedown', this._mouseDown);\n    if (isTouch) {\n      this.dragEl.addEventListener('touchstart', touchstart);\n      this.dragEl.addEventListener('pointerdown', pointerdown);\n      // this.dragEl.style.touchAction = 'none'; // not needed unlike pointerdown doc comment\n    }\n    this.el.classList.remove('ui-draggable-disabled');\n    this.el.classList.add('ui-draggable');\n  }\n\n  public disable(forDestroy = false): void {\n    if (this.disabled === true) return;\n    super.disable();\n    this.dragEl.removeEventListener('mousedown', this._mouseDown);\n    if (isTouch) {\n      this.dragEl.removeEventListener('touchstart', touchstart);\n      this.dragEl.removeEventListener('pointerdown', pointerdown);\n    }\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) this._mouseUp(this.mouseDownEvent);\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 call when mouse goes down before a dragstart happens */\n  protected _mouseDown(e: MouseEvent): boolean {\n    // don't let more than one widget handle mouseStart\n    if (DDManager.mouseHandled) return;\n    if (e.button !== 0) return true; // only left click\n\n    // make sure we are not clicking on known object that handles mouseDown (TODO: make this extensible ?) #2054\n    const skipMouseDown = ['input', 'textarea', 'button', 'select', 'option'];\n    const name = (e.target as HTMLElement).nodeName.toLowerCase();\n    if (skipMouseDown.find(skip => skip === name)) return true;\n\n    // make sure we are clicking on a drag handle or child of it...\n    // Note: we don't need to check that's handle is an immediate child, as mouseHandled will prevent parents from also handling it (lowest wins)\n    //\n    // REMOVE: why would we get the event if it wasn't for us or child ?\n    // let className = this.option.handle.substring(1);\n    // let el = e.target as HTMLElement;\n    // while (el && !el.classList.contains(className)) { el = el.parentElement; }\n    // if (!el) return;\n    this.mouseDownEvent = e;\n    delete this.dragging;\n    delete DDManager.dragElement;\n    delete DDManager.dropElement;\n    // document handler so we can continue receiving moves as the item is 'fixed' position, and capture=true so WE get a first crack\n    document.addEventListener('mousemove', this._mouseMove, true); // true=capture, not bubble\n    document.addEventListener('mouseup', this._mouseUp, true);\n    if (isTouch) {\n      this.dragEl.addEventListener('touchmove', touchmove);\n      this.dragEl.addEventListener('touchend', touchend);\n    }\n\n    e.preventDefault();\n    DDManager.mouseHandled = true;\n    return true;\n  }\n\n  /** @internal called when the main page (after successful mousedown) receives a move event to drag the item around the screen */\n  protected _mouseMove(e: DragEvent): boolean {\n    // console.log(`${count++} move ${e.x},${e.y}`)\n    let s = this.mouseDownEvent;\n\n    if (this.dragging) {\n      this._dragFollow(e);\n      const ev = Utils.initEvent<DragEvent>(e, { target: this.el, type: 'drag' });\n      if (this.option.drag) {\n        this.option.drag(ev, this.ui());\n      }\n      this.triggerEvent('drag', ev);\n    } else if (Math.abs(e.x - s.x) + Math.abs(e.y - s.y) > 3) {\n      /**\n       * don't start unless we've moved at least 3 pixels\n       */\n      this.dragging = true;\n      DDManager.dragElement = this;\n      // if we're dragging an actual grid item, set the current drop as the grid (to detect enter/leave)\n      let grid = (this.el as GridItemHTMLElement).gridstackNode?.grid;\n      if (grid) {\n        DDManager.dropElement = (grid.el as DDElementHost).ddElement.ddDroppable;\n      } else {\n        delete DDManager.dropElement;\n      }\n      this.helper = this._createHelper(e);\n      this._setupHelperContainmentStyle();\n      this.dragOffset = this._getDragOffset(e, this.el, this.helperContainment);\n      const ev = Utils.initEvent<DragEvent>(e, { target: this.el, type: 'dragstart' });\n\n      this._setupHelperStyle(e);\n      if (this.option.start) {\n        this.option.start(ev, this.ui());\n      }\n      this.triggerEvent('dragstart', ev);\n    }\n    e.preventDefault(); // needed otherwise we get text sweep text selection as we drag around\n    return true;\n  }\n\n  /** @internal call when the mouse gets released to drop the item at current location */\n  protected _mouseUp(e: MouseEvent): void {\n    document.removeEventListener('mousemove', this._mouseMove, true);\n    document.removeEventListener('mouseup', this._mouseUp, true);\n    if (isTouch) {\n      this.dragEl.removeEventListener('touchmove', touchmove, true);\n      this.dragEl.removeEventListener('touchend', touchend, true);\n    }\n    if (this.dragging) {\n      delete this.dragging;\n\n      // reset the drop target if dragging over ourself (already parented, just moving during stop callback below)\n      if (DDManager.dropElement?.el === this.el.parentElement) {\n        delete DDManager.dropElement;\n      }\n\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 = Utils.initEvent<DragEvent>(e, { target: this.el, type: 'dragstop' });\n      if (this.option.stop) {\n        this.option.stop(ev); // NOTE: destroy() will be called when removing item, so expect NULL ptr after!\n      }\n      this.triggerEvent('dragstop', ev);\n\n      // call the droppable method to receive the item\n      if (DDManager.dropElement) {\n        DDManager.dropElement.drop(e);\n      }\n    }\n    delete this.helper;\n    delete this.mouseDownEvent;\n    delete DDManager.dragElement;\n    delete DDManager.dropElement;\n    delete DDManager.mouseHandled;\n    e.preventDefault();\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 = Utils.cloneNode(this.el);\n    }\n    if (!document.body.contains(helper)) {\n      Utils.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 set the fix position of the dragged item */\n  protected _setupHelperStyle(e: DragEvent): DDDraggable {\n    this.helper.classList.add('ui-draggable-dragging');\n    // TODO: set all at once with style.cssText += ... ? https://stackoverflow.com/questions/3968593\n    const style = this.helper.style;\n    style.pointerEvents = 'none'; // needed for over items to get enter/leave\n    // style.cursor = 'move'; //  TODO: can't set with pointerEvents=none ! (done in CSS as well)\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    this._dragFollow(e); // now position it\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 restore back the original style before dragging */\n  protected _removeHelperStyle(): DDDraggable {\n    this.helper.classList.remove('ui-draggable-dragging');\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 updates the top/left position to follow the mouse */\n  protected _dragFollow(e: DragEvent): void {\n    let containmentRect = { left: 0, top: 0 };\n    // if (this.helper.style.position === 'absolute') { // we use 'fixed'\n    //   const { left, top } = this.helperContainment.getBoundingClientRect();\n    //   containmentRect = { left, top };\n    // }\n    const style = this.helper.style;\n    const offset = this.dragOffset;\n    style.left = e.clientX + offset.offsetLeft - containmentRect.left + 'px';\n    style.top = e.clientY + offset.offsetTop - containmentRect.top + 'px';\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 */\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      Utils.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 * dd-droppable.ts 6.0.3\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 { Utils } from './utils';\nimport { DDElementHost } from './dd-element';\nimport { isTouch, pointerenter, pointerleave } from './dd-touch';\nimport { GridHTMLElement } from './gridstack';\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// let count = 0; // TEST\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  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._mouseEnter = this._mouseEnter.bind(this);\n    this._mouseLeave = this._mouseLeave.bind(this);\n    this.enable();\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 === false) return;\n    super.enable();\n    this.el.classList.add('ui-droppable');\n    this.el.classList.remove('ui-droppable-disabled');\n    this.el.addEventListener('mouseenter', this._mouseEnter);\n    this.el.addEventListener('mouseleave', this._mouseLeave);\n    if (isTouch) {\n      this.el.addEventListener('pointerenter', pointerenter);\n      this.el.addEventListener('pointerleave', pointerleave);\n    }\n  }\n\n  public disable(forDestroy = false): void {\n    if (this.disabled === true) return;\n    super.disable();\n    this.el.classList.remove('ui-droppable');\n    if (!forDestroy) this.el.classList.add('ui-droppable-disabled');\n    this.el.removeEventListener('mouseenter', this._mouseEnter);\n    this.el.removeEventListener('mouseleave', this._mouseLeave);\n    if (isTouch) {\n      this.el.removeEventListener('pointerenter', pointerenter);\n      this.el.removeEventListener('pointerleave', pointerleave);\n    }\n  }\n\n  public destroy(): void {\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 _mouseEnter(e: MouseEvent): void {\n    // console.log(`${count++} Enter ${this.el.id || (this.el as GridHTMLElement).gridstack.opts.id}`); // TEST\n    if (!DDManager.dragElement) return;\n    if (!this._canDrop()) return;\n    e.preventDefault();\n    e.stopPropagation();\n\n    // make sure when we enter this, that the last one gets a leave FIRST to correctly cleanup as we don't always do\n    if (DDManager.dropElement && DDManager.dropElement !== this) {\n      DDManager.dropElement._mouseLeave(e as DragEvent);\n    }\n    DDManager.dropElement = this;\n\n    const ev = Utils.initEvent<DragEvent>(e, { 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.classList.add('ui-droppable-over');\n    // console.log('tracking'); // TEST\n  }\n\n  /** @internal called when the item is leaving our area, stop tracking if we had moving item */\n  protected _mouseLeave(e: MouseEvent): void {\n    // console.log(`${count++} Leave ${this.el.id || (this.el as GridHTMLElement).gridstack.opts.id}`); // TEST\n    if (!DDManager.dragElement || DDManager.dropElement !== this) return;\n    e.preventDefault();\n    e.stopPropagation();\n\n    const ev = Utils.initEvent<DragEvent>(e, { 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    if (DDManager.dropElement === this) {\n      delete DDManager.dropElement;\n      // console.log('not tracking'); // TEST\n\n      // if we're still over a parent droppable, send it an enter as we don't get one from leaving nested children\n      let parentDrop: DDDroppable;\n      let parent: DDElementHost = this.el.parentElement;\n      while (!parentDrop && parent) {\n        parentDrop = parent.ddElement?.ddDroppable;\n        parent = parent.parentElement;\n      }\n      if (parentDrop) {\n        parentDrop._mouseEnter(e);\n      }\n    }\n  }\n\n  /** item is being dropped on us - called by the drag mouseup handler - this calls the client drop event */\n  public drop(e: MouseEvent): void {\n    e.preventDefault();\n    const ev = Utils.initEvent<DragEvent>(e, { 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  }\n\n  /** @internal true if element matches the string/method accept option */\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) return this;\n    if (typeof this.option.accept === 'string') {\n      this.accept = (el: HTMLElement) => el.matches(this.option.accept as string);\n    } else {\n      this.accept = this.option.accept;\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 6.0.3\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","/**\r\n * dd-gridstack.ts 6.0.3\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 { GridItemHTMLElement, GridStackNode, GridStackElement, DDUIData, DDDragInOpt, GridStackPosition } from './types';\r\nimport { GridStack } from './gridstack';\r\nimport { Utils } from './utils';\r\nimport { DDManager } from './dd-manager';\r\nimport { DDElement, DDElementHost } from './dd-element';\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// let count = 0; // TEST\r\n\r\n/**\r\n * HTML Native Mouse and Touch Events Drag and Drop functionality.\r\n */\r\nexport class DDGridStack {\r\n\r\n  /** get the global (but static to this code) DD implementation */\r\n  static get(): DDGridStack {\r\n    return dd;\r\n  }\r\n\r\n  public resizable(el: GridItemHTMLElement, opts: DDOpts, key?: DDKey, value?: DDValue): DDGridStack {\r\n    this._getDDElements(el).forEach(dEl => {\r\n      if (opts === 'disable' || opts === 'enable') {\r\n        dEl.ddResizable && dEl.ddResizable[opts](); // can't create DD as it requires options for setupResizable()\r\n      } else if (opts === 'destroy') {\r\n        dEl.ddResizable && dEl.cleanResizable();\r\n      } else if (opts === 'option') {\r\n        dEl.setupResizable({ [key]: value });\r\n      } else {\r\n        const grid = dEl.el.gridstackNode.grid;\r\n        let handles = dEl.el.getAttribute('gs-resize-handles') ? dEl.el.getAttribute('gs-resize-handles') : grid.opts.resizable.handles;\r\n        let autoHide = !grid.opts.alwaysShowResizeHandle;\r\n        dEl.setupResizable({\r\n          ...grid.opts.resizable,\r\n          ...{ handles, autoHide },\r\n          ...{\r\n            start: opts.start,\r\n            stop: opts.stop,\r\n            resize: opts.resize\r\n          }\r\n        });\r\n      }\r\n    });\r\n    return this;\r\n  }\r\n\r\n  public draggable(el: GridItemHTMLElement, opts: DDOpts, key?: DDKey, value?: DDValue): DDGridStack {\r\n    this._getDDElements(el).forEach(dEl => {\r\n      if (opts === 'disable' || opts === 'enable') {\r\n        dEl.ddDraggable && dEl.ddDraggable[opts](); // can't create DD as it requires options for setupDraggable()\r\n      } else if (opts === 'destroy') {\r\n        dEl.ddDraggable && dEl.cleanDraggable();\r\n      } else if (opts === 'option') {\r\n        dEl.setupDraggable({ [key]: value });\r\n      } else {\r\n        const grid = dEl.el.gridstackNode.grid;\r\n        dEl.setupDraggable({\r\n          ...grid.opts.draggable,\r\n          ...{\r\n            // containment: (grid._isNested && !grid.opts.dragOut) ? grid.el.parentElement : (grid.opts.draggable.containment || null),\r\n            start: opts.start,\r\n            stop: opts.stop,\r\n            drag: opts.drag\r\n          }\r\n        });\r\n      }\r\n    });\r\n    return this;\r\n  }\r\n\r\n  public dragIn(el: GridStackElement, opts: DDDragInOpt): DDGridStack {\r\n    this._getDDElements(el).forEach(dEl => dEl.setupDraggable(opts));\r\n    return this;\r\n  }\r\n\r\n  public droppable(el: GridItemHTMLElement, opts: DDOpts | DDDropOpt, key?: DDKey, value?: DDValue): DDGridStack {\r\n    if (typeof opts.accept === 'function' && !opts._accept) {\r\n      opts._accept = opts.accept;\r\n      opts.accept = (el) => opts._accept(el);\r\n    }\r\n    this._getDDElements(el).forEach(dEl => {\r\n      if (opts === 'disable' || opts === 'enable') {\r\n        dEl.ddDroppable && dEl.ddDroppable[opts]();\r\n      } else if (opts === 'destroy') {\r\n        if (dEl.ddDroppable) { // error to call destroy if not there\r\n          dEl.cleanDroppable();\r\n        }\r\n      } else if (opts === 'option') {\r\n        dEl.setupDroppable({ [key]: value });\r\n      } else {\r\n        dEl.setupDroppable(opts);\r\n      }\r\n    });\r\n    return this;\r\n  }\r\n\r\n  /** true if element is droppable */\r\n  public isDroppable(el: DDElementHost): boolean {\r\n    return !!(el && el.ddElement && el.ddElement.ddDroppable && !el.ddElement.ddDroppable.disabled);\r\n  }\r\n\r\n  /** true if element is draggable */\r\n  public isDraggable(el: DDElementHost): boolean {\r\n    return !!(el && el.ddElement && el.ddElement.ddDraggable && !el.ddElement.ddDraggable.disabled);\r\n  }\r\n\r\n  /** true if element is draggable */\r\n  public isResizable(el: DDElementHost): boolean {\r\n    return !!(el && el.ddElement && el.ddElement.ddResizable && !el.ddElement.ddResizable.disabled);\r\n  }\r\n\r\n  public on(el: GridItemHTMLElement, name: string, callback: DDCallback): DDGridStack {\r\n    this._getDDElements(el).forEach(dEl =>\r\n      dEl.on(name, (event: Event) => {\r\n        callback(\r\n          event,\r\n          DDManager.dragElement ? DDManager.dragElement.el : event.target as GridItemHTMLElement,\r\n          DDManager.dragElement ? DDManager.dragElement.helper : null)\r\n      })\r\n    );\r\n    return this;\r\n  }\r\n\r\n  public off(el: GridItemHTMLElement, name: string): DDGridStack {\r\n    this._getDDElements(el).forEach(dEl => dEl.off(name));\r\n    return this;\r\n  }\r\n\r\n  /** @internal returns a list of DD elements, creating them on the fly by default */\r\n  protected _getDDElements(els: GridStackElement, create = true): DDElement[] {\r\n    let hosts = Utils.getElements(els) as DDElementHost[];\r\n    if (!hosts.length) return [];\r\n    let list = hosts.map(e => e.ddElement || (create ? DDElement.init(e) : null));\r\n    if (!create) { list.filter(d => d); } // remove nulls\r\n    return list;\r\n  }\r\n}\r\n\r\n/** global instance */\r\nconst dd = new DDGridStack;\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 31k (41k -> 72k)\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    dd.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          dd.off(el, 'drag'); // stop calling us\r\n          return; // full grid or can't grow\r\n        }\r\n        if (node._willFitPos) {\r\n          // use the auto position instead #1687\r\n          Utils.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  dd.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    // console.log(`over ${this.el.gridstack.opts.id} ${count++}`); // TEST\r\n      let node = el.gridstackNode;\r\n      // ignore drop enter on ourself (unless we temporarily removed) which happens on a simple drag of our item\r\n      if (node?.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      // console.log('dropover without leave'); // TEST\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      // console.log('dropover cloning node'); // TEST\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      dd.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    // console.log(`out ${this.el.gridstack.opts.id} ${count++}`); // TEST\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      // console.log('drop delete _gridstackNodeOrig') // TEST\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      dd.off(el, 'drag');\r\n      // if we made a copy ('helper' which is temp) of the original node then insert a copy, else we move the original node (#1102)\r\n      // as the helper will be nuked by jquery-ui otherwise\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        this._removeDD(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 // TODO: now would be ideal time to _removeHelperStyle() overriding floating styles (native only)\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 (!dd.isDroppable(trashEl)) {\r\n      dd.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    handle: '.grid-stack-item-content',\r\n    appendTo: 'body',\r\n    // revert: 'invalid',\r\n    // scroll: false,\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  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  const noMove = node.noMove || this.opts.disableDrag;\r\n  const noResize = node.noResize || this.opts.disableResize;\r\n\r\n  // check for disabled grid first\r\n  if (this.opts.staticGrid || (noMove && noResize)) {\r\n    if (node._initDD) {\r\n      this._removeDD(el); // nukes everything instead of just disable, will add some styles back next\r\n      delete node._initDD;\r\n    }\r\n    el.classList.add('ui-draggable-disabled', 'ui-resizable-disabled'); // add styles one might depend on #1435\r\n    return this;\r\n  }\r\n\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        this._removeDD(el);\r\n        gridToNotify.engine.removedNodes.push(node);\r\n        gridToNotify._triggerRemoveEvent();\r\n        // break circular links and remove DOM\r\n        delete el.gridstackNode;\r\n        delete node.el;\r\n        el.remove();\r\n      } else {\r\n        Utils.removePositioningStyles(target);\r\n        if (node._temporaryRemoved) {\r\n          // got removed - restore item back to before dragging position\r\n          Utils.copyPos(node, node._orig);// @ts-ignore\r\n          this._writePosAttr(target, node);\r\n          this.engine.addNode(node);\r\n        } else {\r\n          // move to new placeholder location\r\n          this._writePosAttr(target, node);\r\n        }\r\n        if (this._gsEventHandler[event.type]) {\r\n          this._gsEventHandler[event.type](event, target);\r\n        }\r\n      }\r\n      // @ts-ignore\r\n      this._extraDragRow = 0;// @ts-ignore\r\n      this._updateContainerHeight();// @ts-ignore\r\n      this._triggerChangeEvent();\r\n\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  dd.draggable(el, noMove ? 'disable' : 'enable')\r\n    .resizable(el, noResize ? 'disable' : 'enable');\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  // console.log('_onStartMoving placeholder') // TEST\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    // console.log('engine.addNode x=' + node.x); // TEST\r\n    this.engine.addNode(node); // will add, fix collisions, update attr and clear _temporaryRemoved\r\n    node._moving = true; // AFTER, mark as moving object (wanted fix location before)\r\n  }\r\n\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    dd.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  dd.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    // console.log('leave delete _gridstackNodeOrig') // TEST\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  * 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/** removes any drag&drop present (called during destroy) */\r\nGridStack.prototype._removeDD = function(this: GridStack, el: GridItemHTMLElement): GridStack {\r\n  dd.draggable(el, 'destroy').resizable(el, 'destroy');\r\n  if (el.gridstackNode) {\r\n    delete el.gridstackNode._initDD; // reset our DD init flag\r\n  }\r\n  return this;\r\n}\r\n\r\n","/**\n * dd-manager.ts 6.0.3\n * Copyright (c) 2021 Alain Dumesny - see GridStack root license\n */\n\nimport { DDDraggable } from './dd-draggable';\nimport { DDDroppable } from './dd-droppable';\nimport { DDResizable } from './dd-resizable';\n\n/**\n * globals that are shared across Drag & Drop instances\n */\nexport class DDManager {\n  /** true if a mouse down event was handled */\n  public static mouseHandled: boolean;\n\n  /** item being dragged */\n  public static dragElement: DDDraggable;\n\n  /** item we are currently over as drop target */\n  public static dropElement: DDDroppable;\n\n  /** current item we're over for resizing purpose (ignore nested grid resize handles) */\n  public static overResizeElement: DDResizable;\n\n}\n","/**\n * dd-resizable-handle.ts 6.0.3\n * Copyright (c) 2021-2022 Alain Dumesny - see GridStack root license\n */\n\nimport { isTouch, pointerdown, touchend, touchmove, touchstart } from './dd-touch';\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    if (isTouch) {\n      this.el.addEventListener('touchstart', touchstart);\n      this.el.addEventListener('pointerdown', pointerdown);\n      // this.el.style.touchAction = 'none'; // not needed unlike pointerdown doc comment\n    }\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    if (isTouch) {\n      this.el.removeEventListener('touchstart', touchstart);\n      this.el.removeEventListener('pointerdown', pointerdown);\n    }\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) {\n    this.mouseDownEvent = e;\n    document.addEventListener('mousemove', this._mouseMove, true); // capture, not bubble\n    document.addEventListener('mouseup', this._mouseUp, true);\n    if (isTouch) {\n      this.el.addEventListener('touchmove', touchmove);\n      this.el.addEventListener('touchend', touchend);\n    }\n    e.stopPropagation();\n    e.preventDefault();\n  }\n\n  /** @internal */\n  protected _mouseMove(e: MouseEvent) {\n    let s = this.mouseDownEvent;\n    if (this.moving) {\n      this._triggerEvent('move', e);\n    } else if (Math.abs(e.x - s.x) + Math.abs(e.y - s.y) > 2) {\n      // don't start unless we've moved at least 3 pixels\n      this.moving = true;\n      this._triggerEvent('start', this.mouseDownEvent);\n      this._triggerEvent('move', e);\n    }\n    e.stopPropagation();\n    e.preventDefault();\n  }\n\n  /** @internal */\n  protected _mouseUp(e: MouseEvent) {\n    if (this.moving) {\n      this._triggerEvent('stop', e);\n    }\n    document.removeEventListener('mousemove', this._mouseMove, true);\n    document.removeEventListener('mouseup', this._mouseUp, true);\n    if (isTouch) {\n      this.el.removeEventListener('touchmove', touchmove);\n      this.el.removeEventListener('touchend', touchend);\n    }\n    delete this.moving;\n    delete this.mouseDownEvent;\n    e.stopPropagation();\n    e.preventDefault();\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 6.0.3\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 { Utils } from './utils';\nimport { DDUIData, Rect, Size } from './types';\nimport { DDManager } from './dd-manager';\n\n// import { GridItemHTMLElement } from './types'; let count = 0; // TEST\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    // create var event binding so we can easily remove and still look like TS methods (unlike anonymous functions)\n    this._mouseOver = this._mouseOver.bind(this);\n    this._mouseOut = this._mouseOut.bind(this);\n    this.enable();\n    this._setupAutoHide(this.option.autoHide);\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    this._setupAutoHide(this.option.autoHide);\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    this._setupAutoHide(false);\n  }\n\n  public destroy(): void {\n    this._removeHandlers();\n    this._setupAutoHide(false);\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(this.option.autoHide);\n    }\n    return this;\n  }\n\n  /** @internal turns auto hide on/off */\n  protected _setupAutoHide(auto: boolean): DDResizable {\n    if (auto) {\n      this.el.classList.add('ui-resizable-autohide');\n      // use mouseover and not mouseenter to get better performance and track for nested cases\n      this.el.addEventListener('mouseover', this._mouseOver);\n      this.el.addEventListener('mouseout', this._mouseOut);\n    } else {\n      this.el.classList.remove('ui-resizable-autohide');\n      this.el.removeEventListener('mouseover', this._mouseOver);\n      this.el.removeEventListener('mouseout', this._mouseOut);\n      if (DDManager.overResizeElement === this) {\n        delete DDManager.overResizeElement;\n      }\n    }\n    return this;\n  }\n\n  /** @internal */\n  protected _mouseOver(e: Event) {\n    // console.log(`${count++} pre-enter ${(this.el as GridItemHTMLElement).gridstackNode._id}`)\n    // already over a child, ignore. Ideally we just call e.stopPropagation() but see https://github.com/gridstack/gridstack.js/issues/2018\n    if (DDManager.overResizeElement || DDManager.dragElement) return;\n    DDManager.overResizeElement = this;\n    // console.log(`${count++} enter ${(this.el as GridItemHTMLElement).gridstackNode._id}`)\n    this.el.classList.remove('ui-resizable-autohide');\n  }\n\n  /** @internal */\n  protected _mouseOut(e: Event) {\n    // console.log(`${count++} pre-leave ${(this.el as GridItemHTMLElement).gridstackNode._id}`)\n    if (DDManager.overResizeElement !== this) return;\n    delete DDManager.overResizeElement;\n    // console.log(`${count++} leave ${(this.el as GridItemHTMLElement).gridstackNode._id}`)\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 = Utils.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 = Utils.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 = Utils.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 * touch.ts 6.0.3\n * Copyright (c) 2021 Alain Dumesny - see GridStack root license\n */\n\nimport { DDManager } from './dd-manager';\n\n/**\n * Detect touch support - Windows Surface devices and other touch devices\n * should we use this instead ? (what we had for always showing resize handles)\n * /Android|webOS|iPhone|iPad|iPod|BlackBerry|IEMobile|Opera Mini/i.test(navigator.userAgent)\n */\nexport const isTouch: boolean = ( 'ontouchstart' in document\n  || 'ontouchstart' in window\n  // || !!window.TouchEvent // true on Windows 10 Chrome desktop so don't use this\n  || ((window as any).DocumentTouch && document instanceof (window as any).DocumentTouch)\n  || navigator.maxTouchPoints > 0\n  || (navigator as any).msMaxTouchPoints > 0\n);\n\n// interface TouchCoord {x: number, y: number};\n\nclass DDTouch {\n  public static touchHandled: boolean;\n  public static pointerLeaveTimeout: number;\n}\n\n/**\n* Get the x,y position of a touch event\n*/\n// function getTouchCoords(e: TouchEvent): TouchCoord {\n//   return {\n//     x: e.changedTouches[0].pageX,\n//     y: e.changedTouches[0].pageY\n//   };\n// }\n\n/**\n * Simulate a mouse event based on a corresponding touch event\n * @param {Object} e A touch event\n * @param {String} simulatedType The corresponding mouse event\n */\nfunction simulateMouseEvent(e: TouchEvent, simulatedType: string) {\n\n  // Ignore multi-touch events\n  if (e.touches.length > 1) return;\n\n  // Prevent \"Ignored attempt to cancel a touchmove event with cancelable=false\" errors\n  if (e.cancelable) e.preventDefault();\n\n  const touch = e.changedTouches[0], simulatedEvent = document.createEvent('MouseEvents');\n\n  // Initialize the simulated mouse event using the touch event's coordinates\n  simulatedEvent.initMouseEvent(\n    simulatedType,    // type\n    true,             // bubbles\n    true,             // cancelable\n    window,           // view\n    1,                // detail\n    touch.screenX,    // screenX\n    touch.screenY,    // screenY\n    touch.clientX,    // clientX\n    touch.clientY,    // clientY\n    false,            // ctrlKey\n    false,            // altKey\n    false,            // shiftKey\n    false,            // metaKey\n    0,                // button\n    null              // relatedTarget\n  );\n\n  // Dispatch the simulated event to the target element\n  e.target.dispatchEvent(simulatedEvent);\n}\n\n/**\n * Simulate a mouse event based on a corresponding Pointer event\n * @param {Object} e A pointer event\n * @param {String} simulatedType The corresponding mouse event\n */\nfunction simulatePointerMouseEvent(e: PointerEvent, simulatedType: string) {\n\n  // Prevent \"Ignored attempt to cancel a touchmove event with cancelable=false\" errors\n  if (e.cancelable) e.preventDefault();\n\n  const simulatedEvent = document.createEvent('MouseEvents');\n\n  // Initialize the simulated mouse event using the touch event's coordinates\n  simulatedEvent.initMouseEvent(\n    simulatedType,    // type\n    true,             // bubbles\n    true,             // cancelable\n    window,           // view\n    1,                // detail\n    e.screenX,    // screenX\n    e.screenY,    // screenY\n    e.clientX,    // clientX\n    e.clientY,    // clientY\n    false,            // ctrlKey\n    false,            // altKey\n    false,            // shiftKey\n    false,            // metaKey\n    0,                // button\n    null              // relatedTarget\n  );\n\n  // Dispatch the simulated event to the target element\n  e.target.dispatchEvent(simulatedEvent);\n}\n\n\n/**\n * Handle the touchstart events\n * @param {Object} e The widget element's touchstart event\n */\nexport function touchstart(e: TouchEvent) {\n  // Ignore the event if another widget is already being handled\n  if (DDTouch.touchHandled) return;  DDTouch.touchHandled = true;\n\n  // Simulate the mouse events\n  // simulateMouseEvent(e, 'mouseover');\n  // simulateMouseEvent(e, 'mousemove');\n  simulateMouseEvent(e, 'mousedown');\n}\n\n/**\n * Handle the touchmove events\n * @param {Object} e The document's touchmove event\n */\nexport function touchmove(e: TouchEvent) {\n  // Ignore event if not handled by us\n  if (!DDTouch.touchHandled)  return;\n\n  simulateMouseEvent(e, 'mousemove');\n}\n\n/**\n * Handle the touchend events\n * @param {Object} e The document's touchend event\n */\nexport function touchend(e: TouchEvent) {\n\n  // Ignore event if not handled\n  if (!DDTouch.touchHandled) return;\n\n  // cancel delayed leave event when we release on ourself which happens BEFORE we get this!\n  if (DDTouch.pointerLeaveTimeout) {\n    window.clearTimeout(DDTouch.pointerLeaveTimeout);\n    delete DDTouch.pointerLeaveTimeout;\n  }\n\n  const wasDragging = !!DDManager.dragElement;\n\n  // Simulate the mouseup event\n  simulateMouseEvent(e, 'mouseup');\n  // simulateMouseEvent(event, 'mouseout');\n\n  // If the touch interaction did not move, it should trigger a click\n  if (!wasDragging) {\n    simulateMouseEvent(e, 'click');\n  }\n\n  // Unset the flag to allow other widgets to inherit the touch event\n  DDTouch.touchHandled = false;\n}\n\n/**\n * Note we don't get touchenter/touchleave (which are deprecated)\n * see https://stackoverflow.com/questions/27908339/js-touch-equivalent-for-mouseenter\n * so instead of PointerEvent to still get enter/leave and send the matching mouse event.\n */\nexport function pointerdown(e: PointerEvent) {\n  (e.target as HTMLElement).releasePointerCapture(e.pointerId) // <- Important!\n}\n\nexport function pointerenter(e: PointerEvent) {\n  // ignore the initial one we get on pointerdown on ourself\n  if (!DDManager.dragElement) {\n    // console.log('pointerenter ignored');\n    return;\n  }\n  // console.log('pointerenter');\n  simulatePointerMouseEvent(e, 'mouseenter');\n}\n\nexport function pointerleave(e: PointerEvent) {\n  // ignore the leave on ourself we get before releasing the mouse over ourself\n  // by delaying sending the event and having the up event cancel us\n  if (!DDManager.dragElement) {\n    // console.log('pointerleave ignored');\n    return;\n  }\n  DDTouch.pointerLeaveTimeout = window.setTimeout(() => {\n    delete DDTouch.pointerLeaveTimeout;\n    // console.log('pointerleave delayed');\n    simulatePointerMouseEvent(e, 'mouseleave');\n  }, 10);\n}\n\n","/**\n * gridstack-engine.ts 6.0.3\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(flag = true): GridStackEngine {\n    if (!!this.batchMode === flag) return this;\n    this.batchMode = flag;\n    if (flag) {\n      this._prevFloat = this._float;\n      this._float = true; // let things go anywhere for now... will restore and possibly reposition later\n      this.saveInitial(); // since begin update (which is called multiple times) won't do this\n    } else {\n      this._float = this._prevFloat;\n      delete this._prevFloat;\n      this._packNodes()._notify();\n    }\n    return this;\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    o.collide = collide; // save it so we don't have to find it again\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.batchUpdate(false);\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    // check if we're covering 50% collision and could move\n    let canMove = clone.moveNode(clonedNode, o) && clone.getRow() <= this.maxRow;\n    // else check if we can force a swap (float=true, or different shapes) on non-resize\n    if (!canMove && !o.resizing && o.collide) {\n      let collide = o.collide.el.gridstackNode; // find the source node the clone collided with at 50%\n      if (this.swap(node, collide)) { // swaps and mark dirty\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.batchUpdate(false);\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 * GridStack 6.0.3\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, obsolete } from './utils';\r\nimport { GridDefaults, ColumnOptions, GridItemHTMLElement, GridStackElement, GridStackEventHandlerCallback,\r\n  GridStackNode, GridStackOptions, GridStackWidget, numberOrString, DDUIData, DDDragInOpt, GridStackPosition } from './types';\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\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/**\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) {\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 point to a parent grid item if we're nested */\r\n  protected _isNested?: GridStackNode;\r\n  /** @internal unique class name for our generated CSS style sheet */\r\n  protected _styleSheetClass?: string;\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    // save original setting so we can restore on save\r\n    if (opts.alwaysShowResizeHandle !== undefined) {\r\n      (opts as any)._alwaysShowResizeHandle = opts.alwaysShowResizeHandle;\r\n    }\r\n\r\n    // elements DOM 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')) || GridDefaults.column,\r\n      minRow: rowAttr ? rowAttr : Utils.toNumber(el.getAttribute('gs-min-row')) || GridDefaults.minRow,\r\n      maxRow: rowAttr ? rowAttr : Utils.toNumber(el.getAttribute('gs-max-row')) || GridDefaults.maxRow,\r\n      staticGrid: Utils.toBool(el.getAttribute('gs-static')) || GridDefaults.staticGrid,\r\n      draggable: {\r\n        handle: (opts.handleClass ? '.' + opts.handleClass : (opts.handle ? opts.handle : '')) || GridDefaults.draggable.handle,\r\n      },\r\n      removableOptions: {\r\n        accept: opts.itemClass ? '.' + opts.itemClass : GridDefaults.removableOptions.accept,\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    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._isNested = parentGridItemEl.gridstackNode;\r\n      this._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    // see if we need to adjust auto-hide\r\n    if (this.opts.alwaysShowResizeHandle === 'mobile') {\r\n      this.opts.alwaysShowResizeHandle = isTouch;\r\n    }\r\n\r\n    this._styleSheetClass = 'grid-stack-instance-' + (Math.random() * 10000).toFixed(0)\r\n    this.el.classList.add(this._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.batchUpdate(false);\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      const origShow = (o as any)._alwaysShowResizeHandle;\r\n      delete (o as any)._alwaysShowResizeHandle;\r\n      if (origShow !== undefined) {\r\n        o.alwaysShowResizeHandle = origShow;\r\n      } else {\r\n        delete o.alwaysShowResizeHandle;\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.batchUpdate(false);\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   * use before calling a bunch of `addWidget()` to prevent un-necessary relayouts in between (more efficient)\r\n   * and get a single event callback. You will see no changes until `batchUpdate(false)` is called.\r\n   */\r\n  public batchUpdate(flag = true): GridStack {\r\n    this.engine.batchUpdate(flag);\r\n    if (!flag) {\r\n      this._triggerRemoveEvent();\r\n      this._triggerAddEvent();\r\n      this._triggerChangeEvent();\r\n    }\r\n    return this;\r\n  }\r\n\r\n  /**\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  /** 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._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._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    if (this.opts.float !== val) {\r\n      this.opts.float = this.engine.float = val;\r\n      this._triggerChangeEvent();\r\n    }\r\n    return this;\r\n  }\r\n\r\n  /**\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      this._removeDD(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      this._removeDD(n.el);\r\n    });\r\n    this.engine.removeAll(removeDOM);\r\n    this._triggerRemoveEvent();\r\n    return this;\r\n  }\r\n\r\n  /**\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._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._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._isNested) {\r\n      if (this.opts.column !== this._isNested.w) {\r\n        changedColumn = true;\r\n        this.column(this._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._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  static GDRev = '6.0.3';\r\n\r\n  /*\r\n   * drag&drop empty stubs that will be implemented in dd-gridstack.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: {handle: '.grid-stack-item-content', appendTo: 'body'}\r\n   **/\r\n  public static setupDragIn(dragIn?: string, dragInOptions?: DDDragInOpt): void { /* implemented in dd-gridstack.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 removes any drag&drop present (called during destroy) */\r\n  public _removeDD(el: GridItemHTMLElement): GridStack { return this }\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  // legacy method removed\r\n  public commit(): GridStack { obsolete(this, this.batchUpdate(false), 'commit', 'batchUpdate', '5.2'); return this; }\r\n}\r\n\r\n/*\r\n * and include D&D by default, which override some methods here\r\n * TODO: while we can generate a gridstack-static.js at smaller size - saves about 31k (41k -> 72k)\r\n * I don't know how to generate the DD only code at the remaining 31k to delay load as code depends on Gridstack.ts\r\n */\r\nimport { DDGridStack } from './dd-gridstack';\r\nimport { isTouch } from './dd-touch';\r\nexport * from './dd-gridstack';\r\n","/**\r\n * types.ts 6.0.3\r\n * Copyright (c) 2021 Alain Dumesny - see GridStack root license\r\n */\r\n\r\nimport { GridStack } from './gridstack';\r\nimport { GridStackEngine } from './gridstack-engine';\r\n\r\n// default values for grid options - used during init and when saving out\r\nexport const GridDefaults: GridStackOptions = {\r\n  alwaysShowResizeHandle: 'mobile',\r\n  animate: true,\r\n  auto: true,\r\n  cellHeight: 'auto',\r\n  cellHeightThrottle: 100,\r\n  cellHeightUnit: 'px',\r\n  column: 12,\r\n  draggable: { handle: '.grid-stack-item-content', appendTo: 'body' },\r\n  handle: '.grid-stack-item-content',\r\n  itemClass: 'grid-stack-item',\r\n  margin: 10,\r\n  marginUnit: 'px',\r\n  maxRow: 0,\r\n  minRow: 0,\r\n  oneColumnSize: 768,\r\n  placeholderClass: 'grid-stack-placeholder',\r\n  placeholderText: '',\r\n  removableOptions: { accept: '.grid-stack-item' },\r\n  resizable: { handles: 'se' },\r\n  rtl: 'auto',\r\n\r\n  // **** same as not being set ****\r\n  // disableDrag: false,\r\n  // disableOneColumnMode: false,\r\n  // disableResize: false,\r\n  // float: false,\r\n  // handleClass: null,\r\n  // oneColumnModeDomSort: false,\r\n  // removable: false,\r\n  // staticGrid: false,\r\n  // styleInHead: false,\r\n};\r\n\r\n/** different layout options when changing # of columns,\r\n * including a custom function that takes new/old column count, and array of new/old positions\r\n * Note: new list may be partially already filled if we have a cache of the layout at that size and new items were added later.\r\n */\r\nexport type ColumnOptions = 'moveScale' | 'move' | 'scale' | 'none' |\r\n  ((column: number, oldColumn: number, nodes: GridStackNode[], oldNodes: GridStackNode[]) => void);\r\n\r\nexport type numberOrString = number | string;\r\nexport interface GridItemHTMLElement extends HTMLElement {\r\n  /** pointer to grid node instance */\r\n  gridstackNode?: GridStackNode;\r\n  /** @internal */\r\n  _gridstackNodeOrig?: GridStackNode;\r\n}\r\n\r\nexport type GridStackElement = string | HTMLElement | GridItemHTMLElement;\r\n\r\nexport type GridStackEventHandlerCallback = (event: Event, arg2?: GridItemHTMLElement | GridStackNode | GridStackNode[], newNode?: GridStackNode) => void;\r\n\r\n/**\r\n * Defines the options for a Grid\r\n */\r\nexport interface GridStackOptions {\r\n  /**\r\n   * accept widgets dragged from other grids or from outside (default: `false`). Can be:\r\n   * `true` (uses `'.grid-stack-item'` class filter) or `false`,\r\n   * string for explicit class name,\r\n   * function returning a boolean. See [example](http://gridstack.github.io/gridstack.js/demo/two.html)\r\n   */\r\n  acceptWidgets?: boolean | string | ((element: Element) => boolean);\r\n\r\n  /** possible values (default: `mobile`) - does not apply to non-resizable widgets\r\n    * `false` the resizing handles are only shown while hovering over a widget\r\n    * `true` the resizing handles are always shown\r\n    * 'mobile' if running on a mobile device, default to `true` (since there is no hovering per say), else `false`.\r\n    * this uses this condition on browser agent check:\r\n    `alwaysShowResizeHandle: /Android|webOS|iPhone|iPad|iPod|BlackBerry|IEMobile|Opera Mini/i.test( navigator.userAgent )`\r\n    See [example](http://gridstack.github.io/gridstack.js/demo/mobile.html) */\r\n  alwaysShowResizeHandle?: true | false | 'mobile';\r\n\r\n  /** turns animation on (default?: true) */\r\n  animate?: boolean;\r\n\r\n  /** if false gridstack will not initialize existing items (default?: true) */\r\n  auto?: boolean;\r\n\r\n  /**\r\n   * one cell height (default?: 'auto'). Can be:\r\n   *  an integer (px)\r\n   *  a string (ex: '100px', '10em', '10rem'). Note: % doesn't right - see demo/cell-height.html\r\n   *  0, in which case the library will not generate styles for rows. Everything must be defined in your own CSS files.\r\n   *  'auto' - height will be calculated for square cells (width / column) and updated live as you resize the window - also see `cellHeightThrottle`\r\n   *  'initial' - similar to 'auto' (start at square cells) but stay that size during window resizing.\r\n   */\r\n  cellHeight?: numberOrString;\r\n\r\n  /** throttle time delay (in ms) used when cellHeight='auto' to improve performance vs usability (default?: 100).\r\n   * A value of 0 will make it instant at a cost of re-creating the CSS file at ever window resize event!\r\n   * */\r\n  cellHeightThrottle?: number;\r\n\r\n  /** (internal) unit for cellHeight (default? 'px') which is set when a string cellHeight with a unit is passed (ex: '10rem') */\r\n  cellHeightUnit?: string;\r\n\r\n  /** list of children item to create when calling load() or addGrid() */\r\n  children?: GridStackWidget[];\r\n\r\n  /** number of columns (default?: 12). Note: IF you change this, CSS also have to change. See https://github.com/gridstack/gridstack.js#change-grid-columns.\r\n   * Note: for nested grids, it is recommended to use 'auto' which will always match the container grid-item current width (in column) to keep inside and outside\r\n   * items always to same. flag is not supported for regular non-nested grids.\r\n   */\r\n  column?: number | 'auto';\r\n\r\n  /** additional class on top of '.grid-stack' (which is required for our CSS) to differentiate this instance.\r\n  Note: only used by addGrid(), else your element should have the needed class */\r\n  class?: string;\r\n\r\n  /** disallows dragging of widgets (default?: false) */\r\n  disableDrag?: boolean;\r\n\r\n  /** disables the onColumnMode when the grid width is less than oneColumnSize (default?: false) */\r\n  disableOneColumnMode?: boolean;\r\n\r\n  /** disallows resizing of widgets (default?: false). */\r\n  disableResize?: boolean;\r\n\r\n  /** allows to override UI draggable options. (default?: { handle?: '.grid-stack-item-content', appendTo?: 'body' }) */\r\n  draggable?: DDDragOpt;\r\n\r\n  /** allows to drag external items using this selector - see dragInOptions. (default: undefined) */\r\n  dragIn?: string;\r\n\r\n  /** allows to drag external items using these options. See `GridStack.setupDragIn()` instead (not per grid really).\r\n   * (default?: { handle: '.grid-stack-item-content', appendTo: 'body' })\r\n   * helper can be 'clone' or your own function (set what the drag/dropped item will be instead)\r\n   */\r\n  dragInOptions?: DDDragInOpt;\r\n\r\n  /** let user drag nested grid items out of a parent or not (default true - not supported yet) */\r\n  //dragOut?: boolean;\r\n\r\n  /** the type of engine to create (so you can subclass) default to GridStackEngine */\r\n  engineClass?: typeof GridStackEngine;\r\n\r\n  /** enable floating widgets (default?: false) See example (http://gridstack.github.io/gridstack.js/demo/float.html) */\r\n  float?: boolean;\r\n\r\n  /** draggable handle selector (default?: '.grid-stack-item-content') */\r\n  handle?: string;\r\n\r\n  /** draggable handle class (e.g. 'grid-stack-item-content'). If set 'handle' is ignored (default?: null) */\r\n  handleClass?: string;\r\n\r\n  /** id used to debug grid instance, not currently stored in DOM attributes */\r\n  id?: numberOrString;\r\n\r\n  /** additional widget class (default?: 'grid-stack-item') */\r\n  itemClass?: string;\r\n\r\n  /**\r\n   * gap between grid item and content (default?: 10). This will set all 4 sides and support the CSS formats below\r\n   *  an integer (px)\r\n   *  a string with possible units (ex: '2em', '20px', '2rem')\r\n   *  string with space separated values (ex: '5px 10px 0 20px' for all 4 sides, or '5em 10em' for top/bottom and left/right pairs like CSS).\r\n   * Note: all sides must have same units (last one wins, default px)\r\n   */\r\n  margin?: numberOrString;\r\n\r\n  /** OLD way to optionally set each side - use margin: '5px 10px 0 20px' instead. Used internally to store each side. */\r\n  marginTop?: numberOrString;\r\n  marginRight?: numberOrString;\r\n  marginBottom?: numberOrString;\r\n  marginLeft?: numberOrString;\r\n\r\n  /** (internal) unit for margin (default? 'px') set when `margin` is set as string with unit (ex: 2rem') */\r\n  marginUnit?: string;\r\n\r\n  /** maximum rows amount. Default? is 0 which means no maximum rows */\r\n  maxRow?: number;\r\n\r\n  /** minimum rows amount. Default is `0`. You can also do this with `min-height` CSS attribute\r\n   * on the grid div in pixels, which will round to the closest row.\r\n   */\r\n  minRow?: number;\r\n\r\n  /** minimal width before grid will be shown in one column mode (default?: 768) */\r\n  oneColumnSize?: number;\r\n\r\n  /**\r\n   * set to true if you want oneColumnMode to use the DOM order and ignore x,y from normal multi column\r\n   * layouts during sorting. This enables you to have custom 1 column layout that differ from the rest. (default?: false)\r\n   */\r\n  oneColumnModeDomSort?: boolean;\r\n\r\n  /** class for placeholder (default?: 'grid-stack-placeholder') */\r\n  placeholderClass?: string;\r\n\r\n  /** placeholder default content (default?: '') */\r\n  placeholderText?: string;\r\n\r\n  /** allows to override UI resizable options. (default?: { handles: 'se' }) */\r\n  resizable?: DDResizeOpt;\r\n\r\n  /**\r\n   * if true widgets could be removed by dragging outside of the grid. It could also be a selector string (ex: \".trash\"),\r\n   * in this case widgets will be removed by dropping them there (default?: false)\r\n   * See example (http://gridstack.github.io/gridstack.js/demo/two.html)\r\n   */\r\n  removable?: boolean | string;\r\n\r\n  /** allows to override UI removable options. (default?: { accept: '.grid-stack-item' }) */\r\n  removableOptions?: DDRemoveOpt;\r\n\r\n  /** fix grid number of rows. This is a shortcut of writing `minRow:N, maxRow:N`. (default `0` no constrain) */\r\n  row?: number;\r\n\r\n  /**\r\n   * if true turns grid to RTL. Possible values are true, false, 'auto' (default?: 'auto')\r\n   * See [example](http://gridstack.github.io/gridstack.js/demo/rtl.html)\r\n   */\r\n  rtl?: boolean | 'auto';\r\n\r\n  /**\r\n   * makes grid static (default?: false). If `true` widgets are not movable/resizable.\r\n   * You don't even need draggable/resizable. A CSS class\r\n   * 'grid-stack-static' is also added to the element.\r\n   */\r\n  staticGrid?: boolean;\r\n\r\n  /** if `true` will add style element to `<head>` otherwise will add it to element's parent node (default `false`). */\r\n  styleInHead?: boolean;\r\n}\r\n\r\n/** options used during GridStackEngine.moveNode() */\r\nexport interface GridStackMoveOpts extends GridStackPosition {\r\n  /** node to skip collision */\r\n  skip?: GridStackNode;\r\n  /** do we pack (default true) */\r\n  pack?: boolean;\r\n  /** true if we are calling this recursively to prevent simple swap or coverage collision - default false*/\r\n  nested?: boolean;\r\n  /** vars to calculate other cells coordinates */\r\n  cellWidth?: number;\r\n  cellHeight?: number;\r\n  marginTop?: number;\r\n  marginBottom?: number;\r\n  marginLeft?: number;\r\n  marginRight?: number;\r\n  /** position in pixels of the currently dragged items (for overlap check) */\r\n  rect?: GridStackPosition;\r\n  /** true if we're live resizing */\r\n  resizing?: boolean;\r\n  /** best node (most coverage) we collied with */\r\n  collide?: GridStackNode;\r\n}\r\n\r\nexport interface GridStackPosition {\r\n  /** widget position x (default?: 0) */\r\n  x?: number;\r\n  /** widget position y (default?: 0) */\r\n  y?: number;\r\n  /** widget dimension width (default?: 1) */\r\n  w?: number;\r\n  /** widget dimension height (default?: 1) */\r\n  h?: number;\r\n}\r\n\r\n/**\r\n * GridStack Widget creation options\r\n */\r\nexport interface GridStackWidget extends GridStackPosition {\r\n  /** if true then x, y parameters will be ignored and widget will be places on the first available position (default?: false) */\r\n  autoPosition?: boolean;\r\n  /** minimum width allowed during resize/creation (default?: undefined = un-constrained) */\r\n  minW?: number;\r\n  /** maximum width allowed during resize/creation (default?: undefined = un-constrained) */\r\n  maxW?: number;\r\n  /** minimum height allowed during resize/creation (default?: undefined = un-constrained) */\r\n  minH?: number;\r\n  /** maximum height allowed during resize/creation (default?: undefined = un-constrained) */\r\n  maxH?: number;\r\n  /** prevent resizing (default?: undefined = un-constrained) */\r\n  noResize?: boolean;\r\n  /** prevents moving (default?: undefined = un-constrained) */\r\n  noMove?: boolean;\r\n  /** prevents being moved by others during their (default?: undefined = un-constrained) */\r\n  locked?: boolean;\r\n  /** widgets can have their own custom resize handles. For example 'e,w' will make that particular widget only resize east and west. See `resizable: {handles: string}` option */\r\n  resizeHandles?: string;\r\n  /** value for `gs-id` stored on the widget (default?: undefined) */\r\n  id?: numberOrString;\r\n  /** html to append inside as content */\r\n  content?: string;\r\n  /** optional nested grid options and list of children, which then turns into actual instance at runtime */\r\n  subGrid?: GridStackOptions | GridStack;\r\n}\r\n\r\n/** Drag&Drop resize options */\r\nexport interface DDResizeOpt {\r\n  /** do resize handle hide by default until mouse over ? - default: true on desktop, false on mobile*/\r\n  autoHide?: boolean;\r\n  /**\r\n   * sides where you can resize from (ex: 'e, se, s, sw, w') - default 'se' (south-east)\r\n   * Note: it is not recommended to resize from the top sides as weird side effect may occur.\r\n  */\r\n  handles?: string;\r\n}\r\n\r\n/** Drag&Drop remove options */\r\nexport interface DDRemoveOpt {\r\n  /** class that can be removed (default?: '.' + opts.itemClass) */\r\n  accept?: string;\r\n}\r\n\r\n/** Drag&Drop dragging options */\r\nexport interface DDDragOpt {\r\n  /** class selector of items that can be dragged. default to '.grid-stack-item-content' */\r\n  handle?: string;\r\n  /** default to 'body' */\r\n  appendTo?: string;\r\n  /** default to `true` */\r\n  // scroll?: boolean;\r\n  /** parent constraining where item can be dragged out from (default: null = no constrain) */\r\n  // containment?: string;\r\n}\r\nexport interface DDDragInOpt extends DDDragOpt {\r\n    /** used when dragging item from the outside, and canceling (ex: 'invalid' or your own method)*/\r\n    // revert?: string | ((event: Event) => HTMLElement);\r\n    /** helper function when dropping (ex: 'clone' or your own method) */\r\n    helper?: string | ((event: Event) => HTMLElement);\r\n}\r\n\r\nexport interface Size {\r\n  width: number;\r\n  height: number;\r\n}\r\nexport interface Position {\r\n  top: number;\r\n  left: number;\r\n}\r\nexport interface Rect extends Size, Position {}\r\n\r\n/** data that is passed during drag and resizing callbacks */\r\nexport interface DDUIData {\r\n  position?: Position;\r\n  size?: Size;\r\n  /* fields not used by GridStack but sent by jq ? leave in case we go back to them...\r\n  originalPosition? : Position;\r\n  offset?: Position;\r\n  originalSize?: Size;\r\n  element?: HTMLElement[];\r\n  helper?: HTMLElement[];\r\n  originalElement?: HTMLElement[];\r\n  */\r\n}\r\n\r\n/**\r\n * internal descriptions describing the items in the grid\r\n */\r\nexport interface GridStackNode extends GridStackWidget {\r\n  /** pointer back to HTML element */\r\n  el?: GridItemHTMLElement;\r\n  /** pointer back to Grid instance */\r\n  grid?: GridStack;\r\n  /** @internal internal id used to match when cloning engines or saving column layouts */\r\n  _id?: number;\r\n  /** @internal */\r\n  _dirty?: boolean;\r\n  /** @internal */\r\n  _updating?: boolean;\r\n  /** @internal true when over trash/another grid so we don't bother removing drag CSS style that would animate back to old position */\r\n  _isAboutToRemove?: boolean;\r\n  /** @internal true if item came from outside of the grid -> actual item need to be moved over */\r\n  _isExternal?: boolean;\r\n  /** @internal moving vs resizing */\r\n  _moving?: boolean;\r\n  /** @internal true if we jumped down past item below (one time jump so we don't have to totally pass it) */\r\n  _skipDown?: boolean;\r\n  /** @internal original values before a drag/size */\r\n  _orig?: GridStackPosition;\r\n  /** @internal position in pixels used during collision check  */\r\n  _rect?: GridStackPosition;\r\n  /** @internal top/left pixel location before a drag so we can detect direction of move from last position*/\r\n  _lastUiPosition?: Position;\r\n  /** @internal set on the item being dragged/resized remember the last positions we've tried (but failed) so we don't try again during drag/resize */\r\n  _lastTried?: GridStackPosition;\r\n  /** @internal position willItFit() will use to position the item */\r\n  _willFitPos?: GridStackPosition;\r\n  /** @internal last drag Y pixel position used to incrementally update V scroll bar */\r\n  _prevYPix?: number;\r\n  /** @internal true if we've remove the item from ourself (dragging out) but might revert it back (release on nothing -> goes back) */\r\n  _temporaryRemoved?: boolean;\r\n  /** @internal true if we should remove DOM element on _notify() rather than clearing _id (old way) */\r\n  _removeDOM?: boolean;\r\n  /** @internal */\r\n  _initDD?: boolean;\r\n}\r\n","/**\r\n * utils.ts 6.0.3\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 **removed** in a future release');\r\n    return f.apply(self, args);\r\n  }\r\n  wrapper.prototype = f.prototype;\r\n  return wrapper;\r\n}\r\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 **removed** in a future release');\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 **removed** in a future release');\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    // list of fields we will skip during cloneDeep (nested objects, other internal)\r\n    const skipFields = ['_isNested', 'el', 'grid', 'subGrid', 'engine'];\r\n    // return JSON.parse(JSON.stringify(obj)); // doesn't work with date format ?\r\n    const ret = Utils.clone(obj);\r\n    for (const key in ret) {\r\n      // NOTE: we don't support function/circular dependencies so skip those properties for now...\r\n      if (ret.hasOwnProperty(key) && typeof(ret[key]) === 'object' && key.substring(0, 2) !== '__' && !skipFields.find(k => k === key)) {\r\n        ret[key] = Utils.cloneDeep(obj[key]);\r\n      }\r\n    }\r\n    return ret;\r\n  }\r\n\r\n  /** deep clone the given HTML node, removing teh unique id field */\r\n  public static cloneNode(el: HTMLElement): HTMLElement {\r\n    const node = el.cloneNode(true) as HTMLElement;\r\n    node.removeAttribute('id');\r\n    return node;\r\n  }\r\n\r\n  public static appendTo(el: HTMLElement, parent: string | HTMLElement | Node): void {\r\n    let parentNode: HTMLElement;\r\n    if (typeof parent === 'string') {\r\n      parentNode = document.querySelector(parent as string);\r\n    } else {\r\n      parentNode = parent as HTMLElement;\r\n    }\r\n    if (parentNode) {\r\n      parentNode.appendChild(el);\r\n    }\r\n  }\r\n\r\n  // public static setPositionRelative(el: HTMLElement): void {\r\n  //   if (!(/^(?:r|a|f)/).test(window.getComputedStyle(el).position)) {\r\n  //     el.style.position = \"relative\";\r\n  //   }\r\n  // }\r\n\r\n  public static addElStyles(el: HTMLElement, styles: { [prop: string]: string | string[] }): void {\r\n    if (styles instanceof Object) {\r\n      for (const s in styles) {\r\n        if (styles.hasOwnProperty(s)) {\r\n          if (Array.isArray(styles[s])) {\r\n            // support fallback value\r\n            (styles[s] as string[]).forEach(val => {\r\n              el.style[s] = val;\r\n            });\r\n          } else {\r\n            el.style[s] = styles[s];\r\n          }\r\n        }\r\n      }\r\n    }\r\n  }\r\n\r\n  public static initEvent<T>(e: DragEvent | MouseEvent, info: { type: string; target?: EventTarget }): T {\r\n    const evt = { type: info.type };\r\n    const obj = {\r\n      button: 0,\r\n      which: 0,\r\n      buttons: 1,\r\n      bubbles: true,\r\n      cancelable: true,\r\n      target: info.target ? info.target : e.target\r\n    };\r\n    // don't check for `instanceof DragEvent` as Safari use MouseEvent #1540\r\n    if ((e as DragEvent).dataTransfer) {\r\n      evt['dataTransfer'] = (e as DragEvent).dataTransfer; // workaround 'readonly' field.\r\n    }\r\n    ['altKey','ctrlKey','metaKey','shiftKey'].forEach(p => evt[p] = e[p]); // keys\r\n    ['pageX','pageY','clientX','clientY','screenX','screenY'].forEach(p => evt[p] = e[p]); // point info\r\n    return {...evt, ...obj} as unknown as T;\r\n  }\r\n\r\n  /** returns true if event is inside the given element rectangle */\r\n  // Note: Safari Mac has null event.relatedTarget which causes #1684 so check if DragEvent is inside the coordinates instead\r\n  //    this.el.contains(event.relatedTarget as HTMLElement)\r\n  // public static inside(e: MouseEvent, el: HTMLElement): boolean {\r\n  //   // srcElement, toElement, target: all set to placeholder when leaving simple grid, so we can't use that (Chrome)\r\n  //   let target: HTMLElement = e.relatedTarget || (e as any).fromElement;\r\n  //   if (!target) {\r\n  //     const { bottom, left, right, top } = el.getBoundingClientRect();\r\n  //     return (e.x < right && e.x > left && e.y < bottom && e.y > top);\r\n  //   }\r\n  //   return el.contains(target);\r\n  // }\r\n}\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__(270);\n"],"sourceRoot":""}