[ Index ]

PHP Cross Reference of BuddyPress

title

Body

[close]

/src/bp-core/js/ -> block-data.js (source)

   1  // modules are defined as an array
   2  // [ module function, map of requires ]
   3  //
   4  // map of requires is short require name -> numeric require
   5  //
   6  // anything defined in a previous bundle is accessed via the
   7  // orig method which is the require for previous bundles
   8  parcelRequire = (function (modules, cache, entry, globalName) {
   9    // Save the require from previous bundle to this closure if any
  10    var previousRequire = typeof parcelRequire === 'function' && parcelRequire;
  11    var nodeRequire = typeof require === 'function' && require;
  12  
  13    function newRequire(name, jumped) {
  14      if (!cache[name]) {
  15        if (!modules[name]) {
  16          // if we cannot find the module within our internal map or
  17          // cache jump to the current global require ie. the last bundle
  18          // that was added to the page.
  19          var currentRequire = typeof parcelRequire === 'function' && parcelRequire;
  20          if (!jumped && currentRequire) {
  21            return currentRequire(name, true);
  22          }
  23  
  24          // If there are other bundles on this page the require from the
  25          // previous one is saved to 'previousRequire'. Repeat this as
  26          // many times as there are bundles until the module is found or
  27          // we exhaust the require chain.
  28          if (previousRequire) {
  29            return previousRequire(name, true);
  30          }
  31  
  32          // Try the node require function if it exists.
  33          if (nodeRequire && typeof name === 'string') {
  34            return nodeRequire(name);
  35          }
  36  
  37          var err = new Error('Cannot find module \'' + name + '\'');
  38          err.code = 'MODULE_NOT_FOUND';
  39          throw err;
  40        }
  41  
  42        localRequire.resolve = resolve;
  43        localRequire.cache = {};
  44  
  45        var module = cache[name] = new newRequire.Module(name);
  46  
  47        modules[name][0].call(module.exports, localRequire, module, module.exports, this);
  48      }
  49  
  50      return cache[name].exports;
  51  
  52      function localRequire(x){
  53        return newRequire(localRequire.resolve(x));
  54      }
  55  
  56      function resolve(x){
  57        return modules[name][1][x] || x;
  58      }
  59    }
  60  
  61    function Module(moduleName) {
  62      this.id = moduleName;
  63      this.bundle = newRequire;
  64      this.exports = {};
  65    }
  66  
  67    newRequire.isParcelRequire = true;
  68    newRequire.Module = Module;
  69    newRequire.modules = modules;
  70    newRequire.cache = cache;
  71    newRequire.parent = previousRequire;
  72    newRequire.register = function (id, exports) {
  73      modules[id] = [function (require, module) {
  74        module.exports = exports;
  75      }, {}];
  76    };
  77  
  78    var error;
  79    for (var i = 0; i < entry.length; i++) {
  80      try {
  81        newRequire(entry[i]);
  82      } catch (e) {
  83        // Save first error but execute all entries
  84        if (!error) {
  85          error = e;
  86        }
  87      }
  88    }
  89  
  90    if (entry.length) {
  91      // Expose entry point to Node, AMD or browser globals
  92      // Based on https://github.com/ForbesLindesay/umd/blob/master/template.js
  93      var mainExports = newRequire(entry[entry.length - 1]);
  94  
  95      // CommonJS
  96      if (typeof exports === "object" && typeof module !== "undefined") {
  97        module.exports = mainExports;
  98  
  99      // RequireJS
 100      } else if (typeof define === "function" && define.amd) {
 101       define(function () {
 102         return mainExports;
 103       });
 104  
 105      // <script>
 106      } else if (globalName) {
 107        this[globalName] = mainExports;
 108      }
 109    }
 110  
 111    // Override the current require with this new one
 112    parcelRequire = newRequire;
 113  
 114    if (error) {
 115      // throw error from earlier, _after updating parcelRequire_
 116      throw error;
 117    }
 118  
 119    return newRequire;
 120  })({"DCTP":[function(require,module,exports) {
 121  function _arrayWithHoles(arr) {
 122    if (Array.isArray(arr)) return arr;
 123  }
 124  
 125  module.exports = _arrayWithHoles;
 126  },{}],"LoeL":[function(require,module,exports) {
 127  function _iterableToArrayLimit(arr, i) {
 128    if (typeof Symbol === "undefined" || !(Symbol.iterator in Object(arr))) return;
 129    var _arr = [];
 130    var _n = true;
 131    var _d = false;
 132    var _e = undefined;
 133  
 134    try {
 135      for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) {
 136        _arr.push(_s.value);
 137  
 138        if (i && _arr.length === i) break;
 139      }
 140    } catch (err) {
 141      _d = true;
 142      _e = err;
 143    } finally {
 144      try {
 145        if (!_n && _i["return"] != null) _i["return"]();
 146      } finally {
 147        if (_d) throw _e;
 148      }
 149    }
 150  
 151    return _arr;
 152  }
 153  
 154  module.exports = _iterableToArrayLimit;
 155  },{}],"jEQo":[function(require,module,exports) {
 156  function _arrayLikeToArray(arr, len) {
 157    if (len == null || len > arr.length) len = arr.length;
 158  
 159    for (var i = 0, arr2 = new Array(len); i < len; i++) {
 160      arr2[i] = arr[i];
 161    }
 162  
 163    return arr2;
 164  }
 165  
 166  module.exports = _arrayLikeToArray;
 167  },{}],"Dbv9":[function(require,module,exports) {
 168  var arrayLikeToArray = require("./arrayLikeToArray");
 169  
 170  function _unsupportedIterableToArray(o, minLen) {
 171    if (!o) return;
 172    if (typeof o === "string") return arrayLikeToArray(o, minLen);
 173    var n = Object.prototype.toString.call(o).slice(8, -1);
 174    if (n === "Object" && o.constructor) n = o.constructor.name;
 175    if (n === "Map" || n === "Set") return Array.from(n);
 176    if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return arrayLikeToArray(o, minLen);
 177  }
 178  
 179  module.exports = _unsupportedIterableToArray;
 180  },{"./arrayLikeToArray":"jEQo"}],"MWEO":[function(require,module,exports) {
 181  function _nonIterableRest() {
 182    throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
 183  }
 184  
 185  module.exports = _nonIterableRest;
 186  },{}],"DERy":[function(require,module,exports) {
 187  var arrayWithHoles = require("./arrayWithHoles");
 188  
 189  var iterableToArrayLimit = require("./iterableToArrayLimit");
 190  
 191  var unsupportedIterableToArray = require("./unsupportedIterableToArray");
 192  
 193  var nonIterableRest = require("./nonIterableRest");
 194  
 195  function _slicedToArray(arr, i) {
 196    return arrayWithHoles(arr) || iterableToArrayLimit(arr, i) || unsupportedIterableToArray(arr, i) || nonIterableRest();
 197  }
 198  
 199  module.exports = _slicedToArray;
 200  },{"./arrayWithHoles":"DCTP","./iterableToArrayLimit":"LoeL","./unsupportedIterableToArray":"Dbv9","./nonIterableRest":"MWEO"}],"Ih1j":[function(require,module,exports) {
 201  "use strict";
 202  
 203  Object.defineProperty(exports, "__esModule", {
 204    value: true
 205  });
 206  exports.STORE_KEY = void 0;
 207  
 208  /**
 209   * Identifier key for BP Core store reducer.
 210   *
 211   * @type {string}
 212   */
 213  var STORE_KEY = 'bp/core';
 214  exports.STORE_KEY = STORE_KEY;
 215  },{}],"DDtj":[function(require,module,exports) {
 216  "use strict";
 217  
 218  Object.defineProperty(exports, "__esModule", {
 219    value: true
 220  });
 221  exports.getActiveComponents = void 0;
 222  
 223  /**
 224   * Returns the list of Active BP Components.
 225   *
 226   * @param {Object} state The current state.
 227   * @return {array} The list of Active BP Components.
 228   */
 229  var getActiveComponents = function getActiveComponents(state) {
 230    return state.components || [];
 231  };
 232  
 233  exports.getActiveComponents = getActiveComponents;
 234  },{}],"gg2v":[function(require,module,exports) {
 235  "use strict";
 236  
 237  Object.defineProperty(exports, "__esModule", {
 238    value: true
 239  });
 240  exports.TYPES = void 0;
 241  
 242  /**
 243   * Action types.
 244   *
 245   * @type {Object}
 246   */
 247  var TYPES = {
 248    GET_ACTIVE_COMPONENTS: 'GET_ACTIVE_COMPONENTS',
 249    FETCH_FROM_API: 'FETCH_FROM_API'
 250  };
 251  exports.TYPES = TYPES;
 252  },{}],"NTbX":[function(require,module,exports) {
 253  "use strict";
 254  
 255  Object.defineProperty(exports, "__esModule", {
 256    value: true
 257  });
 258  exports.getActiveComponents = getActiveComponents;
 259  exports.fetchFromAPI = fetchFromAPI;
 260  
 261  var _actionTypes = require("./action-types");
 262  
 263  /**
 264   * Internal dependencies.
 265   */
 266  
 267  /**
 268   * Returns the list of active components.
 269   *
 270   * @return {Object} Object for action.
 271   */
 272  function getActiveComponents(list) {
 273    return {
 274      type: _actionTypes.TYPES.GET_ACTIVE_COMPONENTS,
 275      list: list
 276    };
 277  }
 278  /**
 279   * Returns an action object used to fetch something from the API.
 280   *
 281   * @param {string} path Endpoint path.
 282   * @param {boolean} parse Should we parse the request.
 283   * @return {Object} Object for action.
 284   */
 285  
 286  
 287  function fetchFromAPI(path, parse) {
 288    return {
 289      type: _actionTypes.TYPES.FETCH_FROM_API,
 290      path: path,
 291      parse: parse
 292    };
 293  }
 294  },{"./action-types":"gg2v"}],"rqzK":[function(require,module,exports) {
 295  /**
 296   * Copyright (c) 2014-present, Facebook, Inc.
 297   *
 298   * This source code is licensed under the MIT license found in the
 299   * LICENSE file in the root directory of this source tree.
 300   */
 301  
 302  var runtime = (function (exports) {
 303    "use strict";
 304  
 305    var Op = Object.prototype;
 306    var hasOwn = Op.hasOwnProperty;
 307    var undefined; // More compressible than void 0.
 308    var $Symbol = typeof Symbol === "function" ? Symbol : {};
 309    var iteratorSymbol = $Symbol.iterator || "@@iterator";
 310    var asyncIteratorSymbol = $Symbol.asyncIterator || "@@asyncIterator";
 311    var toStringTagSymbol = $Symbol.toStringTag || "@@toStringTag";
 312  
 313    function wrap(innerFn, outerFn, self, tryLocsList) {
 314      // If outerFn provided and outerFn.prototype is a Generator, then outerFn.prototype instanceof Generator.
 315      var protoGenerator = outerFn && outerFn.prototype instanceof Generator ? outerFn : Generator;
 316      var generator = Object.create(protoGenerator.prototype);
 317      var context = new Context(tryLocsList || []);
 318  
 319      // The ._invoke method unifies the implementations of the .next,
 320      // .throw, and .return methods.
 321      generator._invoke = makeInvokeMethod(innerFn, self, context);
 322  
 323      return generator;
 324    }
 325    exports.wrap = wrap;
 326  
 327    // Try/catch helper to minimize deoptimizations. Returns a completion
 328    // record like context.tryEntries[i].completion. This interface could
 329    // have been (and was previously) designed to take a closure to be
 330    // invoked without arguments, but in all the cases we care about we
 331    // already have an existing method we want to call, so there's no need
 332    // to create a new function object. We can even get away with assuming
 333    // the method takes exactly one argument, since that happens to be true
 334    // in every case, so we don't have to touch the arguments object. The
 335    // only additional allocation required is the completion record, which
 336    // has a stable shape and so hopefully should be cheap to allocate.
 337    function tryCatch(fn, obj, arg) {
 338      try {
 339        return { type: "normal", arg: fn.call(obj, arg) };
 340      } catch (err) {
 341        return { type: "throw", arg: err };
 342      }
 343    }
 344  
 345    var GenStateSuspendedStart = "suspendedStart";
 346    var GenStateSuspendedYield = "suspendedYield";
 347    var GenStateExecuting = "executing";
 348    var GenStateCompleted = "completed";
 349  
 350    // Returning this object from the innerFn has the same effect as
 351    // breaking out of the dispatch switch statement.
 352    var ContinueSentinel = {};
 353  
 354    // Dummy constructor functions that we use as the .constructor and
 355    // .constructor.prototype properties for functions that return Generator
 356    // objects. For full spec compliance, you may wish to configure your
 357    // minifier not to mangle the names of these two functions.
 358    function Generator() {}
 359    function GeneratorFunction() {}
 360    function GeneratorFunctionPrototype() {}
 361  
 362    // This is a polyfill for %IteratorPrototype% for environments that
 363    // don't natively support it.
 364    var IteratorPrototype = {};
 365    IteratorPrototype[iteratorSymbol] = function () {
 366      return this;
 367    };
 368  
 369    var getProto = Object.getPrototypeOf;
 370    var NativeIteratorPrototype = getProto && getProto(getProto(values([])));
 371    if (NativeIteratorPrototype &&
 372        NativeIteratorPrototype !== Op &&
 373        hasOwn.call(NativeIteratorPrototype, iteratorSymbol)) {
 374      // This environment has a native %IteratorPrototype%; use it instead
 375      // of the polyfill.
 376      IteratorPrototype = NativeIteratorPrototype;
 377    }
 378  
 379    var Gp = GeneratorFunctionPrototype.prototype =
 380      Generator.prototype = Object.create(IteratorPrototype);
 381    GeneratorFunction.prototype = Gp.constructor = GeneratorFunctionPrototype;
 382    GeneratorFunctionPrototype.constructor = GeneratorFunction;
 383    GeneratorFunctionPrototype[toStringTagSymbol] =
 384      GeneratorFunction.displayName = "GeneratorFunction";
 385  
 386    // Helper for defining the .next, .throw, and .return methods of the
 387    // Iterator interface in terms of a single ._invoke method.
 388    function defineIteratorMethods(prototype) {
 389      ["next", "throw", "return"].forEach(function(method) {
 390        prototype[method] = function(arg) {
 391          return this._invoke(method, arg);
 392        };
 393      });
 394    }
 395  
 396    exports.isGeneratorFunction = function(genFun) {
 397      var ctor = typeof genFun === "function" && genFun.constructor;
 398      return ctor
 399        ? ctor === GeneratorFunction ||
 400          // For the native GeneratorFunction constructor, the best we can
 401          // do is to check its .name property.
 402          (ctor.displayName || ctor.name) === "GeneratorFunction"
 403        : false;
 404    };
 405  
 406    exports.mark = function(genFun) {
 407      if (Object.setPrototypeOf) {
 408        Object.setPrototypeOf(genFun, GeneratorFunctionPrototype);
 409      } else {
 410        genFun.__proto__ = GeneratorFunctionPrototype;
 411        if (!(toStringTagSymbol in genFun)) {
 412          genFun[toStringTagSymbol] = "GeneratorFunction";
 413        }
 414      }
 415      genFun.prototype = Object.create(Gp);
 416      return genFun;
 417    };
 418  
 419    // Within the body of any async function, `await x` is transformed to
 420    // `yield regeneratorRuntime.awrap(x)`, so that the runtime can test
 421    // `hasOwn.call(value, "__await")` to determine if the yielded value is
 422    // meant to be awaited.
 423    exports.awrap = function(arg) {
 424      return { __await: arg };
 425    };
 426  
 427    function AsyncIterator(generator, PromiseImpl) {
 428      function invoke(method, arg, resolve, reject) {
 429        var record = tryCatch(generator[method], generator, arg);
 430        if (record.type === "throw") {
 431          reject(record.arg);
 432        } else {
 433          var result = record.arg;
 434          var value = result.value;
 435          if (value &&
 436              typeof value === "object" &&
 437              hasOwn.call(value, "__await")) {
 438            return PromiseImpl.resolve(value.__await).then(function(value) {
 439              invoke("next", value, resolve, reject);
 440            }, function(err) {
 441              invoke("throw", err, resolve, reject);
 442            });
 443          }
 444  
 445          return PromiseImpl.resolve(value).then(function(unwrapped) {
 446            // When a yielded Promise is resolved, its final value becomes
 447            // the .value of the Promise<{value,done}> result for the
 448            // current iteration.
 449            result.value = unwrapped;
 450            resolve(result);
 451          }, function(error) {
 452            // If a rejected Promise was yielded, throw the rejection back
 453            // into the async generator function so it can be handled there.
 454            return invoke("throw", error, resolve, reject);
 455          });
 456        }
 457      }
 458  
 459      var previousPromise;
 460  
 461      function enqueue(method, arg) {
 462        function callInvokeWithMethodAndArg() {
 463          return new PromiseImpl(function(resolve, reject) {
 464            invoke(method, arg, resolve, reject);
 465          });
 466        }
 467  
 468        return previousPromise =
 469          // If enqueue has been called before, then we want to wait until
 470          // all previous Promises have been resolved before calling invoke,
 471          // so that results are always delivered in the correct order. If
 472          // enqueue has not been called before, then it is important to
 473          // call invoke immediately, without waiting on a callback to fire,
 474          // so that the async generator function has the opportunity to do
 475          // any necessary setup in a predictable way. This predictability
 476          // is why the Promise constructor synchronously invokes its
 477          // executor callback, and why async functions synchronously
 478          // execute code before the first await. Since we implement simple
 479          // async functions in terms of async generators, it is especially
 480          // important to get this right, even though it requires care.
 481          previousPromise ? previousPromise.then(
 482            callInvokeWithMethodAndArg,
 483            // Avoid propagating failures to Promises returned by later
 484            // invocations of the iterator.
 485            callInvokeWithMethodAndArg
 486          ) : callInvokeWithMethodAndArg();
 487      }
 488  
 489      // Define the unified helper method that is used to implement .next,
 490      // .throw, and .return (see defineIteratorMethods).
 491      this._invoke = enqueue;
 492    }
 493  
 494    defineIteratorMethods(AsyncIterator.prototype);
 495    AsyncIterator.prototype[asyncIteratorSymbol] = function () {
 496      return this;
 497    };
 498    exports.AsyncIterator = AsyncIterator;
 499  
 500    // Note that simple async functions are implemented on top of
 501    // AsyncIterator objects; they just return a Promise for the value of
 502    // the final result produced by the iterator.
 503    exports.async = function(innerFn, outerFn, self, tryLocsList, PromiseImpl) {
 504      if (PromiseImpl === void 0) PromiseImpl = Promise;
 505  
 506      var iter = new AsyncIterator(
 507        wrap(innerFn, outerFn, self, tryLocsList),
 508        PromiseImpl
 509      );
 510  
 511      return exports.isGeneratorFunction(outerFn)
 512        ? iter // If outerFn is a generator, return the full iterator.
 513        : iter.next().then(function(result) {
 514            return result.done ? result.value : iter.next();
 515          });
 516    };
 517  
 518    function makeInvokeMethod(innerFn, self, context) {
 519      var state = GenStateSuspendedStart;
 520  
 521      return function invoke(method, arg) {
 522        if (state === GenStateExecuting) {
 523          throw new Error("Generator is already running");
 524        }
 525  
 526        if (state === GenStateCompleted) {
 527          if (method === "throw") {
 528            throw arg;
 529          }
 530  
 531          // Be forgiving, per 25.3.3.3.3 of the spec:
 532          // https://people.mozilla.org/~jorendorff/es6-draft.html#sec-generatorresume
 533          return doneResult();
 534        }
 535  
 536        context.method = method;
 537        context.arg = arg;
 538  
 539        while (true) {
 540          var delegate = context.delegate;
 541          if (delegate) {
 542            var delegateResult = maybeInvokeDelegate(delegate, context);
 543            if (delegateResult) {
 544              if (delegateResult === ContinueSentinel) continue;
 545              return delegateResult;
 546            }
 547          }
 548  
 549          if (context.method === "next") {
 550            // Setting context._sent for legacy support of Babel's
 551            // function.sent implementation.
 552            context.sent = context._sent = context.arg;
 553  
 554          } else if (context.method === "throw") {
 555            if (state === GenStateSuspendedStart) {
 556              state = GenStateCompleted;
 557              throw context.arg;
 558            }
 559  
 560            context.dispatchException(context.arg);
 561  
 562          } else if (context.method === "return") {
 563            context.abrupt("return", context.arg);
 564          }
 565  
 566          state = GenStateExecuting;
 567  
 568          var record = tryCatch(innerFn, self, context);
 569          if (record.type === "normal") {
 570            // If an exception is thrown from innerFn, we leave state ===
 571            // GenStateExecuting and loop back for another invocation.
 572            state = context.done
 573              ? GenStateCompleted
 574              : GenStateSuspendedYield;
 575  
 576            if (record.arg === ContinueSentinel) {
 577              continue;
 578            }
 579  
 580            return {
 581              value: record.arg,
 582              done: context.done
 583            };
 584  
 585          } else if (record.type === "throw") {
 586            state = GenStateCompleted;
 587            // Dispatch the exception by looping back around to the
 588            // context.dispatchException(context.arg) call above.
 589            context.method = "throw";
 590            context.arg = record.arg;
 591          }
 592        }
 593      };
 594    }
 595  
 596    // Call delegate.iterator[context.method](context.arg) and handle the
 597    // result, either by returning a { value, done } result from the
 598    // delegate iterator, or by modifying context.method and context.arg,
 599    // setting context.delegate to null, and returning the ContinueSentinel.
 600    function maybeInvokeDelegate(delegate, context) {
 601      var method = delegate.iterator[context.method];
 602      if (method === undefined) {
 603        // A .throw or .return when the delegate iterator has no .throw
 604        // method always terminates the yield* loop.
 605        context.delegate = null;
 606  
 607        if (context.method === "throw") {
 608          // Note: ["return"] must be used for ES3 parsing compatibility.
 609          if (delegate.iterator["return"]) {
 610            // If the delegate iterator has a return method, give it a
 611            // chance to clean up.
 612            context.method = "return";
 613            context.arg = undefined;
 614            maybeInvokeDelegate(delegate, context);
 615  
 616            if (context.method === "throw") {
 617              // If maybeInvokeDelegate(context) changed context.method from
 618              // "return" to "throw", let that override the TypeError below.
 619              return ContinueSentinel;
 620            }
 621          }
 622  
 623          context.method = "throw";
 624          context.arg = new TypeError(
 625            "The iterator does not provide a 'throw' method");
 626        }
 627  
 628        return ContinueSentinel;
 629      }
 630  
 631      var record = tryCatch(method, delegate.iterator, context.arg);
 632  
 633      if (record.type === "throw") {
 634        context.method = "throw";
 635        context.arg = record.arg;
 636        context.delegate = null;
 637        return ContinueSentinel;
 638      }
 639  
 640      var info = record.arg;
 641  
 642      if (! info) {
 643        context.method = "throw";
 644        context.arg = new TypeError("iterator result is not an object");
 645        context.delegate = null;
 646        return ContinueSentinel;
 647      }
 648  
 649      if (info.done) {
 650        // Assign the result of the finished delegate to the temporary
 651        // variable specified by delegate.resultName (see delegateYield).
 652        context[delegate.resultName] = info.value;
 653  
 654        // Resume execution at the desired location (see delegateYield).
 655        context.next = delegate.nextLoc;
 656  
 657        // If context.method was "throw" but the delegate handled the
 658        // exception, let the outer generator proceed normally. If
 659        // context.method was "next", forget context.arg since it has been
 660        // "consumed" by the delegate iterator. If context.method was
 661        // "return", allow the original .return call to continue in the
 662        // outer generator.
 663        if (context.method !== "return") {
 664          context.method = "next";
 665          context.arg = undefined;
 666        }
 667  
 668      } else {
 669        // Re-yield the result returned by the delegate method.
 670        return info;
 671      }
 672  
 673      // The delegate iterator is finished, so forget it and continue with
 674      // the outer generator.
 675      context.delegate = null;
 676      return ContinueSentinel;
 677    }
 678  
 679    // Define Generator.prototype.{next,throw,return} in terms of the
 680    // unified ._invoke helper method.
 681    defineIteratorMethods(Gp);
 682  
 683    Gp[toStringTagSymbol] = "Generator";
 684  
 685    // A Generator should always return itself as the iterator object when the
 686    // @@iterator function is called on it. Some browsers' implementations of the
 687    // iterator prototype chain incorrectly implement this, causing the Generator
 688    // object to not be returned from this call. This ensures that doesn't happen.
 689    // See https://github.com/facebook/regenerator/issues/274 for more details.
 690    Gp[iteratorSymbol] = function() {
 691      return this;
 692    };
 693  
 694    Gp.toString = function() {
 695      return "[object Generator]";
 696    };
 697  
 698    function pushTryEntry(locs) {
 699      var entry = { tryLoc: locs[0] };
 700  
 701      if (1 in locs) {
 702        entry.catchLoc = locs[1];
 703      }
 704  
 705      if (2 in locs) {
 706        entry.finallyLoc = locs[2];
 707        entry.afterLoc = locs[3];
 708      }
 709  
 710      this.tryEntries.push(entry);
 711    }
 712  
 713    function resetTryEntry(entry) {
 714      var record = entry.completion || {};
 715      record.type = "normal";
 716      delete record.arg;
 717      entry.completion = record;
 718    }
 719  
 720    function Context(tryLocsList) {
 721      // The root entry object (effectively a try statement without a catch
 722      // or a finally block) gives us a place to store values thrown from
 723      // locations where there is no enclosing try statement.
 724      this.tryEntries = [{ tryLoc: "root" }];
 725      tryLocsList.forEach(pushTryEntry, this);
 726      this.reset(true);
 727    }
 728  
 729    exports.keys = function(object) {
 730      var keys = [];
 731      for (var key in object) {
 732        keys.push(key);
 733      }
 734      keys.reverse();
 735  
 736      // Rather than returning an object with a next method, we keep
 737      // things simple and return the next function itself.
 738      return function next() {
 739        while (keys.length) {
 740          var key = keys.pop();
 741          if (key in object) {
 742            next.value = key;
 743            next.done = false;
 744            return next;
 745          }
 746        }
 747  
 748        // To avoid creating an additional object, we just hang the .value
 749        // and .done properties off the next function object itself. This
 750        // also ensures that the minifier will not anonymize the function.
 751        next.done = true;
 752        return next;
 753      };
 754    };
 755  
 756    function values(iterable) {
 757      if (iterable) {
 758        var iteratorMethod = iterable[iteratorSymbol];
 759        if (iteratorMethod) {
 760          return iteratorMethod.call(iterable);
 761        }
 762  
 763        if (typeof iterable.next === "function") {
 764          return iterable;
 765        }
 766  
 767        if (!isNaN(iterable.length)) {
 768          var i = -1, next = function next() {
 769            while (++i < iterable.length) {
 770              if (hasOwn.call(iterable, i)) {
 771                next.value = iterable[i];
 772                next.done = false;
 773                return next;
 774              }
 775            }
 776  
 777            next.value = undefined;
 778            next.done = true;
 779  
 780            return next;
 781          };
 782  
 783          return next.next = next;
 784        }
 785      }
 786  
 787      // Return an iterator with no values.
 788      return { next: doneResult };
 789    }
 790    exports.values = values;
 791  
 792    function doneResult() {
 793      return { value: undefined, done: true };
 794    }
 795  
 796    Context.prototype = {
 797      constructor: Context,
 798  
 799      reset: function(skipTempReset) {
 800        this.prev = 0;
 801        this.next = 0;
 802        // Resetting context._sent for legacy support of Babel's
 803        // function.sent implementation.
 804        this.sent = this._sent = undefined;
 805        this.done = false;
 806        this.delegate = null;
 807  
 808        this.method = "next";
 809        this.arg = undefined;
 810  
 811        this.tryEntries.forEach(resetTryEntry);
 812  
 813        if (!skipTempReset) {
 814          for (var name in this) {
 815            // Not sure about the optimal order of these conditions:
 816            if (name.charAt(0) === "t" &&
 817                hasOwn.call(this, name) &&
 818                !isNaN(+name.slice(1))) {
 819              this[name] = undefined;
 820            }
 821          }
 822        }
 823      },
 824  
 825      stop: function() {
 826        this.done = true;
 827  
 828        var rootEntry = this.tryEntries[0];
 829        var rootRecord = rootEntry.completion;
 830        if (rootRecord.type === "throw") {
 831          throw rootRecord.arg;
 832        }
 833  
 834        return this.rval;
 835      },
 836  
 837      dispatchException: function(exception) {
 838        if (this.done) {
 839          throw exception;
 840        }
 841  
 842        var context = this;
 843        function handle(loc, caught) {
 844          record.type = "throw";
 845          record.arg = exception;
 846          context.next = loc;
 847  
 848          if (caught) {
 849            // If the dispatched exception was caught by a catch block,
 850            // then let that catch block handle the exception normally.
 851            context.method = "next";
 852            context.arg = undefined;
 853          }
 854  
 855          return !! caught;
 856        }
 857  
 858        for (var i = this.tryEntries.length - 1; i >= 0; --i) {
 859          var entry = this.tryEntries[i];
 860          var record = entry.completion;
 861  
 862          if (entry.tryLoc === "root") {
 863            // Exception thrown outside of any try block that could handle
 864            // it, so set the completion value of the entire function to
 865            // throw the exception.
 866            return handle("end");
 867          }
 868  
 869          if (entry.tryLoc <= this.prev) {
 870            var hasCatch = hasOwn.call(entry, "catchLoc");
 871            var hasFinally = hasOwn.call(entry, "finallyLoc");
 872  
 873            if (hasCatch && hasFinally) {
 874              if (this.prev < entry.catchLoc) {
 875                return handle(entry.catchLoc, true);
 876              } else if (this.prev < entry.finallyLoc) {
 877                return handle(entry.finallyLoc);
 878              }
 879  
 880            } else if (hasCatch) {
 881              if (this.prev < entry.catchLoc) {
 882                return handle(entry.catchLoc, true);
 883              }
 884  
 885            } else if (hasFinally) {
 886              if (this.prev < entry.finallyLoc) {
 887                return handle(entry.finallyLoc);
 888              }
 889  
 890            } else {
 891              throw new Error("try statement without catch or finally");
 892            }
 893          }
 894        }
 895      },
 896  
 897      abrupt: function(type, arg) {
 898        for (var i = this.tryEntries.length - 1; i >= 0; --i) {
 899          var entry = this.tryEntries[i];
 900          if (entry.tryLoc <= this.prev &&
 901              hasOwn.call(entry, "finallyLoc") &&
 902              this.prev < entry.finallyLoc) {
 903            var finallyEntry = entry;
 904            break;
 905          }
 906        }
 907  
 908        if (finallyEntry &&
 909            (type === "break" ||
 910             type === "continue") &&
 911            finallyEntry.tryLoc <= arg &&
 912            arg <= finallyEntry.finallyLoc) {
 913          // Ignore the finally entry if control is not jumping to a
 914          // location outside the try/catch block.
 915          finallyEntry = null;
 916        }
 917  
 918        var record = finallyEntry ? finallyEntry.completion : {};
 919        record.type = type;
 920        record.arg = arg;
 921  
 922        if (finallyEntry) {
 923          this.method = "next";
 924          this.next = finallyEntry.finallyLoc;
 925          return ContinueSentinel;
 926        }
 927  
 928        return this.complete(record);
 929      },
 930  
 931      complete: function(record, afterLoc) {
 932        if (record.type === "throw") {
 933          throw record.arg;
 934        }
 935  
 936        if (record.type === "break" ||
 937            record.type === "continue") {
 938          this.next = record.arg;
 939        } else if (record.type === "return") {
 940          this.rval = this.arg = record.arg;
 941          this.method = "return";
 942          this.next = "end";
 943        } else if (record.type === "normal" && afterLoc) {
 944          this.next = afterLoc;
 945        }
 946  
 947        return ContinueSentinel;
 948      },
 949  
 950      finish: function(finallyLoc) {
 951        for (var i = this.tryEntries.length - 1; i >= 0; --i) {
 952          var entry = this.tryEntries[i];
 953          if (entry.finallyLoc === finallyLoc) {
 954            this.complete(entry.completion, entry.afterLoc);
 955            resetTryEntry(entry);
 956            return ContinueSentinel;
 957          }
 958        }
 959      },
 960  
 961      "catch": function(tryLoc) {
 962        for (var i = this.tryEntries.length - 1; i >= 0; --i) {
 963          var entry = this.tryEntries[i];
 964          if (entry.tryLoc === tryLoc) {
 965            var record = entry.completion;
 966            if (record.type === "throw") {
 967              var thrown = record.arg;
 968              resetTryEntry(entry);
 969            }
 970            return thrown;
 971          }
 972        }
 973  
 974        // The context.catch method must only be called with a location
 975        // argument that corresponds to a known catch block.
 976        throw new Error("illegal catch attempt");
 977      },
 978  
 979      delegateYield: function(iterable, resultName, nextLoc) {
 980        this.delegate = {
 981          iterator: values(iterable),
 982          resultName: resultName,
 983          nextLoc: nextLoc
 984        };
 985  
 986        if (this.method === "next") {
 987          // Deliberately forget the last sent value so that we don't
 988          // accidentally pass it on to the delegate.
 989          this.arg = undefined;
 990        }
 991  
 992        return ContinueSentinel;
 993      }
 994    };
 995  
 996    // Regardless of whether this script is executing as a CommonJS module
 997    // or not, return the runtime object so that we can declare the variable
 998    // regeneratorRuntime in the outer scope, which allows this module to be
 999    // injected easily by `bin/regenerator --include-runtime script.js`.
1000    return exports;
1001  
1002  }(
1003    // If this script is executing as a CommonJS module, use module.exports
1004    // as the regeneratorRuntime namespace. Otherwise create a new empty
1005    // object. Either way, the resulting object will be used to initialize
1006    // the regeneratorRuntime variable at the top of this file.
1007    typeof module === "object" ? module.exports : {}
1008  ));
1009  
1010  try {
1011    regeneratorRuntime = runtime;
1012  } catch (accidentalStrictMode) {
1013    // This module should not be running in strict mode, so the above
1014    // assignment should always work unless something is misconfigured. Just
1015    // in case runtime.js accidentally runs in strict mode, we can escape
1016    // strict mode using a global Function call. This could conceivably fail
1017    // if a Content Security Policy forbids using Function, but in that case
1018    // the proper solution is to fix the accidental strict mode problem. If
1019    // you've misconfigured your bundler to force strict mode and applied a
1020    // CSP to forbid Function, and you're not willing to fix either of those
1021    // problems, please detail your unique predicament in a GitHub issue.
1022    Function("r", "regeneratorRuntime = r")(runtime);
1023  }
1024  
1025  },{}],"BxGn":[function(require,module,exports) {
1026  module.exports = require("regenerator-runtime");
1027  
1028  },{"regenerator-runtime":"rqzK"}],"SaI5":[function(require,module,exports) {
1029  "use strict";
1030  
1031  Object.defineProperty(exports, "__esModule", {
1032    value: true
1033  });
1034  exports.getActiveComponents = getActiveComponents;
1035  
1036  var _regenerator = _interopRequireDefault(require("@babel/runtime/regenerator"));
1037  
1038  var _actions = require("./actions");
1039  
1040  function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
1041  
1042  var _marked = /*#__PURE__*/_regenerator.default.mark(getActiveComponents);
1043  
1044  /**
1045   * Resolver for retrieving active BP Components.
1046   */
1047  function getActiveComponents() {
1048    var list;
1049    return _regenerator.default.wrap(function getActiveComponents$(_context) {
1050      while (1) {
1051        switch (_context.prev = _context.next) {
1052          case 0:
1053            _context.next = 2;
1054            return (0, _actions.fetchFromAPI)('/buddypress/v1/components?status=active', true);
1055  
1056          case 2:
1057            list = _context.sent;
1058            _context.next = 5;
1059            return (0, _actions.getActiveComponents)(list);
1060  
1061          case 5:
1062          case "end":
1063            return _context.stop();
1064        }
1065      }
1066    }, _marked);
1067  }
1068  },{"@babel/runtime/regenerator":"BxGn","./actions":"NTbX"}],"cQfh":[function(require,module,exports) {
1069  function _defineProperty(obj, key, value) {
1070    if (key in obj) {
1071      Object.defineProperty(obj, key, {
1072        value: value,
1073        enumerable: true,
1074        configurable: true,
1075        writable: true
1076      });
1077    } else {
1078      obj[key] = value;
1079    }
1080  
1081    return obj;
1082  }
1083  
1084  module.exports = _defineProperty;
1085  },{}],"yrui":[function(require,module,exports) {
1086  "use strict";
1087  
1088  Object.defineProperty(exports, "__esModule", {
1089    value: true
1090  });
1091  exports.default = void 0;
1092  
1093  var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
1094  
1095  var _actionTypes = require("./action-types");
1096  
1097  function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
1098  
1099  function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) { symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); } keys.push.apply(keys, symbols); } return keys; }
1100  
1101  function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { (0, _defineProperty2.default)(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
1102  
1103  /**
1104   * Default state.
1105   */
1106  var DEFAULT_STATE = {
1107    components: []
1108  };
1109  /**
1110   * Reducer for the BuddyPress data store.
1111   *
1112   * @param   {Object}  state   The current state in the store.
1113   * @param   {Object}  action  Action object.
1114   *
1115   * @return  {Object}          New or existing state.
1116   */
1117  
1118  var reducer = function reducer() {
1119    var state = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : DEFAULT_STATE;
1120    var action = arguments.length > 1 ? arguments[1] : undefined;
1121  
1122    switch (action.type) {
1123      case _actionTypes.TYPES.GET_ACTIVE_COMPONENTS:
1124        return _objectSpread(_objectSpread({}, state), {}, {
1125          components: action.list
1126        });
1127    }
1128  
1129    return state;
1130  };
1131  
1132  var _default = reducer;
1133  exports.default = _default;
1134  },{"@babel/runtime/helpers/defineProperty":"cQfh","./action-types":"gg2v"}],"KdPQ":[function(require,module,exports) {
1135  "use strict";
1136  
1137  Object.defineProperty(exports, "__esModule", {
1138    value: true
1139  });
1140  exports.controls = void 0;
1141  
1142  /**
1143   * WordPress dependencies.
1144   */
1145  var _wp = wp,
1146      apiFetch = _wp.apiFetch;
1147  /**
1148   * Default export for registering the controls with the store.
1149   *
1150   * @return {Object} An object with the controls to register with the store on
1151   *                  the controls property of the registration object.
1152   */
1153  
1154  var controls = {
1155    FETCH_FROM_API: function FETCH_FROM_API(_ref) {
1156      var path = _ref.path,
1157          parse = _ref.parse;
1158      return apiFetch({
1159        path: path,
1160        parse: parse
1161      });
1162    }
1163  };
1164  exports.controls = controls;
1165  },{}],"QFc2":[function(require,module,exports) {
1166  "use strict";
1167  
1168  Object.defineProperty(exports, "__esModule", {
1169    value: true
1170  });
1171  exports.default = exports.BP_CORE_STORE_KEY = void 0;
1172  
1173  var _constants = require("./constants");
1174  
1175  var selectors = _interopRequireWildcard(require("./selectors"));
1176  
1177  var actions = _interopRequireWildcard(require("./actions"));
1178  
1179  var resolvers = _interopRequireWildcard(require("./resolvers"));
1180  
1181  var _reducers = _interopRequireDefault(require("./reducers"));
1182  
1183  var _controls = require("./controls");
1184  
1185  function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
1186  
1187  function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function (nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
1188  
1189  function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
1190  
1191  /**
1192   * WordPress dependencies.
1193   */
1194  var _wp = wp,
1195      registerStore = _wp.data.registerStore;
1196  /**
1197   * Internal dependencies.
1198   */
1199  
1200  registerStore(_constants.STORE_KEY, {
1201    reducer: _reducers.default,
1202    actions: actions,
1203    selectors: selectors,
1204    controls: _controls.controls,
1205    resolvers: resolvers
1206  });
1207  var BP_CORE_STORE_KEY = _constants.STORE_KEY;
1208  exports.BP_CORE_STORE_KEY = BP_CORE_STORE_KEY;
1209  var _default = BP_CORE_STORE_KEY;
1210  exports.default = _default;
1211  },{"./constants":"Ih1j","./selectors":"DDtj","./actions":"NTbX","./resolvers":"SaI5","./reducers":"yrui","./controls":"KdPQ"}],"qcHp":[function(require,module,exports) {
1212  "use strict";
1213  
1214  Object.defineProperty(exports, "__esModule", {
1215    value: true
1216  });
1217  exports.isActive = isActive;
1218  exports.activityTypes = activityTypes;
1219  exports.loggedInUser = loggedInUser;
1220  exports.postAuhor = postAuhor;
1221  exports.currentPostId = currentPostId;
1222  exports.getCurrentWidgetsSidebar = getCurrentWidgetsSidebar;
1223  exports.default = void 0;
1224  
1225  var _slicedToArray2 = _interopRequireDefault(require("@babel/runtime/helpers/slicedToArray"));
1226  
1227  var _register = _interopRequireDefault(require("./register"));
1228  
1229  function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
1230  
1231  /**
1232   * WordPress dependencies.
1233   */
1234  var _wp = wp,
1235      useSelect = _wp.data.useSelect;
1236  /**
1237   * External dependencies.
1238   */
1239  
1240  var _lodash = lodash,
1241      find = _lodash.find,
1242      get = _lodash.get;
1243  /**
1244   * Internal dependencies.
1245   */
1246  
1247  /**
1248   * Checks whether a component or the feature of an active component is enabled.
1249   *
1250   * @since 9.0.0
1251   *
1252   * @param {string} component (required) The component to check.
1253   * @param {string} feature (optional) The feature to check.
1254   * @return {boolean} Whether a component or the feature of an active component is enabled.
1255   */
1256  function isActive(component) {
1257    var feature = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : '';
1258    var components = useSelect(function (select) {
1259      return select(_register.default).getActiveComponents();
1260    }, []);
1261    var activeComponent = find(components, ['name', component]);
1262  
1263    if (!feature) {
1264      return !!activeComponent;
1265    }
1266  
1267    return get(activeComponent, ['features', feature]);
1268  }
1269  
1270  var _default = isActive;
1271  /**
1272   * Checks whether a component or the feature of an active component is enabled.
1273   *
1274   * @since 9.0.0
1275   *
1276   * @return {array} An array of objects keyed by activity types.
1277   */
1278  
1279  exports.default = _default;
1280  
1281  function activityTypes() {
1282    var components = useSelect(function (select) {
1283      return select(_register.default).getActiveComponents();
1284    }, []);
1285    var activityComponent = find(components, ['name', 'activity']);
1286  
1287    if (!activityComponent) {
1288      return [];
1289    }
1290  
1291    var activityTypes = get(activityComponent, ['features', 'types']);
1292    var activityTypesList = [];
1293    Object.entries(activityTypes).forEach(function (_ref) {
1294      var _ref2 = (0, _slicedToArray2.default)(_ref, 2),
1295          type = _ref2[0],
1296          label = _ref2[1];
1297  
1298      activityTypesList.push({
1299        label: label,
1300        value: type
1301      });
1302    });
1303    return activityTypesList;
1304  }
1305  /**
1306   * Returns the logged in user object.
1307   *
1308   * @since 9.0.0
1309   *
1310   * @return {Object} The logged in user object.
1311   */
1312  
1313  
1314  function loggedInUser() {
1315    var loggedInUser = useSelect(function (select) {
1316      var store = select('core');
1317  
1318      if (store) {
1319        return select('core').getCurrentUser();
1320      }
1321  
1322      return {};
1323    }, []);
1324    return loggedInUser;
1325  }
1326  /**
1327   * Returns the post author user object.
1328   *
1329   * @since 9.0.0
1330   *
1331   * @return {Object} The post author user object.
1332   */
1333  
1334  
1335  function postAuhor() {
1336    var postAuhor = useSelect(function (select) {
1337      var editorStore = select('core/editor');
1338      var coreStore = select('core');
1339  
1340      if (editorStore && coreStore) {
1341        var postAuthorId = editorStore.getCurrentPostAttribute('author');
1342        var authorsList = coreStore.getAuthors();
1343        return find(authorsList, ['id', postAuthorId]);
1344      }
1345  
1346      return {};
1347    }, []);
1348    return postAuhor;
1349  }
1350  /**
1351   * Returns the current post ID.
1352   *
1353   * @since 9.0.0
1354   *
1355   * @return {integer} The current post ID.
1356   */
1357  
1358  
1359  function currentPostId() {
1360    var currentPostId = useSelect(function (select) {
1361      var store = select('core/editor');
1362  
1363      if (store) {
1364        return store.getCurrentPostId();
1365      }
1366  
1367      return 0;
1368    }, []);
1369    return currentPostId;
1370  }
1371  /**
1372   * Get the current sidebar of a Widget Block.
1373   *
1374   * @since 9.0.0
1375   *
1376   * @param {string} widgetClientId clientId of the sidebar widget.
1377   * @return {object} An object containing the sidebar Id.
1378   */
1379  
1380  
1381  function getCurrentWidgetsSidebar() {
1382    var widgetClientId = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : '';
1383    var currentWidgetsSidebar = useSelect(function (select) {
1384      var blockEditorStore = select('core/block-editor');
1385      var widgetsStore = select('core/edit-widgets');
1386  
1387      if (widgetClientId && widgetsStore && blockEditorStore) {
1388        var areas = blockEditorStore.getBlocks();
1389        var parents = blockEditorStore.getBlockParents(widgetClientId);
1390        var sidebars = [];
1391        areas.forEach(function (_ref3) {
1392          var clientId = _ref3.clientId,
1393              attributes = _ref3.attributes;
1394          sidebars.push({
1395            id: attributes.id,
1396            isCurrent: -1 !== parents.indexOf(clientId)
1397          });
1398        });
1399        return find(sidebars, ['isCurrent', true]);
1400      }
1401  
1402      return {};
1403    }, []);
1404    return currentWidgetsSidebar;
1405  }
1406  },{"@babel/runtime/helpers/slicedToArray":"DERy","./register":"QFc2"}],"xHVY":[function(require,module,exports) {
1407  "use strict";
1408  
1409  Object.defineProperty(exports, "__esModule", {
1410    value: true
1411  });
1412  exports.default = void 0;
1413  
1414  var _utils = _interopRequireWildcard(require("./utils"));
1415  
1416  function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function (nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
1417  
1418  function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
1419  
1420  // Data.
1421  var _default = {
1422    isActive: _utils.default,
1423    activityTypes: _utils.activityTypes,
1424    loggedInUser: _utils.loggedInUser,
1425    postAuhor: _utils.postAuhor,
1426    currentPostId: _utils.currentPostId,
1427    getCurrentWidgetsSidebar: _utils.getCurrentWidgetsSidebar
1428  };
1429  exports.default = _default;
1430  },{"./utils":"qcHp"}],"tYf0":[function(require,module,exports) {
1431  "use strict";
1432  
1433  Object.defineProperty(exports, "__esModule", {
1434    value: true
1435  });
1436  Object.defineProperty(exports, "blockData", {
1437    enumerable: true,
1438    get: function () {
1439      return _data.default;
1440    }
1441  });
1442  
1443  var _data = _interopRequireDefault(require("./data"));
1444  
1445  function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
1446  },{"./data":"xHVY"}]},{},["tYf0"], "bpBlock")


Generated: Sat Oct 23 01:01:04 2021 Cross-referenced by PHPXref 0.7.1