diff -r 3d4e9c994f10 -r a86126ab1dd4 wp/wp-includes/js/dist/priority-queue.js
--- a/wp/wp-includes/js/dist/priority-queue.js	Tue Oct 22 16:11:46 2019 +0200
+++ b/wp/wp-includes/js/dist/priority-queue.js	Tue Dec 15 13:49:49 2020 +0100
@@ -82,18 +82,87 @@
 /******/
 /******/
 /******/ 	// Load entry module and return exports
-/******/ 	return __webpack_require__(__webpack_require__.s = 346);
+/******/ 	return __webpack_require__(__webpack_require__.s = 467);
 /******/ })
 /************************************************************************/
 /******/ ({
 
-/***/ 346:
+/***/ 467:
 /***/ (function(module, __webpack_exports__, __webpack_require__) {
 
 "use strict";
+// ESM COMPAT FLAG
 __webpack_require__.r(__webpack_exports__);
-/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "createQueue", function() { return createQueue; });
-var requestIdleCallback = window.requestIdleCallback ? window.requestIdleCallback : window.requestAnimationFrame;
+
+// EXPORTS
+__webpack_require__.d(__webpack_exports__, "createQueue", function() { return /* binding */ build_module_createQueue; });
+
+// CONCATENATED MODULE: ./node_modules/@wordpress/priority-queue/build-module/request-idle-callback.js
+/**
+ * @typedef {( timeOrDeadline: IdleDeadline | number ) => void} Callback
+ */
+
+/**
+ * @return {(callback: Callback) => void} RequestIdleCallback
+ */
+function createRequestIdleCallback() {
+  if (typeof window === 'undefined') {
+    return function (callback) {
+      setTimeout(function () {
+        return callback(Date.now());
+      }, 0);
+    };
+  }
+
+  return window.requestIdleCallback || window.requestAnimationFrame;
+}
+/* harmony default export */ var request_idle_callback = (createRequestIdleCallback());
+
+// CONCATENATED MODULE: ./node_modules/@wordpress/priority-queue/build-module/index.js
+/**
+ * Internal dependencies
+ */
+
+/**
+ * Enqueued callback to invoke once idle time permits.
+ *
+ * @typedef {()=>void} WPPriorityQueueCallback
+ */
+
+/**
+ * An object used to associate callbacks in a particular context grouping.
+ *
+ * @typedef {{}} WPPriorityQueueContext
+ */
+
+/**
+ * Function to add callback to priority queue.
+ *
+ * @typedef {(element:WPPriorityQueueContext,item:WPPriorityQueueCallback)=>void} WPPriorityQueueAdd
+ */
+
+/**
+ * Function to flush callbacks from priority queue.
+ *
+ * @typedef {(element:WPPriorityQueueContext)=>boolean} WPPriorityQueueFlush
+ */
+
+/**
+ * Reset the queue.
+ *
+ * @typedef {()=>void} WPPriorityQueueReset
+ */
+
+/**
+ * Priority queue instance.
+ *
+ * @typedef {Object} WPPriorityQueue
+ *
+ * @property {WPPriorityQueueAdd}   add   Add callback to queue for context.
+ * @property {WPPriorityQueueFlush} flush Flush queue for context.
+ * @property {WPPriorityQueueReset} reset Reset queue.
+ */
+
 /**
  * Creates a context-aware queue that only executes
  * the last task of a given context.
@@ -114,28 +183,61 @@
  * queue.add( ctx2, () => console.log( 'This will be printed second' ) );
  *```
  *
- * @return {Object} Queue object with `add` and `flush` methods.
+ * @return {WPPriorityQueue} Queue object with `add`, `flush` and `reset` methods.
  */
 
-var createQueue = function createQueue() {
+var build_module_createQueue = function createQueue() {
+  /** @type {WPPriorityQueueContext[]} */
   var waitingList = [];
+  /** @type {WeakMap<WPPriorityQueueContext,WPPriorityQueueCallback>} */
+
   var elementsMap = new WeakMap();
   var isRunning = false;
+  /* eslint-disable jsdoc/valid-types */
+
+  /**
+   * Callback to process as much queue as time permits.
+   *
+   * @param {IdleDeadline|number} deadline Idle callback deadline object, or
+   *                                       animation frame timestamp.
+   */
+
+  /* eslint-enable */
 
   var runWaitingList = function runWaitingList(deadline) {
+    var hasTimeRemaining = typeof deadline === 'number' ? function () {
+      return false;
+    } : function () {
+      return deadline.timeRemaining() > 0;
+    };
+
     do {
       if (waitingList.length === 0) {
         isRunning = false;
         return;
       }
 
-      var nextElement = waitingList.shift();
-      elementsMap.get(nextElement)();
+      var nextElement =
+      /** @type {WPPriorityQueueContext} */
+      waitingList.shift();
+      var callback =
+      /** @type {WPPriorityQueueCallback} */
+      elementsMap.get(nextElement);
+      callback();
       elementsMap.delete(nextElement);
-    } while (deadline && deadline.timeRemaining && deadline.timeRemaining() > 0);
+    } while (hasTimeRemaining());
 
-    requestIdleCallback(runWaitingList);
+    request_idle_callback(runWaitingList);
   };
+  /**
+   * Add a callback to the queue for a given context.
+   *
+   * @type {WPPriorityQueueAdd}
+   *
+   * @param {WPPriorityQueueContext}  element Context object.
+   * @param {WPPriorityQueueCallback} item    Callback function.
+   */
+
 
   var add = function add(element, item) {
     if (!elementsMap.has(element)) {
@@ -146,24 +248,52 @@
 
     if (!isRunning) {
       isRunning = true;
-      requestIdleCallback(runWaitingList);
+      request_idle_callback(runWaitingList);
     }
   };
+  /**
+   * Flushes queue for a given context, returning true if the flush was
+   * performed, or false if there is no queue for the given context.
+   *
+   * @type {WPPriorityQueueFlush}
+   *
+   * @param {WPPriorityQueueContext} element Context object.
+   *
+   * @return {boolean} Whether flush was performed.
+   */
+
 
   var flush = function flush(element) {
     if (!elementsMap.has(element)) {
       return false;
     }
 
-    elementsMap.delete(element);
     var index = waitingList.indexOf(element);
     waitingList.splice(index, 1);
+    var callback =
+    /** @type {WPPriorityQueueCallback} */
+    elementsMap.get(element);
+    elementsMap.delete(element);
+    callback();
     return true;
   };
+  /**
+   * Reset the queue without running the pending callbacks.
+   *
+   * @type {WPPriorityQueueReset}
+   */
+
+
+  var reset = function reset() {
+    waitingList = [];
+    elementsMap = new WeakMap();
+    isRunning = false;
+  };
 
   return {
     add: add,
-    flush: flush
+    flush: flush,
+    reset: reset
   };
 };