[ Index ]

PHP Cross Reference of WordPress Trunk (Updated Daily)

title

Body

[close]

/wp-includes/js/dist/ -> hooks.js (source)

   1  this["wp"] = this["wp"] || {}; this["wp"]["hooks"] =
   2  /******/ (function(modules) { // webpackBootstrap
   3  /******/     // The module cache
   4  /******/     var installedModules = {};
   5  /******/
   6  /******/     // The require function
   7  /******/ 	function __webpack_require__(moduleId) {
   8  /******/
   9  /******/         // Check if module is in cache
  10  /******/         if(installedModules[moduleId]) {
  11  /******/             return installedModules[moduleId].exports;
  12  /******/         }
  13  /******/         // Create a new module (and put it into the cache)
  14  /******/         var module = installedModules[moduleId] = {
  15  /******/             i: moduleId,
  16  /******/             l: false,
  17  /******/             exports: {}
  18  /******/         };
  19  /******/
  20  /******/         // Execute the module function
  21  /******/         modules[moduleId].call(module.exports, module, module.exports, __webpack_require__);
  22  /******/
  23  /******/         // Flag the module as loaded
  24  /******/         module.l = true;
  25  /******/
  26  /******/         // Return the exports of the module
  27  /******/         return module.exports;
  28  /******/     }
  29  /******/
  30  /******/
  31  /******/     // expose the modules object (__webpack_modules__)
  32  /******/     __webpack_require__.m = modules;
  33  /******/
  34  /******/     // expose the module cache
  35  /******/     __webpack_require__.c = installedModules;
  36  /******/
  37  /******/     // define getter function for harmony exports
  38  /******/     __webpack_require__.d = function(exports, name, getter) {
  39  /******/         if(!__webpack_require__.o(exports, name)) {
  40  /******/             Object.defineProperty(exports, name, { enumerable: true, get: getter });
  41  /******/         }
  42  /******/     };
  43  /******/
  44  /******/     // define __esModule on exports
  45  /******/     __webpack_require__.r = function(exports) {
  46  /******/         if(typeof Symbol !== 'undefined' && Symbol.toStringTag) {
  47  /******/             Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
  48  /******/         }
  49  /******/         Object.defineProperty(exports, '__esModule', { value: true });
  50  /******/     };
  51  /******/
  52  /******/     // create a fake namespace object
  53  /******/     // mode & 1: value is a module id, require it
  54  /******/     // mode & 2: merge all properties of value into the ns
  55  /******/     // mode & 4: return value when already ns object
  56  /******/     // mode & 8|1: behave like require
  57  /******/     __webpack_require__.t = function(value, mode) {
  58  /******/         if(mode & 1) value = __webpack_require__(value);
  59  /******/         if(mode & 8) return value;
  60  /******/         if((mode & 4) && typeof value === 'object' && value && value.__esModule) return value;
  61  /******/         var ns = Object.create(null);
  62  /******/         __webpack_require__.r(ns);
  63  /******/         Object.defineProperty(ns, 'default', { enumerable: true, value: value });
  64  /******/         if(mode & 2 && typeof value != 'string') for(var key in value) __webpack_require__.d(ns, key, function(key) { return value[key]; }.bind(null, key));
  65  /******/         return ns;
  66  /******/     };
  67  /******/
  68  /******/     // getDefaultExport function for compatibility with non-harmony modules
  69  /******/     __webpack_require__.n = function(module) {
  70  /******/         var getter = module && module.__esModule ?
  71  /******/ 			function getDefault() { return module['default']; } :
  72  /******/ 			function getModuleExports() { return module; };
  73  /******/         __webpack_require__.d(getter, 'a', getter);
  74  /******/         return getter;
  75  /******/     };
  76  /******/
  77  /******/     // Object.prototype.hasOwnProperty.call
  78  /******/     __webpack_require__.o = function(object, property) { return Object.prototype.hasOwnProperty.call(object, property); };
  79  /******/
  80  /******/     // __webpack_public_path__
  81  /******/     __webpack_require__.p = "";
  82  /******/
  83  /******/
  84  /******/     // Load entry module and return exports
  85  /******/     return __webpack_require__(__webpack_require__.s = 351);
  86  /******/ })
  87  /************************************************************************/
  88  /******/ ({
  89  
  90  /***/ 17:
  91  /***/ (function(module, __webpack_exports__, __webpack_require__) {
  92  
  93  "use strict";
  94  
  95  // CONCATENATED MODULE: ./node_modules/@babel/runtime/helpers/esm/arrayWithoutHoles.js
  96  function _arrayWithoutHoles(arr) {
  97    if (Array.isArray(arr)) {
  98      for (var i = 0, arr2 = new Array(arr.length); i < arr.length; i++) {
  99        arr2[i] = arr[i];
 100      }
 101  
 102      return arr2;
 103    }
 104  }
 105  // EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/iterableToArray.js
 106  var iterableToArray = __webpack_require__(30);
 107  
 108  // CONCATENATED MODULE: ./node_modules/@babel/runtime/helpers/esm/nonIterableSpread.js
 109  function _nonIterableSpread() {
 110    throw new TypeError("Invalid attempt to spread non-iterable instance");
 111  }
 112  // CONCATENATED MODULE: ./node_modules/@babel/runtime/helpers/esm/toConsumableArray.js
 113  /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return _toConsumableArray; });
 114  
 115  
 116  
 117  function _toConsumableArray(arr) {
 118    return _arrayWithoutHoles(arr) || Object(iterableToArray["a" /* default */])(arr) || _nonIterableSpread();
 119  }
 120  
 121  /***/ }),
 122  
 123  /***/ 30:
 124  /***/ (function(module, __webpack_exports__, __webpack_require__) {
 125  
 126  "use strict";
 127  /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return _iterableToArray; });
 128  function _iterableToArray(iter) {
 129    if (Symbol.iterator in Object(iter) || Object.prototype.toString.call(iter) === "[object Arguments]") return Array.from(iter);
 130  }
 131  
 132  /***/ }),
 133  
 134  /***/ 351:
 135  /***/ (function(module, __webpack_exports__, __webpack_require__) {
 136  
 137  "use strict";
 138  __webpack_require__.r(__webpack_exports__);
 139  
 140  // CONCATENATED MODULE: ./node_modules/@wordpress/hooks/build-module/validateNamespace.js
 141  /**
 142   * Validate a namespace string.
 143   *
 144   * @param  {string} namespace The namespace to validate - should take the form
 145   *                            `vendor/plugin/function`.
 146   *
 147   * @return {boolean}             Whether the namespace is valid.
 148   */
 149  function validateNamespace(namespace) {
 150    if ('string' !== typeof namespace || '' === namespace) {
 151      // eslint-disable-next-line no-console
 152      console.error('The namespace must be a non-empty string.');
 153      return false;
 154    }
 155  
 156    if (!/^[a-zA-Z][a-zA-Z0-9_.\-\/]*$/.test(namespace)) {
 157      // eslint-disable-next-line no-console
 158      console.error('The namespace can only contain numbers, letters, dashes, periods, underscores and slashes.');
 159      return false;
 160    }
 161  
 162    return true;
 163  }
 164  
 165  /* harmony default export */ var build_module_validateNamespace = (validateNamespace);
 166  
 167  // CONCATENATED MODULE: ./node_modules/@wordpress/hooks/build-module/validateHookName.js
 168  /**
 169   * Validate a hookName string.
 170   *
 171   * @param  {string} hookName The hook name to validate. Should be a non empty string containing
 172   *                           only numbers, letters, dashes, periods and underscores. Also,
 173   *                           the hook name cannot begin with `__`.
 174   *
 175   * @return {boolean}            Whether the hook name is valid.
 176   */
 177  function validateHookName(hookName) {
 178    if ('string' !== typeof hookName || '' === hookName) {
 179      // eslint-disable-next-line no-console
 180      console.error('The hook name must be a non-empty string.');
 181      return false;
 182    }
 183  
 184    if (/^__/.test(hookName)) {
 185      // eslint-disable-next-line no-console
 186      console.error('The hook name cannot begin with `__`.');
 187      return false;
 188    }
 189  
 190    if (!/^[a-zA-Z][a-zA-Z0-9_.-]*$/.test(hookName)) {
 191      // eslint-disable-next-line no-console
 192      console.error('The hook name can only contain numbers, letters, dashes, periods and underscores.');
 193      return false;
 194    }
 195  
 196    return true;
 197  }
 198  
 199  /* harmony default export */ var build_module_validateHookName = (validateHookName);
 200  
 201  // CONCATENATED MODULE: ./node_modules/@wordpress/hooks/build-module/createAddHook.js
 202  /**
 203   * Internal dependencies
 204   */
 205  
 206  
 207  
 208  /**
 209   * Returns a function which, when invoked, will add a hook.
 210   *
 211   * @param  {Object}   hooks Stored hooks, keyed by hook name.
 212   *
 213   * @return {Function}       Function that adds a new hook.
 214   */
 215  
 216  function createAddHook(hooks) {
 217    /**
 218     * Adds the hook to the appropriate hooks container.
 219     *
 220     * @param {string}   hookName  Name of hook to add
 221     * @param {string}   namespace The unique namespace identifying the callback in the form `vendor/plugin/function`.
 222     * @param {Function} callback  Function to call when the hook is run
 223     * @param {?number}  priority  Priority of this hook (default=10)
 224     */
 225    return function addHook(hookName, namespace, callback) {
 226      var priority = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : 10;
 227  
 228      if (!build_module_validateHookName(hookName)) {
 229        return;
 230      }
 231  
 232      if (!build_module_validateNamespace(namespace)) {
 233        return;
 234      }
 235  
 236      if ('function' !== typeof callback) {
 237        // eslint-disable-next-line no-console
 238        console.error('The hook callback must be a function.');
 239        return;
 240      } // Validate numeric priority
 241  
 242  
 243      if ('number' !== typeof priority) {
 244        // eslint-disable-next-line no-console
 245        console.error('If specified, the hook priority must be a number.');
 246        return;
 247      }
 248  
 249      var handler = {
 250        callback: callback,
 251        priority: priority,
 252        namespace: namespace
 253      };
 254  
 255      if (hooks[hookName]) {
 256        // Find the correct insert index of the new hook.
 257        var handlers = hooks[hookName].handlers;
 258        var i;
 259  
 260        for (i = handlers.length; i > 0; i--) {
 261          if (priority >= handlers[i - 1].priority) {
 262            break;
 263          }
 264        }
 265  
 266        if (i === handlers.length) {
 267          // If append, operate via direct assignment.
 268          handlers[i] = handler;
 269        } else {
 270          // Otherwise, insert before index via splice.
 271          handlers.splice(i, 0, handler);
 272        } // We may also be currently executing this hook.  If the callback
 273        // we're adding would come after the current callback, there's no
 274        // problem; otherwise we need to increase the execution index of
 275        // any other runs by 1 to account for the added element.
 276  
 277  
 278        (hooks.__current || []).forEach(function (hookInfo) {
 279          if (hookInfo.name === hookName && hookInfo.currentIndex >= i) {
 280            hookInfo.currentIndex++;
 281          }
 282        });
 283      } else {
 284        // This is the first hook of its type.
 285        hooks[hookName] = {
 286          handlers: [handler],
 287          runs: 0
 288        };
 289      }
 290  
 291      if (hookName !== 'hookAdded') {
 292        doAction('hookAdded', hookName, namespace, callback, priority);
 293      }
 294    };
 295  }
 296  
 297  /* harmony default export */ var build_module_createAddHook = (createAddHook);
 298  
 299  // CONCATENATED MODULE: ./node_modules/@wordpress/hooks/build-module/createRemoveHook.js
 300  /**
 301   * Internal dependencies
 302   */
 303  
 304  
 305  
 306  /**
 307   * Returns a function which, when invoked, will remove a specified hook or all
 308   * hooks by the given name.
 309   *
 310   * @param  {Object}   hooks      Stored hooks, keyed by hook name.
 311   * @param  {boolean}     removeAll  Whether to remove all callbacks for a hookName, without regard to namespace. Used to create `removeAll*` functions.
 312   *
 313   * @return {Function}            Function that removes hooks.
 314   */
 315  
 316  function createRemoveHook(hooks, removeAll) {
 317    /**
 318     * Removes the specified callback (or all callbacks) from the hook with a
 319     * given hookName and namespace.
 320     *
 321     * @param {string}    hookName  The name of the hook to modify.
 322     * @param {string}    namespace The unique namespace identifying the callback in the form `vendor/plugin/function`.
 323     *
 324     * @return {number}             The number of callbacks removed.
 325     */
 326    return function removeHook(hookName, namespace) {
 327      if (!build_module_validateHookName(hookName)) {
 328        return;
 329      }
 330  
 331      if (!removeAll && !build_module_validateNamespace(namespace)) {
 332        return;
 333      } // Bail if no hooks exist by this name
 334  
 335  
 336      if (!hooks[hookName]) {
 337        return 0;
 338      }
 339  
 340      var handlersRemoved = 0;
 341  
 342      if (removeAll) {
 343        handlersRemoved = hooks[hookName].handlers.length;
 344        hooks[hookName] = {
 345          runs: hooks[hookName].runs,
 346          handlers: []
 347        };
 348      } else {
 349        // Try to find the specified callback to remove.
 350        var handlers = hooks[hookName].handlers;
 351  
 352        var _loop = function _loop(i) {
 353          if (handlers[i].namespace === namespace) {
 354            handlers.splice(i, 1);
 355            handlersRemoved++; // This callback may also be part of a hook that is
 356            // currently executing.  If the callback we're removing
 357            // comes after the current callback, there's no problem;
 358            // otherwise we need to decrease the execution index of any
 359            // other runs by 1 to account for the removed element.
 360  
 361            (hooks.__current || []).forEach(function (hookInfo) {
 362              if (hookInfo.name === hookName && hookInfo.currentIndex >= i) {
 363                hookInfo.currentIndex--;
 364              }
 365            });
 366          }
 367        };
 368  
 369        for (var i = handlers.length - 1; i >= 0; i--) {
 370          _loop(i);
 371        }
 372      }
 373  
 374      if (hookName !== 'hookRemoved') {
 375        doAction('hookRemoved', hookName, namespace);
 376      }
 377  
 378      return handlersRemoved;
 379    };
 380  }
 381  
 382  /* harmony default export */ var build_module_createRemoveHook = (createRemoveHook);
 383  
 384  // CONCATENATED MODULE: ./node_modules/@wordpress/hooks/build-module/createHasHook.js
 385  /**
 386   * Returns a function which, when invoked, will return whether any handlers are
 387   * attached to a particular hook.
 388   *
 389   * @param  {Object}   hooks Stored hooks, keyed by hook name.
 390   *
 391   * @return {Function}       Function that returns whether any handlers are
 392   *                          attached to a particular hook and optional namespace.
 393   */
 394  function createHasHook(hooks) {
 395    /**
 396     * Returns whether any handlers are attached for the given hookName and optional namespace.
 397     *
 398     * @param {string}  hookName  The name of the hook to check for.
 399     * @param {?string} namespace Optional. The unique namespace identifying the callback
 400     *                                      in the form `vendor/plugin/function`.
 401     *
 402     * @return {boolean} Whether there are handlers that are attached to the given hook.
 403     */
 404    return function hasHook(hookName, namespace) {
 405      // Use the namespace if provided.
 406      if ('undefined' !== typeof namespace) {
 407        return hookName in hooks && hooks[hookName].handlers.some(function (hook) {
 408          return hook.namespace === namespace;
 409        });
 410      }
 411  
 412      return hookName in hooks;
 413    };
 414  }
 415  
 416  /* harmony default export */ var build_module_createHasHook = (createHasHook);
 417  
 418  // EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/toConsumableArray.js + 2 modules
 419  var toConsumableArray = __webpack_require__(17);
 420  
 421  // CONCATENATED MODULE: ./node_modules/@wordpress/hooks/build-module/createRunHook.js
 422  
 423  
 424  /**
 425   * Returns a function which, when invoked, will execute all callbacks
 426   * registered to a hook of the specified type, optionally returning the final
 427   * value of the call chain.
 428   *
 429   * @param  {Object}   hooks          Stored hooks, keyed by hook name.
 430   * @param  {?boolean}    returnFirstArg Whether each hook callback is expected to
 431   *                                   return its first argument.
 432   *
 433   * @return {Function}                Function that runs hook callbacks.
 434   */
 435  function createRunHook(hooks, returnFirstArg) {
 436    /**
 437     * Runs all callbacks for the specified hook.
 438     *
 439     * @param  {string} hookName The name of the hook to run.
 440     * @param  {...*}   args     Arguments to pass to the hook callbacks.
 441     *
 442     * @return {*}               Return value of runner, if applicable.
 443     */
 444    return function runHooks(hookName) {
 445      if (!hooks[hookName]) {
 446        hooks[hookName] = {
 447          handlers: [],
 448          runs: 0
 449        };
 450      }
 451  
 452      hooks[hookName].runs++;
 453      var handlers = hooks[hookName].handlers; // The following code is stripped from production builds.
 454  
 455      if (false) {}
 456  
 457      for (var _len = arguments.length, args = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
 458        args[_key - 1] = arguments[_key];
 459      }
 460  
 461      if (!handlers || !handlers.length) {
 462        return returnFirstArg ? args[0] : undefined;
 463      }
 464  
 465      var hookInfo = {
 466        name: hookName,
 467        currentIndex: 0
 468      };
 469  
 470      hooks.__current.push(hookInfo);
 471  
 472      while (hookInfo.currentIndex < handlers.length) {
 473        var handler = handlers[hookInfo.currentIndex];
 474        var result = handler.callback.apply(null, args);
 475  
 476        if (returnFirstArg) {
 477          args[0] = result;
 478        }
 479  
 480        hookInfo.currentIndex++;
 481      }
 482  
 483      hooks.__current.pop();
 484  
 485      if (returnFirstArg) {
 486        return args[0];
 487      }
 488    };
 489  }
 490  
 491  /* harmony default export */ var build_module_createRunHook = (createRunHook);
 492  
 493  // CONCATENATED MODULE: ./node_modules/@wordpress/hooks/build-module/createCurrentHook.js
 494  /**
 495   * Returns a function which, when invoked, will return the name of the
 496   * currently running hook, or `null` if no hook of the given type is currently
 497   * running.
 498   *
 499   * @param  {Object}   hooks          Stored hooks, keyed by hook name.
 500   *
 501   * @return {Function}                Function that returns the current hook.
 502   */
 503  function createCurrentHook(hooks) {
 504    /**
 505     * Returns the name of the currently running hook, or `null` if no hook of
 506     * the given type is currently running.
 507     *
 508     * @return {?string}             The name of the currently running hook, or
 509     *                               `null` if no hook is currently running.
 510     */
 511    return function currentHook() {
 512      if (!hooks.__current || !hooks.__current.length) {
 513        return null;
 514      }
 515  
 516      return hooks.__current[hooks.__current.length - 1].name;
 517    };
 518  }
 519  
 520  /* harmony default export */ var build_module_createCurrentHook = (createCurrentHook);
 521  
 522  // CONCATENATED MODULE: ./node_modules/@wordpress/hooks/build-module/createDoingHook.js
 523  /**
 524   * Returns a function which, when invoked, will return whether a hook is
 525   * currently being executed.
 526   *
 527   * @param  {Object}   hooks Stored hooks, keyed by hook name.
 528   *
 529   * @return {Function}       Function that returns whether a hook is currently
 530   *                          being executed.
 531   */
 532  function createDoingHook(hooks) {
 533    /**
 534     * Returns whether a hook is currently being executed.
 535     *
 536     * @param  {?string} hookName The name of the hook to check for.  If
 537     *                            omitted, will check for any hook being executed.
 538     *
 539     * @return {boolean}             Whether the hook is being executed.
 540     */
 541    return function doingHook(hookName) {
 542      // If the hookName was not passed, check for any current hook.
 543      if ('undefined' === typeof hookName) {
 544        return 'undefined' !== typeof hooks.__current[0];
 545      } // Return the __current hook.
 546  
 547  
 548      return hooks.__current[0] ? hookName === hooks.__current[0].name : false;
 549    };
 550  }
 551  
 552  /* harmony default export */ var build_module_createDoingHook = (createDoingHook);
 553  
 554  // CONCATENATED MODULE: ./node_modules/@wordpress/hooks/build-module/createDidHook.js
 555  /**
 556   * Internal dependencies
 557   */
 558  
 559  /**
 560   * Returns a function which, when invoked, will return the number of times a
 561   * hook has been called.
 562   *
 563   * @param  {Object}   hooks Stored hooks, keyed by hook name.
 564   *
 565   * @return {Function}       Function that returns a hook's call count.
 566   */
 567  
 568  function createDidHook(hooks) {
 569    /**
 570     * Returns the number of times an action has been fired.
 571     *
 572     * @param  {string} hookName The hook name to check.
 573     *
 574     * @return {number}          The number of times the hook has run.
 575     */
 576    return function didHook(hookName) {
 577      if (!build_module_validateHookName(hookName)) {
 578        return;
 579      }
 580  
 581      return hooks[hookName] && hooks[hookName].runs ? hooks[hookName].runs : 0;
 582    };
 583  }
 584  
 585  /* harmony default export */ var build_module_createDidHook = (createDidHook);
 586  
 587  // CONCATENATED MODULE: ./node_modules/@wordpress/hooks/build-module/createHooks.js
 588  /**
 589   * Internal dependencies
 590   */
 591  
 592  
 593  
 594  
 595  
 596  
 597  
 598  /**
 599   * Returns an instance of the hooks object.
 600   *
 601   * @return {Object} Object that contains all hooks.
 602   */
 603  
 604  function createHooks() {
 605    var actions = Object.create(null);
 606    var filters = Object.create(null);
 607    actions.__current = [];
 608    filters.__current = [];
 609    return {
 610      addAction: build_module_createAddHook(actions),
 611      addFilter: build_module_createAddHook(filters),
 612      removeAction: build_module_createRemoveHook(actions),
 613      removeFilter: build_module_createRemoveHook(filters),
 614      hasAction: build_module_createHasHook(actions),
 615      hasFilter: build_module_createHasHook(filters),
 616      removeAllActions: build_module_createRemoveHook(actions, true),
 617      removeAllFilters: build_module_createRemoveHook(filters, true),
 618      doAction: build_module_createRunHook(actions),
 619      applyFilters: build_module_createRunHook(filters, true),
 620      currentAction: build_module_createCurrentHook(actions),
 621      currentFilter: build_module_createCurrentHook(filters),
 622      doingAction: build_module_createDoingHook(actions),
 623      doingFilter: build_module_createDoingHook(filters),
 624      didAction: build_module_createDidHook(actions),
 625      didFilter: build_module_createDidHook(filters),
 626      actions: actions,
 627      filters: filters
 628    };
 629  }
 630  
 631  /* harmony default export */ var build_module_createHooks = (createHooks);
 632  
 633  // CONCATENATED MODULE: ./node_modules/@wordpress/hooks/build-module/index.js
 634  /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "addAction", function() { return addAction; });
 635  /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "addFilter", function() { return addFilter; });
 636  /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "removeAction", function() { return removeAction; });
 637  /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "removeFilter", function() { return removeFilter; });
 638  /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "hasAction", function() { return hasAction; });
 639  /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "hasFilter", function() { return hasFilter; });
 640  /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "removeAllActions", function() { return removeAllActions; });
 641  /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "removeAllFilters", function() { return removeAllFilters; });
 642  /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "doAction", function() { return doAction; });
 643  /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "applyFilters", function() { return applyFilters; });
 644  /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "currentAction", function() { return currentAction; });
 645  /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "currentFilter", function() { return currentFilter; });
 646  /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "doingAction", function() { return doingAction; });
 647  /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "doingFilter", function() { return doingFilter; });
 648  /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "didAction", function() { return didAction; });
 649  /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "didFilter", function() { return didFilter; });
 650  /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "actions", function() { return build_module_actions; });
 651  /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "filters", function() { return build_module_filters; });
 652  /* concated harmony reexport createHooks */__webpack_require__.d(__webpack_exports__, "createHooks", function() { return build_module_createHooks; });
 653  /**
 654   * Internal dependencies
 655   */
 656  
 657  
 658  var _createHooks = build_module_createHooks(),
 659      addAction = _createHooks.addAction,
 660      addFilter = _createHooks.addFilter,
 661      removeAction = _createHooks.removeAction,
 662      removeFilter = _createHooks.removeFilter,
 663      hasAction = _createHooks.hasAction,
 664      hasFilter = _createHooks.hasFilter,
 665      removeAllActions = _createHooks.removeAllActions,
 666      removeAllFilters = _createHooks.removeAllFilters,
 667      doAction = _createHooks.doAction,
 668      applyFilters = _createHooks.applyFilters,
 669      currentAction = _createHooks.currentAction,
 670      currentFilter = _createHooks.currentFilter,
 671      doingAction = _createHooks.doingAction,
 672      doingFilter = _createHooks.doingFilter,
 673      didAction = _createHooks.didAction,
 674      didFilter = _createHooks.didFilter,
 675      build_module_actions = _createHooks.actions,
 676      build_module_filters = _createHooks.filters;
 677  
 678  
 679  
 680  
 681  /***/ })
 682  
 683  /******/ });


Generated: Sat Nov 23 20:47:33 2019 Cross-referenced by PHPXref 0.7