初始化代码

uniapp/uni-app/components/miniprogram_npm/eventemitter3/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2014 Arnout Kazemier
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

uniapp/uni-app/components/miniprogram_npm/eventemitter3/README.md

@@ -0,0 +1,92 @@
+# EventEmitter3
+
+[![Version npm](https://img.shields.io/npm/v/eventemitter3.svg?style=flat-square)](https://www.npmjs.com/package/eventemitter3)[![Build Status](https://img.shields.io/travis/primus/eventemitter3/master.svg?style=flat-square)](https://travis-ci.org/primus/eventemitter3)[![Dependencies](https://img.shields.io/david/primus/eventemitter3.svg?style=flat-square)](https://david-dm.org/primus/eventemitter3)[![Coverage Status](https://img.shields.io/coveralls/primus/eventemitter3/master.svg?style=flat-square)](https://coveralls.io/r/primus/eventemitter3?branch=master)[![IRC channel](https://img.shields.io/badge/IRC-irc.freenode.net%23primus-00a8ff.svg?style=flat-square)](https://webchat.freenode.net/?channels=primus)
+
+[![Sauce Test Status](https://saucelabs.com/browser-matrix/eventemitter3.svg)](https://saucelabs.com/u/eventemitter3)
+
+EventEmitter3 is a high performance EventEmitter. It has been micro-optimized
+for various of code paths making this, one of, if not the fastest EventEmitter
+available for Node.js and browsers. The module is API compatible with the
+EventEmitter that ships by default with Node.js but there are some slight
+differences:
+
+- Domain support has been removed.
+- We do not `throw` an error when you emit an `error` event and nobody is
+  listening.
+- The `newListener` and `removeListener` events have been removed as they
+  are useful only in some uncommon use-cases.
+- The `setMaxListeners`, `getMaxListeners`, `prependListener` and
+  `prependOnceListener` methods are not available.
+- Support for custom context for events so there is no need to use `fn.bind`.
+- The `removeListener` method removes all matching listeners, not only the
+  first.
+
+It's a drop in replacement for existing EventEmitters, but just faster. Free
+performance, who wouldn't want that? The EventEmitter is written in EcmaScript 3
+so it will work in the oldest browsers and node versions that you need to
+support.
+
+## Installation
+
+```bash
+$ npm install --save eventemitter3
+```
+
+## CDN
+
+Recommended CDN:
+
+```text
+https://unpkg.com/eventemitter3@latest/umd/eventemitter3.min.js
+```
+
+## Usage
+
+After installation the only thing you need to do is require the module:
+
+```js
+var EventEmitter = require('eventemitter3');
+```
+
+And you're ready to create your own EventEmitter instances. For the API
+documentation, please follow the official Node.js documentation:
+
+http://nodejs.org/api/events.html
+
+### Contextual emits
+
+We've upgraded the API of the `EventEmitter.on`, `EventEmitter.once` and
+`EventEmitter.removeListener` to accept an extra argument which is the `context`
+or `this` value that should be set for the emitted events. This means you no
+longer have the overhead of an event that required `fn.bind` in order to get a
+custom `this` value.
+
+```js
+var EE = new EventEmitter()
+  , context = { foo: 'bar' };
+
+function emitted() {
+  console.log(this === context); // true
+}
+
+EE.once('event-name', emitted, context);
+EE.on('another-event', emitted, context);
+EE.removeListener('another-event', emitted, context);
+```
+
+### Tests and benchmarks
+
+This module is well tested. You can run:
+
+- `npm test` to run the tests under Node.js.
+- `npm run test-browser` to run the tests in real browsers via Sauce Labs.
+
+We also have a set of benchmarks to compare EventEmitter3 with some available
+alternatives. To run the benchmarks run `npm run benchmark`.
+
+Tests and benchmarks are not included in the npm package. If you want to play
+with them you have to clone the GitHub repository.
+
+## License
+
+[MIT](LICENSE)

uniapp/uni-app/components/miniprogram_npm/eventemitter3/index.d.ts

@@ -0,0 +1,67 @@
+type EventNames<T extends string | symbol | { [K in string | symbol]: any[] }> = T extends string | symbol ? T : keyof T;
+type EventArgs<T extends string | symbol | { [K in string | symbol]: any[] }, K extends EventNames<T>> = T extends string | symbol ? any[] : K extends keyof T ? T[K] : never;
+
+/**
+ * Minimal `EventEmitter` interface that is molded against the Node.js
+ * `EventEmitter` interface.
+ */
+declare class EventEmitter<EventTypes extends string | symbol | { [K in keyof EventTypes]: any[] } = string | symbol> {
+  static prefixed: string | boolean;
+
+  /**
+   * Return an array listing the events for which the emitter has registered
+   * listeners.
+   */
+  eventNames(): Array<EventNames<EventTypes>>;
+
+  /**
+   * Return the listeners registered for a given event.
+   */
+  listeners<T extends EventNames<EventTypes>>(event: T): Array<EventEmitter.ListenerFn<EventArgs<EventTypes, T>>>;
+
+  /**
+   * Return the number of listeners listening to a given event.
+   */
+  listenerCount(event: EventNames<EventTypes>): number;
+
+  /**
+   * Calls each of the listeners registered for a given event.
+   */
+  emit<T extends EventNames<EventTypes>>(event: T, ...args: EventArgs<EventTypes, T>): boolean;
+
+  /**
+   * Add a listener for a given event.
+   */
+  on<T extends EventNames<EventTypes>>(event: T, fn: EventEmitter.ListenerFn<EventArgs<EventTypes, T>>, context?: any): this;
+  addListener<T extends EventNames<EventTypes>>(event: T, fn: EventEmitter.ListenerFn<EventArgs<EventTypes, T>>, context?: any): this;
+
+  /**
+   * Add a one-time listener for a given event.
+   */
+  once<T extends EventNames<EventTypes>>(event: T, fn: EventEmitter.ListenerFn<EventArgs<EventTypes, T>>, context?: any): this;
+
+  /**
+   * Remove the listeners of a given event.
+   */
+  removeListener<T extends EventNames<EventTypes>>(event: T, fn?: EventEmitter.ListenerFn<EventArgs<EventTypes, T>>, context?: any, once?: boolean): this;
+  off<T extends EventNames<EventTypes>>(event: T, fn?: EventEmitter.ListenerFn<EventArgs<EventTypes, T>>, context?: any, once?: boolean): this;
+
+  /**
+   * Remove all listeners, or those of the specified event.
+   */
+  removeAllListeners(event?: EventNames<EventTypes>): this;
+}
+
+declare namespace EventEmitter {
+  export interface ListenerFn<Args extends any[] = any[]> {
+    (...args: Args): void;
+  }
+
+  export interface EventEmitterStatic {
+    new<EventTypes extends string | symbol | { [K in keyof EventTypes]: any[] } = string | symbol>(): EventEmitter<EventTypes>;
+  }
+
+  export const EventEmitter: EventEmitterStatic;
+}
+
+export = EventEmitter;

uniapp/uni-app/components/miniprogram_npm/eventemitter3/index.js

@@ -0,0 +1,347 @@
+'use strict';
+
+var has = Object.prototype.hasOwnProperty,
+    prefix = '~';
+/**
+ * Constructor to create a storage for our `EE` objects.
+ * An `Events` instance is a plain object whose properties are event names.
+ *
+ * @constructor
+ * @private
+ */
+
+function Events() {} //
+// We try to not inherit from `Object.prototype`. In some engines creating an
+// instance in this way is faster than calling `Object.create(null)` directly.
+// If `Object.create(null)` is not supported we prefix the event names with a
+// character to make sure that the built-in object properties are not
+// overridden or used as an attack vector.
+//
+
+
+if (Object.create) {
+  Events.prototype = Object.create(null); //
+  // This hack is needed because the `__proto__` property is still inherited in
+  // some old browsers like Android 4, iPhone 5.1, Opera 11 and Safari 5.
+  //
+
+  if (!new Events().__proto__) prefix = false;
+}
+/**
+ * Representation of a single event listener.
+ *
+ * @param {Function} fn The listener function.
+ * @param {*} context The context to invoke the listener with.
+ * @param {Boolean} [once=false] Specify if the listener is a one-time listener.
+ * @constructor
+ * @private
+ */
+
+
+function EE(fn, context, once) {
+  this.fn = fn;
+  this.context = context;
+  this.once = once || false;
+}
+/**
+ * Add a listener for a given event.
+ *
+ * @param {EventEmitter} emitter Reference to the `EventEmitter` instance.
+ * @param {(String|Symbol)} event The event name.
+ * @param {Function} fn The listener function.
+ * @param {*} context The context to invoke the listener with.
+ * @param {Boolean} once Specify if the listener is a one-time listener.
+ * @returns {EventEmitter}
+ * @private
+ */
+
+
+function addListener(emitter, event, fn, context, once) {
+  if (typeof fn !== 'function') {
+    throw new TypeError('The listener must be a function');
+  }
+
+  var listener = new EE(fn, context || emitter, once),
+      evt = prefix ? prefix + event : event;
+  if (!emitter._events[evt]) emitter._events[evt] = listener, emitter._eventsCount++;else if (!emitter._events[evt].fn) emitter._events[evt].push(listener);else emitter._events[evt] = [emitter._events[evt], listener];
+  return emitter;
+}
+/**
+ * Clear event by name.
+ *
+ * @param {EventEmitter} emitter Reference to the `EventEmitter` instance.
+ * @param {(String|Symbol)} evt The Event name.
+ * @private
+ */
+
+
+function clearEvent(emitter, evt) {
+  if (--emitter._eventsCount === 0) emitter._events = new Events();else delete emitter._events[evt];
+}
+/**
+ * Minimal `EventEmitter` interface that is molded against the Node.js
+ * `EventEmitter` interface.
+ *
+ * @constructor
+ * @public
+ */
+
+
+function EventEmitter() {
+  this._events = new Events();
+  this._eventsCount = 0;
+}
+/**
+ * Return an array listing the events for which the emitter has registered
+ * listeners.
+ *
+ * @returns {Array}
+ * @public
+ */
+
+
+EventEmitter.prototype.eventNames = function eventNames() {
+  var names = [],
+      events,
+      name;
+  if (this._eventsCount === 0) return names;
+
+  for (name in events = this._events) {
+    if (has.call(events, name)) names.push(prefix ? name.slice(1) : name);
+  }
+
+  if (Object.getOwnPropertySymbols) {
+    return names.concat(Object.getOwnPropertySymbols(events));
+  }
+
+  return names;
+};
+/**
+ * Return the listeners registered for a given event.
+ *
+ * @param {(String|Symbol)} event The event name.
+ * @returns {Array} The registered listeners.
+ * @public
+ */
+
+
+EventEmitter.prototype.listeners = function listeners(event) {
+  var evt = prefix ? prefix + event : event,
+      handlers = this._events[evt];
+  if (!handlers) return [];
+  if (handlers.fn) return [handlers.fn];
+
+  for (var i = 0, l = handlers.length, ee = new Array(l); i < l; i++) {
+    ee[i] = handlers[i].fn;
+  }
+
+  return ee;
+};
+/**
+ * Return the number of listeners listening to a given event.
+ *
+ * @param {(String|Symbol)} event The event name.
+ * @returns {Number} The number of listeners.
+ * @public
+ */
+
+
+EventEmitter.prototype.listenerCount = function listenerCount(event) {
+  var evt = prefix ? prefix + event : event,
+      listeners = this._events[evt];
+  if (!listeners) return 0;
+  if (listeners.fn) return 1;
+  return listeners.length;
+};
+/**
+ * Calls each of the listeners registered for a given event.
+ *
+ * @param {(String|Symbol)} event The event name.
+ * @returns {Boolean} `true` if the event had listeners, else `false`.
+ * @public
+ */
+
+
+EventEmitter.prototype.emit = function emit(event, a1, a2, a3, a4, a5) {
+  var evt = prefix ? prefix + event : event;
+  if (!this._events[evt]) return false;
+  var listeners = this._events[evt],
+      len = arguments.length,
+      args,
+      i;
+
+  if (listeners.fn) {
+    if (listeners.once) this.removeListener(event, listeners.fn, undefined, true);
+
+    switch (len) {
+      case 1:
+        return listeners.fn.call(listeners.context), true;
+
+      case 2:
+        return listeners.fn.call(listeners.context, a1), true;
+
+      case 3:
+        return listeners.fn.call(listeners.context, a1, a2), true;
+
+      case 4:
+        return listeners.fn.call(listeners.context, a1, a2, a3), true;
+
+      case 5:
+        return listeners.fn.call(listeners.context, a1, a2, a3, a4), true;
+
+      case 6:
+        return listeners.fn.call(listeners.context, a1, a2, a3, a4, a5), true;
+    }
+
+    for (i = 1, args = new Array(len - 1); i < len; i++) {
+      args[i - 1] = arguments[i];
+    }
+
+    listeners.fn.apply(listeners.context, args);
+  } else {
+    var length = listeners.length,
+        j;
+
+    for (i = 0; i < length; i++) {
+      if (listeners[i].once) this.removeListener(event, listeners[i].fn, undefined, true);
+
+      switch (len) {
+        case 1:
+          listeners[i].fn.call(listeners[i].context);
+          break;
+
+        case 2:
+          listeners[i].fn.call(listeners[i].context, a1);
+          break;
+
+        case 3:
+          listeners[i].fn.call(listeners[i].context, a1, a2);
+          break;
+
+        case 4:
+          listeners[i].fn.call(listeners[i].context, a1, a2, a3);
+          break;
+
+        default:
+          if (!args) for (j = 1, args = new Array(len - 1); j < len; j++) {
+            args[j - 1] = arguments[j];
+          }
+          listeners[i].fn.apply(listeners[i].context, args);
+      }
+    }
+  }
+
+  return true;
+};
+/**
+ * Add a listener for a given event.
+ *
+ * @param {(String|Symbol)} event The event name.
+ * @param {Function} fn The listener function.
+ * @param {*} [context=this] The context to invoke the listener with.
+ * @returns {EventEmitter} `this`.
+ * @public
+ */
+
+
+EventEmitter.prototype.on = function on(event, fn, context) {
+  return addListener(this, event, fn, context, false);
+};
+/**
+ * Add a one-time listener for a given event.
+ *
+ * @param {(String|Symbol)} event The event name.
+ * @param {Function} fn The listener function.
+ * @param {*} [context=this] The context to invoke the listener with.
+ * @returns {EventEmitter} `this`.
+ * @public
+ */
+
+
+EventEmitter.prototype.once = function once(event, fn, context) {
+  return addListener(this, event, fn, context, true);
+};
+/**
+ * Remove the listeners of a given event.
+ *
+ * @param {(String|Symbol)} event The event name.
+ * @param {Function} fn Only remove the listeners that match this function.
+ * @param {*} context Only remove the listeners that have this context.
+ * @param {Boolean} once Only remove one-time listeners.
+ * @returns {EventEmitter} `this`.
+ * @public
+ */
+
+
+EventEmitter.prototype.removeListener = function removeListener(event, fn, context, once) {
+  var evt = prefix ? prefix + event : event;
+  if (!this._events[evt]) return this;
+
+  if (!fn) {
+    clearEvent(this, evt);
+    return this;
+  }
+
+  var listeners = this._events[evt];
+
+  if (listeners.fn) {
+    if (listeners.fn === fn && (!once || listeners.once) && (!context || listeners.context === context)) {
+      clearEvent(this, evt);
+    }
+  } else {
+    for (var i = 0, events = [], length = listeners.length; i < length; i++) {
+      if (listeners[i].fn !== fn || once && !listeners[i].once || context && listeners[i].context !== context) {
+        events.push(listeners[i]);
+      }
+    } //
+    // Reset the array, or remove it completely if we have no more listeners.
+    //
+
+
+    if (events.length) this._events[evt] = events.length === 1 ? events[0] : events;else clearEvent(this, evt);
+  }
+
+  return this;
+};
+/**
+ * Remove all listeners, or those of the specified event.
+ *
+ * @param {(String|Symbol)} [event] The event name.
+ * @returns {EventEmitter} `this`.
+ * @public
+ */
+
+
+EventEmitter.prototype.removeAllListeners = function removeAllListeners(event) {
+  var evt;
+
+  if (event) {
+    evt = prefix ? prefix + event : event;
+    if (this._events[evt]) clearEvent(this, evt);
+  } else {
+    this._events = new Events();
+    this._eventsCount = 0;
+  }
+
+  return this;
+}; //
+// Alias methods names because people roll like that.
+//
+
+
+EventEmitter.prototype.off = EventEmitter.prototype.removeListener;
+EventEmitter.prototype.addListener = EventEmitter.prototype.on; //
+// Expose the prefix.
+//
+
+EventEmitter.prefixed = prefix; //
+// Allow `EventEmitter` to be imported as module namespace.
+//
+
+EventEmitter.EventEmitter = EventEmitter; //
+// Expose the module.
+//
+
+if ('undefined' !== typeof module) {
+  module.exports = EventEmitter;
+}

uniapp/uni-app/components/miniprogram_npm/eventemitter3/package.json

@@ -0,0 +1,84 @@
+{
+  "_from": "eventemitter3@^4.0.0",
+  "_id": "eventemitter3@4.0.0",
+  "_inBundle": false,
+  "_integrity": "sha512-qerSRB0p+UDEssxTtm6EDKcE7W4OaoisfIMl4CngyEhjpYglocpNg6UEqCvemdGhosAsg4sO2dXJOdyBifPGCg==",
+  "_location": "/eventemitter3",
+  "_phantomChildren": {},
+  "_requested": {
+    "type": "range",
+    "registry": true,
+    "raw": "eventemitter3@^4.0.0",
+    "name": "eventemitter3",
+    "escapedName": "eventemitter3",
+    "rawSpec": "^4.0.0",
+    "saveSpec": null,
+    "fetchSpec": "^4.0.0"
+  },
+  "_requiredBy": [
+    "/widget-ui"
+  ],
+  "_resolved": "https://registry.npmjs.org/eventemitter3/-/eventemitter3-4.0.0.tgz",
+  "_shasum": "d65176163887ee59f386d64c82610b696a4a74eb",
+  "_spec": "eventemitter3@^4.0.0",
+  "_where": "C:\\Users\\sanfordsun\\WeChatProjects\\minicode-177\\node_modules\\widget-ui",
+  "author": {
+    "name": "Arnout Kazemier"
+  },
+  "bugs": {
+    "url": "https://github.com/primus/eventemitter3/issues"
+  },
+  "bundleDependencies": false,
+  "deprecated": false,
+  "description": "EventEmitter3 focuses on performance while maintaining a Node.js AND browser compatible interface.",
+  "devDependencies": {
+    "assume": "~2.2.0",
+    "browserify": "~16.2.0",
+    "mocha": "~6.1.0",
+    "nyc": "~14.1.0",
+    "pre-commit": "~1.2.0",
+    "sauce-browsers": "~2.0.0",
+    "sauce-test": "~1.3.3",
+    "uglify-js": "~3.6.0"
+  },
+  "files": [
+    "index.js",
+    "index.d.ts",
+    "umd"
+  ],
+  "homepage": "https://github.com/primus/eventemitter3#readme",
+  "keywords": [
+    "EventEmitter",
+    "EventEmitter2",
+    "EventEmitter3",
+    "Events",
+    "addEventListener",
+    "addListener",
+    "emit",
+    "emits",
+    "emitter",
+    "event",
+    "once",
+    "pub/sub",
+    "publish",
+    "reactor",
+    "subscribe"
+  ],
+  "license": "MIT",
+  "main": "index.js",
+  "name": "eventemitter3",
+  "repository": {
+    "type": "git",
+    "url": "git://github.com/primus/eventemitter3.git"
+  },
+  "scripts": {
+    "benchmark": "find benchmarks/run -name '*.js' -exec benchmarks/start.sh {} \\;",
+    "browserify": "rm -rf umd && mkdir umd && browserify index.js -s EventEmitter3 -o umd/eventemitter3.js",
+    "minify": "uglifyjs umd/eventemitter3.js --source-map -cm -o umd/eventemitter3.min.js",
+    "prepublishOnly": "npm run browserify && npm run minify",
+    "test": "nyc --reporter=html --reporter=text mocha test/test.js",
+    "test-browser": "node test/browser.js"
+  },
+  "typings": "index.d.ts",
+  "version": "4.0.0"
+}

uniapp/uni-app/components/miniprogram_npm/eventemitter3/umd/eventemitter3.js

@@ -0,0 +1,404 @@
+(function (f) {
+  if (typeof exports === "object" && typeof module !== "undefined") {
+    module.exports = f();
+  } else if (typeof define === "function" && define.amd) {
+    define([], f);
+  } else {
+    var g;
+
+    if (typeof window !== "undefined") {
+      g = window;
+    } else if (typeof global !== "undefined") {
+      g = global;
+    } else if (typeof self !== "undefined") {
+      g = self;
+    } else {
+      g = this;
+    }
+
+    g.EventEmitter3 = f();
+  }
+})(function () {
+  var define, module, exports;
+  return function () {
+    function r(e, n, t) {
+      function o(i, f) {
+        if (!n[i]) {
+          if (!e[i]) {
+            var c = "function" == typeof require && require;
+            if (!f && c) return c(i, !0);
+            if (u) return u(i, !0);
+            var a = new Error("Cannot find module '" + i + "'");
+            throw a.code = "MODULE_NOT_FOUND", a;
+          }
+
+          var p = n[i] = {
+            exports: {}
+          };
+          e[i][0].call(p.exports, function (r) {
+            var n = e[i][1][r];
+            return o(n || r);
+          }, p, p.exports, r, e, n, t);
+        }
+
+        return n[i].exports;
+      }
+
+      for (var u = "function" == typeof require && require, i = 0; i < t.length; i++) o(t[i]);
+
+      return o;
+    }
+
+    return r;
+  }()({
+    1: [function (require, module, exports) {
+      'use strict';
+
+      var has = Object.prototype.hasOwnProperty,
+          prefix = '~';
+      /**
+       * Constructor to create a storage for our `EE` objects.
+       * An `Events` instance is a plain object whose properties are event names.
+       *
+       * @constructor
+       * @private
+       */
+
+      function Events() {} //
+      // We try to not inherit from `Object.prototype`. In some engines creating an
+      // instance in this way is faster than calling `Object.create(null)` directly.
+      // If `Object.create(null)` is not supported we prefix the event names with a
+      // character to make sure that the built-in object properties are not
+      // overridden or used as an attack vector.
+      //
+
+
+      if (Object.create) {
+        Events.prototype = Object.create(null); //
+        // This hack is needed because the `__proto__` property is still inherited in
+        // some old browsers like Android 4, iPhone 5.1, Opera 11 and Safari 5.
+        //
+
+        if (!new Events().__proto__) prefix = false;
+      }
+      /**
+       * Representation of a single event listener.
+       *
+       * @param {Function} fn The listener function.
+       * @param {*} context The context to invoke the listener with.
+       * @param {Boolean} [once=false] Specify if the listener is a one-time listener.
+       * @constructor
+       * @private
+       */
+
+
+      function EE(fn, context, once) {
+        this.fn = fn;
+        this.context = context;
+        this.once = once || false;
+      }
+      /**
+       * Add a listener for a given event.
+       *
+       * @param {EventEmitter} emitter Reference to the `EventEmitter` instance.
+       * @param {(String|Symbol)} event The event name.
+       * @param {Function} fn The listener function.
+       * @param {*} context The context to invoke the listener with.
+       * @param {Boolean} once Specify if the listener is a one-time listener.
+       * @returns {EventEmitter}
+       * @private
+       */
+
+
+      function addListener(emitter, event, fn, context, once) {
+        if (typeof fn !== 'function') {
+          throw new TypeError('The listener must be a function');
+        }
+
+        var listener = new EE(fn, context || emitter, once),
+            evt = prefix ? prefix + event : event;
+        if (!emitter._events[evt]) emitter._events[evt] = listener, emitter._eventsCount++;else if (!emitter._events[evt].fn) emitter._events[evt].push(listener);else emitter._events[evt] = [emitter._events[evt], listener];
+        return emitter;
+      }
+      /**
+       * Clear event by name.
+       *
+       * @param {EventEmitter} emitter Reference to the `EventEmitter` instance.
+       * @param {(String|Symbol)} evt The Event name.
+       * @private
+       */
+
+
+      function clearEvent(emitter, evt) {
+        if (--emitter._eventsCount === 0) emitter._events = new Events();else delete emitter._events[evt];
+      }
+      /**
+       * Minimal `EventEmitter` interface that is molded against the Node.js
+       * `EventEmitter` interface.
+       *
+       * @constructor
+       * @public
+       */
+
+
+      function EventEmitter() {
+        this._events = new Events();
+        this._eventsCount = 0;
+      }
+      /**
+       * Return an array listing the events for which the emitter has registered
+       * listeners.
+       *
+       * @returns {Array}
+       * @public
+       */
+
+
+      EventEmitter.prototype.eventNames = function eventNames() {
+        var names = [],
+            events,
+            name;
+        if (this._eventsCount === 0) return names;
+
+        for (name in events = this._events) {
+          if (has.call(events, name)) names.push(prefix ? name.slice(1) : name);
+        }
+
+        if (Object.getOwnPropertySymbols) {
+          return names.concat(Object.getOwnPropertySymbols(events));
+        }
+
+        return names;
+      };
+      /**
+       * Return the listeners registered for a given event.
+       *
+       * @param {(String|Symbol)} event The event name.
+       * @returns {Array} The registered listeners.
+       * @public
+       */
+
+
+      EventEmitter.prototype.listeners = function listeners(event) {
+        var evt = prefix ? prefix + event : event,
+            handlers = this._events[evt];
+        if (!handlers) return [];
+        if (handlers.fn) return [handlers.fn];
+
+        for (var i = 0, l = handlers.length, ee = new Array(l); i < l; i++) {
+          ee[i] = handlers[i].fn;
+        }
+
+        return ee;
+      };
+      /**
+       * Return the number of listeners listening to a given event.
+       *
+       * @param {(String|Symbol)} event The event name.
+       * @returns {Number} The number of listeners.
+       * @public
+       */
+
+
+      EventEmitter.prototype.listenerCount = function listenerCount(event) {
+        var evt = prefix ? prefix + event : event,
+            listeners = this._events[evt];
+        if (!listeners) return 0;
+        if (listeners.fn) return 1;
+        return listeners.length;
+      };
+      /**
+       * Calls each of the listeners registered for a given event.
+       *
+       * @param {(String|Symbol)} event The event name.
+       * @returns {Boolean} `true` if the event had listeners, else `false`.
+       * @public
+       */
+
+
+      EventEmitter.prototype.emit = function emit(event, a1, a2, a3, a4, a5) {
+        var evt = prefix ? prefix + event : event;
+        if (!this._events[evt]) return false;
+        var listeners = this._events[evt],
+            len = arguments.length,
+            args,
+            i;
+
+        if (listeners.fn) {
+          if (listeners.once) this.removeListener(event, listeners.fn, undefined, true);
+
+          switch (len) {
+            case 1:
+              return listeners.fn.call(listeners.context), true;
+
+            case 2:
+              return listeners.fn.call(listeners.context, a1), true;
+
+            case 3:
+              return listeners.fn.call(listeners.context, a1, a2), true;
+
+            case 4:
+              return listeners.fn.call(listeners.context, a1, a2, a3), true;
+
+            case 5:
+              return listeners.fn.call(listeners.context, a1, a2, a3, a4), true;
+
+            case 6:
+              return listeners.fn.call(listeners.context, a1, a2, a3, a4, a5), true;
+          }
+
+          for (i = 1, args = new Array(len - 1); i < len; i++) {
+            args[i - 1] = arguments[i];
+          }
+
+          listeners.fn.apply(listeners.context, args);
+        } else {
+          var length = listeners.length,
+              j;
+
+          for (i = 0; i < length; i++) {
+            if (listeners[i].once) this.removeListener(event, listeners[i].fn, undefined, true);
+
+            switch (len) {
+              case 1:
+                listeners[i].fn.call(listeners[i].context);
+                break;
+
+              case 2:
+                listeners[i].fn.call(listeners[i].context, a1);
+                break;
+
+              case 3:
+                listeners[i].fn.call(listeners[i].context, a1, a2);
+                break;
+
+              case 4:
+                listeners[i].fn.call(listeners[i].context, a1, a2, a3);
+                break;
+
+              default:
+                if (!args) for (j = 1, args = new Array(len - 1); j < len; j++) {
+                  args[j - 1] = arguments[j];
+                }
+                listeners[i].fn.apply(listeners[i].context, args);
+            }
+          }
+        }
+
+        return true;
+      };
+      /**
+       * Add a listener for a given event.
+       *
+       * @param {(String|Symbol)} event The event name.
+       * @param {Function} fn The listener function.
+       * @param {*} [context=this] The context to invoke the listener with.
+       * @returns {EventEmitter} `this`.
+       * @public
+       */
+
+
+      EventEmitter.prototype.on = function on(event, fn, context) {
+        return addListener(this, event, fn, context, false);
+      };
+      /**
+       * Add a one-time listener for a given event.
+       *
+       * @param {(String|Symbol)} event The event name.
+       * @param {Function} fn The listener function.
+       * @param {*} [context=this] The context to invoke the listener with.
+       * @returns {EventEmitter} `this`.
+       * @public
+       */
+
+
+      EventEmitter.prototype.once = function once(event, fn, context) {
+        return addListener(this, event, fn, context, true);
+      };
+      /**
+       * Remove the listeners of a given event.
+       *
+       * @param {(String|Symbol)} event The event name.
+       * @param {Function} fn Only remove the listeners that match this function.
+       * @param {*} context Only remove the listeners that have this context.
+       * @param {Boolean} once Only remove one-time listeners.
+       * @returns {EventEmitter} `this`.
+       * @public
+       */
+
+
+      EventEmitter.prototype.removeListener = function removeListener(event, fn, context, once) {
+        var evt = prefix ? prefix + event : event;
+        if (!this._events[evt]) return this;
+
+        if (!fn) {
+          clearEvent(this, evt);
+          return this;
+        }
+
+        var listeners = this._events[evt];
+
+        if (listeners.fn) {
+          if (listeners.fn === fn && (!once || listeners.once) && (!context || listeners.context === context)) {
+            clearEvent(this, evt);
+          }
+        } else {
+          for (var i = 0, events = [], length = listeners.length; i < length; i++) {
+            if (listeners[i].fn !== fn || once && !listeners[i].once || context && listeners[i].context !== context) {
+              events.push(listeners[i]);
+            }
+          } //
+          // Reset the array, or remove it completely if we have no more listeners.
+          //
+
+
+          if (events.length) this._events[evt] = events.length === 1 ? events[0] : events;else clearEvent(this, evt);
+        }
+
+        return this;
+      };
+      /**
+       * Remove all listeners, or those of the specified event.
+       *
+       * @param {(String|Symbol)} [event] The event name.
+       * @returns {EventEmitter} `this`.
+       * @public
+       */
+
+
+      EventEmitter.prototype.removeAllListeners = function removeAllListeners(event) {
+        var evt;
+
+        if (event) {
+          evt = prefix ? prefix + event : event;
+          if (this._events[evt]) clearEvent(this, evt);
+        } else {
+          this._events = new Events();
+          this._eventsCount = 0;
+        }
+
+        return this;
+      }; //
+      // Alias methods names because people roll like that.
+      //
+
+
+      EventEmitter.prototype.off = EventEmitter.prototype.removeListener;
+      EventEmitter.prototype.addListener = EventEmitter.prototype.on; //
+      // Expose the prefix.
+      //
+
+      EventEmitter.prefixed = prefix; //
+      // Allow `EventEmitter` to be imported as module namespace.
+      //
+
+      EventEmitter.EventEmitter = EventEmitter; //
+      // Expose the module.
+      //
+
+      if ('undefined' !== typeof module) {
+        module.exports = EventEmitter;
+      }
+    }, {}]
+  }, {}, [1])(1);
+});

uniapp/uni-app/components/miniprogram_npm/eventemitter3/umd/eventemitter3.min.js

@@ -0,0 +1,162 @@
+!function (e) {
+  if ("object" == typeof exports && "undefined" != typeof module) module.exports = e();else if ("function" == typeof define && define.amd) define([], e);else {
+    ("undefined" != typeof window ? window : "undefined" != typeof global ? global : "undefined" != typeof self ? self : this).EventEmitter3 = e();
+  }
+}(function () {
+  return function i(s, f, c) {
+    function u(t, e) {
+      if (!f[t]) {
+        if (!s[t]) {
+          var n = "function" == typeof require && require;
+          if (!e && n) return n(t, !0);
+          if (a) return a(t, !0);
+          var r = new Error("Cannot find module '" + t + "'");
+          throw r.code = "MODULE_NOT_FOUND", r;
+        }
+
+        var o = f[t] = {
+          exports: {}
+        };
+        s[t][0].call(o.exports, function (e) {
+          return u(s[t][1][e] || e);
+        }, o, o.exports, i, s, f, c);
+      }
+
+      return f[t].exports;
+    }
+
+    for (var a = "function" == typeof require && require, e = 0; e < c.length; e++) u(c[e]);
+
+    return u;
+  }({
+    1: [function (e, t, n) {
+      "use strict";
+
+      var r = Object.prototype.hasOwnProperty,
+          v = "~";
+
+      function o() {}
+
+      function f(e, t, n) {
+        this.fn = e, this.context = t, this.once = n || !1;
+      }
+
+      function i(e, t, n, r, o) {
+        if ("function" != typeof n) throw new TypeError("The listener must be a function");
+        var i = new f(n, r || e, o),
+            s = v ? v + t : t;
+        return e._events[s] ? e._events[s].fn ? e._events[s] = [e._events[s], i] : e._events[s].push(i) : (e._events[s] = i, e._eventsCount++), e;
+      }
+
+      function u(e, t) {
+        0 == --e._eventsCount ? e._events = new o() : delete e._events[t];
+      }
+
+      function s() {
+        this._events = new o(), this._eventsCount = 0;
+      }
+
+      Object.create && (o.prototype = Object.create(null), new o().__proto__ || (v = !1)), s.prototype.eventNames = function () {
+        var e,
+            t,
+            n = [];
+        if (0 === this._eventsCount) return n;
+
+        for (t in e = this._events) r.call(e, t) && n.push(v ? t.slice(1) : t);
+
+        return Object.getOwnPropertySymbols ? n.concat(Object.getOwnPropertySymbols(e)) : n;
+      }, s.prototype.listeners = function (e) {
+        var t = v ? v + e : e,
+            n = this._events[t];
+        if (!n) return [];
+        if (n.fn) return [n.fn];
+
+        for (var r = 0, o = n.length, i = new Array(o); r < o; r++) i[r] = n[r].fn;
+
+        return i;
+      }, s.prototype.listenerCount = function (e) {
+        var t = v ? v + e : e,
+            n = this._events[t];
+        return n ? n.fn ? 1 : n.length : 0;
+      }, s.prototype.emit = function (e, t, n, r, o, i) {
+        var s = v ? v + e : e;
+        if (!this._events[s]) return !1;
+        var f,
+            c,
+            u = this._events[s],
+            a = arguments.length;
+
+        if (u.fn) {
+          switch (u.once && this.removeListener(e, u.fn, void 0, !0), a) {
+            case 1:
+              return u.fn.call(u.context), !0;
+
+            case 2:
+              return u.fn.call(u.context, t), !0;
+
+            case 3:
+              return u.fn.call(u.context, t, n), !0;
+
+            case 4:
+              return u.fn.call(u.context, t, n, r), !0;
+
+            case 5:
+              return u.fn.call(u.context, t, n, r, o), !0;
+
+            case 6:
+              return u.fn.call(u.context, t, n, r, o, i), !0;
+          }
+
+          for (c = 1, f = new Array(a - 1); c < a; c++) f[c - 1] = arguments[c];
+
+          u.fn.apply(u.context, f);
+        } else {
+          var l,
+              p = u.length;
+
+          for (c = 0; c < p; c++) switch (u[c].once && this.removeListener(e, u[c].fn, void 0, !0), a) {
+            case 1:
+              u[c].fn.call(u[c].context);
+              break;
+
+            case 2:
+              u[c].fn.call(u[c].context, t);
+              break;
+
+            case 3:
+              u[c].fn.call(u[c].context, t, n);
+              break;
+
+            case 4:
+              u[c].fn.call(u[c].context, t, n, r);
+              break;
+
+            default:
+              if (!f) for (l = 1, f = new Array(a - 1); l < a; l++) f[l - 1] = arguments[l];
+              u[c].fn.apply(u[c].context, f);
+          }
+        }
+
+        return !0;
+      }, s.prototype.on = function (e, t, n) {
+        return i(this, e, t, n, !1);
+      }, s.prototype.once = function (e, t, n) {
+        return i(this, e, t, n, !0);
+      }, s.prototype.removeListener = function (e, t, n, r) {
+        var o = v ? v + e : e;
+        if (!this._events[o]) return this;
+        if (!t) return u(this, o), this;
+        var i = this._events[o];
+        if (i.fn) i.fn !== t || r && !i.once || n && i.context !== n || u(this, o);else {
+          for (var s = 0, f = [], c = i.length; s < c; s++) (i[s].fn !== t || r && !i[s].once || n && i[s].context !== n) && f.push(i[s]);
+
+          f.length ? this._events[o] = 1 === f.length ? f[0] : f : u(this, o);
+        }
+        return this;
+      }, s.prototype.removeAllListeners = function (e) {
+        var t;
+        return e ? (t = v ? v + e : e, this._events[t] && u(this, t)) : (this._events = new o(), this._eventsCount = 0), this;
+      }, s.prototype.off = s.prototype.removeListener, s.prototype.addListener = s.prototype.on, s.prefixed = v, s.EventEmitter = s, void 0 !== t && (t.exports = s);
+    }, {}]
+  }, {}, [1])(1);
+});