{"version":3,"file":"gridstack-all.js","mappings":"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","sources":["webpack://GridStack/webpack/universalModuleDefinition","webpack://GridStack/webpack/bootstrap","webpack://GridStack/webpack/runtime/define property getters","webpack://GridStack/webpack/runtime/hasOwnProperty shorthand","webpack://GridStack/./src/utils.ts","webpack://GridStack/./src/gridstack-engine.ts","webpack://GridStack/./src/types.ts","webpack://GridStack/./src/dd-manager.ts","webpack://GridStack/./src/dd-touch.ts","webpack://GridStack/./src/dd-resizable-handle.ts","webpack://GridStack/./src/dd-base-impl.ts","webpack://GridStack/./src/dd-resizable.ts","webpack://GridStack/./src/dd-draggable.ts","webpack://GridStack/./src/dd-droppable.ts","webpack://GridStack/./src/dd-element.ts","webpack://GridStack/./src/gridstack.ts","webpack://GridStack/./src/dd-gridstack.ts"],"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, () => {\nreturn ","// The require scope\nvar __webpack_require__ = {};\n\n","// define getter functions for harmony exports\n__webpack_require__.d = (exports, definition) => {\n\tfor(var key in definition) {\n\t\tif(__webpack_require__.o(definition, key) && !__webpack_require__.o(exports, key)) {\n\t\t\tObject.defineProperty(exports, key, { enumerable: true, get: definition[key] });\n\t\t}\n\t}\n};","__webpack_require__.o = (obj, prop) => (Object.prototype.hasOwnProperty.call(obj, prop))","/**\r\n * utils.ts 10.1.2\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\nexport interface DragTransform {\r\n  xScale: number;\r\n  yScale: number;\r\n  xOffset: number;\r\n  yOffset: number;\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. optional root which defaults to document (for shadow dom) */\r\n  static getElements(els: GridStackElement, root: HTMLElement | Document = document): HTMLElement[] {\r\n    if (typeof els === 'string') {\r\n      const doc = ('getElementById' in root) ? root as Document : undefined;\r\n\r\n      // Note: very common for people use to id='1,2,3' which is only legal as HTML5 id, but not CSS selectors\r\n      // so if we start with a number, assume it's an id and just return that one item...\r\n      // see https://github.com/gridstack/gridstack.js/issues/2234#issuecomment-1523796562\r\n      if (doc && !isNaN(+els[0])) { // start with digit\r\n        const el = doc.getElementById(els);\r\n        return el ? [el] : [];\r\n      }\r\n\r\n      let list = root.querySelectorAll(els);\r\n      if (!list.length && els[0] !== '.' && els[0] !== '#') {\r\n        list = root.querySelectorAll('.' + els);\r\n        if (!list.length) { list = root.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. optional root which defaults to document (for shadow dom) */\r\n  static getElement(els: GridStackElement, root: HTMLElement | Document = document): HTMLElement {\r\n    if (typeof els === 'string') {\r\n      const doc = ('getElementById' in root) ? root as Document : undefined;\r\n      if (!els.length) return null;\r\n      if (doc && els[0] === '#') {\r\n        return doc.getElementById(els.substring(1));\r\n      }\r\n      if (els[0] === '#' || els[0] === '.' || els[0] === '[') {\r\n        return root.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 (doc && !isNaN(+els[0])) { // start with digit\r\n        return doc.getElementById(els);\r\n      }\r\n\r\n      // finally try string, then id, then class\r\n      let el = root.querySelector(els);\r\n      if (doc && !el) { el = doc.getElementById(els) }\r\n      if (!el) { el = root.querySelector('.' + els) }\r\n      return el as HTMLElement;\r\n    }\r\n    return els;\r\n  }\r\n\r\n  /** true if we should resize to content. strict=true when only 'sizeToContent:true' and not a number which lets user adjust */\r\n  static shouldSizeToContent(n: GridStackNode | undefined, strict = false): boolean {\r\n    return n?.grid && (strict ? \r\n    (n.sizeToContent === true || (n.grid.opts.sizeToContent === true && n.sizeToContent === undefined)) :\r\n    (!!n.sizeToContent || (n.grid.opts.sizeToContent && n.sizeToContent !== false)));\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  /** returns the area a and b overlap */\r\n  static areaIntercept(a: GridStackPosition, b: GridStackPosition): number {\r\n    let x0 = (a.x > b.x) ? a.x : b.x;\r\n    let x1 = (a.x+a.w < b.x+b.w) ? a.x+a.w : b.x+b.w;\r\n    if (x1 <= x0) return 0; // no overlap\r\n    let y0 = (a.y > b.y) ? a.y : b.y;\r\n    let y1 = (a.y+a.h < b.y+b.h) ? a.y+a.h : b.y+b.h;\r\n    if (y1 <= y0) return 0; // no overlap\r\n    return (x1-x0) * (y1-y0);\r\n  }\r\n\r\n  /** returns the area */\r\n  static area(a: GridStackPosition): number {\r\n    return a.w * a.h;\r\n  }\r\n\r\n  /**\r\n   * Sorts array of nodes\r\n   * @param nodes array to sort\r\n   * @param dir 1 for ascending, -1 for descending (optional)\r\n   **/\r\n  static sort(nodes: GridStackNode[], dir: 1 | -1 = 1): GridStackNode[] {\r\n    const und = 10000;\r\n    return nodes.sort((a, b) => {\r\n      let diffY = dir * ((a.y ?? und) - (b.y ?? und));\r\n      if (diffY === 0) return dir * ((a.x ?? und) - (b.x ?? und));\r\n      return diffY;\r\n    });\r\n  }\r\n\r\n  /** find an item by id */\r\n  static find(nodes: GridStackNode[], id: string): GridStackNode | undefined {\r\n    return id ? nodes.find(n => n.id === id) : undefined;\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, options?: { nonce?: string }): CSSStyleSheet {\r\n    let style: HTMLStyleElement = document.createElement('style');\r\n    const nonce = options?.nonce\r\n    if (nonce) style.nonce = nonce\r\n    style.setAttribute('type', 'text/css');\r\n    style.setAttribute('gs-style-id', id);\r\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\r\n    if ((style 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, parent?: HTMLElement): void {\r\n    const target = parent || document;\r\n    let el = target.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      if (val === 'auto' || val === '') h = 0;\r\n      else {\r\n        let match = val.match(/^(-[0-9]+\\.[0-9]+|[0-9]*\\.[0-9]+|-[0-9]+|[0-9]+)(px|em|rem|vh|vw|%|cm|mm)?$/);\r\n        if (!match) {\r\n          throw new Error(`Invalid height val = ${val}`);\r\n        }\r\n        unit = match[2] || 'px';\r\n        h = parseFloat(match[1]);\r\n      }\r\n    } else {\r\n      h = val;\r\n    }\r\n    return { h, unit };\r\n  }\r\n\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 optionally min/max as well */\r\n  static copyPos(a: GridStackWidget, b: GridStackWidget, doMinMax = false): GridStackWidget {\r\n    if (b.x !== undefined) a.x = b.x;\r\n    if (b.y !== undefined) a.y = b.y;\r\n    if (b.w !== undefined) a.w = b.w;\r\n    if (b.h !== undefined) 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 || 1) === (b.w || 1) && (a.h || 1) === (b.h || 1);\r\n  }\r\n\r\n  /** given a node, makes sure it's min/max are valid */\r\n  static sanitizeMinMax(node: GridStackNode) {\r\n    // remove 0, undefine, null\r\n    if (!node.minW) { delete node.minW; }\r\n    if (!node.minH) { delete node.minH; }\r\n    if (!node.maxW) { delete node.maxW; }\r\n    if (!node.maxH) { delete node.maxH; }\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  /** removes internal fields '_' and default values for saving */\r\n  static removeInternalForSave(n: GridStackNode, removeEl = true): void {\r\n    for (let key in n) { if (key[0] === '_' || n[key] === null || n[key] === undefined ) delete n[key]; }\r\n    delete n.grid;\r\n    if (removeEl) delete n.el;\r\n    // delete default values (will be re-created on read)\r\n    if (!n.autoPosition) delete n.autoPosition;\r\n    if (!n.noResize) delete n.noResize;\r\n    if (!n.noMove) delete n.noMove;\r\n    if (!n.locked) delete n.locked;\r\n    if (n.w === 1 || n.w === n.minW) delete n.w;\r\n    if (n.h === 1 || n.h === n.minH) delete n.h;\r\n  }\r\n\r\n  /** return the closest parent (or itself) matching the given class */\r\n  // static closestUpByClass(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 = ['parentGrid', 'el', 'grid', 'subGrid', 'engine'];\r\n    // return JSON.parse(JSON.stringify(obj)); // doesn't work with date format ?\r\n    const ret = Utils.clone(obj);\r\n    for (const key in ret) {\r\n      // NOTE: we don't support function/circular dependencies so skip those properties for now...\r\n      if (ret.hasOwnProperty(key) && typeof(ret[key]) === 'object' && key.substring(0, 2) !== '__' && !skipFields.find(k => k === key)) {\r\n        ret[key] = Utils.cloneDeep(obj[key]);\r\n      }\r\n    }\r\n    return ret;\r\n  }\r\n\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): void {\r\n    let parentNode: HTMLElement;\r\n    if (typeof parent === 'string') {\r\n      parentNode = Utils.getElement(parent);\r\n    } else {\r\n      parentNode = parent;\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(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  /** copies the MouseEvent properties and sends it as another event to the given target */\r\n  public static simulateMouseEvent(e: MouseEvent, simulatedType: string, target?: EventTarget): void {\r\n    const simulatedEvent = document.createEvent('MouseEvents');\r\n    simulatedEvent.initMouseEvent(\r\n      simulatedType, // type\r\n      true,         // bubbles\r\n      true,         // cancelable\r\n      window,       // view\r\n      1,            // detail\r\n      e.screenX,    // screenX\r\n      e.screenY,    // screenY\r\n      e.clientX,    // clientX\r\n      e.clientY,    // clientY\r\n      e.ctrlKey,    // ctrlKey\r\n      e.altKey,     // altKey\r\n      e.shiftKey,   // shiftKey\r\n      e.metaKey,    // metaKey\r\n      0,            // button\r\n      e.target      // relatedTarget\r\n    );\r\n    (target || e.target).dispatchEvent(simulatedEvent);\r\n  }\r\n\r\n  /**\r\n   * defines an element that is used to get the offset and scale from grid transforms\r\n   * returns the scale and offsets from said element\r\n  */\r\n  public static getValuesFromTransformedElement(parent: HTMLElement): DragTransform {\r\n    const transformReference = document.createElement('div');\r\n    Utils.addElStyles(transformReference, {\r\n      opacity: '0',\r\n      position: 'fixed',\r\n      top: 0 + 'px',\r\n      left: 0 + 'px',\r\n      width: '1px',\r\n      height: '1px',\r\n      zIndex: '-999999',\r\n    });\r\n    parent.appendChild(transformReference);\r\n    const transformValues = transformReference.getBoundingClientRect();\r\n    parent.removeChild(transformReference);\r\n    transformReference.remove();\r\n    return {\r\n      xScale: 1 / transformValues.width,\r\n      yScale: 1 / transformValues.height,\r\n      xOffset: transformValues.left,\r\n      yOffset: transformValues.top,\r\n    }\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","/**\n * gridstack-engine.ts 10.1.2\n * Copyright (c) 2021-2022 Alain Dumesny - see GridStack root license\n */\n\nimport { Utils } from './utils';\nimport { GridStackNode, ColumnOptions, GridStackPosition, GridStackMoveOpts, SaveFcn, CompactOptions } 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 back (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 */\n  public static _idSeq = 0;\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, doPack = 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.cleanNodes();\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      if (doPack) this._packNodes();\n      this._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.batchMode && !this._prevFloat) && !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 | undefined {\n    const skipId = skip._id;\n    const skip2Id = skip2?._id;\n    return this.nodes.find(n => n._id !== skipId && n._id !== skip2Id && Utils.isIntercepted(n, area));\n  }\n  public collideAll(skip: GridStackNode, area = skip, skip2?: GridStackNode): GridStackNode[] {\n    const skipId = skip._id;\n    const skip2Id = skip2?._id;\n    return this.nodes.filter(n => n._id !== skipId && n._id !== skip2Id && Utils.isIntercepted(n, area));\n  }\n\n  /** does a pixel coverage collision based on where we started, returning the node that has the most coverage that is >50% mid line */\n  protected directionCollideCoverage(node: GridStackNode, o: GridStackMoveOpts, collides: GridStackNode[]): GridStackNode | undefined {\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    let overMax = 0.5; // need >50%\n    for (let n of collides) {\n      if (n.locked || !n._rect) {\n        break;\n      }\n      let r2 = n._rect; // overlapping target\n      let yOver = Number.MAX_VALUE, xOver = Number.MAX_VALUE;\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  /** does a pixel coverage returning the node that has the most coverage by area */\n  /*\n  protected collideCoverage(r: GridStackPosition, collides: GridStackNode[]): {collide: GridStackNode, over: number} {\n    let collide: GridStackNode;\n    let overMax = 0;\n    collides.forEach(n => {\n      if (n.locked || !n._rect) return;\n      let over = Utils.areaIntercept(r, n._rect);\n      if (over > overMax) {\n        overMax = over;\n        collide = n;\n      }\n    });\n    return {collide, over: overMax};\n  }\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 | undefined {\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 - optionally keeping the sort order exactly the same ('list' mode) vs truly finding an empty spaces */\n  public compact(layout: CompactOptions = 'compact', doSort = true): GridStackEngine {\n    if (this.nodes.length === 0) return this;\n    if (doSort) this.sortNodes();\n    const wasBatch = this.batchMode;\n    if (!wasBatch) this.batchUpdate();\n    const wasColumnResize = this._inColumnResize;\n    if (!wasColumnResize) this._inColumnResize = true; // faster addNode()\n    let copyNodes = this.nodes;\n    this.nodes = []; // pretend we have no nodes to conflict layout to start with...\n    copyNodes.forEach((n, index, list) => {\n      let after: GridStackNode;\n      if (!n.locked) {\n        n.autoPosition = true;\n        if (layout === 'list' && index) after = list[index - 1];\n      }\n      this.addNode(n, false, after); // 'false' for add event trigger\n    });\n    if (!wasColumnResize) delete this._inColumnResize;\n    if (!wasBatch) this.batchUpdate(false);\n    return this;\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 = 1): GridStackEngine {\n    this.nodes = Utils.sort(this.nodes, dir);\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._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    Utils.sanitizeMinMax(node);\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    this.nodeBoundFix(node, resizing);\n    return node;\n  }\n\n  /** part2 of preparing a node to fit inside our grid - checks for x,y,w from grid dimensions */\n  public nodeBoundFix(node: GridStackNode, resizing?: boolean): GridStackEngine {\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 user loaded a larger than allowed widget for current # of columns,\n    // remember it's position & width so we can restore back (1 -> 12 column) #1655 #1985\n    // IFF we're not in the middle of column resizing!\n    const saveOrig = (node.x || 0) + (node.w || 1) > this.column;\n    if (saveOrig && this.column < 12 && !this._inColumnResize && node._id && this.findCacheLayout(node, 12) === -1) {\n      let copy = {...node}; // need _id + positions\n      if (copy.autoPosition || copy.x === undefined) { delete copy.x; delete copy.y; }\n      else copy.x = Math.min(11, copy.x);\n      copy.w = Math.min(12, copy.w || 1);\n      this.cacheOneLayout(copy, 12);\n    }\n\n    if (node.w > this.column) {\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 this;\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  /** find the first available empty spot for the given node width/height, updating the x,y attributes. return true if found.\n   * optionally you can pass your own existing node list and column count, otherwise defaults to that engine data.\n   * Optionally pass a widget to start search AFTER, meaning the order will remain the same but possibly have empty slots we skipped\n   */\n  public findEmptyPosition(node: GridStackNode, nodeList = this.nodes, column = this.column, after?: GridStackNode): boolean {\n    let start = after ? after.y * column + (after.x + after.w) : 0;\n    let found = false;\n    for (let i = start; !found; ++i) {\n      let x = i % column;\n      let y = Math.floor(i / column);\n      if (x + node.w > column) {\n        continue;\n      }\n      let box = {x, y, w: node.w, h: node.h};\n      if (!nodeList.find(n => Utils.isIntercepted(box, n))) {\n        if (node.x !== x || node.y !== y) node._dirty = true;\n        node.x = x;\n        node.y = y;\n        delete node.autoPosition;\n        found = true;\n      }\n    }\n    return found;\n  }\n\n  /** call to add the given node to our list, fixing collision and re-packing */\n  public addNode(node: GridStackNode, triggerAddEvent = false, after?: GridStackNode): 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    this._inColumnResize ? this.nodeBoundFix(node) : this.prepareNode(node);\n    delete node._temporaryRemoved;\n    delete node._removeDOM;\n\n    let skipCollision: boolean;\n    if (node.autoPosition && this.findEmptyPosition(node, this.nodes, this.column, after)) {\n      delete node.autoPosition; // found our slot\n      skipCollision = true;\n    }\n\n    this.nodes.push(node);\n    if (triggerAddEvent) { this.addedNodes.push(node); }\n\n    if (!skipCollision) 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._id === node._id)) {\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._id !== node._id);\n    if (!node._isAboutToRemove) this._packNodes(); // if dragged out, no need to relayout as already done...\n    this._notify([node]);\n    return this;\n  }\n\n  public removeAll(removeDOM = true, triggerEvent = true): GridStackEngine {\n    delete this._layouts;\n    if (!this.nodes.length) 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    const removedNodes = this.nodes;\n    this.removedNodes = triggerEvent ? removedNodes : [];\n    this.nodes = [];\n    return this._notify(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._id === node._id) {\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, while still being under maxRow or at least not making it worse\n    // (case where widget was somehow added past our max #2449)\n    let canMove = clone.moveNode(clonedNode, o) && clone.getRow() <= Math.max(this.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    let wasUndefinedPack: boolean;\n    if (o.pack === undefined && !this.batchMode) {\n      wasUndefinedPack = o.pack = true;\n    }\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    this.nodeBoundFix(nn, resizing);\n    Utils.copyPos(o, nn);\n\n    if (!o.forceCollide && 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      let activeDrag = node._moving && !o.nested;\n      // check to make sure we actually collided over 50% surface area while dragging\n      let collide = activeDrag ? this.directionCollideCoverage(node, o, collides) : collides[0];\n      // if we're enabling creation of sub-grids on the fly, see if we're covering 80% of either one, if we didn't already do that\n      if (activeDrag && collide && node.grid?.opts?.subGridDynamic && !node.grid._isTemp) {\n        let over = Utils.areaIntercept(o.rect, collide._rect);\n        let a1 = Utils.area(o.rect);\n        let a2 = Utils.area(collide._rect);\n        let perc = over / (a1 < a2 ? a1 : a2);\n        if (perc > .8) {\n          collide.grid.makeSubGrid(collide.el, undefined, node);\n          collide = undefined;\n        }\n      }\n\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        if (wasUndefinedPack) delete o.pack;\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, saveCB?: SaveFcn): 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      // use layout info fields instead if set\n      let w: GridStackNode = {...n, ...(wl || {})};\n      Utils.removeInternalForSave(w, !saveElement);\n      if (saveCB) saveCB(n, w);\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 (n.y >= 0 && 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 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 columnChanged(prevColumn: number, column: number, layout: ColumnOptions = 'moveScale'): GridStackEngine {\n    if (!this.nodes.length || !column || prevColumn === column) return this;\n\n    // in this mode no layout is done whatsoever, up to the caller to handle it\n    if (layout === 'none') return this;\n\n    // simpler shortcuts layouts\n    const doCompact = layout === 'compact' || layout === 'list';\n    if (doCompact) {\n      this.sortNodes(1); // sort with original layout once and only once (new column will affect order otherwise)\n    }\n\n    // cache the current layout in case they want to go back (like 12 -> 1 -> 12) as it requires original data IFF we're sizing down (see below)\n    if (column < prevColumn) 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    let nodes = doCompact ? this.nodes : Utils.sort(this.nodes, -1); // current column reverse sorting so we can insert last to front (limit collision)\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    if (column > prevColumn && this._layouts) {\n      const 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            if (!doCompact && !cacheNode.autoPosition) {\n              n.x = cacheNode.x ?? n.x;\n              n.y = cacheNode.y ?? n.y;\n            }\n            n.w = cacheNode.w ?? n.w;\n            if (cacheNode.x == undefined || cacheNode.y === undefined) n.autoPosition = true;\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          const n = nodes[j];\n          // still current, use cache info positions\n          if (doCompact) {\n            n.w = cacheNode.w; // only w is used, and don't trim the list\n            return;\n          }\n          if (cacheNode.autoPosition || isNaN(cacheNode.x) || isNaN(cacheNode.y)) {\n            this.findEmptyPosition(cacheNode, newNodes);\n          }\n          if (!cacheNode.autoPosition) {\n            n.x = cacheNode.x ?? n.x;\n            n.y = cacheNode.y ?? n.y;\n            n.w = cacheNode.w ?? n.w;\n            newNodes.push(n);\n          }\n          nodes.splice(j, 1);\n        }\n      });\n    }\n\n    // much simpler layout that just compacts\n    if (doCompact) {\n      this.compact(layout, false);\n    } else {\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 {\n          let ratio = doCompact ? 1 : 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 : 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);\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    }\n\n    this.nodes.forEach(n => delete n._orig); // clear _orig before batch=false so it doesn't handle float=true restore\n    this.batchUpdate(false, !doCompact);\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      // make sure we have an id in case this is new layout, else re-use id already set\n      if (n._id === undefined) {\n        const existing = n.id ? this.nodes.find(n2 => n2.id === n.id) : undefined; // find existing node using users id\n        n._id = existing?._id ?? GridStackEngine._idSeq++;\n      }\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 l: GridStackNode = {x: n.x, y: n.y, w: n.w, _id: n._id}\n    if (n.autoPosition || n.x === undefined) { delete l.x; delete l.y; if (n.autoPosition) l.autoPosition = true; }\n    this._layouts = this._layouts || [];\n    this._layouts[column] = this._layouts[column] || [];\n    let index = this.findCacheLayout(n, column);\n    if (index === -1)\n      this._layouts[column].push(l);\n    else\n      this._layouts[column][index] = l;\n    return this;\n  }\n\n  protected findCacheLayout(n: GridStackNode, column: number): number | undefined {\n    return this._layouts?.[column]?.findIndex(l => l._id === n._id) ?? -1;\n  }\n\n  public removeNodeFromLayoutCache(n: GridStackNode) {\n    if (!this._layouts) {\n      return;\n    }\n    for (let i = 0; i < this._layouts.length; i++) {\n      let index = this.findCacheLayout(n, i);\n      if (index !== -1) {\n        this._layouts[i].splice(index, 1);\n      }\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 * types.ts 10.1.2\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', scroll: true },\r\n  handle: '.grid-stack-item-content',\r\n  itemClass: 'grid-stack-item',\r\n  margin: 10,\r\n  marginUnit: 'px',\r\n  maxRow: 0,\r\n  minRow: 0,\r\n  placeholderClass: 'grid-stack-placeholder',\r\n  placeholderText: '',\r\n  removableOptions: { accept: 'grid-stack-item', decline: 'grid-stack-non-removable'},\r\n  resizable: { handles: 'se' },\r\n  rtl: 'auto',\r\n\r\n  // **** same as not being set ****\r\n  // disableDrag: false,\r\n  // disableResize: false,\r\n  // float: false,\r\n  // handleClass: null,\r\n  // removable: false,\r\n  // staticGrid: false,\r\n  // styleInHead: false,\r\n  //removable\r\n};\r\n\r\n/** default dragIn options */\r\nexport 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/**\r\n * different layout options when changing # of columns, 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 * Options are:\r\n * 'list' - treat items as sorted list, keeping items (un-sized unless too big for column count) sequentially reflowing them\r\n * 'compact' - similar to list, but using compact() method which will possibly re-order items if an empty slots are available due to a larger item needing to be pushed to next row\r\n * 'moveScale' - will scale and move items by the ratio new newColumnCount / oldColumnCount\r\n * 'move' | 'scale' - will only size or move items\r\n * 'none' will leave items unchanged, unless they don't fit in column count\r\n */\r\nexport type ColumnOptions = 'list' | 'compact' | 'moveScale' | 'move' | 'scale' | 'none' |\r\n  ((column: number, oldColumn: number, nodes: GridStackNode[], oldNodes: GridStackNode[]) => void);\r\nexport type CompactOptions = 'list' | 'compact';\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\n/** specific and general event handlers for the .on() method */\r\nexport type GridStackEventHandler = (event: Event) => void;\r\nexport type GridStackElementHandler = (event: Event, el: GridItemHTMLElement) => void;\r\nexport type GridStackNodesHandler = (event: Event, nodes: GridStackNode[]) => void;\r\nexport type GridStackDroppedHandler = (event: Event, previousNode: GridStackNode, newNode: GridStackNode) => void;\r\nexport type GridStackEventHandlerCallback = GridStackEventHandler | GridStackElementHandler | GridStackNodesHandler | GridStackDroppedHandler;\r\n\r\n/** optional function called during load() to callback the user on new added/remove grid items | grids */\r\nexport type AddRemoveFcn = (parent: HTMLElement, w: GridStackWidget, add: boolean, grid: boolean) => HTMLElement | undefined;\r\n\r\n/** optional function called during save() to let the caller add additional custom data to the GridStackWidget structure that will get returned */\r\nexport type SaveFcn = (node: GridStackNode, w: GridStackWidget) => void;\r\n\r\nexport type ResizeToContentFcn = (el: GridItemHTMLElement) => void;\r\n\r\n/** describes the responsive nature of the grid */\r\nexport interface Responsive {\r\n  /** wanted width to maintain (+-50%) to dynamically pick a column count */\r\n  columnWidth?: number;\r\n  /** maximum number of columns allowed (default: 12). Note: make sure to have correct extra CSS to support this.*/\r\n  columnMax?: number;\r\n  /** global re-layout mode when changing columns */\r\n  layout?: ColumnOptions;\r\n  /** specify if breakpoints are for window size or grid size (default:false = grid) */\r\n  breakpointForWindow?: boolean;\r\n  /** explicit width:column breakpoints instead of automatic 'columnWidth'. Note: make sure to have correct extra CSS to support this.*/\r\n  breakpoints?: Breakpoint[];\r\n}\r\n\r\nexport interface Breakpoint {\r\n  /** <= width for the breakpoint to trigger */\r\n  w?: number;\r\n  /** column count */\r\n  c: number;\r\n  /** re-layout mode if different from global one */\r\n  layout?: ColumnOptions;\r\n  /** TODO: children layout, which spells out exact locations and could omit/add some children */\r\n  // children?: GridStackWidget[];\r\n}\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    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 work 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  /** responsive column layout for width:column behavior */\r\n  columnOpts?: Responsive;\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  /** 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  /** 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  /** 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  /** If you are using a nonce-based Content Security Policy, pass your nonce here and\r\n   * GridStack will add it to the <style> elements it creates. */\r\n  nonce?: string;\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  /** set to true if all grid items (by default, but item can also override) height should be based on content size instead of WidgetItem.h to avoid v-scrollbars.\r\n   Note: this is still row based, not pixels, so it will use ceil(getBoundingClientRect().height / getCellHeight()) */\r\n   sizeToContent?: boolean;\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  /** list of differences in options for automatically created sub-grids under us (inside our grid-items) */\r\n  subGridOpts?: GridStackOptions;\r\n\r\n  /** enable/disable the creation of sub-grids on the fly by dragging items completely\r\n   * over others (nest) vs partially (push). Forces `DDDragOpt.pause=true` to accomplish that. */\r\n  subGridDynamic?: 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  /** for collision check even if we don't move */\r\n  forceCollide?: boolean;\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 direct resizing by the user (default?: undefined = un-constrained) */\r\n  noResize?: boolean;\r\n  /** prevents direct moving by the user (default?: undefined = un-constrained) */\r\n  noMove?: boolean;\r\n  /** same as noMove+noResize but also prevents being pushed by other widgets or api (default?: undefined = un-constrained) */\r\n  locked?: boolean;\r\n  /** value for `gs-id` stored on the widget (default?: undefined) */\r\n  id?: string;\r\n  /** html to append inside as content */\r\n  content?: string;\r\n  /** local (vs grid) override - see GridStackOptions.\r\n   * Note: This also allow you to set a maximum h value (but user changeable during normal resizing) to prevent unlimited content from taking too much space (get scrollbar) */\r\n  sizeToContent?: boolean | number;\r\n  /** local override of GridStack.resizeToContentParent that specify the class to use for the parent (actual) vs child (wanted) height */\r\n  resizeToContentParent?: string;\r\n  /** optional nested grid options and list of children, which then turns into actual instance at runtime to get options from */\r\n  subGridOpts?: GridStackOptions;\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  /** class that cannot be removed (default: 'grid-stack-non-removable') */\r\n  decline?: 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  /** if set (true | msec), dragging placement (collision) will only happen after a pause by the user. Note: this is Global */\r\n  pause?: boolean | number;\r\n  /** default to `true` */\r\n  scroll?: boolean;\r\n  /** prevents dragging from starting on specified elements, listed as comma separated selectors (eg: '.no-drag'). default built in is 'input,textarea,button,select,option' */\r\n  cancel?: string;\r\n}\r\nexport interface DDDragInOpt extends DDDragOpt {\r\n  /** helper function when dropping: 'clone' or your own method */\r\n  helper?: 'clone' | ((event: Event) => HTMLElement);\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}\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  draggable?: HTMLElement;\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 runtime descriptions describing the widgets 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 parent Grid instance */\r\n  grid?: GridStack;\r\n  /** actual sub-grid instance */\r\n  subGrid?: GridStack;\r\n  /** @internal internal id used to match when cloning engines or saving column layouts */\r\n  _id?: number;\r\n  /** @internal does the node attr ned to be updated due to changed x,y,w,h values */\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 Mouse event that's causing moving|resizing */\r\n  _event?: MouseEvent;\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 had drag&drop been initialized */\r\n  _initDD?: boolean;\r\n}\r\n","/**\n * dd-manager.ts 10.1.2\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  /** if set (true | in msec), dragging placement (collision) will only happen after a pause by the user*/\n  public static pauseDrag: boolean | number;\n\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 * touch.ts 10.1.2\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 = typeof window !== 'undefined' && typeof document !== 'undefined' &&\n( 'ontouchstart' in document\n  || 'ontouchstart' in window\n  // || !!window.TouchEvent // true on Windows 10 Chrome desktop so don't use this\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  || ((window as any).DocumentTouch && document instanceof (window as any).DocumentTouch)\n  || navigator.maxTouchPoints > 0\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\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): void {\n  // Ignore the event if another widget is already being handled\n  if (DDTouch.touchHandled) return;\n  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): void {\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): void {\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): void {\n  // console.log(\"pointer down\")\n  if (e.pointerType === 'mouse') return;\n  (e.target as HTMLElement).releasePointerCapture(e.pointerId) // <- Important!\n}\n\nexport function pointerenter(e: PointerEvent): void {\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  if (e.pointerType === 'mouse') return;\n  simulatePointerMouseEvent(e, 'mouseenter');\n}\n\nexport function pointerleave(e: PointerEvent): void {\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  if (e.pointerType === 'mouse') return;\n  DDTouch.pointerLeaveTimeout = window.setTimeout(() => {\n    delete DDTouch.pointerLeaveTimeout;\n    // console.log('pointerleave delayed');\n    simulatePointerMouseEvent(e, 'mouseleave');\n  }, 10);\n}\n\n","/**\n * dd-resizable-handle.ts 10.1.2\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 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(protected host: HTMLElement, protected dir: string, protected option: DDResizableHandleOpt) {\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 = this.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.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): void {\n    this.mouseDownEvent = e;\n    document.addEventListener('mousemove', this._mouseMove, { capture: true, passive: 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): void {\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(); passive = true\n  }\n\n  /** @internal */\n  protected _mouseUp(e: MouseEvent): void {\n    if (this.moving) {\n      this._triggerEvent('stop', e);\n    }\n    document.removeEventListener('mousemove', this._mouseMove, true);\n    document.removeEventListener('mouseup', this._mouseUp, 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-base-impl.ts 10.1.2\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-resizable.ts 10.1.2\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, GridItemHTMLElement, 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\ninterface RectScaleReciprocal {\n  x: number;\n  y: number;\n}\n\nexport class DDResizable extends DDBaseImplement implements HTMLElementExtendOpt<DDResizableOpt> {\n  /** @internal */\n  protected handlers: DDResizableHandle[];\n  /** @internal */\n  protected originalRect: Rect;\n  /** @internal */\n  protected rectScale: RectScaleReciprocal = { x: 1, y: 1 };\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  /** @internal */\n  protected sizeToContent: boolean;\n\n  // have to be public else complains for HTMLElementExtendOpt ?\n  constructor(public el: GridItemHTMLElement, public option: DDResizableOpt = {}) {\n    super();\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.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._setupAutoHide(false);\n  }\n\n  public destroy(): void {\n    this._removeHandlers();\n    this._setupAutoHide(false);\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  // eslint-disable-next-line @typescript-eslint/no-unused-vars\n  protected _mouseOver(e: Event): void {\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  // eslint-disable-next-line @typescript-eslint/no-unused-vars\n  protected _mouseOut(e: Event): void {\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    this.handlers = this.option.handles.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.sizeToContent = Utils.shouldSizeToContent(this.el.gridstackNode, true); // strick true only and not number\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\n    const parent = this.el.parentElement;\n    const dragTransform = Utils.getValuesFromTransformedElement(parent);\n    this.rectScale = {\n      x: dragTransform.xScale,\n      y: dragTransform.yScale\n    };\n\n    if (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 = this.sizeToContent ? 0 : event.clientY - oEvent.clientY; // prevent vert resize\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 / this.rectScale.x || oWidth;\n    const maxHeight = this.option.maxHeight || Number.MAX_SAFE_INTEGER;\n    const minHeight = this.option.minHeight / this.rectScale.y || 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      const scaleReciprocal = key === 'width' || key === 'left' ? this.rectScale.x : key === 'height' || key === 'top' ? this.rectScale.y : 1;\n      this.el.style[key] = (value - containmentRect[key]) * scaleReciprocal + '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) * this.rectScale.x,\n        top: (rect.top - containmentRect.top) * this.rectScale.y\n      },\n      size: {\n        width: rect.width * this.rectScale.x,\n        height: rect.height * this.rectScale.y\n      }\n      /* Gridstack ONLY needs position set above... keep around in case.\n      element: [this.el], // The object representing the element to be resized\n      helper: [], // TODO: not support yet - The object representing the helper that's being resized\n      originalElement: [this.el],// we don't wrap here, so simplify as this.el //The object representing the original element before it is wrapped\n      originalPosition: { // The position represented as { left, top } before the resizable is resized\n        left: this.originalRect.left - containmentRect.left,\n        top: this.originalRect.top - containmentRect.top\n      },\n      originalSize: { // The size represented as { width, height } before the resizable is resized\n        width: this.originalRect.width,\n        height: this.originalRect.height\n      }\n      */\n    };\n  }\n}\n","/**\n * dd-draggable.ts 10.1.2\n * Copyright (c) 2021-2022 Alain Dumesny - see GridStack root license\n */\n\nimport { DDManager } from './dd-manager';\nimport { DragTransform, 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?: 'clone' | HTMLElement | ((event: Event) => HTMLElement);\n  cancel?: string;\n  // containment?: string | HTMLElement; // TODO: not implemented yet\n  // revert?: string | boolean | unknown; // TODO: not implemented yet\n  // scroll?: boolean;\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// make sure we are not clicking on known object that handles mouseDown\nconst skipMouseDown = 'input,textarea,button,select,option,[contenteditable=\"true\"],.ui-resizable-handle';\n\n// let count = 0; // TEST\n\nexport class DDDraggable extends DDBaseImplement implements HTMLElementExtendOpt<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', 'minWidth', 'willChange'];\n  /** @internal pause before we call the actual drag hit collision code */\n  protected dragTimeout: number;\n  /** @internal */\n  protected dragTransform: DragTransform = {\n    xScale: 1,\n    yScale: 1,\n    xOffset: 0,\n    yOffset: 0\n  };\n\n  constructor(public el: HTMLElement, public option: DDDraggableOpt = {}) {\n    super();\n\n    // get the element that is actually supposed to be dragged by\n    let handleName = option.handle.substring(1);\n    this.dragEl = el.classList.contains(handleName) ? 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  }\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    if (!forDestroy) this.el.classList.add('ui-draggable-disabled');\n  }\n\n  public destroy(): void {\n    if (this.dragTimeout) window.clearTimeout(this.dragTimeout);\n    delete this.dragTimeout;\n    if (this.mouseDownEvent) 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, or ones supplied by the user\n    if ((e.target as HTMLElement).closest(skipMouseDown)) return true;\n    if (this.option.cancel) {\n      if ((e.target as HTMLElement).closest(this.option.cancel)) return true;\n    }\n\n    // REMOVE: why would we get the event if it wasn't for us or child ?\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    // 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\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, { capture: true, passive: 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    // preventDefault() prevents blur event which occurs just after mousedown event.\n    // if an editable content has focus, then blur must be call\n    if (document.activeElement) (document.activeElement as HTMLElement).blur();\n\n    DDManager.mouseHandled = true;\n    return true;\n  }\n\n  /** @internal method to call actual drag event */\n  protected _callDrag(e: DragEvent): void {\n    if (!this.dragging) return;\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  }\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      // delay actual grid handling drag until we pause for a while if set\n      if (DDManager.pauseDrag) {\n        const pause = Number.isInteger(DDManager.pauseDrag) ? DDManager.pauseDrag as number : 100;\n        if (this.dragTimeout) window.clearTimeout(this.dragTimeout);\n        this.dragTimeout = window.setTimeout(() => this._callDrag(e), pause);\n      } else {\n        this._callDrag(e);\n      }\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.dragTransform = Utils.getValuesFromTransformedElement(\n        this.helperContainment\n      );\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(); // passive = true. OLD: was 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.parentElement : 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.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 (!node?._isAboutToRemove && this.dragElementOriginStyle) {\n      let helper = this.helper;\n      // don't animate, otherwise we animate offseted when switching back to 'absolute' from 'fixed'.\n      // TODO: this also removes resizing animation which doesn't have this issue, but others.\n      // Ideally both would animate ('move' would immediately restore 'absolute' and adjust coordinate to match,\n      // then trigger a delay (repaint) to restore to final dest with animate) but then we need to make sure 'resizestop'\n      // is called AFTER 'transitionend' event is received (see https://github.com/gridstack/gridstack.js/issues/2033)\n      let transition = this.dragElementOriginStyle['transition'] || null;\n      helper.style.transition = this.dragElementOriginStyle['transition'] = 'none'; // can't be NULL #1973\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) * this.dragTransform.xScale + 'px';\n    style.top = (e.clientY + offset.offsetTop - containmentRect.top) * this.dragTransform.yScale + '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 (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      xformOffsetX = this.dragTransform.xOffset;\n      xformOffsetY = this.dragTransform.yOffset;\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 * this.dragTransform.xScale,\n      height: targetOffset.height * this.dragTransform.yScale\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) * this.dragTransform.yScale,\n        left: (offset.left - containmentRect.left) * this.dragTransform.xScale\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 10.1.2\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 { DDUIData } from './types';\n\nexport interface DDDroppableOpt {\n  accept?: string | ((el: HTMLElement) => boolean);\n  drop?: (event: DragEvent, ui: DDUIData) => void;\n  over?: (event: DragEvent, ui: DDUIData) => void;\n  out?: (event: DragEvent, ui: DDUIData) => 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\n  constructor(public el: HTMLElement, public option: DDDroppableOpt = {}) {\n    super();\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(DDManager.dragElement.el)) 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, true); // calledByEnter = true\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, calledByEnter = false): 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      if (!calledByEnter) {\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\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(el: HTMLElement): boolean {\n    return el && (!this.accept || this.accept(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.classList.contains(this.option.accept as string) || 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): DDUIData {\n    return {\n      draggable: drag.el,\n      ...drag.ui()\n    };\n  }\n}\n\n","/**\n * dd-elements.ts 10.1.2\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 ddDraggable?: DDDraggable;\n  public ddDroppable?: DDDroppable;\n  public ddResizable?: DDResizable;\n\n  constructor(public el: DDElementHost) {}\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 * GridStack 10.1.2\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, DragTransform } from './utils';\r\nimport {\r\n  gridDefaults, ColumnOptions, GridItemHTMLElement, GridStackElement, GridStackEventHandlerCallback,\r\n  GridStackNode, GridStackWidget, numberOrString, DDUIData, DDDragInOpt, GridStackPosition, GridStackOptions,\r\n  dragInDefaultOptions, GridStackEventHandler, GridStackNodesHandler, AddRemoveFcn, SaveFcn, CompactOptions, GridStackMoveOpts, ResizeToContentFcn, GridStackDroppedHandler, GridStackElementHandler\r\n} from './types';\r\n\r\n/*\r\n * and include D&D by default\r\n * TODO: while we could generate a gridstack-static.js at smaller size - saves about 31k (41k -> 72k)\r\n * I don't know how to generate the DD only code at the remaining 31k to delay load as code depends on Gridstack.ts\r\n * also it caused loading issues in prod - see https://github.com/gridstack/gridstack.js/issues/2039\r\n */\r\nimport { DDGridStack } from './dd-gridstack';\r\nimport { isTouch } from './dd-touch';\r\nimport { DDManager } from './dd-manager';\r\nimport { DDElementHost } from './dd-element';/** global instance */\r\nconst dd = new DDGridStack;\r\n\r\n// export all dependent file as well to make it easier for users to just import the main file\r\nexport * from './types';\r\nexport * from './utils';\r\nexport * from './gridstack-engine';\r\nexport * from './dd-gridstack';\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' | 'resizecontent';\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  _max?: number; // internal tracker of the max # of rows we created\r\n}\r\n\r\n// extend with internal fields we need - TODO: move other items in here\r\ninterface InternalGridStackOptions extends GridStackOptions {\r\n  _alwaysShowResizeHandle?: true | false | 'mobile'; // so we can restore for save\r\n}\r\n\r\n// temporary legacy (<10.x) support\r\ninterface OldOneColumnOpts extends GridStackOptions {\r\n  /** disables the onColumnMode when the grid width is less (default?: false) */\r\n  disableOneColumnMode?: boolean;\r\n  /** minimal width before grid will be shown in one column mode (default?: 768) */\r\n  oneColumnSize?: number;\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  oneColumnModeDomSort?: boolean;\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    if (typeof document === 'undefined') return null; // temp workaround SSR\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    if (typeof document === 'undefined') return grids; // temp workaround SSR\r\n    GridStack.getGridElements(selector).forEach(el => {\r\n      if (!el.gridstack) {\r\n        el.gridstack = new GridStack(el, Utils.cloneDeep(options));\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    let el = parent as GridHTMLElement;\r\n    if (el.gridstack) {\r\n      // already a grid - set option and load data\r\n      const grid = el.gridstack;\r\n      if (opt) grid.opts = { ...grid.opts, ...opt };\r\n      if (opt.children !== undefined) grid.load(opt.children);\r\n      return grid;\r\n    }\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    const parentIsGrid = parent.classList.contains('grid-stack');\r\n    if (!parentIsGrid || GridStack.addRemoveCB) {\r\n      if (GridStack.addRemoveCB) {\r\n        el = GridStack.addRemoveCB(parent, opt, true, true);\r\n      } else {\r\n        let doc = document.implementation.createHTMLDocument(''); // IE needs a param\r\n        doc.body.innerHTML = `<div class=\"grid-stack ${opt.class || ''}\"></div>`;\r\n        el = doc.body.children[0] as HTMLElement;\r\n        parent.appendChild(el);\r\n      }\r\n    }\r\n\r\n    // create grid class and load any children\r\n    let grid = GridStack.init(opt, el);\r\n    return grid;\r\n  }\r\n\r\n  /** call this method to register your engine instead of the default one.\r\n   * See instead `GridStackOptions.engineClass` if you only need to\r\n   * replace just one instance.\r\n   */\r\n  static registerEngine(engineClass: typeof GridStackEngine): void {\r\n    GridStack.engineClass = engineClass;\r\n  }\r\n\r\n  /**\r\n   * callback method use when new items|grids needs to be created or deleted, instead of the default\r\n   * item: <div class=\"grid-stack-item\"><div class=\"grid-stack-item-content\">w.content</div></div>\r\n   * grid: <div class=\"grid-stack\">grid content...</div>\r\n   * add = true: the returned DOM element will then be converted to a GridItemHTMLElement using makeWidget()|GridStack:init().\r\n   * add = false: the item will be removed from DOM (if not already done)\r\n   * grid = true|false for grid vs grid-items\r\n   */\r\n  public static addRemoveCB?: AddRemoveFcn;\r\n\r\n  /**\r\n   * callback during saving to application can inject extra data for each widget, on top of the grid layout properties\r\n   */\r\n  public static saveCB?: SaveFcn;\r\n\r\n  /** callback to use for resizeToContent instead of the built in one */\r\n  public static resizeToContentCB?: ResizeToContentFcn;\r\n  /** parent class for sizing content. defaults to '.grid-stack-item-content' */\r\n  public static resizeToContentParent = '.grid-stack-item-content';\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  /** engine used to implement non DOM grid functionality */\r\n  public engine: GridStackEngine;\r\n\r\n  /** point to a parent grid item if we're nested (inside a grid-item in between 2 Grids) */\r\n  public parentGridItem?: GridStackNode;\r\n\r\n  protected static engineClass: typeof GridStackEngine;\r\n  protected resizeObserver: ResizeObserver;\r\n\r\n  /** @internal unique class name for our generated CSS style sheet */\r\n  protected _styleSheetClass?: string;\r\n  /** @internal true if we got created by drag over gesture, so we can removed on drag out (temporary) */\r\n  public _isTemp?: boolean;\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 prevent cached layouts from being updated when loading into small column layouts */\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 limit auto cell resizing method */\r\n  protected _sizeThrottle: () => void;\r\n  /** @internal limit auto cell resizing method */\r\n  protected prevWidth: number;\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  /** @internal meant to store the scale of the active grid */\r\n  protected dragTransform: DragTransform = { xScale: 1, yScale: 1, xOffset: 0, yOffset: 0 };\r\n  private _skipInitialResize: boolean;\r\n\r\n  /**\r\n   * Construct a grid item from the given element and options\r\n   * @param el the HTML element tied to this grid after it's been initialized\r\n   * @param opts grid options - public for classes to access, but use methods to modify!\r\n   */\r\n  public constructor(public el: GridHTMLElement, public opts: GridStackOptions = {}) {\r\n    el.gridstack = this;\r\n    opts = opts || {}; // handles null/undefined/0\r\n\r\n    if (!el.classList.contains('grid-stack')) {\r\n      this.el.classList.add('grid-stack');\r\n    }\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    // save original setting so we can restore on save\r\n    if (opts.alwaysShowResizeHandle !== undefined) {\r\n      (opts as InternalGridStackOptions)._alwaysShowResizeHandle = opts.alwaysShowResizeHandle;\r\n    }\r\n    let bk = opts.columnOpts?.breakpoints;\r\n    // LEGACY: oneColumnMode stuff changed in v10.x - check if user explicitly set something to convert over\r\n    const oldOpts: OldOneColumnOpts = opts;\r\n    if (oldOpts.oneColumnModeDomSort) {\r\n      delete oldOpts.oneColumnModeDomSort;\r\n      console.log('warning: Gridstack oneColumnModeDomSort no longer supported. Use GridStackOptions.columnOpts instead.')\r\n    }\r\n    if (oldOpts.oneColumnSize || oldOpts.disableOneColumnMode === false) {\r\n      const oneSize = oldOpts.oneColumnSize || 768;\r\n      delete oldOpts.oneColumnSize;\r\n      delete oldOpts.disableOneColumnMode;\r\n      opts.columnOpts = opts.columnOpts || {};\r\n      bk = opts.columnOpts.breakpoints = opts.columnOpts.breakpoints || [];\r\n      let oneColumn = bk.find(b => b.c === 1);\r\n      if (!oneColumn) {\r\n        oneColumn = { c: 1, w: oneSize };\r\n        bk.push(oneColumn, { c: 12, w: oneSize + 1 });\r\n      } else oneColumn.w = oneSize;\r\n    }\r\n    //...end LEGACY\r\n    // cleanup responsive opts (must have columnWidth | breakpoints) then sort breakpoints by size (so we can match during resize)\r\n    const resp = opts.columnOpts;\r\n    if (resp) {\r\n      if (!resp.columnWidth && !resp.breakpoints?.length) {\r\n        delete opts.columnOpts;\r\n        bk = undefined;\r\n      } else {\r\n        resp.columnMax = resp.columnMax || 12;\r\n      }\r\n    }\r\n    if (bk?.length > 1) bk.sort((a, b) => (b.w || 0) - (a.w || 0));\r\n\r\n    // elements DOM attributes override any passed options (like CSS style) - merge the two together\r\n    let defaults: GridStackOptions = {\r\n      ...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 || gridDefaults.removableOptions.accept,\r\n        decline: gridDefaults.removableOptions.decline\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    opts = Utils.defaults(opts, defaults);\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    this.checkDynamicColumn();\r\n    this.el.classList.add('gs-' + opts.column);\r\n\r\n    if (opts.rtl === 'auto') {\r\n      opts.rtl = (el.style.direction === 'rtl');\r\n    }\r\n    if (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    const grandParent: GridItemHTMLElement = this.el.parentElement?.parentElement;\r\n    let parentGridItem = grandParent?.classList.contains(gridDefaults.itemClass) ? grandParent.gridstackNode : undefined;\r\n    if (parentGridItem) {\r\n      parentGridItem.subGrid = this;\r\n      this.parentGridItem = parentGridItem;\r\n      this.el.classList.add('grid-stack-nested');\r\n      parentGridItem.el.classList.add('grid-stack-sub-grid');\r\n    }\r\n\r\n    this._isAutoCellHeight = (opts.cellHeight === 'auto');\r\n    if (this._isAutoCellHeight || 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 opts.cellHeight == 'number' && opts.cellHeightUnit && opts.cellHeightUnit !== gridDefaults.cellHeightUnit) {\r\n        opts.cellHeight = opts.cellHeight + opts.cellHeightUnit;\r\n        delete opts.cellHeightUnit;\r\n      }\r\n      this.cellHeight(opts.cellHeight, false);\r\n    }\r\n\r\n    // see if we need to adjust auto-hide\r\n    if (opts.alwaysShowResizeHandle === 'mobile') {\r\n      opts.alwaysShowResizeHandle = isTouch;\r\n    }\r\n\r\n    this._styleSheetClass = 'gs-id-' + GridStackEngine._idSeq++;\r\n    this.el.classList.add(this._styleSheetClass);\r\n\r\n    this._setStaticClass();\r\n\r\n    let engineClass = opts.engineClass || GridStack.engineClass || GridStackEngine;\r\n    this.engine = new engineClass({\r\n      column: this.getColumn(),\r\n      float: opts.float,\r\n      maxRow: 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    // create initial global styles BEFORE loading children so resizeToContent margin can be calculated correctly\r\n    this._updateStyles(false, 0);\r\n\r\n    if (opts.auto) {\r\n      this.batchUpdate(); // prevent in between re-layout #1535 TODO: this only set float=true, need to prevent collision check...\r\n      this.getGridItems().forEach(el => this._prepareElement(el));\r\n      this.batchUpdate(false);\r\n    }\r\n\r\n    // load any passed in children as well, which overrides any DOM layout done above\r\n    if (opts.children) {\r\n      let children = opts.children;\r\n      delete opts.children;\r\n      if (children.length) this.load(children); // don't load empty\r\n    }\r\n\r\n    // if (this.engine.nodes.length) this._updateStyles(); // update based on # of children. done in engine onChange CB\r\n    this.setAnimation(opts.animate);\r\n\r\n    // dynamic grids require pausing during drag to detect over to nest vs push\r\n    if (opts.subGridDynamic && !DDManager.pauseDrag) DDManager.pauseDrag = true;\r\n    if (opts.draggable?.pause !== undefined) DDManager.pauseDrag = opts.draggable.pause;\r\n\r\n    this._setupRemoveDrop();\r\n    this._setupAcceptWidget();\r\n    this._updateResizeEvent();\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    function isGridStackWidget(w: GridStackNode): w is GridStackNode { // https://medium.com/ovrsea/checking-the-type-of-an-object-in-typescript-the-type-guards-24d98d9119b0\r\n      return w.el !== undefined || w.x !== undefined || w.y !== undefined || w.w !== undefined || w.h !== undefined || w.content !== undefined ? true : false;\r\n    }\r\n\r\n    let el: GridItemHTMLElement;\r\n    let node: GridStackNode;\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      node = options = els;\r\n      if (node?.el) {\r\n        el = node.el; // re-use element stored in the node\r\n      } else if (GridStack.addRemoveCB) {\r\n        el = GridStack.addRemoveCB(this.el, options, true, false);\r\n      } else {\r\n        let content = options?.content || '';\r\n        let doc = document.implementation.createHTMLDocument(''); // IE needs a param\r\n        doc.body.innerHTML = `<div class=\"grid-stack-item ${this.opts.itemClass || ''}\"><div class=\"grid-stack-item-content\">${content}</div></div>`;\r\n        el = doc.body.children[0] as HTMLElement;\r\n      }\r\n    } else {\r\n      el = els as HTMLElement;\r\n    }\r\n\r\n    if (!el) return;\r\n\r\n    // if the caller ended up initializing the widget in addRemoveCB, or we stared with one already, skip the rest\r\n    node = el.gridstackNode;\r\n    if (node && el.parentElement === this.el && this.engine.nodes.find(n => n._id === node._id)) return el;\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    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    this.makeWidget(el, options);\r\n\r\n    return el;\r\n  }\r\n\r\n  /**\r\n   * Convert an existing gridItem element into a sub-grid with the given (optional) options, else inherit them\r\n   * from the parent's subGrid options.\r\n   * @param el gridItem element to convert\r\n   * @param ops (optional) sub-grid options, else default to node, then parent settings, else defaults\r\n   * @param nodeToAdd (optional) node to add to the newly created sub grid (used when dragging over existing regular item)\r\n   * @param saveContent if true (default) the html inside .grid-stack-content will be saved to child widget\r\n   * @returns newly created grid\r\n   */\r\n  public makeSubGrid(el: GridItemHTMLElement, ops?: GridStackOptions, nodeToAdd?: GridStackNode, saveContent = true): GridStack {\r\n    let node = el.gridstackNode;\r\n    if (!node) {\r\n      node = this.makeWidget(el).gridstackNode;\r\n    }\r\n    if (node.subGrid?.el) return node.subGrid; // already done\r\n\r\n    // find the template subGrid stored on a parent as fallback...\r\n    let subGridTemplate: GridStackOptions; // eslint-disable-next-line @typescript-eslint/no-this-alias\r\n    let grid: GridStack = this;\r\n    while (grid && !subGridTemplate) {\r\n      subGridTemplate = grid.opts?.subGridOpts;\r\n      grid = grid.parentGridItem?.grid;\r\n    }\r\n    //... and set the create options\r\n    ops = Utils.cloneDeep({ ...(subGridTemplate || {}), children: undefined, ...(ops || node.subGridOpts || {}) });\r\n    node.subGridOpts = ops;\r\n\r\n    // if column special case it set, remember that flag and set default\r\n    let autoColumn: boolean;\r\n    if (ops.column === 'auto') {\r\n      autoColumn = true;\r\n      ops.column = Math.max(node.w || 1, nodeToAdd?.w || 1);\r\n      delete ops.columnOpts; // driven by parent\r\n    }\r\n\r\n    // if we're converting an existing full item, move over the content to be the first sub item in the new grid\r\n    let content = node.el.querySelector('.grid-stack-item-content') as HTMLElement;\r\n    let newItem: HTMLElement;\r\n    let newItemOpt: GridStackNode;\r\n    if (saveContent) {\r\n      this._removeDD(node.el); // remove D&D since it's set on content div\r\n      newItemOpt = { ...node, x: 0, y: 0 };\r\n      Utils.removeInternalForSave(newItemOpt);\r\n      delete newItemOpt.subGridOpts;\r\n      if (node.content) {\r\n        newItemOpt.content = node.content;\r\n        delete node.content;\r\n      }\r\n      if (GridStack.addRemoveCB) {\r\n        newItem = GridStack.addRemoveCB(this.el, newItemOpt, true, false);\r\n      } else {\r\n        let doc = document.implementation.createHTMLDocument(''); // IE needs a param\r\n        doc.body.innerHTML = `<div class=\"grid-stack-item\"></div>`;\r\n        newItem = doc.body.children[0] as HTMLElement;\r\n        newItem.appendChild(content);\r\n        doc.body.innerHTML = `<div class=\"grid-stack-item-content\"></div>`;\r\n        content = doc.body.children[0] as HTMLElement;\r\n        node.el.appendChild(content);\r\n      }\r\n      this._prepareDragDropByNode(node); // ... and restore original D&D\r\n    }\r\n\r\n    // if we're adding an additional item, make the container large enough to have them both\r\n    if (nodeToAdd) {\r\n      let w = autoColumn ? ops.column : node.w;\r\n      let h = node.h + nodeToAdd.h;\r\n      let style = node.el.style;\r\n      style.transition = 'none'; // show up instantly so we don't see scrollbar with nodeToAdd\r\n      this.update(node.el, { w, h });\r\n      setTimeout(() => style.transition = null); // recover animation\r\n    }\r\n\r\n    let subGrid = node.subGrid = GridStack.addGrid(content, ops);\r\n    if (nodeToAdd?._moving) subGrid._isTemp = true; // prevent re-nesting as we add over\r\n    if (autoColumn) subGrid._autoColumn = true;\r\n\r\n    // add the original content back as a child of hte newly created grid\r\n    if (saveContent) {\r\n      subGrid.addWidget(newItem, newItemOpt);\r\n    }\r\n\r\n    // now add any additional node\r\n    if (nodeToAdd) {\r\n      if (nodeToAdd._moving) {\r\n        // create an artificial event even for the just created grid to receive this item\r\n        window.setTimeout(() => Utils.simulateMouseEvent(nodeToAdd._event, 'mouseenter', subGrid.el), 0);\r\n      } else {\r\n        subGrid.addWidget(node.el, node);\r\n      }\r\n    }\r\n    return subGrid;\r\n  }\r\n\r\n  /**\r\n   * called when an item was converted into a nested grid to accommodate a dragged over item, but then item leaves - return back\r\n   * to the original grid-item. Also called to remove empty sub-grids when last item is dragged out (since re-creating is simple)\r\n   */\r\n  public removeAsSubGrid(nodeThatRemoved?: GridStackNode): void {\r\n    let pGrid = this.parentGridItem?.grid;\r\n    if (!pGrid) return;\r\n\r\n    pGrid.batchUpdate();\r\n    pGrid.removeWidget(this.parentGridItem.el, true, true);\r\n    this.engine.nodes.forEach(n => {\r\n      // migrate any children over and offsetting by our location\r\n      n.x += this.parentGridItem.x;\r\n      n.y += this.parentGridItem.y;\r\n      pGrid.addWidget(n.el, n);\r\n    });\r\n    pGrid.batchUpdate(false);\r\n    if (this.parentGridItem) delete this.parentGridItem.subGrid;\r\n    delete this.parentGridItem;\r\n\r\n    // create an artificial event for the original grid now that this one is gone (got a leave, but won't get enter)\r\n    if (nodeThatRemoved) {\r\n      window.setTimeout(() => Utils.simulateMouseEvent(nodeThatRemoved._event, 'mouseenter', pGrid.el), 0);\r\n    }\r\n  }\r\n\r\n  /**\r\n   * saves the current layout returning a list of widgets for serialization which might include any nested grids.\r\n   * @param saveContent if true (default) the latest html inside .grid-stack-content will be saved to GridStackWidget.content field, else it will\r\n   * be removed.\r\n   * @param saveGridOpt if true (default false), save the grid options itself, so you can call the new GridStack.addGrid()\r\n   * to recreate everything from scratch. GridStackOptions.children would then contain the widget list instead.\r\n   * @param saveCB callback for each node -> widget, so application can insert additional data to be saved into the widget data structure.\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, saveCB = GridStack.saveCB): GridStackWidget[] | GridStackOptions {\r\n    // return copied GridStackWidget (with optionally .el) we can modify at will...\r\n    let list = this.engine.save(saveContent, saveCB);\r\n\r\n    // check for HTML content and nested grids\r\n    list.forEach(n => {\r\n      if (saveContent && n.el && !n.subGrid && !saveCB) { // 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 && !saveCB) { delete n.content; }\r\n        // check for nested grid\r\n        if (n.subGrid?.el) {\r\n          const listOrOpt = n.subGrid.save(saveContent, saveGridOpt, saveCB);\r\n          n.subGridOpts = (saveGridOpt ? listOrOpt : { children: listOrOpt }) as GridStackOptions;\r\n          delete n.subGrid;\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: InternalGridStackOptions = 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      }\r\n      const origShow = o._alwaysShowResizeHandle;\r\n      delete o._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(items: GridStackWidget[], addRemove: boolean | AddRemoveFcn = GridStack.addRemoveCB || true): GridStack {\r\n    items = Utils.cloneDeep(items); // so we can mod\r\n    const column = this.getColumn();\r\n\r\n    // if we have a mix of new items without coordinates and existing items, separate them out so they can be added after #2639\r\n    let addAfter = items.filter(n => (n.x === undefined || n.y === undefined) && !Utils.find(this.engine.nodes, n.id));\r\n    if (addAfter.length && addAfter.length !== items.length) {\r\n      items = items.filter(n => !Utils.find(addAfter, n.id));\r\n    } else addAfter = [];\r\n\r\n    // if passed list has coordinates, use them (insert from end to beginning for conflict resolution) else keep widget order\r\n    const haveCoord = items.some(w => w.x !== undefined || w.y !== undefined);\r\n    if (haveCoord) items = Utils.sort(items, -1);\r\n    this._insertNotAppend = haveCoord; // if we create in reverse order...\r\n\r\n    // if we're loading a layout into for example 1 column 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 (items.some(n => ((n.x || 0) + (n.w || 1)) > column)) {\r\n      this._ignoreLayoutsNodeChange = true; // skip layout update\r\n      this.engine.cacheLayout(items, 12, true); // TODO: 12 is arbitrary. use max value in layout ?\r\n    }\r\n\r\n    // if given a different callback, temporally set it as global option so creating will use it\r\n    const prevCB = GridStack.addRemoveCB;\r\n    if (typeof (addRemove) === 'function') GridStack.addRemoveCB = addRemove as AddRemoveFcn;\r\n\r\n    let removed: GridStackNode[] = [];\r\n    this.batchUpdate();\r\n\r\n    // if we are blank (loading into empty like startup) temp remove animation\r\n    const noAnim = !this.engine.nodes.length;\r\n    if (noAnim) this.setAnimation(false);\r\n\r\n    // see if any items are missing from new layout and need to be removed first\r\n    if (addRemove) {\r\n      let copyNodes = [...this.engine.nodes]; // don't loop through array you modify\r\n      copyNodes.forEach(n => {\r\n        if (!n.id) return;\r\n        let item = Utils.find(items, n.id);\r\n        if (!item) {\r\n          if (GridStack.addRemoveCB)\r\n            GridStack.addRemoveCB(this.el, n, false, false);\r\n          removed.push(n); // batch keep track\r\n          this.removeWidget(n.el, true, false);\r\n        }\r\n      });\r\n    }\r\n\r\n    // now add/update the widgets - starting with removing items in the new layout we will reposition\r\n    // to reduce collision and add no-coord ones at next available spot\r\n    let updateNodes: GridStackWidget[] = [];\r\n    this.engine.nodes = this.engine.nodes.filter(n => {\r\n      if (Utils.find(items, n.id)) { updateNodes.push(n); return false; } // remove if found from list\r\n      return true;\r\n    });\r\n    items.forEach(w => {\r\n      let item = Utils.find(updateNodes, w.id);\r\n      if (item) {\r\n        // if item sizes to content, re-use the exiting height so it's a better guess at the final size (same if width doesn't change)\r\n        if (Utils.shouldSizeToContent(item)) w.h = item.h;\r\n        // check if missing coord, in which case find next empty slot with new (or old if missing) sizes\r\n        this.engine.nodeBoundFix(w);\r\n        if (w.autoPosition || w.x === undefined || w.y === undefined) {\r\n          w.w = w.w || item.w;\r\n          w.h = w.h || item.h;\r\n          this.engine.findEmptyPosition(w);\r\n        }\r\n\r\n        // add back to current list BUT force a collision check if it 'appears' we didn't change to make sure we don't overlap others now\r\n        this.engine.nodes.push(item);\r\n        if (Utils.samePos(item, w)) {\r\n          this.moveNode(item, { ...w, forceCollide: true });\r\n        }\r\n\r\n        this.update(item.el, w);\r\n        if (w.subGridOpts?.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.subGridOpts.children); // TODO: support updating grid options ?\r\n            this._insertNotAppend = true; // got reset by above call\r\n          }\r\n        }\r\n      } else if (addRemove) {\r\n        this.addWidget(w);\r\n      }\r\n    });\r\n\r\n    // finally append any separate ones that didn't have explicit coordinates last so they can find next empty spot\r\n    if (addRemove) {\r\n      addAfter.forEach(w => this.addWidget(w))\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    prevCB ? GridStack.addRemoveCB = prevCB : delete GridStack.addRemoveCB;\r\n    // delay adding animation back, but check to make sure grid (opt) is still around\r\n    if (noAnim && this.opts?.animate) setTimeout(() => { if (this.opts) this.setAnimation(this.opts.animate) });\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._updateContainerHeight();\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    // do rem/em/cm/mm to px conversion\r\n    if (this.opts.cellHeightUnit === 'rem') {\r\n      return (this.opts.cellHeight as number) * parseFloat(getComputedStyle(document.documentElement).fontSize);\r\n    }\r\n    if (this.opts.cellHeightUnit === 'em') {\r\n      return (this.opts.cellHeight as number) * parseFloat(getComputedStyle(this.el).fontSize);\r\n    }\r\n    if (this.opts.cellHeightUnit === 'cm') {\r\n      // 1cm = 96px/2.54. See https://www.w3.org/TR/css-values-3/#absolute-lengths\r\n      return (this.opts.cellHeight as number) * (96 / 2.54);\r\n    }\r\n    if (this.opts.cellHeightUnit === 'mm') {\r\n      return (this.opts.cellHeight as number) * (96 / 2.54) / 10;\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 h = Utils.toNumber(el.getAttribute('gs-h')) || 1; // since we don't write 1 anymore\r\n      return Math.round(el.offsetHeight / h);\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._updateResizeEvent();\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    this.resizeToContentCheck();\r\n\r\n    if (update) {\r\n      this._updateStyles(true); // true = force re-create for current # of rows\r\n    }\r\n    return this;\r\n  }\r\n\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) , and optionally of window for dynamic column check */\r\n  protected _widthOrContainer(forBreakpoint = false): 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 forBreakpoint && this.opts.columnOpts?.breakpointForWindow ? window.innerWidth : (this.el.clientWidth || this.el.parentElement.clientWidth || window.innerWidth);\r\n  }\r\n  /** checks for dynamic column count for our current size, returning true if changed */\r\n  protected checkDynamicColumn(): boolean {\r\n    const resp = this.opts.columnOpts;\r\n    if (!resp || (!resp.columnWidth && !resp.breakpoints?.length)) return false;\r\n    const column = this.getColumn();\r\n    let newColumn = column;\r\n    const w = this._widthOrContainer(true);\r\n    if (resp.columnWidth) {\r\n      newColumn = Math.min(Math.round(w / resp.columnWidth) || 1, resp.columnMax);\r\n    } else {\r\n      // find the closest breakpoint (already sorted big to small) that matches\r\n      newColumn = resp.columnMax;\r\n      let i = 0;\r\n      while (i < resp.breakpoints.length && w <= resp.breakpoints[i].w) {\r\n        newColumn = resp.breakpoints[i++].c || column;\r\n      }\r\n    }\r\n    if (newColumn !== column) {\r\n      const bk = resp.breakpoints?.find(b => b.c === newColumn);\r\n      this.column(newColumn, bk?.layout || resp.layout);\r\n      return true;\r\n    }\r\n    return false;\r\n  }\r\n\r\n  /**\r\n   * re-layout grid items to reclaim any empty space. Options are:\r\n   * 'list' keep the widget left->right order the same, even if that means leaving an empty slot if things don't fit\r\n   * 'compact' might re-order items to fill any empty space\r\n   *\r\n   * doSort - 'false' to let you do your own sorting ahead in case you need to control a different order. (default to sort)\r\n   */\r\n  public compact(layout: CompactOptions = 'compact', doSort = true): GridStack {\r\n    this.engine.compact(layout, doSort);\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 || column < 1 || this.opts.column === column) return this;\r\n\r\n    let oldColumn = this.getColumn();\r\n    this.opts.column = column;\r\n    if (!this.engine) return this; // called in constructor, noting else to do\r\n\r\n    this.engine.column = column;\r\n    this.el.classList.remove('gs-' + oldColumn);\r\n    this.el.classList.add('gs-' + column);\r\n\r\n    // update the items now, checking if we have a custom children layout\r\n    /*const newChildren = this.opts.columnOpts?.breakpoints?.find(r => r.c === column)?.children;\r\n    if (newChildren) this.load(newChildren);\r\n    else*/ this.engine.columnChanged(oldColumn, column, layout);\r\n    if (this._isAutoCellHeight) this.cellHeight();\r\n\r\n    this.resizeToContentCheck(true); // wait for width resizing\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 { return this.opts.column as number; }\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.offAll();\r\n    this._updateResizeEvent(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      this.el.removeAttribute('gs-current-row');\r\n    } else {\r\n      this.el.parentNode.removeChild(this.el);\r\n    }\r\n    this._removeStylesheet();\r\n    if (this.parentGridItem) delete this.parentGridItem.subGrid;\r\n    delete this.parentGridItem;\r\n    delete this.opts;\r\n    delete this._placeholder;\r\n    delete this.engine;\r\n    delete this.el.gridstack; // remove circular dependency that would prevent a freeing\r\n    delete this.el;\r\n    return this;\r\n  }\r\n\r\n  /**\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 (or have some framework creating DOM), 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   * @param options widget definition to use instead of reading attributes or using default sizing values\r\n   *\r\n   * @example\r\n   * let grid = GridStack.init();\r\n   * grid.el.appendChild('<div id=\"1\" gs-w=\"3\"></div>');\r\n   * grid.el.appendChild('<div id=\"2\"></div>');\r\n   * grid.makeWidget('1');\r\n   * grid.makeWidget('2', {w:2, content: 'hello'});\r\n   */\r\n  public makeWidget(els: GridStackElement, options?: GridStackWidget): GridItemHTMLElement {\r\n    let el = GridStack.getElement(els);\r\n    this._prepareElement(el, true, options);\r\n    const node = el.gridstackNode;\r\n\r\n    this._updateContainerHeight();\r\n\r\n    // see if there is a sub-grid to create\r\n    if (node.subGridOpts) {\r\n      this.makeSubGrid(el, node.subGridOpts, undefined, false); // node.subGrid will be used as option in method, no need to pass\r\n    }\r\n\r\n    // if we're adding an item into 1 column make sure\r\n    // we don't override the larger 12 column layout that was already saved. #1985\r\n    if (this.opts.column === 1) {\r\n      this._ignoreLayoutsNodeChange = true;\r\n    }\r\n    this._triggerAddEvent();\r\n    this._triggerChangeEvent();\r\n    delete this._ignoreLayoutsNodeChange;\r\n\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: 'dropped', callback: GridStackDroppedHandler): GridStack\r\n  public on(name: 'enable' | 'disable', callback: GridStackEventHandler): GridStack\r\n  public on(name: 'change' | 'added' | 'removed' | 'resizecontent', callback: GridStackNodesHandler): GridStack\r\n  public on(name: 'resizestart' | 'resize' | 'resizestop' | 'dragstart' | 'drag' | 'dragstop', callback: GridStackElementHandler): GridStack\r\n  public on(name: string, callback: GridStackEventHandlerCallback): GridStack\r\n  public on(name: GridStackEvent | string, 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    // native CustomEvent handlers - cash the generic handlers so we can easily remove\r\n    if (name === 'change' || name === 'added' || name === 'removed' || name === 'enable' || name === 'disable') {\r\n      let noData = (name === 'enable' || name === 'disable');\r\n      if (noData) {\r\n        this._gsEventHandler[name] = (event: Event) => (callback as GridStackEventHandler)(event);\r\n      } else {\r\n        this._gsEventHandler[name] = (event: CustomEvent) => (callback as GridStackNodesHandler)(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'\r\n      || name === 'resizestop' || name === 'dropped' || name === 'resizecontent') {\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.error('GridStack.on(' + name + ') event not supported');\r\n    }\r\n    return this;\r\n  }\r\n\r\n  /**\r\n   * unsubscribe from the 'on' event GridStackEvent\r\n   * @param name of the event (see possible values) or list of names space separated\r\n   */\r\n  public off(name: GridStackEvent | string): 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  /** remove all event handlers */\r\n  public offAll(): GridStack {\r\n    Object.keys(this._gsEventHandler).forEach((key: GridStackEvent) => this.off(key));\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 && 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      if (removeDOM && GridStack.addRemoveCB) {\r\n        GridStack.addRemoveCB(this.el, node, false, false);\r\n      }\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   * @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 removeAll(removeDOM = true, triggerEvent = 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      if (removeDOM && GridStack.addRemoveCB) {\r\n        GridStack.addRemoveCB(this.el, n, false, false);\r\n      }\r\n      delete n.el.gridstackNode;\r\n      if (!this.opts.staticGrid) this._removeDD(n.el);\r\n    });\r\n    this.engine.removeAll(removeDOM, triggerEvent);\r\n    if (triggerEvent) 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  /** @internal */\r\n  private hasAnimationCSS(): boolean { return this.el.classList.contains('grid-stack-animate') }\r\n\r\n  /**\r\n   * Toggle the grid static state, which permanently removes/add Drag&Drop support, unlike disable()/enable() that just turns it off/on.\r\n   * Also toggle the grid-stack-static class.\r\n   * @param val if true the grid become static.\r\n   * @param updateClass true (default) if css class gets updated\r\n   * @param recurse true (default) if sub-grids also get updated\r\n   */\r\n  public setStatic(val: boolean, updateClass = true, recurse = true): GridStack {\r\n    if (!!this.opts.staticGrid === val) return this;\r\n    val ? this.opts.staticGrid = true : delete this.opts.staticGrid;\r\n    this._setupRemoveDrop();\r\n    this._setupAcceptWidget();\r\n    this.engine.nodes.forEach(n => {\r\n      this._prepareDragDropByNode(n); // either delete or init Drag&drop\r\n      if (n.subGrid && recurse) n.subGrid.setStatic(val, updateClass, recurse);\r\n    });\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      let n = el?.gridstackNode;\r\n      if (!n) return;\r\n      let w = Utils.cloneDeep(opt); // make a copy we can modify in case they re-use it or multiple items\r\n      this.engine.nodeBoundFix(w);\r\n      delete w.autoPosition;\r\n      delete w.id;\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 !== undefined) {\r\n        const itemContent = el.querySelector('.grid-stack-item-content');\r\n        if (itemContent && itemContent.innerHTML !== w.content) {\r\n          itemContent.innerHTML = w.content;\r\n          // restore any sub-grid back\r\n          if (n.subGrid?.el) {\r\n            itemContent.appendChild(n.subGrid.el);\r\n            if (!n.subGrid.opts.styleInHead) n.subGrid._updateStyles(true); // force create\r\n          }\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      Utils.sanitizeMinMax(n);\r\n\r\n      // finally move the widget and update attr\r\n      if (m) {\r\n        const widthChanged = (m.w !== undefined && m.w !== n.w);\r\n        this.moveNode(n, m);\r\n        this.resizeToContentCheck(widthChanged, n); // wait for animation if we changed width\r\n      }\r\n      if (m || changed) {\r\n        this._writeAttr(el, n);\r\n      }\r\n      if (ddChanged) {\r\n        this._prepareDragDropByNode(n);\r\n      }\r\n    });\r\n\r\n    return this;\r\n  }\r\n\r\n  private moveNode(n: GridStackNode, m: GridStackMoveOpts) {\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\r\n  /**\r\n   * Updates widget height to match the content height to avoid v-scrollbar or dead space.\r\n   * Note: this assumes only 1 child under resizeToContentParent='.grid-stack-item-content' (sized to gridItem minus padding) that is at the entire content size wanted.\r\n   * @param el grid item element\r\n   * @param useNodeH set to true if GridStackNode.h should be used instead of actual container height when we don't need to wait for animation to finish to get actual DOM heights\r\n   */\r\n  public resizeToContent(el: GridItemHTMLElement) {\r\n    if (!el) return;\r\n    el.classList.remove('size-to-content-max');\r\n    if (!el.clientHeight) return; // 0 when hidden, skip\r\n    const n = el.gridstackNode;\r\n    if (!n) return;\r\n    const grid = n.grid;\r\n    if (!grid || el.parentElement !== grid.el) return; // skip if we are not inside a grid\r\n    const cell = grid.getCellHeight(true);\r\n    if (!cell) return;\r\n    let height = n.h ? n.h * cell : el.clientHeight; // getBoundingClientRect().height seem to flicker back and forth\r\n    let item: Element;\r\n    if (n.resizeToContentParent) item = el.querySelector(n.resizeToContentParent);\r\n    if (!item) item = el.querySelector(GridStack.resizeToContentParent);\r\n    if (!item) return;\r\n    const padding = el.clientHeight - item.clientHeight; // full - available height to our child (minus border, padding...)\r\n    const itemH = n.h ? n.h * cell - padding : item.clientHeight; // calculated to what cellHeight is or will become (rather than actual to prevent waiting for animation to finish)\r\n    let wantedH: number;\r\n    if (n.subGrid) {\r\n      // sub-grid - use their actual row count * their cell height\r\n      wantedH = n.subGrid.getRow() * n.subGrid.getCellHeight(true);\r\n    } else {\r\n      // NOTE: clientHeight & getBoundingClientRect() is undefined for text and other leaf nodes. use <div> container!\r\n      const child = item.firstElementChild;\r\n      if (!child) { console.error(`Error: GridStack.resizeToContent() widget id:${n.id} '${GridStack.resizeToContentParent}'.firstElementChild is null, make sure to have a div like container. Skipping sizing.`); return; }\r\n      wantedH = child.getBoundingClientRect().height || itemH;\r\n    }\r\n    if (itemH === wantedH) return;\r\n    height += wantedH - itemH;\r\n    let h = Math.ceil(height / cell);\r\n    // check for min/max and special sizing\r\n    const softMax = Number.isInteger(n.sizeToContent) ? n.sizeToContent as number : 0;\r\n    if (softMax && h > softMax) {\r\n      h = softMax;\r\n      el.classList.add('size-to-content-max');  // get v-scroll back\r\n    }\r\n    if (n.minH && h < n.minH) h = n.minH;\r\n    else if (n.maxH && h > n.maxH) h = n.maxH;\r\n    if (h !== n.h) {\r\n      grid._ignoreLayoutsNodeChange = true;\r\n      grid.moveNode(n, { h });\r\n      delete grid._ignoreLayoutsNodeChange;\r\n    }\r\n  }\r\n\r\n  /** call the user resize (so they can do extra work) else our build in version */\r\n  private resizeToContentCBCheck(el: GridItemHTMLElement) {\r\n    if (GridStack.resizeToContentCB) GridStack.resizeToContentCB(el);\r\n    else this.resizeToContent(el);\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?.length) {\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      const addedNodes = [...this.engine.addedNodes];\r\n      this.engine.addedNodes = [];\r\n      this._triggerEvent('added', 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?.length) {\r\n      const removedNodes = [...this.engine.removedNodes];\r\n      this.engine.removedNodes = [];\r\n      this._triggerEvent('removed', removedNodes);\r\n    }\r\n    return this;\r\n  }\r\n\r\n  /** @internal */\r\n  protected _triggerEvent(type: string, data?: GridStackNode[]): GridStack {\r\n    let event = data ? new CustomEvent(type, { bubbles: false, detail: data }) : new Event(type);\r\n    this.el.dispatchEvent(event);\r\n    return this;\r\n  }\r\n\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      const styleLocation = this.opts.styleInHead ? undefined : this.el.parentNode as HTMLElement;\r\n      Utils.removeStylesheet(this._styleSheetClass, styleLocation);\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    if (maxH === undefined) maxH = this.getRow();\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      // insert style to parent (instead of 'head' by default) to support WebComponent\r\n      const styleLocation = this.opts.styleInHead ? undefined : this.el.parentNode as HTMLElement;\r\n      this._styles = Utils.createStylesheet(this._styleSheetClass, styleLocation, {\r\n        nonce: this.opts.nonce,\r\n      });\r\n      if (!this._styles) return this;\r\n      this._styles._max = 0;\r\n\r\n      // these are done once only\r\n      Utils.addCSSRule(this._styles, prefix, `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-n`, `top: ${top};`);\r\n      Utils.addCSSRule(this._styles, `${prefix} > .ui-resizable-s`, `bottom: ${bottom}`);\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        Utils.addCSSRule(this._styles, `${prefix}[gs-y=\"${i}\"]`, `top: ${getHeight(i)}`);\r\n        Utils.addCSSRule(this._styles, `${prefix}[gs-h=\"${i + 1}\"]`, `height: ${getHeight(i + 1)}`); // start at 2\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    const parent = this.parentGridItem;\r\n    let row = this.getRow() + this._extraDragRow; // this checks for minRow already\r\n    const cellHeight = this.opts.cellHeight as number;\r\n    const unit = this.opts.cellHeightUnit;\r\n    if (!cellHeight) return this;\r\n\r\n    // check for css min height (non nested grid). TODO: support mismatch, say: min % while unit is px.\r\n    if (!parent) {\r\n      const cssMinHeight = Utils.parseHeight(getComputedStyle(this.el)['minHeight']);\r\n      if (cssMinHeight.h > 0 && cssMinHeight.unit === unit) {\r\n        const minRow = Math.floor(cssMinHeight.h / cellHeight);\r\n        if (row < minRow) {\r\n          row = minRow;\r\n        }\r\n      }\r\n    }\r\n\r\n    this.el.setAttribute('gs-current-row', String(row));\r\n    this.el.style.removeProperty('min-height');\r\n    this.el.style.removeProperty('height');\r\n    if (row) {\r\n      // nested grids have 'insert:0' to fill the space of parent by default, but we may be taller so use min-height for possible scrollbars\r\n      this.el.style[parent ? 'minHeight' : 'height'] = row * cellHeight + unit;\r\n    }\r\n\r\n    // if we're a nested grid inside an sizeToContent item, tell it to resize itself too\r\n    if (parent && !parent.grid.engine.batchMode && Utils.shouldSizeToContent(parent)) {\r\n      parent.grid.resizeToContentCBCheck(parent.el);\r\n    }\r\n\r\n    return this;\r\n  }\r\n\r\n  /** @internal */\r\n  protected _prepareElement(el: GridItemHTMLElement, triggerAddEvent = false, node?: GridStackNode): GridStack {\r\n    node = node || this._readAttr(el);\r\n    el.gridstackNode = node;\r\n    node.el = el;\r\n    node.grid = this;\r\n    node = this.engine.addNode(node, triggerAddEvent);\r\n\r\n    // write the dom sizes and class\r\n    this._writeAttr(el, node);\r\n    el.classList.add(gridDefaults.itemClass, this.opts.itemClass);\r\n    const sizeToContent = Utils.shouldSizeToContent(node);\r\n    sizeToContent ? el.classList.add('size-to-content') : el.classList.remove('size-to-content');\r\n    if (sizeToContent) this.resizeToContentCheck(false, 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    n.w > 1 ? el.setAttribute('gs-w', String(n.w)) : el.removeAttribute('gs-w');\r\n    n.h > 1 ? el.setAttribute('gs-h', String(n.h)) : el.removeAttribute('gs-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      noResize: 'gs-no-resize',\r\n      noMove: 'gs-no-move',\r\n      locked: 'gs-locked',\r\n      id: 'gs-id',\r\n    };\r\n    for (const key in attrs) {\r\n      if (node[key]) { // 0 is valid for x,y only but done above already and not in list anyway\r\n        el.setAttribute(attrs[key], String(node[key]));\r\n      } 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, clearDefaultAttr = true): GridStackWidget {\r\n    let n: GridStackNode = {};\r\n    n.x = Utils.toNumber(el.getAttribute('gs-x'));\r\n    n.y = Utils.toNumber(el.getAttribute('gs-y'));\r\n    n.w = Utils.toNumber(el.getAttribute('gs-w'));\r\n    n.h = Utils.toNumber(el.getAttribute('gs-h'));\r\n    n.autoPosition = Utils.toBool(el.getAttribute('gs-auto-position'));\r\n    n.noResize = Utils.toBool(el.getAttribute('gs-no-resize'));\r\n    n.noMove = Utils.toBool(el.getAttribute('gs-no-move'));\r\n    n.locked = Utils.toBool(el.getAttribute('gs-locked'));\r\n    n.id = el.getAttribute('gs-id');\r\n\r\n    // read but never written out\r\n    n.maxW = Utils.toNumber(el.getAttribute('gs-max-w'));\r\n    n.minW = Utils.toNumber(el.getAttribute('gs-min-w'));\r\n    n.maxH = Utils.toNumber(el.getAttribute('gs-max-h'));\r\n    n.minH = Utils.toNumber(el.getAttribute('gs-min-h'));\r\n\r\n    // v8.x optimization to reduce un-needed attr that don't render or are default CSS\r\n    if (clearDefaultAttr) {\r\n      if (n.w === 1) el.removeAttribute('gs-w');\r\n      if (n.h === 1) el.removeAttribute('gs-h');\r\n      if (n.maxW) el.removeAttribute('gs-max-w');\r\n      if (n.minW) el.removeAttribute('gs-min-w');\r\n      if (n.maxH) el.removeAttribute('gs-max-h');\r\n      if (n.minH) el.removeAttribute('gs-min-h');\r\n    }\r\n\r\n    // remove any key not found (null or false which is default)\r\n    for (const key in n) {\r\n      if (!n.hasOwnProperty(key)) return;\r\n      if (!n[key] && n[key] !== 0) { // 0 can be valid value (x,y only really)\r\n        delete n[key];\r\n      }\r\n    }\r\n\r\n    return n;\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 - 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 cellHeight==='auto' (square)\r\n   * or `sizeToContent` gridItem options.\r\n   */\r\n  public onResize(): GridStack {\r\n    if (!this.el?.clientWidth) return; // return if we're gone or no size yet (will get called again)\r\n    if (this.prevWidth === this.el.clientWidth) return; // no-op\r\n    this.prevWidth = this.el.clientWidth\r\n    // console.log('onResize ', this.el.clientWidth);\r\n\r\n    this.batchUpdate();\r\n\r\n    // see if we're nested and take our column count from our parent....\r\n    let columnChanged = false;\r\n    if (this._autoColumn && this.parentGridItem) {\r\n      if (this.opts.column !== this.parentGridItem.w) {\r\n        this.column(this.parentGridItem.w, 'none');\r\n        columnChanged = true;\r\n      }\r\n    } else {\r\n      // else check for dynamic column\r\n      columnChanged = this.checkDynamicColumn();\r\n    }\r\n\r\n    // make the cells content square again\r\n    if (this._isAutoCellHeight) this.cellHeight();\r\n\r\n    // update any nested grids, or items size\r\n    this.engine.nodes.forEach(n => {\r\n      if (n.subGrid) n.subGrid.onResize()\r\n    });\r\n\r\n    if (!this._skipInitialResize) this.resizeToContentCheck(columnChanged); // wait for anim of column changed (DOM reflow before we can size correctly)\r\n    delete this._skipInitialResize;\r\n\r\n    this.batchUpdate(false);\r\n\r\n    return this;\r\n  }\r\n\r\n  /** resizes content for given node (or all) if shouldSizeToContent() is true */\r\n  private resizeToContentCheck(delay = false, n: GridStackNode = undefined) {\r\n    if (!this.engine) return; // we've been deleted in between!\r\n\r\n    // update any gridItem height with sizeToContent, but wait for DOM $animation_speed to settle if we changed column count\r\n    // TODO: is there a way to know what the final (post animation) size of the content will be so we can animate the column width and height together rather than sequentially ?\r\n    if (delay && this.hasAnimationCSS()) return setTimeout(() => this.resizeToContentCheck(false, n), 300 + 10);\r\n\r\n    if (n) {\r\n      if (Utils.shouldSizeToContent(n)) this.resizeToContentCBCheck(n.el);\r\n    } else if (this.engine.nodes.some(n => Utils.shouldSizeToContent(n))) {\r\n      const nodes = [...this.engine.nodes]; // in case order changes while resizing one\r\n      this.batchUpdate();\r\n      nodes.forEach(n => {\r\n        if (Utils.shouldSizeToContent(n)) this.resizeToContentCBCheck(n.el);\r\n      });\r\n      this.batchUpdate(false);\r\n    }\r\n    // call this regardless of shouldSizeToContent because widget might need to stretch to take available space after a resize\r\n    if (this._gsEventHandler['resizecontent']) this._gsEventHandler['resizecontent'](null, n ? [n] : this.engine.nodes);\r\n  }\r\n\r\n  /** add or remove the grid element size event handler */\r\n  protected _updateResizeEvent(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 dynamic column (i.e. doing work)\r\n    // or supporting new sizeToContent option.\r\n    const trackSize = !this.parentGridItem && (this._isAutoCellHeight || this.opts.sizeToContent || this.opts.columnOpts\r\n      || this.engine.nodes.find(n => n.sizeToContent));\r\n\r\n    if (!forceRemove && trackSize && !this.resizeObserver) {\r\n      this._sizeThrottle = Utils.throttle(() => this.onResize(), this.opts.cellHeightThrottle);\r\n      this.resizeObserver = new ResizeObserver(() => this._sizeThrottle());\r\n      this.resizeObserver.observe(this.el);\r\n      this._skipInitialResize = true; // makeWidget will originally have called on startup\r\n    } else if ((forceRemove || !trackSize) && this.resizeObserver) {\r\n      this.resizeObserver.disconnect();\r\n      delete this.resizeObserver;\r\n      delete this._sizeThrottle;\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 = '10.1.2';\r\n\r\n  /* ===========================================================================================\r\n   * drag&drop methods that used to be stubbed out and implemented in dd-gridstack.ts\r\n   * but caused loading issues in prod - see https://github.com/gridstack/gridstack.js/issues/2039\r\n   * ===========================================================================================\r\n   */\r\n\r\n  /** get the global (but static to this code) DD implementation */\r\n  public static getDD(): DDGridStack {\r\n    return dd;\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 used) in case the toolbar\r\n   * is dynamically create and needs to be set later.\r\n   * @param dragIn string selector (ex: '.sidebar .grid-stack-item') or list of dom elements\r\n   * @param dragInOptions options - see DDDragInOpt. (default: {handle: '.grid-stack-item-content', appendTo: 'body'}\r\n   * @param root optional root which defaults to document (for shadow dom pas the parent HTMLDocument)\r\n   */\r\n  public static setupDragIn(dragIn?: string | HTMLElement[], dragInOptions?: DDDragInOpt, root: HTMLElement | Document = document): void {\r\n    if (dragInOptions?.pause !== undefined) {\r\n      DDManager.pauseDrag = dragInOptions.pause;\r\n    }\r\n\r\n    dragInOptions = { ...dragInDefaultOptions, ...(dragInOptions || {}) };\r\n    let els: HTMLElement[] = (typeof dragIn === 'string') ? Utils.getElements(dragIn, root) : dragIn;\r\n    if (els.length) els?.forEach(el => {\r\n      if (!dd.isDraggable(el)) dd.dragIn(el, dragInOptions);\r\n    });\r\n  }\r\n\r\n  /**\r\n   * Enables/Disables dragging by the user of specific grid element. If you want all items, and have it affect future items, use enableMove() instead. No-op for static grids.\r\n   * IF you are looking to prevent an item from moving (due to being pushed around by another during collision) use locked property instead.\r\n   * @param els widget or selector to modify.\r\n   * @param val if true widget will be draggable, assuming the parent grid isn't noMove or static.\r\n   */\r\n  public movable(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      const n = el.gridstackNode;\r\n      if (!n) return;\r\n      val ? delete n.noMove : n.noMove = true;\r\n      this._prepareDragDropByNode(n); // init DD if need be, and adjust\r\n    });\r\n    return this;\r\n  }\r\n\r\n  /**\r\n   * Enables/Disables user resizing of specific grid element. If you want all items, and have it affect future items, use enableResize() instead. No-op for static grids.\r\n   * @param els  widget or selector to modify\r\n   * @param val  if true widget will be resizable, assuming the parent grid isn't noResize or static.\r\n   */\r\n  public resizable(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 n = el.gridstackNode;\r\n      if (!n) return;\r\n      val ? delete n.noResize : n.noResize = true;\r\n      this._prepareDragDropByNode(n); // 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   * @param recurse true (default) if sub-grids also get updated\r\n   */\r\n  public disable(recurse = true): GridStack {\r\n    if (this.opts.staticGrid) return;\r\n    this.enableMove(false, recurse);\r\n    this.enableResize(false, recurse);\r\n    this._triggerEvent('disable');\r\n    return this;\r\n  }\r\n  /**\r\n   * Re-enables widgets moving/resizing - see disable().\r\n   * Note: no-op for static grid.\r\n   * This is a shortcut for:\r\n   * @example\r\n   *  grid.enableMove(true);\r\n   *  grid.enableResize(true);\r\n   * @param recurse true (default) if sub-grids also get updated\r\n   */\r\n  public enable(recurse = true): GridStack {\r\n    if (this.opts.staticGrid) return;\r\n    this.enableMove(true, recurse);\r\n    this.enableResize(true, recurse);\r\n    this._triggerEvent('enable');\r\n    return this;\r\n  }\r\n\r\n  /**\r\n   * Enables/disables widget moving. No-op for static grids, and locally defined items still overrule\r\n   * @param recurse true (default) if sub-grids also get updated\r\n   */\r\n  public enableMove(doEnable: boolean, recurse = true): GridStack {\r\n    if (this.opts.staticGrid) return this; // can't move a static grid!\r\n    doEnable ? delete this.opts.disableDrag : this.opts.disableDrag = true; // FIRST before we update children as grid overrides #1658\r\n    this.engine.nodes.forEach(n => {\r\n      this._prepareDragDropByNode(n);\r\n      if (n.subGrid && recurse) n.subGrid.enableMove(doEnable, recurse);\r\n    });\r\n    return this;\r\n  }\r\n\r\n  /**\r\n   * Enables/disables widget resizing. No-op for static grids.\r\n   * @param recurse true (default) if sub-grids also get updated\r\n   */\r\n  public enableResize(doEnable: boolean, recurse = true): GridStack {\r\n    if (this.opts.staticGrid) return this; // can't size a static grid!\r\n    doEnable ? delete this.opts.disableResize : this.opts.disableResize = true; // FIRST before we update children as grid overrides #1658\r\n    this.engine.nodes.forEach(n => {\r\n      this._prepareDragDropByNode(n);\r\n      if (n.subGrid && recurse) n.subGrid.enableResize(doEnable, recurse);\r\n    });\r\n    return this;\r\n  }\r\n\r\n  /** @internal removes any drag&drop present (called during destroy) */\r\n  protected _removeDD(el: DDElementHost): 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    delete el.ddElement;\r\n    return this;\r\n  }\r\n\r\n  /** @internal called to add drag over to support widgets being added externally */\r\n  protected _setupAcceptWidget(): 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\r\n      // if the element is being dragged from outside, scale it down to match the grid's scale\r\n      // and slightly adjust its position relative to the mouse\r\n      if (!node.grid?.el) {\r\n        // this scales the helper down\r\n        helper.style.transform = `scale(${1 / this.dragTransform.xScale},${1 / this.dragTransform.yScale})`;\r\n        // this makes it so that the helper is well positioned relative to the mouse after scaling\r\n        const helperRect = helper.getBoundingClientRect();\r\n        helper.style.left = helperRect.x + (this.dragTransform.xScale - 1) * (event.clientX - helperRect.x) / this.dragTransform.xScale + 'px';\r\n        helper.style.top = helperRect.y + (this.dragTransform.yScale - 1) * (event.clientY - helperRect.y) / this.dragTransform.yScale + 'px';\r\n        helper.style.transformOrigin = `0px 0px`\r\n      }\r\n\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 = {\r\n        position: {\r\n          top: top * this.dragTransform.xScale,\r\n          left: left * this.dragTransform.yScale\r\n        }\r\n      };\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 || this._readAttr(el, false);\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        // 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 #2633\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) {\r\n          node = this._readAttr(el, false); // don't wipe external (e.g. drag toolbar) attr #2354\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          delete node.x;\r\n          delete node.y;\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        GridStack._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          // if we were created as temporary nested grid, go back to before state\r\n          if (this._isTemp) {\r\n            this.removeAsSubGrid(node);\r\n          }\r\n        }\r\n        return false; // prevent parent from receiving msg (which may be grid as well)\r\n      })\r\n      /**\r\n       * end - releasing the mouse\r\n       */\r\n      .on(this.el, 'drop', (event, el: 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        const 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        // disable animation when replacing a placeholder (already positioned) with actual content\r\n        const noAnim = wasAdded && this.opts.animate;\r\n        if (noAnim) this.setAnimation(false);\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?.grid && origNode.grid !== this) {\r\n          let oGrid = origNode.grid;\r\n          oGrid.engine.removeNodeFromLayoutCache(origNode);\r\n          oGrid.engine.removedNodes.push(origNode);\r\n          oGrid._triggerRemoveEvent()._triggerChangeEvent();\r\n          // if it's an empty sub-grid that got auto-created, nuke it\r\n          if (oGrid.parentGridItem && !oGrid.engine.nodes.length && oGrid.opts.subGridDynamic) {\r\n            oGrid.removeAsSubGrid();\r\n          }\r\n        }\r\n\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        delete node.grid._isTemp;\r\n        dd.off(el, 'drag');\r\n        // if we made a copy ('helper' which is temp) of the original node then insert a copy, else we move the original node (#1102)\r\n        // as the helper will be nuked by jquery-ui otherwise. TODO: update old code path\r\n        if (helper !== el) {\r\n          helper.remove();\r\n          el.gridstackNode = origNode; // original item (left behind) is re-stored to pre dragging as the node now has drop info\r\n          if (wasAdded) {\r\n            el = el.cloneNode(true) 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        let subGrid = node.subGrid?.el?.gridstack; // set when actual sub-grid present\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.el.appendChild(el);// @ts-ignore // TODO: now would be ideal time to _removeHelperStyle() overriding floating styles (native only)\r\n        this._prepareElement(el, true, node);\r\n        if (subGrid) {\r\n          subGrid.parentGridItem = node;\r\n          if (!subGrid.opts.styleInHead) subGrid._updateStyles(true); // re-create sub-grid styles now that we've moved\r\n        }\r\n        this._updateContainerHeight();\r\n        this.engine.addedNodes.push(node);// @ts-ignore\r\n        this._triggerAddEvent();// @ts-ignore\r\n        this._triggerChangeEvent();\r\n\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        // delay adding animation back, but check to make sure grid (opt) is still around\r\n        if (noAnim) setTimeout(() => { if (this.opts) this.setAnimation(this.opts.animate) });\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\n  private static _itemRemoving(el: GridItemHTMLElement, remove: boolean) {\r\n    const node = el ? el.gridstackNode : undefined;\r\n    if (!node?.grid || el.classList.contains(node.grid.opts.removableOptions.decline)) 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\n  protected _setupRemoveDrop(): GridStack {\r\n    if (typeof this.opts.removable !== 'string') return this;\r\n    let trashEl = document.querySelector(this.opts.removable) as HTMLElement;\r\n    if (!trashEl) return this;\r\n\r\n    // only register ONE static 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 (!this.opts.staticGrid && !dd.isDroppable(trashEl)) {\r\n      dd.droppable(trashEl, this.opts.removableOptions)\r\n        .on(trashEl, 'dropover', (event, el) => GridStack._itemRemoving(el, true))\r\n        .on(trashEl, 'dropout', (event, el) => GridStack._itemRemoving(el, false));\r\n    }\r\n    return this;\r\n  }\r\n\r\n  /** @internal prepares the element for drag&drop */\r\n  protected _prepareDragDropByNode(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: MouseEvent, 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._event;\r\n        delete node._lastTried;\r\n        const widthChanged = node.w !== node._orig.w;\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 grid = el.gridstackNode.grid;\r\n          if (grid._gsEventHandler[event.type]) {\r\n            grid._gsEventHandler[event.type](event, target);\r\n          }\r\n          grid.engine.nodes.push(node); // temp add it back so we can proper remove it next\r\n          grid.removeWidget(el, true, true);\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        if (event.type === 'resizestop') {\r\n          if (Number.isInteger(node.sizeToContent)) node.sizeToContent = node.h; // new soft limit\r\n          this.resizeToContentCheck(widthChanged, node); // wait for width animation if changed\r\n        }\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 handles actual drag/resize start */\r\n  protected _onStartMoving(el: GridItemHTMLElement, event: Event, ui: DDUIData, node: GridStackNode, cellWidth: number, cellHeight: number): void {\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    // if the element is inside a grid, it has already been scaled\r\n    // we can use that as a scale reference\r\n    if (node.grid?.el) {\r\n      this.dragTransform = Utils.getValuesFromTransformedElement(el);\r\n    }\r\n    // if the element is being dragged from outside (not from any grid)\r\n    // we use the grid as the transformation reference, since the helper is not subject to transformation\r\n    else if (this.placeholder && this.placeholder.closest('.grid-stack')) {\r\n      const gridEl = this.placeholder.closest('.grid-stack') as HTMLElement;\r\n      this.dragTransform = Utils.getValuesFromTransformedElement(gridEl);\r\n    }\r\n    // Fallback\r\n    else {\r\n      this.dragTransform = {\r\n        xScale: 1,\r\n        xOffset: 0,\r\n        yScale: 1,\r\n        yOffset: 0,\r\n      }\r\n    }\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 handles actual drag/resize */\r\n  protected _dragOrResize(el: GridItemHTMLElement, event: MouseEvent, ui: DDUIData, node: GridStackNode, cellWidth: number, cellHeight: number): void {\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      if (this.opts.draggable.scroll !== false) {\r\n        Utils.updateScrollPosition(el, ui.position, distance);\r\n      }\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, 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._event = event;\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.onResize();\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  /** @internal called when item leaving our area by either cursor dropout event\r\n   * or shape is outside our boundaries. remove it from us, and mark temporary if this was\r\n   * our item to start with else restore prev node values from prev grid it came from.\r\n   */\r\n  protected _leave(el: GridItemHTMLElement, helper?: GridItemHTMLElement): void {\r\n    let node = el.gridstackNode;\r\n    if (!node) return;\r\n\r\n    helper = helper || el;\r\n    // restore the scale of the helper on leave\r\n    helper.style.transform = 'scale(1)';\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      GridStack._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  // 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 * dd-gridstack.ts 10.1.2\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, GridStackElement, DDDragInOpt } from './types';\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  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 n = dEl.el.gridstackNode;\r\n        const grid = n.grid;\r\n        let handles = dEl.el.getAttribute('gs-resize-handles') || grid.opts.resizable.handles || 'e,s,se';\r\n        if (handles === 'all') handles = 'n,e,s,w,se,sw,ne,nw';\r\n        // NOTE: keep the resize handles as e,w don't have enough space (10px) to show resize corners anyway. limit during drag instead\r\n        // restrict vertical resize if height is done to match content anyway... odd to have it spring back\r\n        // if (Utils.shouldSizeToContent(n, true)) {\r\n        //   const doE = handles.indexOf('e') !== -1;\r\n        //   const doW = handles.indexOf('w') !== -1;\r\n        //   handles = doE ? (doW ? 'e,w' : 'e') : (doW ? 'w' : '');\r\n        // }\r\n        const 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.parentGridItem && !grid.opts.dragOut) ? grid.el.parentElement : (grid.opts.draggable.containment || null),\r\n            start: opts.start,\r\n            stop: opts.stop,\r\n            drag: opts.drag\r\n          }\r\n        });\r\n      }\r\n    });\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"],"names":["root","factory","exports","module","define","amd","self","__webpack_require__","definition","key","o","Object","defineProperty","enumerable","get","obj","prop","prototype","hasOwnProperty","call","Utils","static","els","document","doc","undefined","isNaN","el","getElementById","list","querySelectorAll","length","Array","from","substring","querySelector","n","strict","grid","sizeToContent","opts","a","b","y","h","x","w","isIntercepted","x0","x1","y0","y1","nodes","dir","und","sort","diffY","id","find","parent","options","style","createElement","nonce","setAttribute","styleSheet","cssText","appendChild","createTextNode","insertBefore","firstChild","getElementsByTagName","sheet","parentNode","remove","selector","rules","addRule","insertRule","v","toLowerCase","Boolean","value","Number","val","unit","match","Error","parseFloat","target","sources","forEach","source","this","defaults","keys","doMinMax","minW","minH","maxW","maxH","node","i","removeEl","autoPosition","noResize","noMove","locked","func","delay","isWaiting","args","setTimeout","position","removeProperty","left","top","width","height","scrollingElement","documentElement","getComputedStyle","test","overflow","overflowY","getScrollElement","parentElement","distance","rect","getBoundingClientRect","innerHeightOrClientHeight","window","innerHeight","clientHeight","bottom","offsetDiffDown","offsetDiffUp","scrollEl","prevScroll","scrollTop","offsetHeight","Math","abs","event","offsetTop","pointerPosY","clientY","scrollBy","behavior","skipFields","ret","clone","k","cloneDeep","cloneNode","removeAttribute","getElement","styles","s","isArray","e","info","evt","type","button","which","buttons","bubbles","cancelable","dataTransfer","p","simulatedType","simulatedEvent","createEvent","initMouseEvent","screenX","screenY","clientX","ctrlKey","altKey","shiftKey","metaKey","dispatchEvent","transformReference","addElStyles","opacity","zIndex","transformValues","removeChild","xScale","yScale","xOffset","yOffset","GridStackEngine","addedNodes","removedNodes","column","maxRow","_float","float","onChange","batchUpdate","flag","doPack","batchMode","_prevFloat","cleanNodes","saveInitial","_packNodes","_notify","_useEntireRowArea","nn","_hasLocked","_moving","_skipDown","_fixCollisions","collide","opt","sortNodes","nested","swap","area","skip","didMove","newOpt","pack","moved","moveNode","copyPos","skip2","skipId","_id","skip2Id","collideAll","filter","directionCollideCoverage","collides","_rect","r0","r","overMax","r2","yOver","MAX_VALUE","xOver","over","min","cacheRects","right","_doSwap","_dirty","touching","isTouching","t","isAreaEmpty","compact","layout","doSort","wasBatch","wasColumnResize","_inColumnResize","copyNodes","index","after","addNode","_updating","_orig","newY","prepareNode","resizing","_idSeq","sanitizeMinMax","nodeBoundFix","before","max","findCacheLayout","copy","cacheOneLayout","samePos","getDirtyNodes","verify","dirtyNodes","concat","_lastTried","some","restoreInitial","findEmptyPosition","nodeList","found","floor","box","triggerAddEvent","skipCollision","_temporaryRemoved","_removeDOM","push","removeNode","removeDOM","triggerEvent","_isAboutToRemove","removeAll","_layouts","moveNodeCheck","changedPosConstrain","clonedNode","map","canMove","getRow","gridstackNode","c","willItFit","_willFitPos","cleanupNode","content","wasUndefinedPack","forceCollide","prevPos","needToMove","activeDrag","subGridDynamic","_isTemp","areaIntercept","a1","a2","makeSubGrid","reduce","row","beginUpdate","endUpdate","save","saveElement","saveCB","len","wl","l","removeInternalForSave","layoutsNodesChange","ratio","round","columnChanged","prevColumn","doCompact","cacheLayout","newNodes","cacheNodes","lastIndex","cacheNode","j","findIndex","splice","move","scale","clear","existing","n2","removeNodeFromLayoutCache","gridDefaults","alwaysShowResizeHandle","animate","auto","cellHeight","cellHeightThrottle","cellHeightUnit","draggable","handle","appendTo","scroll","itemClass","margin","marginUnit","minRow","placeholderClass","placeholderText","removableOptions","accept","decline","resizable","handles","rtl","dragInDefaultOptions","DDManager","isTouch","DocumentTouch","navigator","maxTouchPoints","msMaxTouchPoints","DDTouch","simulateMouseEvent","touches","preventDefault","touch","changedTouches","simulatePointerMouseEvent","touchstart","touchHandled","touchmove","touchend","pointerLeaveTimeout","clearTimeout","wasDragging","dragElement","pointerdown","pointerType","releasePointerCapture","pointerId","pointerenter","pointerleave","DDResizableHandle","constructor","host","option","moving","_mouseDown","bind","_mouseMove","_mouseUp","_init","classList","add","prefix","userSelect","addEventListener","destroy","mouseDownEvent","removeEventListener","capture","passive","stopPropagation","_triggerEvent","name","DDBaseImplement","_eventRegister","disabled","_disabled","on","callback","off","enable","disable","eventName","DDResizable","super","rectScale","_ui","containmentRect","newRect","originalRect","scrolled","temporalRect","size","_mouseOver","_mouseOut","_setupAutoHide","autoHide","_setupHandlers","_removeHandlers","updateOption","updateHandles","updateAutoHide","overResizeElement","handlers","split","trim","start","_resizeStart","stop","_resizeStop","_resizing","shouldSizeToContent","scrollY","startEvent","_setupHelper","_applyChange","ev","initEvent","_getChange","resize","_cleanHelper","elOriginStyleVal","_originStyleProp","parentOriginStylePosition","dragTransform","getValuesFromTransformedElement","oEvent","offsetX","offsetY","indexOf","constrain","_constrainSize","oWidth","oHeight","maxWidth","MAX_SAFE_INTEGER","minWidth","maxHeight","minHeight","containmentEl","scaleReciprocal","DDDraggable","handleName","dragEl","contains","forDestroy","dragTimeout","helper","mouseHandled","closest","cancel","dragging","dropElement","activeElement","blur","_callDrag","drag","ui","_dragFollow","pauseDrag","pause","isInteger","ddElement","ddDroppable","_createHelper","_setupHelperContainmentStyle","helperContainment","dragOffset","_getDragOffset","_setupHelperStyle","_removeHelperStyle","drop","body","dragElementOriginStyle","originStyleProp","pointerEvents","willChange","transition","offset","offsetLeft","xformOffsetX","xformOffsetY","targetOffset","DDDroppable","_mouseEnter","_mouseLeave","_setupAccept","_canDrop","calledByEnter","out","parentDrop","matches","DDElement","ddDraggable","ddResizable","setupDraggable","cleanDraggable","setupResizable","cleanResizable","setupDroppable","cleanDroppable","dd","_getDDElements","dEl","getAttribute","dragIn","droppable","_accept","isDroppable","isDraggable","isResizable","create","hosts","getElements","init","d","GridStack","elOrString","getGridElement","gridstack","console","error","grids","getGridElements","children","load","addRemoveCB","implementation","createHTMLDocument","innerHTML","class","engineClass","placeholder","_placeholder","placeholderChild","className","_gsEventHandler","_extraDragRow","rowAttr","toNumber","_alwaysShowResizeHandle","bk","columnOpts","breakpoints","oldOpts","oneColumnModeDomSort","log","oneColumnSize","disableOneColumnMode","oneSize","oneColumn","resp","columnWidth","columnMax","staticGrid","toBool","handleClass","_initMargin","checkDynamicColumn","direction","grandParent","parentGridItem","subGrid","_isAutoCellHeight","_styleSheetClass","_setStaticClass","engine","getColumn","cbNodes","_writePosAttr","_updateStyles","getGridItems","_prepareElement","setAnimation","_setupRemoveDrop","_setupAcceptWidget","_updateResizeEvent","addWidget","arguments","domAttr","_readAttr","_writeAttr","_insertNotAppend","prepend","makeWidget","ops","nodeToAdd","saveContent","subGridTemplate","autoColumn","subGridOpts","newItem","newItemOpt","_removeDD","_prepareDragDropByNode","update","addGrid","_autoColumn","_event","removeAsSubGrid","nodeThatRemoved","pGrid","removeWidget","saveGridOpt","sub","listOrOpt","marginBottom","marginTop","marginRight","marginLeft","origShow","removeInternalAndSame","items","addRemove","addAfter","haveCoord","_ignoreLayoutsNodeChange","prevCB","removed","noAnim","updateNodes","item","_updateContainerHeight","_triggerRemoveEvent","_triggerAddEvent","_triggerChangeEvent","getCellHeight","forcePixel","fontSize","rows","parseInt","marginDiff","cellWidth","data","parseHeight","resizeToContentCheck","_widthOrContainer","forBreakpoint","breakpointForWindow","innerWidth","clientWidth","newColumn","oldColumn","offAll","setStatic","_removeStylesheet","getFloat","getCellFromPixel","useDocRelative","containerPos","relativeLeft","relativeTop","rowHeight","noData","detail","doAnimate","hasAnimationCSS","updateClass","recurse","warn","m","itemContent","styleInHead","changed","ddChanged","widthChanged","resizeToContent","cell","resizeToContentParent","padding","itemH","wantedH","child","firstElementChild","ceil","softMax","resizeToContentCBCheck","resizeToContentCB","getMargin","elements","CustomEvent","Event","_styles","styleLocation","removeStylesheet","forceUpdate","createStylesheet","_max","addCSSRule","getHeight","cssMinHeight","String","attrs","clearDefaultAttr","classes","onResize","prevWidth","_skipInitialResize","forceRemove","trackSize","resizeObserver","disconnect","_sizeThrottle","throttle","ResizeObserver","observe","margins","dragInOptions","movable","enableMove","enableResize","doEnable","disableDrag","disableResize","_initDD","acceptWidgets","removable","onDrag","transform","helperRect","transformOrigin","_onStartMoving","_dragOrResize","canAccept","_leave","_isExternal","offsetWidth","_gridstackNodeOrig","_itemRemoving","wasAdded","origNode","oGrid","removePositioningStyles","trashEl","onStartMoving","dragOrResize","onEndMoving","gridEl","_lastUiPosition","_prevYPix","mLeft","mRight","mTop","mBottom","mHeight","mWidth","updateScrollPosition","prev","extra","updateScrollResize","commit","Engine","GDRev"],"sourceRoot":""}