comt: comparison src/cm/media/js/lib/yui/yui3-3.15.0/build/event-synthetic/event-synthetic-debug.js

Mercurial Mercurial > comt / comparison

summary | shortlog | changelog | graph | tags | bookmarks | branches | files | changeset | file | latest | revisions | annotate | diff | comparison | raw | help

src/cm/media/js/lib/yui/yui3-3.15.0/build/event-synthetic/event-synthetic-debug.js

changeset 602

e16a97fb364a

equal deleted inserted replaced

-:d334a616c023
+:e16a97fb364a
+YUI.add('event-synthetic', function (Y, NAME) {
+/**
+* Define new DOM events that can be subscribed to from Nodes.
+*
+* @module event
+* @submodule event-synthetic
+*/
+var CustomEvent = Y.CustomEvent,
+DOMMap   = Y.Env.evt.dom_map,
+toArray  = Y.Array,
+YLang    = Y.Lang,
+isObject = YLang.isObject,
+isString = YLang.isString,
+isArray  = YLang.isArray,
+query    = Y.Selector.query,
+noop     = function () {};
+/**
+* <p>The triggering mechanism used by SyntheticEvents.</p>
+*
+* <p>Implementers should not instantiate these directly.  Use the Notifier
+* provided to the event's implemented <code>on(node, sub, notifier)</code> or
+* <code>delegate(node, sub, notifier, filter)</code> methods.</p>
+*
+* @class SyntheticEvent.Notifier
+* @constructor
+* @param handle {EventHandle} the detach handle for the subscription to an
+*              internal custom event used to execute the callback passed to
+*              on(..) or delegate(..)
+* @param emitFacade {Boolean} take steps to ensure the first arg received by
+*              the subscription callback is an event facade
+* @private
+* @since 3.2.0
+*/
+function Notifier(handle, emitFacade) {
+this.handle     = handle;
+this.emitFacade = emitFacade;
+}
+/**
+* <p>Executes the subscription callback, passing the firing arguments as the
+* first parameters to that callback. For events that are configured with
+* emitFacade=true, it is common practice to pass the triggering DOMEventFacade
+* as the first parameter.  Barring a proper DOMEventFacade or EventFacade
+* (from a CustomEvent), a new EventFacade will be generated.  In that case, if
+* fire() is called with a simple object, it will be mixed into the facade.
+* Otherwise, the facade will be prepended to the callback parameters.</p>
+*
+* <p>For notifiers provided to delegate logic, the first argument should be an
+* object with a &quot;currentTarget&quot; property to identify what object to
+* default as 'this' in the callback.  Typically this is gleaned from the
+* DOMEventFacade or EventFacade, but if configured with emitFacade=false, an
+* object must be provided.  In that case, the object will be removed from the
+* callback parameters.</p>
+*
+* <p>Additional arguments passed during event subscription will be
+* automatically added after those passed to fire().</p>
+*
+* @method fire
+* @param {EventFacade|DOMEventFacade|any} e (see description)
+* @param {any[]} [arg*] additional arguments received by all subscriptions
+* @private
+*/
+Notifier.prototype.fire = function (e) {
+// first arg to delegate notifier should be an object with currentTarget
+var args     = toArray(arguments, 0, true),
+handle   = this.handle,
+ce       = handle.evt,
+sub      = handle.sub,
+thisObj  = sub.context,
+delegate = sub.filter,
+event    = e || {},
+ret;
+if (this.emitFacade) {
+if (!e || !e.preventDefault) {
+event = ce._getFacade();
+if (isObject(e) && !e.preventDefault) {
+Y.mix(event, e, true);
+args[0] = event;
+} else {
+args.unshift(event);
+}
+}
+event.type    = ce.type;
+event.details = args.slice();
+if (delegate) {
+event.container = ce.host;
+}
+} else if (delegate && isObject(e) && e.currentTarget) {
+args.shift();
+}
+sub.context = thisObj || event.currentTarget || ce.host;
+ret = ce.fire.apply(ce, args);
+// have to handle preventedFn and stoppedFn manually because
+// Notifier CustomEvents are forced to emitFacade=false
+if (e.prevented && ce.preventedFn) {
+ce.preventedFn.apply(ce, args);
+}
+if (e.stopped && ce.stoppedFn) {
+ce.stoppedFn.apply(ce, args);
+}
+sub.context = thisObj; // reset for future firing
+// to capture callbacks that return false to stopPropagation.
+// Useful for delegate implementations
+return ret;
+};
+/**
+* Manager object for synthetic event subscriptions to aggregate multiple synths on the
+* same node without colliding with actual DOM subscription entries in the global map of
+* DOM subscriptions.  Also facilitates proper cleanup on page unload.
+*
+* @class SynthRegistry
+* @constructor
+* @param el {HTMLElement} the DOM element
+* @param yuid {String} the yuid stamp for the element
+* @param key {String} the generated id token used to identify an event type +
+*                     element in the global DOM subscription map.
+* @private
+*/
+function SynthRegistry(el, yuid, key) {
+this.handles = [];
+this.el      = el;
+this.key     = key;
+this.domkey  = yuid;
+}
+SynthRegistry.prototype = {
+constructor: SynthRegistry,
+// A few object properties to fake the CustomEvent interface for page
+// unload cleanup.  DON'T TOUCH!
+type      : '_synth',
+fn        : noop,
+capture   : false,
+/**
+* Adds a subscription from the Notifier registry.
+*
+* @method register
+* @param handle {EventHandle} the subscription
+* @since 3.4.0
+*/
+register: function (handle) {
+handle.evt.registry = this;
+this.handles.push(handle);
+},
+/**
+* Removes the subscription from the Notifier registry.
+*
+* @method _unregisterSub
+* @param sub {Subscription} the subscription
+* @since 3.4.0
+*/
+unregister: function (sub) {
+var handles = this.handles,
+events = DOMMap[this.domkey],
+i;
+for (i = handles.length - 1; i >= 0; --i) {
+if (handles[i].sub === sub) {
+handles.splice(i, 1);
+break;
+}
+}
+// Clean up left over objects when there are no more subscribers.
+if (!handles.length) {
+delete events[this.key];
+if (!Y.Object.size(events)) {
+delete DOMMap[this.domkey];
+}
+}
+},
+/**
+* Used by the event system's unload cleanup process.  When navigating
+* away from the page, the event system iterates the global map of element
+* subscriptions and detaches everything using detachAll().  Normally,
+* the map is populated with custom events, so this object needs to
+* at least support the detachAll method to duck type its way to
+* cleanliness.
+*
+* @method detachAll
+* @private
+* @since 3.4.0
+*/
+detachAll : function () {
+var handles = this.handles,
+i = handles.length;
+while (--i >= 0) {
+handles[i].detach();
+}
+}
+};
+/**
+* <p>Wrapper class for the integration of new events into the YUI event
+* infrastructure.  Don't instantiate this object directly, use
+* <code>Y.Event.define(type, config)</code>.  See that method for details.</p>
+*
+* <p>Properties that MAY or SHOULD be specified in the configuration are noted
+* below and in the description of <code>Y.Event.define</code>.</p>
+*
+* @class SyntheticEvent
+* @constructor
+* @param cfg {Object} Implementation pieces and configuration
+* @since 3.1.0
+* @in event-synthetic
+*/
+function SyntheticEvent() {
+this._init.apply(this, arguments);
+}
+Y.mix(SyntheticEvent, {
+Notifier: Notifier,
+SynthRegistry: SynthRegistry,
+/**
+* Returns the array of subscription handles for a node for the given event
+* type.  Passing true as the third argument will create a registry entry
+* in the event system's DOM map to host the array if one doesn't yet exist.
+*
+* @method getRegistry
+* @param node {Node} the node
+* @param type {String} the event
+* @param create {Boolean} create a registration entry to host a new array
+*                  if one doesn't exist.
+* @return {Array}
+* @static
+* @protected
+* @since 3.2.0
+*/
+getRegistry: function (node, type, create) {
+var el     = node._node,
+yuid   = Y.stamp(el),
+key    = 'event:' + yuid + type + '_synth',
+events = DOMMap[yuid];
+if (create) {
+if (!events) {
+events = DOMMap[yuid] = {};
+}
+if (!events[key]) {
+events[key] = new SynthRegistry(el, yuid, key);
+}
+}
+return (events && events[key]) || null;
+},
+/**
+* Alternate <code>_delete()</code> method for the CustomEvent object
+* created to manage SyntheticEvent subscriptions.
+*
+* @method _deleteSub
+* @param sub {Subscription} the subscription to clean up
+* @private
+* @since 3.2.0
+*/
+_deleteSub: function (sub) {
+if (sub && sub.fn) {
+var synth = this.eventDef,
+method = (sub.filter) ? 'detachDelegate' : 'detach';
+this._subscribers = [];
+if (CustomEvent.keepDeprecatedSubs) {
+this.subscribers = {};
+}
+synth[method](sub.node, sub, this.notifier, sub.filter);
+this.registry.unregister(sub);
+delete sub.fn;
+delete sub.node;
+delete sub.context;
+}
+},
+prototype: {
+constructor: SyntheticEvent,
+/**
+* Construction logic for the event.
+*
+* @method _init
+* @protected
+*/
+_init: function () {
+var config = this.publishConfig || (this.publishConfig = {});
+// The notification mechanism handles facade creation
+this.emitFacade = ('emitFacade' in config) ?
+config.emitFacade :
+true;
+config.emitFacade  = false;
+},
+/**
+* <p>Implementers MAY provide this method definition.</p>
+*
+* <p>Implement this function if the event supports a different
+* subscription signature.  This function is used by both
+* <code>on()</code> and <code>delegate()</code>.  The second parameter
+* indicates that the event is being subscribed via
+* <code>delegate()</code>.</p>
+*
+* <p>Implementations must remove extra arguments from the args list
+* before returning.  The required args for <code>on()</code>
+* subscriptions are</p>
+* <pre><code>[type, callback, target, context, argN...]</code></pre>
+*
+* <p>The required args for <code>delegate()</code>
+* subscriptions are</p>
+*
+* <pre><code>[type, callback, target, filter, context, argN...]</code></pre>
+*
+* <p>The return value from this function will be stored on the
+* subscription in the '_extra' property for reference elsewhere.</p>
+*
+* @method processArgs
+* @param args {Array} parmeters passed to Y.on(..) or Y.delegate(..)
+* @param delegate {Boolean} true if the subscription is from Y.delegate
+* @return {any}
+*/
+processArgs: noop,
+/**
+* <p>Implementers MAY override this property.</p>
+*
+* <p>Whether to prevent multiple subscriptions to this event that are
+* classified as being the same.  By default, this means the subscribed
+* callback is the same function.  See the <code>subMatch</code>
+* method.  Setting this to true will impact performance for high volume
+* events.</p>
+*
+* @property preventDups
+* @type {Boolean}
+* @default false
+*/
+//preventDups  : false,
+/**
+* <p>Implementers SHOULD provide this method definition.</p>
+*
+* Implementation logic for subscriptions done via <code>node.on(type,
+* fn)</code> or <code>Y.on(type, fn, target)</code>.  This
+* function should set up the monitor(s) that will eventually fire the
+* event.  Typically this involves subscribing to at least one DOM
+* event.  It is recommended to store detach handles from any DOM
+* subscriptions to make for easy cleanup in the <code>detach</code>
+* method.  Typically these handles are added to the <code>sub</code>
+* object.  Also for SyntheticEvents that leverage a single DOM
+* subscription under the hood, it is recommended to pass the DOM event
+* object to <code>notifier.fire(e)</code>.  (The event name on the
+* object will be updated).
+*
+* @method on
+* @param node {Node} the node the subscription is being applied to
+* @param sub {Subscription} the object to track this subscription
+* @param notifier {SyntheticEvent.Notifier} call notifier.fire(..) to
+*              trigger the execution of the subscribers
+*/
+on: noop,
+/**
+* <p>Implementers SHOULD provide this method definition.</p>
+*
+* <p>Implementation logic for detaching subscriptions done via
+* <code>node.on(type, fn)</code>.  This function should clean up any
+* subscriptions made in the <code>on()</code> phase.</p>
+*
+* @method detach
+* @param node {Node} the node the subscription was applied to
+* @param sub {Subscription} the object tracking this subscription
+* @param notifier {SyntheticEvent.Notifier} the Notifier used to
+*              trigger the execution of the subscribers
+*/
+detach: noop,
+/**
+* <p>Implementers SHOULD provide this method definition.</p>
+*
+* <p>Implementation logic for subscriptions done via
+* <code>node.delegate(type, fn, filter)</code> or
+* <code>Y.delegate(type, fn, container, filter)</code>.  Like with
+* <code>on()</code> above, this function should monitor the environment
+* for the event being fired, and trigger subscription execution by
+* calling <code>notifier.fire(e)</code>.</p>
+*
+* <p>This function receives a fourth argument, which is the filter
+* used to identify which Node's are of interest to the subscription.
+* The filter will be either a boolean function that accepts a target
+* Node for each hierarchy level as the event bubbles, or a selector
+* string.  To translate selector strings into filter functions, use
+* <code>Y.delegate.compileFilter(filter)</code>.</p>
+*
+* @method delegate
+* @param node {Node} the node the subscription is being applied to
+* @param sub {Subscription} the object to track this subscription
+* @param notifier {SyntheticEvent.Notifier} call notifier.fire(..) to
+*              trigger the execution of the subscribers
+* @param filter {String|Function} Selector string or function that
+*              accepts an event object and returns null, a Node, or an
+*              array of Nodes matching the criteria for processing.
+* @since 3.2.0
+*/
+delegate       : noop,
+/**
+* <p>Implementers SHOULD provide this method definition.</p>
+*
+* <p>Implementation logic for detaching subscriptions done via
+* <code>node.delegate(type, fn, filter)</code> or
+* <code>Y.delegate(type, fn, container, filter)</code>.  This function
+* should clean up any subscriptions made in the
+* <code>delegate()</code> phase.</p>
+*
+* @method detachDelegate
+* @param node {Node} the node the subscription was applied to
+* @param sub {Subscription} the object tracking this subscription
+* @param notifier {SyntheticEvent.Notifier} the Notifier used to
+*              trigger the execution of the subscribers
+* @param filter {String|Function} Selector string or function that
+*              accepts an event object and returns null, a Node, or an
+*              array of Nodes matching the criteria for processing.
+* @since 3.2.0
+*/
+detachDelegate : noop,
+/**
+* Sets up the boilerplate for detaching the event and facilitating the
+* execution of subscriber callbacks.
+*
+* @method _on
+* @param args {Array} array of arguments passed to
+*              <code>Y.on(...)</code> or <code>Y.delegate(...)</code>
+* @param delegate {Boolean} true if called from
+* <code>Y.delegate(...)</code>
+* @return {EventHandle} the detach handle for this subscription
+* @private
+* since 3.2.0
+*/
+_on: function (args, delegate) {
+var handles  = [],
+originalArgs = args.slice(),
+extra    = this.processArgs(args, delegate),
+selector = args[2],
+method   = delegate ? 'delegate' : 'on',
+nodes, handle;
+// Can't just use Y.all because it doesn't support window (yet?)
+nodes = (isString(selector)) ?
+query(selector) :
+toArray(selector || Y.one(Y.config.win));
+if (!nodes.length && isString(selector)) {
+handle = Y.on('available', function () {
+Y.mix(handle, Y[method].apply(Y, originalArgs), true);
+}, selector);
+return handle;
+}
+Y.Array.each(nodes, function (node) {
+var subArgs = args.slice(),
+filter;
+node = Y.one(node);
+if (node) {
+if (delegate) {
+filter = subArgs.splice(3, 1)[0];
+}
+// (type, fn, el, thisObj, ...) => (fn, thisObj, ...)
+subArgs.splice(0, 4, subArgs[1], subArgs[3]);
+if (!this.preventDups ||
+!this.getSubs(node, args, null, true))
+{
+handles.push(this._subscribe(node, method, subArgs, extra, filter));
+}
+}
+}, this);
+return (handles.length === 1) ?
+handles[0] :
+new Y.EventHandle(handles);
+},
+/**
+* Creates a new Notifier object for use by this event's
+* <code>on(...)</code> or <code>delegate(...)</code> implementation
+* and register the custom event proxy in the DOM system for cleanup.
+*
+* @method _subscribe
+* @param node {Node} the Node hosting the event
+* @param method {String} "on" or "delegate"
+* @param args {Array} the subscription arguments passed to either
+*              <code>Y.on(...)</code> or <code>Y.delegate(...)</code>
+*              after running through <code>processArgs(args)</code> to
+*              normalize the argument signature
+* @param extra {any} Extra data parsed from
+*              <code>processArgs(args)</code>
+* @param filter {String|Function} the selector string or function
+*              filter passed to <code>Y.delegate(...)</code> (not
+*              present when called from <code>Y.on(...)</code>)
+* @return {EventHandle}
+* @private
+* @since 3.2.0
+*/
+_subscribe: function (node, method, args, extra, filter) {
+var dispatcher = new Y.CustomEvent(this.type, this.publishConfig),
+handle     = dispatcher.on.apply(dispatcher, args),
+notifier   = new Notifier(handle, this.emitFacade),
+registry   = SyntheticEvent.getRegistry(node, this.type, true),
+sub        = handle.sub;
+sub.node   = node;
+sub.filter = filter;
+if (extra) {
+this.applyArgExtras(extra, sub);
+}
+Y.mix(dispatcher, {
+eventDef     : this,
+notifier     : notifier,
+host         : node,       // I forget what this is for
+currentTarget: node,       // for generating facades
+target       : node,       // for generating facades
+el           : node._node, // For category detach
+_delete      : SyntheticEvent._deleteSub
+}, true);
+handle.notifier = notifier;
+registry.register(handle);
+// Call the implementation's "on" or "delegate" method
+this[method](node, sub, notifier, filter);
+return handle;
+},
+/**
+* <p>Implementers MAY provide this method definition.</p>
+*
+* <p>Implement this function if you want extra data extracted during
+* processArgs to be propagated to subscriptions on a per-node basis.
+* That is to say, if you call <code>Y.on('xyz', fn, xtra, 'div')</code>
+* the data returned from processArgs will be shared
+* across the subscription objects for all the divs.  If you want each
+* subscription to receive unique information, do that processing
+* here.</p>
+*
+* <p>The default implementation adds the data extracted by processArgs
+* to the subscription object as <code>sub._extra</code>.</p>
+*
+* @method applyArgExtras
+* @param extra {any} Any extra data extracted from processArgs
+* @param sub {Subscription} the individual subscription
+*/
+applyArgExtras: function (extra, sub) {
+sub._extra = extra;
+},
+/**
+* Removes the subscription(s) from the internal subscription dispatch
+* mechanism.  See <code>SyntheticEvent._deleteSub</code>.
+*
+* @method _detach
+* @param args {Array} The arguments passed to
+*                  <code>node.detach(...)</code>
+* @private
+* @since 3.2.0
+*/
+_detach: function (args) {
+// Can't use Y.all because it doesn't support window (yet?)
+// TODO: Does Y.all support window now?
+var target = args[2],
+els    = (isString(target)) ?
+query(target) : toArray(target),
+node, i, len, handles, j;
+// (type, fn, el, context, filter?) => (type, fn, context, filter?)
+args.splice(2, 1);
+for (i = 0, len = els.length; i < len; ++i) {
+node = Y.one(els[i]);
+if (node) {
+handles = this.getSubs(node, args);
+if (handles) {
+for (j = handles.length - 1; j >= 0; --j) {
+handles[j].detach();
+}
+}
+}
+}
+},
+/**
+* Returns the detach handles of subscriptions on a node that satisfy a
+* search/filter function.  By default, the filter used is the
+* <code>subMatch</code> method.
+*
+* @method getSubs
+* @param node {Node} the node hosting the event
+* @param args {Array} the array of original subscription args passed
+*              to <code>Y.on(...)</code> (before
+*              <code>processArgs</code>
+* @param filter {Function} function used to identify a subscription
+*              for inclusion in the returned array
+* @param first {Boolean} stop after the first match (used to check for
+*              duplicate subscriptions)
+* @return {EventHandle[]} detach handles for the matching subscriptions
+*/
+getSubs: function (node, args, filter, first) {
+var registry = SyntheticEvent.getRegistry(node, this.type),
+handles  = [],
+allHandles, i, len, handle;
+if (registry) {
+allHandles = registry.handles;
+if (!filter) {
+filter = this.subMatch;
+}
+for (i = 0, len = allHandles.length; i < len; ++i) {
+handle = allHandles[i];
+if (filter.call(this, handle.sub, args)) {
+if (first) {
+return handle;
+} else {
+handles.push(allHandles[i]);
+}
+}
+}
+}
+return handles.length && handles;
+},
+/**
+* <p>Implementers MAY override this to define what constitutes a
+* &quot;same&quot; subscription.  Override implementations should
+* consider the lack of a comparator as a match, so calling
+* <code>getSubs()</code> with no arguments will return all subs.</p>
+*
+* <p>Compares a set of subscription arguments against a Subscription
+* object to determine if they match.  The default implementation
+* compares the callback function against the second argument passed to
+* <code>Y.on(...)</code> or <code>node.detach(...)</code> etc.</p>
+*
+* @method subMatch
+* @param sub {Subscription} the existing subscription
+* @param args {Array} the calling arguments passed to
+*                  <code>Y.on(...)</code> etc.
+* @return {Boolean} true if the sub can be described by the args
+*                  present
+* @since 3.2.0
+*/
+subMatch: function (sub, args) {
+// Default detach cares only about the callback matching
+return !args[1] || sub.fn === args[1];
+}
+}
+}, true);
+Y.SyntheticEvent = SyntheticEvent;
+/**
+* <p>Defines a new event in the DOM event system.  Implementers are
+* responsible for monitoring for a scenario whereby the event is fired.  A
+* notifier object is provided to the functions identified below.  When the
+* criteria defining the event are met, call notifier.fire( [args] ); to
+* execute event subscribers.</p>
+*
+* <p>The first parameter is the name of the event.  The second parameter is a
+* configuration object which define the behavior of the event system when the
+* new event is subscribed to or detached from.  The methods that should be
+* defined in this configuration object are <code>on</code>,
+* <code>detach</code>, <code>delegate</code>, and <code>detachDelegate</code>.
+* You are free to define any other methods or properties needed to define your
+* event.  Be aware, however, that since the object is used to subclass
+* SyntheticEvent, you should avoid method names used by SyntheticEvent unless
+* your intention is to override the default behavior.</p>
+*
+* <p>This is a list of properties and methods that you can or should specify
+* in the configuration object:</p>
+*
+* <dl>
+*   <dt><code>on</code></dt>
+*       <dd><code>function (node, subscription, notifier)</code> The
+*       implementation logic for subscription.  Any special setup you need to
+*       do to create the environment for the event being fired--E.g. native
+*       DOM event subscriptions.  Store subscription related objects and
+*       state on the <code>subscription</code> object.  When the
+*       criteria have been met to fire the synthetic event, call
+*       <code>notifier.fire(e)</code>.  See Notifier's <code>fire()</code>
+*       method for details about what to pass as parameters.</dd>
+*
+*   <dt><code>detach</code></dt>
+*       <dd><code>function (node, subscription, notifier)</code> The
+*       implementation logic for cleaning up a detached subscription. E.g.
+*       detach any DOM subscriptions added in <code>on</code>.</dd>
+*
+*   <dt><code>delegate</code></dt>
+*       <dd><code>function (node, subscription, notifier, filter)</code> The
+*       implementation logic for subscription via <code>Y.delegate</code> or
+*       <code>node.delegate</code>.  The filter is typically either a selector
+*       string or a function.  You can use
+*       <code>Y.delegate.compileFilter(selectorString)</code> to create a
+*       filter function from a selector string if needed.  The filter function
+*       expects an event object as input and should output either null, a
+*       matching Node, or an array of matching Nodes.  Otherwise, this acts
+*       like <code>on</code> DOM event subscriptions.  Store subscription
+*       related objects and information on the <code>subscription</code>
+*       object.  When the criteria have been met to fire the synthetic event,
+*       call <code>notifier.fire(e)</code> as noted above.</dd>
+*
+*   <dt><code>detachDelegate</code></dt>
+*       <dd><code>function (node, subscription, notifier)</code> The
+*       implementation logic for cleaning up a detached delegate subscription.
+*       E.g. detach any DOM delegate subscriptions added in
+*       <code>delegate</code>.</dd>
+*
+*   <dt><code>publishConfig</code></dt>
+*       <dd>(Object) The configuration object that will be used to instantiate
+*       the underlying CustomEvent. See Notifier's <code>fire</code> method
+*       for details.</dd>
+*
+*   <dt><code>processArgs</code></dt
+*       <dd>
+*          <p><code>function (argArray, fromDelegate)</code> Optional method
+*          to extract any additional arguments from the subscription
+*          signature.  Using this allows <code>on</code> or
+*          <code>delegate</code> signatures like
+*          <code>node.on(&quot;hover&quot;, overCallback,
+*          outCallback)</code>.</p>
+*          <p>When processing an atypical argument signature, make sure the
+*          args array is returned to the normal signature before returning
+*          from the function.  For example, in the &quot;hover&quot; example
+*          above, the <code>outCallback</code> needs to be <code>splice</code>d
+*          out of the array.  The expected signature of the args array for
+*          <code>on()</code> subscriptions is:</p>
+*          <pre>
+*              <code>[type, callback, target, contextOverride, argN...]</code>
+*          </pre>
+*          <p>And for <code>delegate()</code>:</p>
+*          <pre>
+*              <code>[type, callback, target, filter, contextOverride, argN...]</code>
+*          </pre>
+*          <p>where <code>target</code> is the node the event is being
+*          subscribed for.  You can see these signatures documented for
+*          <code>Y.on()</code> and <code>Y.delegate()</code> respectively.</p>
+*          <p>Whatever gets returned from the function will be stored on the
+*          <code>subscription</code> object under
+*          <code>subscription._extra</code>.</p></dd>
+*   <dt><code>subMatch</code></dt>
+*       <dd>
+*           <p><code>function (sub, args)</code>  Compares a set of
+*           subscription arguments against a Subscription object to determine
+*           if they match.  The default implementation compares the callback
+*           function against the second argument passed to
+*           <code>Y.on(...)</code> or <code>node.detach(...)</code> etc.</p>
+*       </dd>
+* </dl>
+*
+* @method define
+* @param type {String} the name of the event
+* @param config {Object} the prototype definition for the new event (see above)
+* @param force {Boolean} override an existing event (use with caution)
+* @return {SyntheticEvent} the subclass implementation instance created to
+*              handle event subscriptions of this type
+* @static
+* @for Event
+* @since 3.1.0
+* @in event-synthetic
+*/
+Y.Event.define = function (type, config, force) {
+var eventDef, Impl, synth;
+if (type && type.type) {
+eventDef = type;
+force = config;
+} else if (config) {
+eventDef = Y.merge({ type: type }, config);
+}
+if (eventDef) {
+if (force || !Y.Node.DOM_EVENTS[eventDef.type]) {
+Impl = function () {
+SyntheticEvent.apply(this, arguments);
+};
+Y.extend(Impl, SyntheticEvent, eventDef);
+synth = new Impl();
+type = synth.type;
+Y.Node.DOM_EVENTS[type] = Y.Env.evt.plugins[type] = {
+eventDef: synth,
+on: function () {
+return synth._on(toArray(arguments));
+},
+delegate: function () {
+return synth._on(toArray(arguments), true);
+},
+detach: function () {
+return synth._detach(toArray(arguments));
+}
+};
+}
+} else if (isString(type) || isArray(type)) {
+Y.Array.each(toArray(type), function (t) {
+Y.Node.DOM_EVENTS[t] = 1;
+});
+}
+return synth;
+};
+}, '@VERSION@', {"requires": ["node-base", "event-custom-complex"]});

comt