1/*! 2 * imagesLoaded PACKAGED v3.0.4 3 * JavaScript is all like "You images are done yet or what?" 4 * MIT License 5 */ 6 7 8/*! 9 * EventEmitter v4.2.4 - git.io/ee 10 * Oliver Caldwell 11 * MIT license 12 * @preserve 13 */ 14 15(function () { 16 17 18 /** 19 * Class for managing events. 20 * Can be extended to provide event functionality in other classes. 21 * 22 * @class EventEmitter Manages event registering and emitting. 23 */ 24 function EventEmitter() { } 25 26 // Shortcuts to improve speed and size 27 28 // Easy access to the prototype 29 var proto = EventEmitter.prototype; 30 31 /** 32 * Finds the index of the listener for the event in it's storage array. 33 * 34 * @param {Function[]} listeners Array of listeners to search through. 35 * @param {Function} listener Method to look for. 36 * @return {Number} Index of the specified listener, -1 if not found 37 * @api private 38 */ 39 function indexOfListener(listeners, listener) { 40 var i = listeners.length; 41 while (i--) { 42 if (listeners[i].listener === listener) { 43 return i; 44 } 45 } 46 47 return -1; 48 } 49 50 /** 51 * Alias a method while keeping the context correct, to allow for overwriting of target method. 52 * 53 * @param {String} name The name of the target method. 54 * @return {Function} The aliased method 55 * @api private 56 */ 57 function alias(name) { 58 return function aliasClosure() { 59 return this[name].apply(this, arguments); 60 }; 61 } 62 63 /** 64 * Returns the listener array for the specified event. 65 * Will initialise the event object and listener arrays if required. 66 * Will return an object if you use a regex search. The object contains keys for each matched event. So /ba[rz]/ might return an object c
vendor: 12,233 bytes, lines 66-359
66ontaining bar and baz. But only if you have either defined them with defineEvent or added some listeners to them. 67 * Each property in the object response is an array of listener functions. 68 * 69 * @param {String|RegExp} evt Name of the event to return the listeners from. 70 * @return {Function[]|Object} All listener functions for the event. 71 */ 72 proto.getListeners = function getListeners(evt) { 73 var events = this._getEvents(); 74 var response; 75 var key; 76 77 // Return a concatenated array of all matching events if 78 // the selector is a regular expression. 79 if (typeof evt === 'object') { 80 response = {}; 81 for (key in events) { 82 if (events.hasOwnProperty(key) && evt.test(key)) { 83 response[key] = events[key]; 84 } 85 } 86 } 87 else { 88 response = events[evt] || (events[evt] = []); 89 } 90 91 return response; 92 }; 93 94 /** 95 * Takes a list of listener objects and flattens it into a list of listener functions. 96 * 97 * @param {Object[]} listeners Raw listener objects. 98 * @return {Function[]} Just the listener functions. 99 */ 100 proto.flattenListeners = function flattenListeners(listeners) { 101 var flatListeners = []; 102 var i; 103 104 for (i = 0; i < listeners.length; i += 1) { 105 flatListeners.push(listeners[i].listener); 106 } 107 108 return flatListeners; 109 }; 110 111 /** 112 * Fetches the requested listeners via getListeners but will always return the results inside an object. This is mainly for internal use but others may find it useful. 113 * 114 * @param {String|RegExp} evt Name of the event to return the listeners from. 115 * @return {Object} All listener functions for an event in an object. 116 */ 117 proto.getListenersAsObject = function getListenersAsObject(evt) { 118 var listeners = this.getListeners(evt); 119 var response; 120 121 if (listeners instanceof Array) { 122 response = {}; 123 response[evt] = listeners; 124 } 125 126 return response || listeners; 127 }; 128 129 /** 130 * Adds a listener function to the specified event. 131 * The listener will not be added if it is a duplicate. 132 * If the listener returns true then it will be removed after it is called. 133 * If you pass a regular expression as the event name then the listener will be added to all events that match it. 134 * 135 * @param {String|RegExp} evt Name of the event to attach the listener to. 136 * @param {Function} listener Method to be called when the event is emitted. If the function returns true then it will be removed after calling. 137 * @return {Object} Current instance of EventEmitter for chaining. 138 */ 139 proto.addListener = function addListener(evt, listener) { 140 var listeners = this.getListenersAsObject(evt); 141 var listenerIsWrapped = typeof listener === 'object'; 142 var key; 143 144 for (key in listeners) { 145 if (listeners.hasOwnProperty(key) && indexOfListener(listeners[key], listener) === -1) { 146 listeners[key].push(listenerIsWrapped ? listener : { 147 listener: listener, 148 once: false 149 }); 150 } 151 } 152 153 return this; 154 }; 155 156 /** 157 * Alias of addListener 158 */ 159 proto.on = alias('addListener'); 160 161 /** 162 * Semi-alias of addListener. It will add a listener that will be 163 * automatically removed after it's first execution. 164 * 165 * @param {String|RegExp} evt Name of the event to attach the listener to. 166 * @param {Function} listener Method to be called when the event is emitted. If the function returns true then it will be removed after calling. 167 * @return {Object} Current instance of EventEmitter for chaining. 168 */ 169 proto.addOnceListener = function addOnceListener(evt, listener) { 170 return this.addListener(evt, { 171 listener: listener, 172 once: true 173 }); 174 }; 175 176 /** 177 * Alias of addOnceListener. 178 */ 179 proto.once = alias('addOnceListener'); 180 181 /** 182 * Defines an event name. This is required if you want to use a regex to add a listener to multiple events at once. If you don't do this then how do you expect it to know what event to add to? Should it just add to every possible match for a regex? No. That is scary and bad. 183 * You need to tell it what event names should be matched by a regex. 184 * 185 * @param {String} evt Name of the event to create. 186 * @return {Object} Current instance of EventEmitter for chaining. 187 */ 188 proto.defineEvent = function defineEvent(evt) { 189 this.getListeners(evt); 190 return this; 191 }; 192 193 /** 194 * Uses defineEvent to define multiple events. 195 * 196 * @param {String[]} evts An array of event names to define. 197 * @return {Object} Current instance of EventEmitter for chaining. 198 */ 199 proto.defineEvents = function defineEvents(evts) { 200 for (var i = 0; i < evts.length; i += 1) { 201 this.defineEvent(evts[i]); 202 } 203 return this; 204 }; 205 206 /** 207 * Removes a listener function from the specified event. 208 * When passed a regular expression as the event name, it will remove the listener from all events that match it. 209 * 210 * @param {String|RegExp} evt Name of the event to remove the listener from. 211 * @param {Function} listener Method to remove from the event. 212 * @return {Object} Current instance of EventEmitter for chaining. 213 */ 214 proto.removeListener = function removeListener(evt, listener) { 215 var listeners = this.getListenersAsObject(evt); 216 var index; 217 var key; 218 219 for (key in listeners) { 220 if (listeners.hasOwnProperty(key)) { 221 index = indexOfListener(listeners[key], listener); 222 223 if (index !== -1) { 224 listeners[key].splice(index, 1); 225 } 226 } 227 } 228 229 return this; 230 }; 231 232 /** 233 * Alias of removeListener 234 */ 235 proto.off = alias('removeListener'); 236 237 /** 238 * Adds listeners in bulk using the manipulateListeners method. 239 * If you pass an object as the second argument you can add to multiple events at once. The object should contain key value pairs of events and listeners or listener arrays. You can also pass it an event name and an array of listeners to be added. 240 * You can also pass it a regular expression to add the array of listeners to all events that match it. 241 * Yeah, this function does quite a bit. That's probably a bad thing. 242 * 243 * @param {String|Object|RegExp} evt An event name if you will pass an array of listeners next. An object if you wish to add to multiple events at once. 244 * @param {Function[]} [listeners] An optional array of listener functions to add. 245 * @return {Object} Current instance of EventEmitter for chaining. 246 */ 247 proto.addListeners = function addListeners(evt, listeners) { 248 // Pass through to manipulateListeners 249 return this.manipulateListeners(false, evt, listeners); 250 }; 251 252 /** 253 * Removes listeners in bulk using the manipulateListeners method. 254 * If you pass an object as the second argument you can remove from multiple events at once. The object should contain key value pairs of events and listeners or listener arrays. 255 * You can also pass it an event name and an array of listeners to be removed. 256 * You can also pass it a regular expression to remove the listeners from all events that match it. 257 * 258 * @param {String|Object|RegExp} evt An event name if you will pass an array of listeners next. An object if you wish to remove from multiple events at once. 259 * @param {Function[]} [listeners] An optional array of listener functions to remove. 260 * @return {Object} Current instance of EventEmitter for chaining. 261 */ 262 proto.removeListeners = function removeListeners(evt, listeners) { 263 // Pass through to manipulateListeners 264 return this.manipulateListeners(true, evt, listeners); 265 }; 266 267 /** 268 * Edits listeners in bulk. The addListeners and removeListeners methods both use this to do their job. You should really use those instead, this is a little lower level. 269 * The first argument will determine if the listeners are removed (true) or added (false). 270 * If you pass an object as the second argument you can add/remove from multiple events at once. The object should contain key value pairs of events and listeners or listener arrays. 271 * You can also pass it an event name and an array of listeners to be added/removed. 272 * You can also pass it a regular expression to manipulate the listeners of all events that match it. 273 * 274 * @param {Boolean} remove True if you want to remove listeners, false if you want to add. 275 * @param {String|Object|RegExp} evt An event name if you will pass an array of listeners next. An object if you wish to add/remove from multiple events at once. 276 * @param {Function[]} [listeners] An optional array of listener functions to add/remove. 277 * @return {Object} Current instance of EventEmitter for chaining. 278 */ 279 proto.manipulateListeners = function manipulateListeners(remove, evt, listeners) { 280 var i; 281 var value; 282 var single = remove ? this.removeListener : this.addListener; 283 var multiple = remove ? this.removeListeners : this.addListeners; 284 285 // If evt is an object then pass each of it's properties to this method 286 if (typeof evt === 'object' && !(evt instanceof RegExp)) { 287 for (i in evt) { 288 if (evt.hasOwnProperty(i) && (value = evt[i])) { 289 // Pass the single listener straight through to the singular method 290 if (typeof value === 'function') { 291 single.call(this, i, value); 292 } 293 else { 294 // Otherwise pass back to the multiple function 295 multiple.call(this, i, value); 296 } 297 } 298 } 299 } 300 else { 301 // So evt must be a string 302 // And listeners must be an array of listeners 303 // Loop over it and pass each one to the multiple method 304 i = listeners.length; 305 while (i--) { 306 single.call(this, evt, listeners[i]); 307 } 308 } 309 310 return this; 311 }; 312 313 /** 314 * Removes all listeners from a specified event. 315 * If you do not specify an event then all listeners will be removed. 316 * That means every event will be emptied. 317 * You can also pass a regex to remove all events that match it. 318 * 319 * @param {String|RegExp} [evt] Optional name of the event to remove all listeners for. Will remove from every event if not passed. 320 * @return {Object} Current instance of EventEmitter for chaining. 321 */ 322 proto.removeEvent = function removeEvent(evt) { 323 var type = typeof evt; 324 var events = this._getEvents(); 325 var key; 326 327 // Remove different things depending on the state of evt 328 if (type === 'string') { 329 // Remove all listeners for the specified event 330 delete events[evt]; 331 } 332 else if (type === 'object') { 333 // Remove all events matching the regex. 334 for (key in events) { 335 if (events.hasOwnProperty(key) && evt.test(key)) { 336 delete events[key]; 337 } 338 } 339 } 340 else { 341 // Remove all listeners in all events 342 delete this._events; 343 } 344 345 return this; 346 }; 347 348 /** 349 * Alias of removeEvent. 350 * 351 * Added to mirror the node API. 352 */ 353 proto.removeAllListeners = alias('removeEvent'); 354 355 /** 356 * Emits an event of your choice. 357 * When emitted, every listener attached to that event will be executed. 358 * If you pass the optional argument array then those arguments will be passed to every listener upon execution. 359 * Because it uses `apply`, your array of arguments will be passed as if you wrote them out separately.
360 * So they will not arrive within the array on the other side, they will be separate. 361 * You can also pass a regular expression to emit to all events that match it. 362 * 363 * @param {String|RegExp} evt Name of the event to emit and execute listeners for. 364 * @param {Array} [args] Optional array of arguments to be passed to each listener. 365 * @return {Object} Current instance of EventEmitter for chaining. 366 */ 367 proto.emitEvent = function emitEvent(evt, args) { 368 var listeners = this.getListenersAsObject(evt); 369 var listener; 370 var i; 371 var key; 372 var response; 373 374 for (key in listeners) { 375 if (listeners.hasOwnProperty(key)) { 376 i = listeners[key].length; 377 378 while (i--) { 379 // If the listener returns true then it shall be removed from the event 380 // The function is executed either with a basic call or an apply if there is an args array 381 listener = listeners[key][i]; 382 383 if (listener.once === true) { 384 this.removeListener(evt, listener.listener); 385 } 386 387 response = listener.listener.apply(this, args || []); 388 389 if (response === this._getOnceReturnValue()) { 390 this.removeListener(evt, listener.listener); 391 } 392 } 393 } 394 } 395 396 return this; 397 }; 398 399 /** 400 * Alias of emitEvent 401 */ 402 proto.trigger = alias('emitEvent'); 403 404 /** 405 * Subtly different from emitEvent in that it will pass its arguments on to the listeners, as opposed to taking a single array of arguments to pass on. 406 * As with emitEvent, you can pass a regex in place of the event name to emit to all events that match it. 407 * 408 * @param {String|RegExp} evt Name of the event to emit and execute listeners for. 409 * @param {...*} Optional additional arguments to be passed to each listener. 410 * @return {Object} Current instance of EventEmitter for chaining. 411 */ 412 proto.emit = function emit(evt) { 413 var args = Array.prototype.slice.call(arguments, 1); 414 return this.emitEvent(evt, args); 415 }; 416 417 /** 418 * Sets the current value to check against when executing listeners. If a 419 * listeners return value matches the one set here then it will be removed 420 * after execution. This value defaults to true. 421 * 422 * @param {*} value The new value to check for when executing listeners. 423 * @return {Object} Current instance of EventEmitter for chaining. 424 */ 425 proto.setOnceReturnValue = function setOnceReturnValue(value) { 426 this._onceReturnValue = value; 427 return this; 428 }; 429 430 /** 431 * Fetches the current value to check against when executing listeners. If 432 * the listeners return value matches this one then it should be removed 433 * automatically. It will return true by default. 434 * 435 * @return {*|Boolean} The current value to check for or the default, true. 436 * @api private 437 */ 438 proto._getOnceReturnValue = function _getOnceReturnValue() { 439 if (this.hasOwnProperty('_onceReturnValue')) { 440 return this._onceReturnValue; 441 } 442 else { 443 return true; 444 } 445 }; 446 447 /** 448 * Fetches the events object and creates one if required. 449 * 450 * @return {Object} The events storage object. 451 * @api private 452 */ 453 proto._getEvents = function _getEvents() { 454 return this._events || (this._events = {}); 455 }; 456 457 // Expose the class either via AMD, CommonJS or the global object 458 if (typeof define === 'function' && define.amd) { 459 define('eventEmitter/EventEmitter', [], function () { 460 return EventEmitter; 461 }); 462 } 463 else if (typeof module === 'object' && module.exports) { 464 module.exports = EventEmitter; 465 } 466 else { 467 this.EventEmitter = EventEmitter; 468 } 469}.call(this)); 470 471/*! 472 * eventie v1.0.3 473 * event binding helper 474 * eventie.bind( elem, 'click', myFn ) 475 * eventie.unbind( elem, 'click', myFn ) 476 */ 477 478/*jshint browser: true, undef: true, unused: true */ 479/*global define: false */ 480 481(function (window) { 482 483 484 485 var docElem = document.documentElement; 486 487 var bind = function () { }; 488 489 if (docElem.addEventListener) { 490 bind = function (obj, type, fn) { 491 obj.addEventListener(type, fn, false); 492 }; 493 } else if (docElem.attachEvent) { 494 bind = function (obj, type, fn) { 495 obj[type + fn] = fn.handleEvent ? 496 function () { 497 var event = window.event; 498 // add event.target 499 event.target = event.target || event.srcElement; 500 fn.handleEvent.call(fn, event); 501 } : 502 function () { 503 var event = window.event; 504 // add event.target 505 event.target = event.target || event.srcElement; 506 fn.call(obj, event); 507 }; 508 obj.attachEvent("on" + type, obj[type + fn]); 509 }; 510 } 511 512 var unbind = function () { }; 513 514 if (docElem.removeEventListener) { 515 unbind = function (obj, type, fn) { 516 obj.removeEventListener(type, fn, false); 517 }; 518 } else if (docElem.detachEvent) { 519 unbind = function (obj, type, fn) { 520 obj.detachEvent("on" + type, obj[type + fn]); 521 try { 522 delete obj[type + fn]; 523 } catch (err) { 524 // can't delete window object properties 525 obj[type + fn] = undefined; 526 } 527 }; 528 } 529 530 var eventie = { 531 bind: bind, 532 unbind: unbind 533 }; 534 535 // transport 536 if (typeof define === 'function' && define.amd) { 537 // AMD 538 define('eventie/eventie', eventie); 539 } else { 540 // browser global 541 window.eventie = eventie; 542 } 543 544})(this); 545 546/*! 547 * imagesLoaded v3.0.4 548 * JavaScript is all like "You images are done yet or what?" 549 * MIT License 550 */ 551 552(function (window) { 553 554 555 556 var $ = window.jQuery; 557 var console = window.console; 558 var hasConsole = typeof console !== 'undefined'; 559 560 // -------------------------- helpers -------------------------- // 561 562 // extend objects 563 function extend(a, b) { 564 for (var prop in b) { 565 a[prop] = b[prop]; 566 } 567 return a; 568 } 569 570 var objToString = Object.prototype.toString; 571 function isArray(obj) { 572 return objToString.call(obj) === '[object Array]'; 573 } 574 575 // turn element or nodeList into an array 576 function makeArray(obj) { 577 var ary = []; 578 if (isArray(obj)) { 579 // use object if already an array 580 ary = obj;
581 } else if (typeof obj.length === 'number') { 582 // convert nodeList to array 583 for (var i = 0, len = obj.length; i < len; i++) { 584 ary.push(obj[i]); 585 } 586 } else { 587 // array of single index 588 ary.push(obj); 589 } 590 return ary; 591 } 592 593 // -------------------------- -------------------------- // 594 595 function defineImagesLoaded(EventEmitter, eventie) { 596 597 /** 598 * @param {Array, Element, NodeList, String} elem 599 * @param {Object or Function} options - if function, use as callback 600 * @param {Function} onAlways - callback function 601 */ 602 function ImagesLoaded(elem, options, onAlways) { 603 // coerce ImagesLoaded() without new, to be new ImagesLoaded() 604 if (!(this instanceof ImagesLoaded)) { 605 return new ImagesLoaded(elem, options); 606 } 607 // use elem as selector string 608 if (typeof elem === 'string') { 609 elem = document.querySelectorAll(elem); 610 } 611 612 this.elements = makeArray(elem); 613 this.options = extend({}, this.options); 614 615 if (typeof options === 'function') { 616 onAlways = options; 617 } else { 618 extend(this.options, options); 619 } 620 621 if (onAlways) { 622 this.on('always', onAlways); 623 } 624 625 this.getImages(); 626 627 if ($) { 628 // add jQuery Deferred object 629 this.jqDeferred = new $.Deferred(); 630 } 631 632 // HACK check async to allow time to bind listeners 633 var _this = this; 634 setTimeout(function () { 635 _this.check(); 636 }); 637 } 638 639 ImagesLoaded.prototype = new EventEmitter(); 640 641 ImagesLoaded.prototype.options = {}; 642 643 ImagesLoaded.prototype.getImages = function () { 644 this.images = []; 645 646 // filter & find items if we have an item selector 647 for (var i = 0, len = this.elements.length; i < len; i++) { 648 var elem = this.elements[i]; 649 // filter siblings 650 if (elem.nodeName === 'IMG') { 651 this.addImage(elem); 652 } 653 // find children 654 var childElems = elem.querySelectorAll('img'); 655 // concat childElems to filterFound array 656 for (var j = 0, jLen = childElems.length; j < jLen; j++) { 657 var img = childElems[j]; 658 this.addImage(img); 659 } 660 } 661 }; 662 663 /** 664 * @param {Image} img 665 */ 666 ImagesLoaded.prototype.addImage = function (img) { 667 var loadingImage = new LoadingImage(img); 668 this.images.push(loadingImage); 669 }; 670 671 ImagesLoaded.prototype.check = function () { 672 var _this = this; 673 var checkedCount = 0; 674 var length = this.images.length; 675 this.hasAnyBroken = false; 676 // complete if no images 677 if (!length) { 678 this.complete(); 679 return; 680 } 681 682 function onConfirm(image, message) { 683 if (_this.options.debug && hasConsole) { 684 console.log('confirm', image, message); 685 } 686 687 _this.progress(image); 688 checkedCount++; 689 if (checkedCount === length) { 690 _this.complete(); 691 } 692 return true; // bind once 693 } 694 695 for (var i = 0; i < length; i++) { 696 var loadingImage = this.images[i]; 697 loadingImage.on('confirm', onConfirm); 698 loadingImage.check(); 699 } 700 }; 701 702 ImagesLoaded.prototype.progress = function (image) { 703 this.hasAnyBroken = this.hasAnyBroken || !image.isLoaded; 704 // HACK - Chrome triggers event before object properties have changed. #83 705 var _this = this; 706 setTimeout(function () {
707 _this.emit('progress', _this, image); 708 if (_this.jqDeferred) { 709 _this.jqDeferred.notify(_this, image); 710 } 711 }); 712 }; 713 714 ImagesLoaded.prototype.complete = function () { 715 var eventName = this.hasAnyBroken ? 'fail' : 'done'; 716 this.isComplete = true; 717 var _this = this; 718 // HACK - another setTimeout so that confirm happens after progress 719 setTimeout(function () { 720 _this.emit(eventName, _this); 721 _this.emit('always', _this); 722 if (_this.jqDeferred) { 723 var jqMethod = _this.hasAnyBroken ? 'reject' : 'resolve'; 724 _this.jqDeferred[jqMethod](_this); 725 } 726 }); 727 }; 728 729 // -------------------------- jquery -------------------------- // 730 731 if ($) { 732 $.fn.imagesLoaded = function (options, callback) { 733 var instance = new ImagesLoaded(this, options, callback); 734 return instance.jqDeferred.promise($(this)); 735 }; 736 } 737 738 739 // -------------------------- -------------------------- // 740 741 var cache = {}; 742 743 function LoadingImage(img) { 744 this.img = img; 745 } 746 747 LoadingImage.prototype = new EventEmitter(); 748 749 LoadingImage.prototype.check = function () { 750 // first check cached any previous images that have same src 751 var cached = cache[this.img.src]; 752 if (cached) { 753 this.useCached(cached); 754 return; 755 } 756 // add this to cache 757 cache[this.img.src] = this; 758 759 // If complete is true and browser supports natural sizes, 760 // try to check for image status manually. 761 if (this.img.complete && this.img.naturalWidth !== undefined) { 762 // report based on naturalWidth 763 this.confirm(this.img.naturalWidth !== 0, 'naturalWidth'); 764 return; 765 } 766 767 // If none of the checks above matched, simulate loading on detached element. 768 var proxyImage = this.proxyImage = new Image(); 769 eventie.bind(proxyImage, 'load', this); 770 eventie.bind(proxyImage, 'error', this); 771 proxyImage.src = this.img.src; 772 }; 773 774 LoadingImage.prototype.useCached = function (cached) { 775 if (cached.isConfirmed) { 776 this.confirm(cached.isLoaded, 'cached was confirmed'); 777 } else { 778 var _this = this; 779 cached.on('confirm', function (image) { 780 _this.confirm(image.isLoaded, 'cache emitted confirmed'); 781 return true; // bind once 782 }); 783 } 784 }; 785 786 LoadingImage.prototype.confirm = function (isLoaded, message) { 787 this.isConfirmed = true; 788 this.isLoaded = isLoaded; 789 this.emit('confirm', this, message); 790 }; 791 792 // trigger specified handler for event type 793 LoadingImage.prototype.handleEvent = function (event) { 794 var method = 'on' + event.type; 795 if (this[method]) { 796 this[method](event); 797 } 798 }; 799 800 LoadingImage.prototype.onload = function () { 801 this.confirm(true, 'onload'); 802 this.unbindProxyEvents(); 803 }; 804 805 LoadingImage.prototype.onerror = function () { 806 this.confirm(false, 'onerror'); 807 this.unbindProxyEvents(); 808 }; 809 810 LoadingImage.prototype.unbindProxyEvents = function () { 811 eventie.unbind(this.proxyImage, 'load', this); 812 eventie.unbind(this.proxyImage, 'error', this); 813 }; 814 815 // ----- ----- // 816 817 return ImagesLoaded; 818 } 819 820 // -------------------------- transport -------------------------- // 821 822 if (typeof define === 'function' && define.amd) { 823 // AMD 824 define([ 825 'eventEmitter/EventEmitter', 826 'eventie/eventie' 827 ], 828 defineImagesLoaded); 829 } else { 830 // browser global 831 window.imagesLoaded = defineImagesLoaded( 832 window.EventEmitter, 833 window.eventie 834 ); 835 } 836 837})(window);
Line numbers count LF bytes from the start of the resource, as the search results do. Vendor segments are library code the classifier recognised; they are stored but not indexed. Bytes are shown as Latin1 characters, one per byte.