···

       
2
       
 
       
const mutationObservers: Map<HTMLElement, MutationObserver> = new Map();

     

       
3
       
 
       
const resizeListeners: Map<HTMLElement, Array<() => void>> = new Map();

     

       
4
       
 
       


     

       
5
       
-
       
const resizeObserver = new ResizeObserver(entries => {

     

       
6
       
-
       
  const parents = new Set<Element>();

     

       
7
       
-
       
  for (let i = 0; i < entries.length; i++) {

     

       
8
       
-
       
    const parent = entries[i].target.parentElement;

     

       
9
       
-
       
    if (parent && !parents.has(parent)) {

     

       
10
       
-
       
      parents.add(parent);

     

       
11
       
-
       
      const listeners = resizeListeners.get(parent) || [];

     

       
12
       
-
       
      for (let i = 0; i < listeners.length; i++) listeners[i]();

     

       
13
       
-
       
    }

     

       
14
       
-
       
  }

     

       
15
       
-
       
});

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
16
       
 
       


     

       
17
       
 
       
export function observeScrollArea(

     

       
18
       
 
       
  element: HTMLElement,

     
···

       
41
       
 
       
        for (let j = 0; j < entry.addedNodes.length; j++) {

     

       
42
       
 
       
          const node = entry.addedNodes[j];

     

       
43
       
 
       
          if (node.nodeType === Node.ELEMENT_NODE) {

     

       
44
       
-
       
            resizeObserver.observe(node as Element, resizeOptions);

     

       
45
       
 
       
          }

     

       
46
       
 
       
        }

     

       
47
       
 
       


     

       
48
       
 
       
        for (let j = 0; j < entry.removedNodes.length; j++) {

     

       
49
       
 
       
          const node = entry.removedNodes[j];

     

       
50
       
 
       
          if (node.nodeType === Node.ELEMENT_NODE) {

     

       
51
       
-
       
            resizeObserver.unobserve(node as Element);

     

       
52
       
 
       
          }

     

       
53
       
 
       
        }

     

       
54
       
 
       
      }

     
···

       
58
       
 
       
      const childNodes = element.childNodes;

     

       
59
       
 
       
      for (let i = 0; i < childNodes.length; i++)

     

       
60
       
 
       
        if (childNodes[i].nodeType === Node.ELEMENT_NODE)

     

       
61
       
-
       
          resizeObserver.observe(childNodes[i] as Element, resizeOptions);

     

       
62
       
 
       
      mutationObserver.observe(element, { childList: true });

     

       
63
       
 
       
    });

     

       
64
       
 
       


     
···

       
77
       
 
       
      const childNodes = element.childNodes;

     

       
78
       
 
       
      for (let i = 0; i < childNodes.length; i++)

     

       
79
       
 
       
        if (childNodes[i].nodeType === Node.ELEMENT_NODE)

     

       
80
       
-
       
          resizeObserver.unobserve(childNodes[i] as Element);

     

       
81
       
 
       


     

       
82
       
 
       
      resizeListeners.delete(element);

     

       
83
       
 
       
      mutationObservers.delete(element);

     

···

       
2
       
 
       
const mutationObservers: Map<HTMLElement, MutationObserver> = new Map();

     

       
3
       
 
       
const resizeListeners: Map<HTMLElement, Array<() => void>> = new Map();

     

       
4
       
 
       


     

       
5
       
+
       
const resizeObserver =

     

       
6
       
+
       
  typeof ResizeObserver !== 'undefined'

     

       
7
       
+
       
    ? new ResizeObserver(entries => {

     

       
8
       
+
       
        const parents = new Set<Element>();

     

       
9
       
+
       
        for (let i = 0; i < entries.length; i++) {

     

       
10
       
+
       
          const parent = entries[i].target.parentElement;

     

       
11
       
+
       
          if (parent && !parents.has(parent)) {

     

       
12
       
+
       
            parents.add(parent);

     

       
13
       
+
       
            const listeners = resizeListeners.get(parent) || [];

     

       
14
       
+
       
            for (let i = 0; i < listeners.length; i++) listeners[i]();

     

       
15
       
+
       
          }

     

       
16
       
+
       
        }

     

       
17
       
+
       
      })

     

       
18
       
+
       
    : undefined;

     

       
19
       
 
       


     

       
20
       
 
       
export function observeScrollArea(

     

       
21
       
 
       
  element: HTMLElement,

     
···

       
44
       
 
       
        for (let j = 0; j < entry.addedNodes.length; j++) {

     

       
45
       
 
       
          const node = entry.addedNodes[j];

     

       
46
       
 
       
          if (node.nodeType === Node.ELEMENT_NODE) {

     

       
47
       
+
       
            resizeObserver!.observe(node as Element, resizeOptions);

     

       
48
       
 
       
          }

     

       
49
       
 
       
        }

     

       
50
       
 
       


     

       
51
       
 
       
        for (let j = 0; j < entry.removedNodes.length; j++) {

     

       
52
       
 
       
          const node = entry.removedNodes[j];

     

       
53
       
 
       
          if (node.nodeType === Node.ELEMENT_NODE) {

     

       
54
       
+
       
            resizeObserver!.unobserve(node as Element);

     

       
55
       
 
       
          }

     

       
56
       
 
       
        }

     

       
57
       
 
       
      }

     
···

       
61
       
 
       
      const childNodes = element.childNodes;

     

       
62
       
 
       
      for (let i = 0; i < childNodes.length; i++)

     

       
63
       
 
       
        if (childNodes[i].nodeType === Node.ELEMENT_NODE)

     

       
64
       
+
       
          resizeObserver!.observe(childNodes[i] as Element, resizeOptions);

     

       
65
       
 
       
      mutationObserver.observe(element, { childList: true });

     

       
66
       
 
       
    });

     

       
67
       
 
       


     
···

       
80
       
 
       
      const childNodes = element.childNodes;

     

       
81
       
 
       
      for (let i = 0; i < childNodes.length; i++)

     

       
82
       
 
       
        if (childNodes[i].nodeType === Node.ELEMENT_NODE)

     

       
83
       
+
       
          resizeObserver!.unobserve(childNodes[i] as Element);

     

       
84
       
 
       


     

       
85
       
 
       
      resizeListeners.delete(element);

     

       
86
       
 
       
      mutationObservers.delete(element);