Update measurement logic to use getBoundingClientRect() where possible.  Re-map helper methods in the jQuery namespace to use the new measurement (box) class.
Change update() function to use box class directly so measurement is only done once instead of a max of 4 times for each element.  Re-use container measurements for all children instead of recalculating with each iteration
Pretty sure these are either misnamed or misdirected.  Changing implementation to match the names
Don't need to pass settings object anymore since makeUtility() normalizes the arguments passed to the helper methods
Don't need skip_invisible anymore because box class normalizes behavior of elements with display: none or detached from the DOM to return undefined on any comparisons.  This means they're always effectively skipped anyway and will never be triggered to appear.  Add prune_detached setting to determine whether an item that has been detected as detached from the DOM is removed from the elements list so it stops getting checked on update().  This is optional since the element may be re-attached later, and we may want to trigger appear at that point.  In the case of AJAX-loaded (and unloaded) content, setting prune_detached to true keeps the elements list from getting out of control
Queue up items to be triggered and fire with setTimeout(0).  The normal appear trigger is fast enough that this doesn't make too much of a difference, but when an appear callback is set and run synchronously from the update() function, scrolling can be slowed significantly.  The change protects against that and ensures we slow down scrolling as little as possible in all circumstances
Consolidate logic for pruning the elements list so it's done all at once, in the update() function
Per jQuery documentation, if the document is already ready when a function is passed to .ready(), it is run immediately.  By definition, at this point in the code, the DOM is ready because we've already been interacting with it.  As far as I can tell this code is an attempt to mitigate the issue with webkit reporting 0 width and height on images that haven't been loaded yet and don't have an expicit size set.  It can't possibly be working in that way, as evidenced by the continued complaints around that behavior.  I do believe the updated measurement logic fixes the issue, though, in that it will return a box with 0 width and height but the correct position, so it can still be compared to the viewport.  jQuery's :visible would have reported the image as invisible so it would be skipped with the default settings, but the new logic only skips the element if it is not part of the layout (display: hidden or detached from the DOM)
Change scroll and resize event bindings to use a one-time binding and re-attach only if there are elements remaining in the list.  This is a simple way to have the plugin clean up after itself once its work is done.
Default appear and load callbacks to $.noop so they can be called without checking whether they're set.  Removed extraneous variable assignments before callbacks since the parameter is a number and is passed by value anyway.
Make sure there is an original image to load before trying to load it.  Setting an invalid src on the temp image would result in a failure and leave the load even handler and the DOM element in memory indefinitely.  This also allows the appear callback to completely handle the loading of content so the plugin can be used for more than just images.  Short-circuited the .loaded check at the beginning to keep the indentation from getting out of control
Add error event binding to the temporary image to make sure we can unbind its handler(s) regardless of disposition to allow it to be garbage collected.  Added an error callback as well since that could be useful to know about
Change element-level event binding to one-time handler so it gets cleaned up after triggering.  Remove the .loaded bailout since the appear event handler is already double-protected by its own one-time binding and its own .loaded check
Hiding the image causes the browser to have to re-calculate the page layout, only to have to do so again when it is re-shown.  On slow devices, this will cause a visible flicker.  On faster devices, it slows down painting on scroll.  This isn't a great solution, but it's backwards compatible.  For the fadeIn() effect, it would be better to set opacity: 0 instead of using hide(), but in case anyone is using slideDown() or show() with a duration set, I left the hide() in there and simply skip it if the effect is show() without a duration set (e.g. immediate)
Run update() on window.load if the script is being run before load is complete.  The layout may shift as the remaining content is downloaded, so we'll make one final attempt to load anything that should be showing before relying to scroll or resize to expose new content.  If the script is run after page load is complete, this is totally unnecessary and is skipped
.attr() can never return an explicit false, only unefined or empty string.  Simplified the logic to be more expressive about what it actualy does
same grey pixel, compressed with pngout