975 lines
100 KiB
JavaScript
975 lines
100 KiB
JavaScript
(function e(t,n,r){function s(o,u){if(!n[o]){if(!t[o]){var a=typeof require=="function"&&require;if(!u&&a)return a(o,!0);if(i)return i(o,!0);throw new Error("Cannot find module '"+o+"'")}var f=n[o]={exports:{}};t[o][0].call(f.exports,function(e){var n=t[o][1][e];return s(n?n:e)},f,f.exports,e,t,n,r)}return n[o].exports}var i=typeof require=="function"&&require;for(var o=0;o<r.length;o++)s(r[o]);return s})({1:[function(require,module,exports){
|
|
'use strict';
|
|
|
|
/* eslint-env browser */
|
|
|
|
/** @namespace cssInjector */
|
|
|
|
/**
|
|
* @summary Insert base stylesheet into DOM
|
|
*
|
|
* @desc Creates a new `<style>...</style>` element from the named text string(s) and inserts it but only if it does not already exist in the specified container as per `referenceElement`.
|
|
*
|
|
* > Caveat: If stylesheet is for use in a shadow DOM, you must specify a local `referenceElement`.
|
|
*
|
|
* @returns A reference to the newly created `<style>...</style>` element.
|
|
*
|
|
* @param {string|string[]} cssRules
|
|
* @param {string} [ID]
|
|
* @param {undefined|null|Element|string} [referenceElement] - Container for insertion. Overloads:
|
|
* * `undefined` type (or omitted): injects stylesheet at top of `<head>...</head>` element
|
|
* * `null` value: injects stylesheet at bottom of `<head>...</head>` element
|
|
* * `Element` type: injects stylesheet immediately before given element, wherever it is found.
|
|
* * `string` type: injects stylesheet immediately before given first element found that matches the given css selector.
|
|
*
|
|
* @memberOf cssInjector
|
|
*/
|
|
function cssInjector(cssRules, ID, referenceElement) {
|
|
if (typeof referenceElement === 'string') {
|
|
referenceElement = document.querySelector(referenceElement);
|
|
if (!referenceElement) {
|
|
throw 'Cannot find reference element for CSS injection.';
|
|
}
|
|
} else if (referenceElement && !(referenceElement instanceof Element)) {
|
|
throw 'Given value not a reference element.';
|
|
}
|
|
|
|
var container = referenceElement && referenceElement.parentNode || document.head || document.getElementsByTagName('head')[0];
|
|
|
|
if (ID) {
|
|
ID = cssInjector.idPrefix + ID;
|
|
|
|
if (container.querySelector('#' + ID)) {
|
|
return; // stylesheet already in DOM
|
|
}
|
|
}
|
|
|
|
var style = document.createElement('style');
|
|
style.type = 'text/css';
|
|
if (ID) {
|
|
style.id = ID;
|
|
}
|
|
if (cssRules instanceof Array) {
|
|
cssRules = cssRules.join('\n');
|
|
}
|
|
cssRules = '\n' + cssRules + '\n';
|
|
if (style.styleSheet) {
|
|
style.styleSheet.cssText = cssRules;
|
|
} else {
|
|
style.appendChild(document.createTextNode(cssRules));
|
|
}
|
|
|
|
if (referenceElement === undefined) {
|
|
referenceElement = container.firstChild;
|
|
}
|
|
|
|
container.insertBefore(style, referenceElement);
|
|
|
|
return style;
|
|
}
|
|
|
|
/**
|
|
* @summary Optional prefix for `<style>` tag IDs.
|
|
* @desc Defaults to `'injected-stylesheet-'`.
|
|
* @type {string}
|
|
* @memberOf cssInjector
|
|
*/
|
|
cssInjector.idPrefix = 'injected-stylesheet-';
|
|
|
|
// Interface
|
|
module.exports = cssInjector;
|
|
|
|
},{}],2:[function(require,module,exports){
|
|
/* eslint-env browser */
|
|
|
|
'use strict';
|
|
|
|
if (!window.FinBar) {
|
|
window.FinBar = require('./');
|
|
}
|
|
|
|
},{"./":3}],3:[function(require,module,exports){
|
|
'use strict';
|
|
|
|
/* eslint-env node, browser */
|
|
|
|
var cssInjector = require('css-injector');
|
|
|
|
// Following is the sole style requirement for bar and thumb elements.
|
|
// Maintained in code so not dependent being in stylesheet.
|
|
var BAR_STYLE = 'position: absolute;';
|
|
var THUMB_STYLE = 'position: absolute;';
|
|
|
|
/**
|
|
* @constructor FinBar
|
|
* @summary Create a scrollbar object.
|
|
* @desc Creating a scrollbar is a three-step process:
|
|
*
|
|
* 1. Instantiate the scrollbar object by calling this constructor function. Upon instantiation, the DOM element for the scrollbar (with a single child element for the scrollbar "thumb") is created but is not insert it into the DOM.
|
|
* 2. After instantiation, it is the caller's responsibility to insert the scrollbar, {@link FinBar#bar|this.bar}, into the DOM.
|
|
* 3. After insertion, the caller must call {@link FinBar#resize|resize()} at least once to size and position the scrollbar and its thumb. After that, `resize()` should also be called repeatedly on resize events (as the content element is being resized).
|
|
*
|
|
* Suggested configurations:
|
|
* * _**Unbound**_<br/>
|
|
* The scrollbar serves merely as a simple range (slider) control. Omit both `options.onchange` and `options.content`.
|
|
* * _**Bound to virtual content element**_<br/>
|
|
* Virtual content is projected into the element using a custom event handler supplied by the programmer in `options.onchange`. A typical use case would be to handle scrolling of the virtual content. Other use cases include data transformations, graphics transformations, _etc._
|
|
* * _**Bound to real content**_<br/>
|
|
* Set `options.content` to the "real" content element but omit `options.onchange`. This will cause the scrollbar to use the built-in event handler (`this.scrollRealContent`) which implements smooth scrolling of the content element within the container.
|
|
*
|
|
* @param {finbarOptions} [options={}] - Options object. See the type definition for member details.
|
|
*/
|
|
function FinBar(options) {
|
|
|
|
// make bound versions of all the mouse event handler
|
|
var bound = this._bound = {};
|
|
Object.keys(handlersToBeBound).forEach(function (key) {
|
|
bound[key] = handlersToBeBound[key].bind(this);
|
|
}, this);
|
|
|
|
/**
|
|
* @name thumb
|
|
* @summary The generated scrollbar thumb element.
|
|
* @desc The thumb element's parent element is always the {@link FinBar#bar|bar} element.
|
|
*
|
|
* This property is typically referenced internally only. The size and position of the thumb element is maintained by `_calcThumb()`.
|
|
* @type {Element}
|
|
* @memberOf FinBar.prototype
|
|
*/
|
|
var thumb = this.thumb = document.createElement('div');
|
|
thumb.classList.add('thumb');
|
|
thumb.setAttribute('style', THUMB_STYLE);
|
|
thumb.onclick = bound.shortStop;
|
|
thumb.onmouseover = bound.onmouseover;
|
|
thumb.onmouseout = this._bound.onmouseout;
|
|
|
|
/**
|
|
* @name bar
|
|
* @summary The generated scrollbar element.
|
|
* @desc The caller inserts this element into the DOM (typically into the content container) and then calls its {@link FinBar#resize|resize()} method.
|
|
*
|
|
* Thus the node tree is typically:
|
|
* * A **content container** element, which contains:
|
|
* * The content element(s)
|
|
* * This **scrollbar element**, which in turn contains:
|
|
* * The **thumb element**
|
|
*
|
|
* @type {Element}
|
|
* @memberOf FinBar.prototype
|
|
*/
|
|
var bar = this.bar = document.createElement('div');
|
|
bar.classList.add('finbar-vertical');
|
|
bar.setAttribute('style', BAR_STYLE);
|
|
bar.onmousedown = this._bound.onmousedown;
|
|
if (this.paging) { bar.onclick = bound.onclick; }
|
|
bar.appendChild(thumb);
|
|
|
|
options = options || {};
|
|
|
|
// presets
|
|
this.orientation = 'vertical';
|
|
this._min = this._index = 0;
|
|
this._max = 100;
|
|
|
|
/**
|
|
* Wheel metric normalization, applied equally to all three axes.
|
|
*
|
|
* This value is overridden with a platform- and browser-specific wheel factor when available in {@link FinBar.normals}.
|
|
*
|
|
* To suppress, delete `FinBar.normals` before instantiation or override this instance variable (with `1.0`) after instantiation.
|
|
* @type {number}
|
|
* @memberOf FinBar.prototype
|
|
*/
|
|
this.normal = getNormal() || 1.0;
|
|
|
|
// options
|
|
Object.keys(options).forEach(function (key) {
|
|
var option = options[key];
|
|
if (option !== undefined) {
|
|
switch (key) {
|
|
|
|
case 'index':
|
|
this._index = option;
|
|
break;
|
|
|
|
case 'range':
|
|
validRange(option);
|
|
this._min = option.min;
|
|
this._max = option.max;
|
|
this.contentSize = option.max - option.min + 1;
|
|
break;
|
|
|
|
default:
|
|
if (
|
|
key.charAt(0) !== '_' &&
|
|
typeof FinBar.prototype[key] !== 'function'
|
|
) {
|
|
// override prototype defaults for standard ;
|
|
// extend with additional properties (for use in onchange event handlers)
|
|
this[key] = option;
|
|
}
|
|
break;
|
|
|
|
}
|
|
}
|
|
}, this);
|
|
|
|
cssInjector(cssFinBars, 'finbar-base', options.cssStylesheetReferenceElement);
|
|
}
|
|
|
|
FinBar.prototype = {
|
|
|
|
/**
|
|
* @summary The scrollbar orientation.
|
|
* @desc Set by the constructor to either `'vertical'` or `'horizontal'`. See the similarly named property in the {@link finbarOptions} object.
|
|
*
|
|
* Useful values are `'vertical'` (the default) or `'horizontal'`.
|
|
*
|
|
* Setting this property resets `this.oh` and `this.deltaProp` and changes the class names so as to reposition the scrollbar as per the CSS rules for the new orientation.
|
|
* @default 'vertical'
|
|
* @type {string}
|
|
* @memberOf FinBar.prototype
|
|
*/
|
|
set orientation(orientation) {
|
|
if (orientation === this._orientation) {
|
|
return;
|
|
}
|
|
|
|
this._orientation = orientation;
|
|
|
|
/**
|
|
* @readonly
|
|
* @name oh
|
|
* @summary <u>O</u>rientation <u>h</u>ash for this scrollbar.
|
|
* @desc Set by the `orientation` setter to either the vertical or the horizontal orientation hash. The property should always be synchronized with `orientation`; do not update directly!
|
|
*
|
|
* This object is used internally to access scrollbars' DOM element properties in a generalized way without needing to constantly query the scrollbar orientation. For example, instead of explicitly coding `this.bar.top` for a vertical scrollbar and `this.bar.left` for a horizontal scrollbar, simply code `this.bar[this.oh.leading]` instead. See the {@link orientationHashType} definition for details.
|
|
*
|
|
* This object is useful externally for coding generalized {@link finbarOnChange} event handler functions that serve both horizontal and vertical scrollbars.
|
|
* @type {orientationHashType}
|
|
* @memberOf FinBar.prototype
|
|
*/
|
|
this.oh = orientationHashes[this._orientation];
|
|
|
|
if (!this.oh) {
|
|
error('Invalid value for `options._orientation.');
|
|
}
|
|
|
|
/**
|
|
* @name deltaProp
|
|
* @summary The name of the `WheelEvent` property this scrollbar should listen to.
|
|
* @desc Set by the constructor. See the similarly named property in the {@link finbarOptions} object.
|
|
*
|
|
* Useful values are `'deltaX'`, `'deltaY'`, or `'deltaZ'`. A value of `null` means to ignore mouse wheel events entirely.
|
|
*
|
|
* The mouse wheel is one-dimensional and only emits events with `deltaY` data. This property is provided so that you can override the default of `'deltaX'` with a value of `'deltaY'` on your horizontal scrollbar primarily to accommodate certain "panoramic" interface designs where the mouse wheel should control horizontal rather than vertical scrolling. Just give `{ deltaProp: 'deltaY' }` in your horizontal scrollbar instantiation.
|
|
*
|
|
* Caveat: Note that a 2-finger drag on an Apple trackpad emits events with _both_ `deltaX ` and `deltaY` data so you might want to delay making the above adjustment until you can determine that you are getting Y data only with no X data at all (which is a sure bet you on a mouse wheel rather than a trackpad).
|
|
|
|
* @type {object|null}
|
|
* @memberOf FinBar.prototype
|
|
*/
|
|
this.deltaProp = this.oh.delta;
|
|
|
|
this.bar.className = this.bar.className.replace(/(vertical|horizontal)/g, orientation);
|
|
|
|
if (this.bar.style.cssText !== BAR_STYLE || this.thumb.style.cssText !== THUMB_STYLE) {
|
|
this.bar.setAttribute('style', BAR_STYLE);
|
|
this.thumb.setAttribute('style', THUMB_STYLE);
|
|
this.resize();
|
|
}
|
|
},
|
|
get orientation() {
|
|
return this._orientation;
|
|
},
|
|
|
|
/**
|
|
* @summary Callback for scroll events.
|
|
* @desc Set by the constructor via the similarly named property in the {@link finbarOptions} object. After instantiation, `this.onchange` may be updated directly.
|
|
*
|
|
* This event handler is called whenever the value of the scrollbar is changed through user interaction. The typical use case is when the content is scrolled. It is called with the `FinBar` object as its context and the current value of the scrollbar (its index, rounded) as the only parameter.
|
|
*
|
|
* Set this property to `null` to stop emitting such events.
|
|
* @type {function(number)|null}
|
|
* @memberOf FinBar.prototype
|
|
*/
|
|
onchange: null,
|
|
|
|
/**
|
|
* @summary Add a CSS class name to the bar element's class list.
|
|
* @desc Set by the constructor. See the similarly named property in the {@link finbarOptions} object.
|
|
*
|
|
* The bar element's class list will always include `finbar-vertical` (or `finbar-horizontal` based on the current orientation). Whenever this property is set to some value, first the old prefix+orientation is removed from the bar element's class list; then the new prefix+orientation is added to the bar element's class list. This property causes _an additional_ class name to be added to the bar element's class list. Therefore, this property will only add at most one additional class name to the list.
|
|
*
|
|
* To remove _classname-orientation_ from the bar element's class list, set this property to a falsy value, such as `null`.
|
|
*
|
|
* > NOTE: You only need to specify an additional class name when you need to have mulltiple different styles of scrollbars on the same page. If this is not a requirement, then you don't need to make a new class; you would just create some additional rules using the same selectors in the built-in stylesheet (../css/finbars.css):
|
|
* *`div.finbar-vertical` (or `div.finbar-horizontal`) for the scrollbar
|
|
* *`div.finbar-vertical > div` (or `div.finbar-horizontal > div`) for the "thumb."
|
|
*
|
|
* Of course, your rules should come after the built-ins.
|
|
* @type {string}
|
|
* @memberOf FinBar.prototype
|
|
*/
|
|
set classPrefix(prefix) {
|
|
if (this._classPrefix) {
|
|
this.bar.classList.remove(this._classPrefix + this.orientation);
|
|
}
|
|
|
|
this._classPrefix = prefix;
|
|
|
|
if (prefix) {
|
|
this.bar.classList.add(prefix + '-' + this.orientation);
|
|
}
|
|
},
|
|
get classPrefix() {
|
|
return this._classPrefix;
|
|
},
|
|
|
|
/**
|
|
* @name increment
|
|
* @summary Number of scrollbar index units representing a pageful. Used exclusively for paging up and down and for setting thumb size relative to content size.
|
|
* @desc Set by the constructor. See the similarly named property in the {@link finbarOptions} object.
|
|
*
|
|
* Can also be given as a parameter to the {@link FinBar#resize|resize} method, which is pertinent because content area size changes affect the definition of a "pageful." However, you only need to do this if this value is being used. It not used when:
|
|
* * you define `paging.up` and `paging.down`
|
|
* * your scrollbar is using `scrollRealContent`
|
|
* @type {number}
|
|
* @memberOf FinBar.prototype
|
|
*/
|
|
increment: 1,
|
|
|
|
/**
|
|
* Default value of multiplier for `WheelEvent#deltaX` (horizontal scrolling delta).
|
|
* @default
|
|
* @memberOf FinBar.prototype
|
|
*/
|
|
deltaXFactor: 1,
|
|
|
|
/**
|
|
* Default value of multiplier for `WheelEvent#deltaY` (vertical scrolling delta).
|
|
* @default
|
|
* @memberOf FinBar.prototype
|
|
*/
|
|
deltaYFactor: 1,
|
|
|
|
/**
|
|
* Default value of multiplier for `WheelEvent#deltaZ` (delpth scrolling delta).
|
|
* @default
|
|
* @memberOf FinBar.prototype
|
|
*/
|
|
deltaZFactor: 1,
|
|
|
|
/**
|
|
* @name barStyles
|
|
* @summary Scrollbar styles to be applied by {@link FinBar#resize|resize()}.
|
|
* @desc Set by the constructor. See the similarly named property in the {@link finbarOptions} object.
|
|
*
|
|
* This is a value to be assigned to {@link FinBar#styles|styles} on each call to {@link FinBar#resize|resize()}. That is, a hash of values to be copied to the scrollbar element's style object on resize; or `null` for none.
|
|
*
|
|
* @see {@link FinBar#style|style}
|
|
* @type {finbarStyles|null}
|
|
* @memberOf FinBar.prototype
|
|
*/
|
|
barStyles: null,
|
|
|
|
/**
|
|
* @name style
|
|
* @summary Additional scrollbar styles.
|
|
* @desc See type definition for more details. These styles are applied directly to the scrollbar's `bar` element.
|
|
*
|
|
* Values are adjusted as follows before being applied to the element:
|
|
* 1. Included "pseudo-property" names from the scrollbar's orientation hash, {@link FinBar#oh|oh}, are translated to actual property names before being applied.
|
|
* 2. When there are margins, percentages are translated to absolute pixel values because CSS ignores margins in its percentage calculations.
|
|
* 3. If you give a value without a unit (a raw number), "px" unit is appended.
|
|
*
|
|
* General notes:
|
|
* 1. It is always preferable to specify styles via a stylesheet. Only set this property when you need to specifically override (a) stylesheet value(s).
|
|
* 2. Can be set directly or via calls to the {@link FinBar#resize|resize} method.
|
|
* 3. Should only be set after the scrollbar has been inserted into the DOM.
|
|
* 4. Before applying these new values to the element, _all_ in-line style values are reset (by removing the element's `style` attribute), exposing inherited values (from stylesheets).
|
|
* 5. Empty object has no effect.
|
|
* 6. Falsey value in place of object has no effect.
|
|
*
|
|
* > CAVEAT: Do not attempt to treat the object you assign to this property as if it were `this.bar.style`. Specifically, changing this object after assigning it will have no effect on the scrollbar. You must assign it again if you want it to have an effect.
|
|
*
|
|
* @see {@link FinBar#barStyles|barStyles}
|
|
* @type {finbarStyles}
|
|
* @memberOf FinBar.prototype
|
|
*/
|
|
set style(styles) {
|
|
var keys = Object.keys(styles = extend({}, styles, this._auxStyles));
|
|
|
|
if (keys.length) {
|
|
var bar = this.bar,
|
|
barRect = bar.getBoundingClientRect(),
|
|
container = this.container || bar.parentElement,
|
|
containerRect = container.getBoundingClientRect(),
|
|
oh = this.oh;
|
|
|
|
// Before applying new styles, revert all styles to values inherited from stylesheets
|
|
bar.setAttribute('style', BAR_STYLE);
|
|
|
|
keys.forEach(function (key) {
|
|
var val = styles[key];
|
|
|
|
if (key in oh) {
|
|
key = oh[key];
|
|
}
|
|
|
|
if (!isNaN(Number(val))) {
|
|
val = (val || 0) + 'px';
|
|
} else if (/%$/.test(val)) {
|
|
// When bar size given as percentage of container, if bar has margins, restate size in pixels less margins.
|
|
// (If left as percentage, CSS's calculation will not exclude margins.)
|
|
var oriented = axis[key],
|
|
margins = barRect[oriented.marginLeading] + barRect[oriented.marginTrailing];
|
|
if (margins) {
|
|
val = parseInt(val, 10) / 100 * containerRect[oriented.size] - margins + 'px';
|
|
}
|
|
}
|
|
|
|
bar.style[key] = val;
|
|
});
|
|
}
|
|
},
|
|
|
|
/**
|
|
* @readonly
|
|
* @name paging
|
|
* @summary Enable page up/dn clicks.
|
|
* @desc Set by the constructor. See the similarly named property in the {@link finbarOptions} object.
|
|
*
|
|
* If truthy, listen for clicks in page-up and page-down regions of scrollbar.
|
|
*
|
|
* If an object, call `.paging.up()` on page-up clicks and `.paging.down()` will be called on page-down clicks.
|
|
*
|
|
* Changing the truthiness of this value after instantiation currently has no effect.
|
|
* @type {boolean|object}
|
|
* @memberOf FinBar.prototype
|
|
*/
|
|
paging: true,
|
|
|
|
/**
|
|
* @name range
|
|
* @summary Setter for the minimum and maximum scroll values.
|
|
* @desc Set by the constructor. These values are the limits for {@link FooBar#index|index}.
|
|
*
|
|
* The setter accepts an object with exactly two numeric properties: `.min` which must be less than `.max`. The values are extracted and the object is discarded.
|
|
*
|
|
* The getter returns a new object with `.min` and '.max`.
|
|
*
|
|
* @type {rangeType}
|
|
* @memberOf FinBar.prototype
|
|
*/
|
|
set range(range) {
|
|
validRange(range);
|
|
this._min = range.min;
|
|
this._max = range.max;
|
|
this.contentSize = range.max - range.min + 1;
|
|
this.index = this.index; // re-clamp
|
|
},
|
|
get range() {
|
|
return {
|
|
min: this._min,
|
|
max: this._max
|
|
};
|
|
},
|
|
|
|
/**
|
|
* @summary Index value of the scrollbar.
|
|
* @desc This is the position of the scroll thumb.
|
|
*
|
|
* Setting this value clamps it to {@link FinBar#min|min}..{@link FinBar#max|max}, scroll the content, and moves thumb.
|
|
*
|
|
* Getting this value returns the current index. The returned value will be in the range `min`..`max`. It is intentionally not rounded.
|
|
*
|
|
* Use this value as an alternative to (or in addition to) using the {@link FinBar#onchange|onchange} callback function.
|
|
*
|
|
* @see {@link FinBar#_setScroll|_setScroll}
|
|
* @type {number}
|
|
* @memberOf FinBar.prototype
|
|
*/
|
|
set index(idx) {
|
|
idx = Math.min(this._max, Math.max(this._min, idx)); // clamp it
|
|
this._setScroll(idx);
|
|
// this._setThumbSize();
|
|
},
|
|
get index() {
|
|
return this._index;
|
|
},
|
|
|
|
/**
|
|
* @private
|
|
* @summary Move the thumb.
|
|
* @desc Also displays the index value in the test panel and invokes the callback.
|
|
* @param idx - The new scroll index, a value in the range `min`..`max`.
|
|
* @param [scaled=f(idx)] - The new thumb position in pixels and scaled relative to the containing {@link FinBar#bar|bar} element, i.e., a proportional number in the range `0`..`thumbMax`. When omitted, a function of `idx` is used.
|
|
* @memberOf FinBar.prototype
|
|
*/
|
|
_setScroll: function (idx, scaled) {
|
|
this._index = idx;
|
|
|
|
// Display the index value in the test panel
|
|
if (this.testPanelItem && this.testPanelItem.index instanceof Element) {
|
|
this.testPanelItem.index.innerHTML = Math.round(idx);
|
|
}
|
|
|
|
// Call the callback
|
|
if (this.onchange) {
|
|
this.onchange.call(this, Math.round(idx));
|
|
}
|
|
|
|
// Move the thumb
|
|
if (scaled === undefined) {
|
|
scaled = (idx - this._min) / (this._max - this._min) * this._thumbMax;
|
|
}
|
|
this.thumb.style[this.oh.leading] = scaled + 'px';
|
|
},
|
|
|
|
scrollRealContent: function (idx) {
|
|
var containerRect = this.content.parentElement.getBoundingClientRect(),
|
|
sizeProp = this.oh.size,
|
|
maxScroll = Math.max(0, this.content[sizeProp] - containerRect[sizeProp]),
|
|
//scroll = Math.min(idx, maxScroll);
|
|
scroll = (idx - this._min) / (this._max - this._min) * maxScroll;
|
|
//console.log('scroll: ' + scroll);
|
|
this.content.style[this.oh.leading] = -scroll + 'px';
|
|
},
|
|
|
|
/**
|
|
* @summary Recalculate thumb position.
|
|
*
|
|
* @desc This method recalculates the thumb size and position. Call it once after inserting your scrollbar into the DOM, and repeatedly while resizing the scrollbar (which typically happens when the scrollbar's parent is resized by user.
|
|
*
|
|
* > This function shifts args if first arg omitted.
|
|
*
|
|
* @param {number} [increment=this.increment] - Resets {@link FooBar#increment|increment} (see).
|
|
*
|
|
* @param {finbarStyles} [barStyles=this.barStyles] - (See type definition for details.) Scrollbar styles to be applied to the bar element.
|
|
*
|
|
* Only specify a `barStyles` object when you need to override stylesheet values. If provided, becomes the new default (`this.barStyles`), for use as a default on subsequent calls.
|
|
*
|
|
* It is generally the case that the scrollbar's new position is sufficiently described by the current styles. Therefore, it is unusual to need to provide a `barStyles` object on every call to `resize`.
|
|
*
|
|
* @returns {FinBar} Self for chaining.
|
|
* @memberOf FinBar.prototype
|
|
*/
|
|
resize: function (increment, barStyles) {
|
|
var bar = this.bar;
|
|
|
|
if (!bar.parentNode) {
|
|
return; // not in DOM yet so nothing to do
|
|
}
|
|
|
|
var container = this.container || bar.parentElement,
|
|
containerRect = container.getBoundingClientRect();
|
|
|
|
// shift args if if 1st arg omitted
|
|
if (typeof increment === 'object') {
|
|
barStyles = increment;
|
|
increment = undefined;
|
|
}
|
|
|
|
this.style = this.barStyles = barStyles || this.barStyles;
|
|
|
|
// Bound to real content: Content was given but no onchange handler.
|
|
// Set up .onchange, .containerSize, and .increment.
|
|
// Note this only makes sense if your index unit is pixels.
|
|
if (this.content) {
|
|
if (!this.onchange) {
|
|
this.onchange = this.scrollRealContent;
|
|
this.contentSize = this.content[this.oh.size];
|
|
this._min = 0;
|
|
this._max = this.contentSize - 1;
|
|
}
|
|
}
|
|
if (this.onchange === this.scrollRealContent) {
|
|
this.containerSize = containerRect[this.oh.size];
|
|
this.increment = this.containerSize / (this.contentSize - this.containerSize) * (this._max - this._min);
|
|
} else {
|
|
this.containerSize = 1;
|
|
this.increment = increment || this.increment;
|
|
}
|
|
|
|
var index = this.index;
|
|
this.testPanelItem = this.testPanelItem || this._addTestPanelItem();
|
|
this._setThumbSize();
|
|
this.index = index;
|
|
|
|
if (this.deltaProp !== null) {
|
|
container.addEventListener('wheel', this._bound.onwheel);
|
|
}
|
|
|
|
return this;
|
|
},
|
|
|
|
/**
|
|
* @summary Shorten trailing end of scrollbar by thickness of some other scrollbar.
|
|
* @desc In the "classical" scenario where vertical scroll bar is on the right and horizontal scrollbar is on the bottom, you want to shorten the "trailing end" (bottom and right ends, respectively) of at least one of them so they don't overlay.
|
|
*
|
|
* This convenience function is an programmatic alternative to hardcoding the correct style with the correct value in your stylesheet; or setting the correct style with the correct value in the {@link FinBar#barStyles|barStyles} object.
|
|
*
|
|
* @see {@link FinBar#foreshortenBy|foreshortenBy}.
|
|
*
|
|
* @param {FinBar|null} otherFinBar - Other scrollbar to avoid by shortening this one; `null` removes the trailing space
|
|
* @returns {FinBar} For chaining
|
|
*/
|
|
shortenBy: function (otherFinBar) { return this.shortenEndBy('trailing', otherFinBar); },
|
|
|
|
/**
|
|
* @summary Shorten leading end of scrollbar by thickness of some other scrollbar.
|
|
* @desc Supports non-classical scrollbar scenarios where vertical scroll bar may be on left and horizontal scrollbar may be on top, in which case you want to shorten the "leading end" rather than the trailing end.
|
|
* @see {@link FinBar#shortenBy|shortenBy}.
|
|
* @param {FinBar|null} otherFinBar - Other scrollbar to avoid by shortening this one; `null` removes the trailing space
|
|
* @returns {FinBar} For chaining
|
|
*/
|
|
foreshortenBy: function (otherFinBar) { return this.shortenEndBy('leading', otherFinBar); },
|
|
|
|
/**
|
|
* @summary Generalized shortening function.
|
|
* @see {@link FinBar#shortenBy|shortenBy}.
|
|
* @see {@link FinBar#foreshortenBy|foreshortenBy}.
|
|
* @param {string} whichEnd - a CSS style property name or an orientation hash name that translates to a CSS style property name.
|
|
* @param {FinBar|null} otherFinBar - Other scrollbar to avoid by shortening this one; `null` removes the trailing space
|
|
* @returns {FinBar} For chaining
|
|
*/
|
|
shortenEndBy: function (whichEnd, otherFinBar) {
|
|
if (!otherFinBar) {
|
|
delete this._auxStyles;
|
|
} else if (otherFinBar instanceof FinBar && otherFinBar.orientation !== this.orientation) {
|
|
var otherStyle = window.getComputedStyle(otherFinBar.bar),
|
|
ooh = orientationHashes[otherFinBar.orientation];
|
|
this._auxStyles = {};
|
|
this._auxStyles[whichEnd] = otherStyle[ooh.thickness];
|
|
}
|
|
return this; // for chaining
|
|
},
|
|
|
|
/**
|
|
* @private
|
|
* @summary Sets the proportional thumb size and hides thumb when 100%.
|
|
* @desc The thumb size has an absolute minimum of 20 (pixels).
|
|
* @memberOf FinBar.prototype
|
|
*/
|
|
_setThumbSize: function () {
|
|
var oh = this.oh,
|
|
thumbComp = window.getComputedStyle(this.thumb),
|
|
thumbMarginLeading = parseInt(thumbComp[oh.marginLeading]),
|
|
thumbMarginTrailing = parseInt(thumbComp[oh.marginTrailing]),
|
|
thumbMargins = thumbMarginLeading + thumbMarginTrailing,
|
|
barSize = this.bar.getBoundingClientRect()[oh.size],
|
|
thumbSize = Math.max(20, barSize * this.containerSize / this.contentSize);
|
|
|
|
if (this.containerSize < this.contentSize) {
|
|
this.bar.style.visibility = 'visible';
|
|
this.thumb.style[oh.size] = thumbSize + 'px';
|
|
} else {
|
|
this.bar.style.visibility = 'hidden';
|
|
}
|
|
|
|
/**
|
|
* @private
|
|
* @name _thumbMax
|
|
* @summary Maximum offset of thumb's leading edge.
|
|
* @desc This is the pixel offset within the scrollbar of the thumb when it is at its maximum position at the extreme end of its range.
|
|
*
|
|
* This value takes into account the newly calculated size of the thumb element (including its margins) and the inner size of the scrollbar (the thumb's containing element, including _its_ margins).
|
|
*
|
|
* NOTE: Scrollbar padding is not taken into account and assumed to be 0 in the current implementation and is assumed to be `0`; use thumb margins in place of scrollbar padding.
|
|
* @type {number}
|
|
* @memberOf FinBar.prototype
|
|
*/
|
|
this._thumbMax = barSize - thumbSize - thumbMargins;
|
|
|
|
this._thumbMarginLeading = thumbMarginLeading; // used in mousedown
|
|
},
|
|
|
|
/**
|
|
* @summary Remove the scrollbar.
|
|
* @desc Unhooks all the event handlers and then removes the element from the DOM. Always call this method prior to disposing of the scrollbar object.
|
|
* @memberOf FinBar.prototype
|
|
*/
|
|
remove: function () {
|
|
this.bar.onmousedown = null;
|
|
this._removeEvt('mousemove');
|
|
this._removeEvt('mouseup');
|
|
|
|
(this.container || this.bar.parentElement)._removeEvt('wheel');
|
|
|
|
this.bar.onclick =
|
|
this.thumb.onclick =
|
|
this.thumb.onmouseover =
|
|
this.thumb.transitionend =
|
|
this.thumb.onmouseout = null;
|
|
|
|
this.bar.remove();
|
|
},
|
|
|
|
/**
|
|
* @private
|
|
* @function _addTestPanelItem
|
|
* @summary Append a test panel element.
|
|
* @desc If there is a test panel in the DOM (typically an `<ol>...</ol>` element) with class names of both `this.classPrefix` and `'test-panel'` (or, barring that, any element with class name `'test-panel'`), an `<li>...</li>` element will be created and appended to it. This new element will contain a span for each class name given.
|
|
*
|
|
* You should define a CSS selector `.listening` for these spans. This class will be added to the spans to alter their appearance when a listener is added with that class name (prefixed with 'on').
|
|
*
|
|
* (This is an internal function that is called once by the constructor on every instantiation.)
|
|
* @returns {Element|undefined} The appended `<li>...</li>` element or `undefined` if there is no test panel.
|
|
* @memberOf FinBar.prototype
|
|
*/
|
|
_addTestPanelItem: function () {
|
|
var testPanelItem,
|
|
testPanelElement = document.querySelector('.' + this._classPrefix + '.test-panel') || document.querySelector('.test-panel');
|
|
|
|
if (testPanelElement) {
|
|
var testPanelItemPartNames = [ 'mousedown', 'mousemove', 'mouseup', 'index' ],
|
|
item = document.createElement('li');
|
|
|
|
testPanelItemPartNames.forEach(function (partName) {
|
|
item.innerHTML += '<span class="' + partName + '">' + partName.replace('mouse', '') + '</span>';
|
|
});
|
|
|
|
testPanelElement.appendChild(item);
|
|
|
|
testPanelItem = {};
|
|
testPanelItemPartNames.forEach(function (partName) {
|
|
testPanelItem[partName] = item.getElementsByClassName(partName)[0];
|
|
});
|
|
}
|
|
|
|
return testPanelItem;
|
|
},
|
|
|
|
_addEvt: function (evtName) {
|
|
var spy = this.testPanelItem && this.testPanelItem[evtName];
|
|
if (spy) { spy.classList.add('listening'); }
|
|
window.addEventListener(evtName, this._bound['on' + evtName]);
|
|
},
|
|
|
|
_removeEvt: function (evtName) {
|
|
var spy = this.testPanelItem && this.testPanelItem[evtName];
|
|
if (spy) { spy.classList.remove('listening'); }
|
|
window.removeEventListener(evtName, this._bound['on' + evtName]);
|
|
}
|
|
};
|
|
|
|
function extend(obj) {
|
|
for (var i = 1; i < arguments.length; ++i) {
|
|
var objn = arguments[i];
|
|
if (objn) {
|
|
for (var key in objn) {
|
|
obj[key] = objn[key];
|
|
}
|
|
}
|
|
}
|
|
return obj;
|
|
}
|
|
|
|
function validRange(range) {
|
|
var keys = Object.keys(range),
|
|
valid = keys.length === 2 &&
|
|
typeof range.min === 'number' &&
|
|
typeof range.max === 'number' &&
|
|
range.min <= range.max;
|
|
|
|
if (!valid) {
|
|
error('Invalid .range object.');
|
|
}
|
|
}
|
|
|
|
/**
|
|
* @private
|
|
* @name handlersToBeBound
|
|
* @type {object}
|
|
* @desc The functions defined in this object are all DOM event handlers that are bound by the FinBar constructor to each new instance. In other words, the `this` value of these handlers, once bound, refer to the FinBar object and not to the event emitter. "Do not consume raw."
|
|
*/
|
|
var handlersToBeBound = {
|
|
shortStop: function (evt) {
|
|
evt.stopPropagation();
|
|
},
|
|
|
|
onwheel: function (evt) {
|
|
this.index += evt[this.deltaProp] * this[this.deltaProp + 'Factor'] * this.normal;
|
|
evt.stopPropagation();
|
|
evt.preventDefault();
|
|
},
|
|
|
|
onclick: function (evt) {
|
|
var thumbBox = this.thumb.getBoundingClientRect(),
|
|
goingUp = evt[this.oh.coordinate] < thumbBox[this.oh.leading];
|
|
|
|
if (typeof this.paging === 'object') {
|
|
this.index = this.paging[goingUp ? 'up' : 'down'](Math.round(this.index));
|
|
} else {
|
|
this.index += goingUp ? -this.increment : this.increment;
|
|
}
|
|
|
|
// make the thumb glow momentarily
|
|
this.thumb.classList.add('hover');
|
|
var self = this;
|
|
this.thumb.addEventListener('transitionend', function waitForIt() {
|
|
this.removeEventListener('transitionend', waitForIt);
|
|
self._bound.onmouseup(evt);
|
|
});
|
|
|
|
evt.stopPropagation();
|
|
},
|
|
|
|
onmouseover: function () {
|
|
this.thumb.classList.add('hover');
|
|
},
|
|
|
|
onmouseout: function () {
|
|
if (!this.dragging) {
|
|
this.thumb.classList.remove('hover');
|
|
}
|
|
},
|
|
|
|
onmousedown: function (evt) {
|
|
var thumbBox = this.thumb.getBoundingClientRect();
|
|
this.pinOffset = evt[this.oh.axis] - thumbBox[this.oh.leading] + this.bar.getBoundingClientRect()[this.oh.leading] + this._thumbMarginLeading;
|
|
document.documentElement.style.cursor = 'default';
|
|
|
|
this.dragging = true;
|
|
|
|
this._addEvt('mousemove');
|
|
this._addEvt('mouseup');
|
|
|
|
evt.stopPropagation();
|
|
evt.preventDefault();
|
|
},
|
|
|
|
onmousemove: function (evt) {
|
|
if (!(evt.buttons & 1)) {
|
|
// mouse button may have been released without `onmouseup` triggering (see
|
|
window.dispatchEvent(new MouseEvent('mouseup', evt));
|
|
return;
|
|
}
|
|
|
|
var scaled = Math.min(this._thumbMax, Math.max(0, evt[this.oh.axis] - this.pinOffset));
|
|
var idx = scaled / this._thumbMax * (this._max - this._min) + this._min;
|
|
|
|
this._setScroll(idx, scaled);
|
|
|
|
evt.stopPropagation();
|
|
evt.preventDefault();
|
|
},
|
|
|
|
onmouseup: function (evt) {
|
|
this._removeEvt('mousemove');
|
|
this._removeEvt('mouseup');
|
|
|
|
this.dragging = false;
|
|
|
|
document.documentElement.style.cursor = 'auto';
|
|
|
|
var thumbBox = this.thumb.getBoundingClientRect();
|
|
if (
|
|
thumbBox.left <= evt.clientX && evt.clientX <= thumbBox.right &&
|
|
thumbBox.top <= evt.clientY && evt.clientY <= thumbBox.bottom
|
|
) {
|
|
this._bound.onmouseover(evt);
|
|
} else {
|
|
this._bound.onmouseout(evt);
|
|
}
|
|
|
|
evt.stopPropagation();
|
|
evt.preventDefault();
|
|
}
|
|
};
|
|
|
|
/**
|
|
* Table of wheel normals to webkit.
|
|
*
|
|
* This object is a dictionary of platform dictionaries, keyed by:
|
|
* * `mac` — macOS
|
|
* * `win` — Window
|
|
*
|
|
* Each platform dictionary is keyed by:
|
|
* * `webkit` — Chrome, Opera, Safari
|
|
* * `moz` — Firefox
|
|
* * `ms` — IE 11 _(Windows only)_
|
|
* * `edge` — Edge _(Windows only)_
|
|
*
|
|
* @todo add `linux` platform
|
|
* @type {object}
|
|
*/
|
|
FinBar.normals = {
|
|
mac: {
|
|
webkit: 1.0,
|
|
moz: 35
|
|
},
|
|
win: {
|
|
webkit: 2.6,
|
|
moz: 85,
|
|
ms: 2.9,
|
|
edge: 2
|
|
}
|
|
};
|
|
|
|
function getNormal() {
|
|
var nav = window.navigator, ua = nav.userAgent;
|
|
var platform = nav.platform.substr(0, 3).toLowerCase();
|
|
var browser = /Edge/.test(ua) ? 'edge' :
|
|
/Opera|OPR|Chrome|Safari/.test(ua) ? 'webkit' :
|
|
/Firefox/.test(ua) ? 'moz' :
|
|
document.documentMode ? 'ms' : // internet explorer
|
|
undefined;
|
|
var platformDictionary = FinBar.normals[platform] || {};
|
|
return platformDictionary[browser];
|
|
}
|
|
|
|
var orientationHashes = {
|
|
vertical: {
|
|
coordinate: 'clientY',
|
|
axis: 'pageY',
|
|
size: 'height',
|
|
outside: 'right',
|
|
inside: 'left',
|
|
leading: 'top',
|
|
trailing: 'bottom',
|
|
marginLeading: 'marginTop',
|
|
marginTrailing: 'marginBottom',
|
|
thickness: 'width',
|
|
delta: 'deltaY'
|
|
},
|
|
horizontal: {
|
|
coordinate: 'clientX',
|
|
axis: 'pageX',
|
|
size: 'width',
|
|
outside: 'bottom',
|
|
inside: 'top',
|
|
leading: 'left',
|
|
trailing: 'right',
|
|
marginLeading: 'marginLeft',
|
|
marginTrailing: 'marginRight',
|
|
thickness: 'height',
|
|
delta: 'deltaX'
|
|
}
|
|
};
|
|
|
|
var axis = {
|
|
top: 'vertical',
|
|
bottom: 'vertical',
|
|
height: 'vertical',
|
|
left: 'horizontal',
|
|
right: 'horizontal',
|
|
width: 'horizontal'
|
|
};
|
|
|
|
var cssFinBars; // definition inserted by gulpfile between following comments
|
|
/* inject:css */
|
|
cssFinBars = 'div.finbar-horizontal,div.finbar-vertical{margin:3px}div.finbar-horizontal>.thumb,div.finbar-vertical>.thumb{background-color:#d3d3d3;-webkit-box-shadow:0 0 1px #000;-moz-box-shadow:0 0 1px #000;box-shadow:0 0 1px #000;border-radius:4px;margin:2px;opacity:.4;transition:opacity .5s}div.finbar-horizontal>.thumb.hover,div.finbar-vertical>.thumb.hover{opacity:1;transition:opacity .5s}div.finbar-vertical{top:0;bottom:0;right:0;width:11px}div.finbar-vertical>.thumb{top:0;right:0;width:7px}div.finbar-horizontal{left:0;right:0;bottom:0;height:11px}div.finbar-horizontal>.thumb{left:0;bottom:0;height:7px}';
|
|
/* endinject */
|
|
|
|
function error(msg) {
|
|
throw 'finbars: ' + msg;
|
|
}
|
|
|
|
// Interface
|
|
module.exports = FinBar;
|
|
|
|
},{"css-injector":1}]},{},[2])
|
|
//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["/Users/joneit/repos/finbars/node_modules/browser-pack/_prelude.js","/Users/joneit/repos/finbars/node_modules/css-injector/index.js","/Users/joneit/repos/finbars/src/fake_add189ae.js","/Users/joneit/repos/finbars/src/index.js"],"names":[],"mappings":"AAAA;ACAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC/EA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACPA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA","file":"generated.js","sourceRoot":"","sourcesContent":["(function e(t,n,r){function s(o,u){if(!n[o]){if(!t[o]){var a=typeof require==\"function\"&&require;if(!u&&a)return a(o,!0);if(i)return i(o,!0);throw new Error(\"Cannot find module '\"+o+\"'\")}var f=n[o]={exports:{}};t[o][0].call(f.exports,function(e){var n=t[o][1][e];return s(n?n:e)},f,f.exports,e,t,n,r)}return n[o].exports}var i=typeof require==\"function\"&&require;for(var o=0;o<r.length;o++)s(r[o]);return s})","'use strict';\n\n/* eslint-env browser */\n\n/** @namespace cssInjector */\n\n/**\n * @summary Insert base stylesheet into DOM\n *\n * @desc Creates a new `<style>...</style>` element from the named text string(s) and inserts it but only if it does not already exist in the specified container as per `referenceElement`.\n *\n * > Caveat: If stylesheet is for use in a shadow DOM, you must specify a local `referenceElement`.\n *\n * @returns A reference to the newly created `<style>...</style>` element.\n *\n * @param {string|string[]} cssRules\n * @param {string} [ID]\n * @param {undefined|null|Element|string} [referenceElement] - Container for insertion. Overloads:\n * * `undefined` type (or omitted): injects stylesheet at top of `<head>...</head>` element\n * * `null` value: injects stylesheet at bottom of `<head>...</head>` element\n * * `Element` type: injects stylesheet immediately before given element, wherever it is found.\n * * `string` type: injects stylesheet immediately before given first element found that matches the given css selector.\n *\n * @memberOf cssInjector\n */\nfunction cssInjector(cssRules, ID, referenceElement) {\n    if (typeof referenceElement === 'string') {\n        referenceElement = document.querySelector(referenceElement);\n        if (!referenceElement) {\n            throw 'Cannot find reference element for CSS injection.';\n        }\n    } else if (referenceElement && !(referenceElement instanceof Element)) {\n        throw 'Given value not a reference element.';\n    }\n\n    var container = referenceElement && referenceElement.parentNode || document.head || document.getElementsByTagName('head')[0];\n\n    if (ID) {\n        ID = cssInjector.idPrefix + ID;\n\n        if (container.querySelector('#' + ID)) {\n            return; // stylesheet already in DOM\n        }\n    }\n\n    var style = document.createElement('style');\n    style.type = 'text/css';\n    if (ID) {\n        style.id = ID;\n    }\n    if (cssRules instanceof Array) {\n        cssRules = cssRules.join('\\n');\n    }\n    cssRules = '\\n' + cssRules + '\\n';\n    if (style.styleSheet) {\n        style.styleSheet.cssText = cssRules;\n    } else {\n        style.appendChild(document.createTextNode(cssRules));\n    }\n\n    if (referenceElement === undefined) {\n        referenceElement = container.firstChild;\n    }\n\n    container.insertBefore(style, referenceElement);\n\n    return style;\n}\n\n/**\n * @summary Optional prefix for `<style>` tag IDs.\n * @desc Defaults to `'injected-stylesheet-'`.\n * @type {string}\n * @memberOf cssInjector\n */\ncssInjector.idPrefix = 'injected-stylesheet-';\n\n// Interface\nmodule.exports = cssInjector;\n","/* eslint-env browser */\n\n'use strict';\n\nif (!window.FinBar) {\n    window.FinBar = require('./');\n}\n","'use strict';\n\n/* eslint-env node, browser */\n\nvar cssInjector = require('css-injector');\n\n// Following is the sole style requirement for bar and thumb elements.\n// Maintained in code so not dependent being in stylesheet.\nvar BAR_STYLE = 'position: absolute;';\nvar THUMB_STYLE = 'position: absolute;';\n\n/**\n * @constructor FinBar\n * @summary Create a scrollbar object.\n * @desc Creating a scrollbar is a three-step process:\n *\n * 1. Instantiate the scrollbar object by calling this constructor function. Upon instantiation, the DOM element for the scrollbar (with a single child element for the scrollbar \"thumb\") is created but is not insert it into the DOM.\n * 2. After instantiation, it is the caller's responsibility to insert the scrollbar, {@link FinBar#bar|this.bar}, into the DOM.\n * 3. After insertion, the caller must call {@link FinBar#resize|resize()} at least once to size and position the scrollbar and its thumb. After that, `resize()` should also be called repeatedly on resize events (as the content element is being resized).\n *\n * Suggested configurations:\n * * _**Unbound**_<br/>\n * The scrollbar serves merely as a simple range (slider) control. Omit both `options.onchange` and `options.content`.\n * * _**Bound to virtual content element**_<br/>\n * Virtual content is projected into the element using a custom event handler supplied by the programmer in `options.onchange`. A typical use case would be to handle scrolling of the virtual content. Other use cases include data transformations, graphics transformations, _etc._\n * * _**Bound to real content**_<br/>\n * Set `options.content` to the \"real\" content element but omit `options.onchange`. This will cause the scrollbar to use the built-in event handler (`this.scrollRealContent`) which implements smooth scrolling of the content element within the container.\n *\n * @param {finbarOptions} [options={}] - Options object. See the type definition for member details.\n */\nfunction FinBar(options) {\n\n    // make bound versions of all the mouse event handler\n    var bound = this._bound = {};\n    Object.keys(handlersToBeBound).forEach(function (key) {\n        bound[key] = handlersToBeBound[key].bind(this);\n    }, this);\n\n    /**\n     * @name thumb\n     * @summary The generated scrollbar thumb element.\n     * @desc The thumb element's parent element is always the {@link FinBar#bar|bar} element.\n     *\n     * This property is typically referenced internally only. The size and position of the thumb element is maintained by `_calcThumb()`.\n     * @type {Element}\n     * @memberOf FinBar.prototype\n     */\n    var thumb = this.thumb = document.createElement('div');\n    thumb.classList.add('thumb');\n    thumb.setAttribute('style', THUMB_STYLE);\n    thumb.onclick = bound.shortStop;\n    thumb.onmouseover = bound.onmouseover;\n    thumb.onmouseout = this._bound.onmouseout;\n\n    /**\n     * @name bar\n     * @summary The generated scrollbar element.\n     * @desc The caller inserts this element into the DOM (typically into the content container) and then calls its {@link FinBar#resize|resize()} method.\n     *\n     * Thus the node tree is typically:\n     * * A **content container** element, which contains:\n     *   * The content element(s)\n     *   * This **scrollbar element**, which in turn contains:\n     *     * The **thumb element**\n     *\n     * @type {Element}\n     * @memberOf FinBar.prototype\n     */\n    var bar = this.bar = document.createElement('div');\n     bar.classList.add('finbar-vertical');\n    bar.setAttribute('style', BAR_STYLE);\n    bar.onmousedown = this._bound.onmousedown;\n    if (this.paging) { bar.onclick = bound.onclick; }\n    bar.appendChild(thumb);\n\n    options = options || {};\n\n    // presets\n    this.orientation = 'vertical';\n    this._min = this._index = 0;\n    this._max = 100;\n\n    /**\n     * Wheel metric normalization, applied equally to all three axes.\n     *\n     * This value is overridden with a platform- and browser-specific wheel factor when available in {@link FinBar.normals}.\n     *\n     * To suppress, delete `FinBar.normals` before instantiation or override this instance variable (with `1.0`) after instantiation.\n     * @type {number}\n     * @memberOf FinBar.prototype\n     */\n    this.normal = getNormal() || 1.0;\n\n    // options\n    Object.keys(options).forEach(function (key) {\n        var option = options[key];\n        if (option !== undefined) {\n            switch (key) {\n\n                case 'index':\n                    this._index = option;\n                    break;\n\n                case 'range':\n                    validRange(option);\n                    this._min = option.min;\n                    this._max = option.max;\n                    this.contentSize = option.max - option.min + 1;\n                    break;\n\n                default:\n                    if (\n                        key.charAt(0) !== '_' &&\n                        typeof FinBar.prototype[key] !== 'function'\n                    ) {\n                        // override prototype defaults for standard ;\n                        // extend with additional properties (for use in onchange event handlers)\n                        this[key] = option;\n                    }\n                    break;\n\n            }\n        }\n    }, this);\n\n    cssInjector(cssFinBars, 'finbar-base', options.cssStylesheetReferenceElement);\n}\n\nFinBar.prototype = {\n\n    /**\n     * @summary The scrollbar orientation.\n     * @desc Set by the constructor to either `'vertical'` or `'horizontal'`. See the similarly named property in the {@link finbarOptions} object.\n     *\n     * Useful values are `'vertical'` (the default) or `'horizontal'`.\n     *\n     * Setting this property resets `this.oh` and `this.deltaProp` and changes the class names so as to reposition the scrollbar as per the CSS rules for the new orientation.\n     * @default 'vertical'\n     * @type {string}\n     * @memberOf FinBar.prototype\n     */\n    set orientation(orientation) {\n        if (orientation === this._orientation) {\n            return;\n        }\n\n        this._orientation = orientation;\n\n        /**\n         * @readonly\n         * @name oh\n         * @summary <u>O</u>rientation <u>h</u>ash for this scrollbar.\n         * @desc Set by the `orientation` setter to either the vertical or the horizontal orientation hash. The property should always be synchronized with `orientation`; do not update directly!\n         *\n         * This object is used internally to access scrollbars' DOM element properties in a generalized way without needing to constantly query the scrollbar orientation. For example, instead of explicitly coding `this.bar.top` for a vertical scrollbar and `this.bar.left` for a horizontal scrollbar, simply code `this.bar[this.oh.leading]` instead. See the {@link orientationHashType} definition for details.\n         *\n         * This object is useful externally for coding generalized {@link finbarOnChange} event handler functions that serve both horizontal and vertical scrollbars.\n         * @type {orientationHashType}\n         * @memberOf FinBar.prototype\n         */\n        this.oh = orientationHashes[this._orientation];\n\n        if (!this.oh) {\n            error('Invalid value for `options._orientation.');\n        }\n\n        /**\n         * @name deltaProp\n         * @summary The name of the `WheelEvent` property this scrollbar should listen to.\n         * @desc Set by the constructor. See the similarly named property in the {@link finbarOptions} object.\n         *\n         * Useful values are `'deltaX'`, `'deltaY'`, or `'deltaZ'`. A value of `null` means to ignore mouse wheel events entirely.\n         *\n         * The mouse wheel is one-dimensional and only emits events with `deltaY` data. This property is provided so that you can override the default of `'deltaX'` with a value of `'deltaY'` on your horizontal scrollbar primarily to accommodate certain \"panoramic\" interface designs where the mouse wheel should control horizontal rather than vertical scrolling. Just give `{ deltaProp: 'deltaY' }` in your horizontal scrollbar instantiation.\n         *\n         * Caveat: Note that a 2-finger drag on an Apple trackpad emits events with _both_ `deltaX ` and `deltaY` data so you might want to delay making the above adjustment until you can determine that you are getting Y data only with no X data at all (which is a sure bet you on a mouse wheel rather than a trackpad).\n\n         * @type {object|null}\n         * @memberOf FinBar.prototype\n         */\n        this.deltaProp = this.oh.delta;\n\n        this.bar.className = this.bar.className.replace(/(vertical|horizontal)/g, orientation);\n\n        if (this.bar.style.cssText !== BAR_STYLE || this.thumb.style.cssText !== THUMB_STYLE) {\n            this.bar.setAttribute('style', BAR_STYLE);\n            this.thumb.setAttribute('style', THUMB_STYLE);\n            this.resize();\n        }\n    },\n    get orientation() {\n        return this._orientation;\n    },\n\n    /**\n     * @summary Callback for scroll events.\n     * @desc Set by the constructor via the similarly named property in the {@link finbarOptions} object. After instantiation, `this.onchange` may be updated directly.\n     *\n     * This event handler is called whenever the value of the scrollbar is changed through user interaction. The typical use case is when the content is scrolled. It is called with the `FinBar` object as its context and the current value of the scrollbar (its index, rounded) as the only parameter.\n     *\n     * Set this property to `null` to stop emitting such events.\n     * @type {function(number)|null}\n     * @memberOf FinBar.prototype\n     */\n    onchange: null,\n\n    /**\n     * @summary Add a CSS class name to the bar element's class list.\n     * @desc Set by the constructor. See the similarly named property in the {@link finbarOptions} object.\n     *\n     * The bar element's class list will always include `finbar-vertical` (or `finbar-horizontal` based on the current orientation). Whenever this property is set to some value, first the old prefix+orientation is removed from the bar element's class list; then the new prefix+orientation is added to the bar element's class list. This property causes _an additional_ class name to be added to the bar element's class list. Therefore, this property will only add at most one additional class name to the list.\n     *\n     * To remove _classname-orientation_ from the bar element's class list, set this property to a falsy value, such as `null`.\n     *\n     * > NOTE: You only need to specify an additional class name when you need to have mulltiple different styles of scrollbars on the same page. If this is not a requirement, then you don't need to make a new class; you would just create some additional rules using the same selectors in the built-in stylesheet (../css/finbars.css):\n     * *`div.finbar-vertical` (or `div.finbar-horizontal`) for the scrollbar\n     * *`div.finbar-vertical > div` (or `div.finbar-horizontal > div`) for the \"thumb.\"\n     *\n     * Of course, your rules should come after the built-ins.\n     * @type {string}\n     * @memberOf FinBar.prototype\n     */\n    set classPrefix(prefix) {\n        if (this._classPrefix) {\n            this.bar.classList.remove(this._classPrefix + this.orientation);\n        }\n\n        this._classPrefix = prefix;\n\n        if (prefix) {\n            this.bar.classList.add(prefix + '-' + this.orientation);\n        }\n    },\n    get classPrefix() {\n        return this._classPrefix;\n    },\n\n    /**\n     * @name increment\n     * @summary Number of scrollbar index units representing a pageful. Used exclusively for paging up and down and for setting thumb size relative to content size.\n     * @desc Set by the constructor. See the similarly named property in the {@link finbarOptions} object.\n     *\n     * Can also be given as a parameter to the {@link FinBar#resize|resize} method, which is pertinent because content area size changes affect the definition of a \"pageful.\" However, you only need to do this if this value is being used. It not used when:\n     * * you define `paging.up` and `paging.down`\n     * * your scrollbar is using `scrollRealContent`\n     * @type {number}\n     * @memberOf FinBar.prototype\n     */\n    increment: 1,\n\n    /**\n     * Default value of multiplier for `WheelEvent#deltaX` (horizontal scrolling delta).\n     * @default\n     * @memberOf FinBar.prototype\n     */\n    deltaXFactor: 1,\n\n    /**\n     * Default value of multiplier for `WheelEvent#deltaY` (vertical scrolling delta).\n     * @default\n     * @memberOf FinBar.prototype\n     */\n    deltaYFactor: 1,\n\n    /**\n     * Default value of multiplier for `WheelEvent#deltaZ` (delpth scrolling delta).\n     * @default\n     * @memberOf FinBar.prototype\n     */\n    deltaZFactor: 1,\n\n    /**\n     * @name barStyles\n     * @summary Scrollbar styles to be applied by {@link FinBar#resize|resize()}.\n     * @desc Set by the constructor. See the similarly named property in the {@link finbarOptions} object.\n     *\n     * This is a value to be assigned to {@link FinBar#styles|styles} on each call to {@link FinBar#resize|resize()}. That is, a hash of values to be copied to the scrollbar element's style object on resize; or `null` for none.\n     *\n     * @see {@link FinBar#style|style}\n     * @type {finbarStyles|null}\n     * @memberOf FinBar.prototype\n     */\n    barStyles: null,\n\n    /**\n     * @name style\n     * @summary Additional scrollbar styles.\n     * @desc See type definition for more details. These styles are applied directly to the scrollbar's `bar` element.\n     *\n     * Values are adjusted as follows before being applied to the element:\n     * 1. Included \"pseudo-property\" names from the scrollbar's orientation hash, {@link FinBar#oh|oh}, are translated to actual property names before being applied.\n     * 2. When there are margins, percentages are translated to absolute pixel values because CSS ignores margins in its percentage calculations.\n     * 3. If you give a value without a unit (a raw number), \"px\" unit is appended.\n     *\n     * General notes:\n     * 1. It is always preferable to specify styles via a stylesheet. Only set this property when you need to specifically override (a) stylesheet value(s).\n     * 2. Can be set directly or via calls to the {@link FinBar#resize|resize} method.\n     * 3. Should only be set after the scrollbar has been inserted into the DOM.\n     * 4. Before applying these new values to the element, _all_ in-line style values are reset (by removing the element's `style` attribute), exposing inherited values (from stylesheets).\n     * 5. Empty object has no effect.\n     * 6. Falsey value in place of object has no effect.\n     *\n     * > CAVEAT: Do not attempt to treat the object you assign to this property as if it were `this.bar.style`. Specifically, changing this object after assigning it will have no effect on the scrollbar. You must assign it again if you want it to have an effect.\n     *\n     * @see {@link FinBar#barStyles|barStyles}\n     * @type {finbarStyles}\n     * @memberOf FinBar.prototype\n     */\n    set style(styles) {\n        var keys = Object.keys(styles = extend({}, styles, this._auxStyles));\n\n        if (keys.length) {\n            var bar = this.bar,\n                barRect = bar.getBoundingClientRect(),\n                container = this.container || bar.parentElement,\n                containerRect = container.getBoundingClientRect(),\n                oh = this.oh;\n\n            // Before applying new styles, revert all styles to values inherited from stylesheets\n            bar.setAttribute('style', BAR_STYLE);\n\n            keys.forEach(function (key) {\n                var val = styles[key];\n\n                if (key in oh) {\n                    key = oh[key];\n                }\n\n                if (!isNaN(Number(val))) {\n                    val = (val || 0) + 'px';\n                } else if (/%$/.test(val)) {\n                    // When bar size given as percentage of container, if bar has margins, restate size in pixels less margins.\n                    // (If left as percentage, CSS's calculation will not exclude margins.)\n                    var oriented = axis[key],\n                        margins = barRect[oriented.marginLeading] + barRect[oriented.marginTrailing];\n                    if (margins) {\n                        val = parseInt(val, 10) / 100 * containerRect[oriented.size] - margins + 'px';\n                    }\n                }\n\n                bar.style[key] = val;\n            });\n        }\n    },\n\n    /**\n     * @readonly\n     * @name paging\n     * @summary Enable page up/dn clicks.\n     * @desc Set by the constructor. See the similarly named property in the {@link finbarOptions} object.\n     *\n     * If truthy, listen for clicks in page-up and page-down regions of scrollbar.\n     *\n     * If an object, call `.paging.up()` on page-up clicks and `.paging.down()` will be called on page-down clicks.\n     *\n     * Changing the truthiness of this value after instantiation currently has no effect.\n     * @type {boolean|object}\n     * @memberOf FinBar.prototype\n     */\n    paging: true,\n\n    /**\n     * @name range\n     * @summary Setter for the minimum and maximum scroll values.\n     * @desc Set by the constructor. These values are the limits for {@link FooBar#index|index}.\n     *\n     * The setter accepts an object with exactly two numeric properties: `.min` which must be less than `.max`. The values are extracted and the object is discarded.\n     *\n     * The getter returns a new object with `.min` and '.max`.\n     *\n     * @type {rangeType}\n     * @memberOf FinBar.prototype\n     */\n    set range(range) {\n        validRange(range);\n        this._min = range.min;\n        this._max = range.max;\n        this.contentSize = range.max - range.min + 1;\n        this.index = this.index; // re-clamp\n    },\n    get range() {\n        return {\n            min: this._min,\n            max: this._max\n        };\n    },\n\n    /**\n     * @summary Index value of the scrollbar.\n     * @desc This is the position of the scroll thumb.\n     *\n     * Setting this value clamps it to {@link FinBar#min|min}..{@link FinBar#max|max}, scroll the content, and moves thumb.\n     *\n     * Getting this value returns the current index. The returned value will be in the range `min`..`max`. It is intentionally not rounded.\n     *\n     * Use this value as an alternative to (or in addition to) using the {@link FinBar#onchange|onchange} callback function.\n     *\n     * @see {@link FinBar#_setScroll|_setScroll}\n     * @type {number}\n     * @memberOf FinBar.prototype\n     */\n    set index(idx) {\n        idx = Math.min(this._max, Math.max(this._min, idx)); // clamp it\n        this._setScroll(idx);\n        // this._setThumbSize();\n    },\n    get index() {\n        return this._index;\n    },\n\n    /**\n     * @private\n     * @summary Move the thumb.\n     * @desc Also displays the index value in the test panel and invokes the callback.\n     * @param idx - The new scroll index, a value in the range `min`..`max`.\n     * @param [scaled=f(idx)] - The new thumb position in pixels and scaled relative to the containing {@link FinBar#bar|bar} element, i.e., a proportional number in the range `0`..`thumbMax`. When omitted, a function of `idx` is used.\n     * @memberOf FinBar.prototype\n     */\n    _setScroll: function (idx, scaled) {\n        this._index = idx;\n\n        // Display the index value in the test panel\n        if (this.testPanelItem && this.testPanelItem.index instanceof Element) {\n            this.testPanelItem.index.innerHTML = Math.round(idx);\n        }\n\n        // Call the callback\n        if (this.onchange) {\n            this.onchange.call(this, Math.round(idx));\n        }\n\n        // Move the thumb\n        if (scaled === undefined) {\n            scaled = (idx - this._min) / (this._max - this._min) * this._thumbMax;\n        }\n        this.thumb.style[this.oh.leading] = scaled + 'px';\n    },\n\n    scrollRealContent: function (idx) {\n        var containerRect = this.content.parentElement.getBoundingClientRect(),\n            sizeProp = this.oh.size,\n            maxScroll = Math.max(0, this.content[sizeProp] - containerRect[sizeProp]),\n            //scroll = Math.min(idx, maxScroll);\n            scroll = (idx - this._min) / (this._max - this._min) * maxScroll;\n        //console.log('scroll: ' + scroll);\n        this.content.style[this.oh.leading] = -scroll + 'px';\n    },\n\n    /**\n     * @summary Recalculate thumb position.\n     *\n     * @desc This method recalculates the thumb size and position. Call it once after inserting your scrollbar into the DOM, and repeatedly while resizing the scrollbar (which typically happens when the scrollbar's parent is resized by user.\n     *\n     * > This function shifts args if first arg omitted.\n     *\n     * @param {number} [increment=this.increment] - Resets {@link FooBar#increment|increment} (see).\n     *\n     * @param {finbarStyles} [barStyles=this.barStyles] - (See type definition for details.) Scrollbar styles to be applied to the bar element.\n     *\n     * Only specify a `barStyles` object when you need to override stylesheet values. If provided, becomes the new default (`this.barStyles`), for use as a default on subsequent calls.\n     *\n     * It is generally the case that the scrollbar's new position is sufficiently described by the current styles. Therefore, it is unusual to need to provide a `barStyles` object on every call to `resize`.\n     *\n     * @returns {FinBar} Self for chaining.\n     * @memberOf FinBar.prototype\n     */\n    resize: function (increment, barStyles) {\n        var bar = this.bar;\n\n        if (!bar.parentNode) {\n            return; // not in DOM yet so nothing to do\n        }\n\n        var container = this.container || bar.parentElement,\n            containerRect = container.getBoundingClientRect();\n\n        // shift args if if 1st arg omitted\n        if (typeof increment === 'object') {\n            barStyles = increment;\n            increment = undefined;\n        }\n\n        this.style = this.barStyles = barStyles || this.barStyles;\n\n        // Bound to real content: Content was given but no onchange handler.\n        // Set up .onchange, .containerSize, and .increment.\n        // Note this only makes sense if your index unit is pixels.\n        if (this.content) {\n            if (!this.onchange) {\n                this.onchange = this.scrollRealContent;\n                this.contentSize = this.content[this.oh.size];\n                this._min = 0;\n                this._max = this.contentSize - 1;\n            }\n        }\n        if (this.onchange === this.scrollRealContent) {\n            this.containerSize = containerRect[this.oh.size];\n            this.increment = this.containerSize / (this.contentSize - this.containerSize) * (this._max - this._min);\n        } else {\n            this.containerSize = 1;\n            this.increment = increment || this.increment;\n        }\n\n        var index = this.index;\n        this.testPanelItem = this.testPanelItem || this._addTestPanelItem();\n        this._setThumbSize();\n        this.index = index;\n\n        if (this.deltaProp !== null) {\n            container.addEventListener('wheel', this._bound.onwheel);\n        }\n\n        return this;\n    },\n\n    /**\n     * @summary Shorten trailing end of scrollbar by thickness of some other scrollbar.\n     * @desc In the \"classical\" scenario where vertical scroll bar is on the right and horizontal scrollbar is on the bottom, you want to shorten the \"trailing end\" (bottom and right ends, respectively) of at least one of them so they don't overlay.\n     *\n     * This convenience function is an programmatic alternative to hardcoding the correct style with the correct value in your stylesheet; or setting the correct style with the correct value in the {@link FinBar#barStyles|barStyles} object.\n     *\n     * @see {@link FinBar#foreshortenBy|foreshortenBy}.\n     *\n     * @param {FinBar|null} otherFinBar - Other scrollbar to avoid by shortening this one; `null` removes the trailing space\n     * @returns {FinBar} For chaining\n     */\n    shortenBy: function (otherFinBar) { return this.shortenEndBy('trailing', otherFinBar); },\n\n    /**\n     * @summary Shorten leading end of scrollbar by thickness of some other scrollbar.\n     * @desc Supports non-classical scrollbar scenarios where vertical scroll bar may be on left and horizontal scrollbar may be on top, in which case you want to shorten the \"leading end\" rather than the trailing end.\n     * @see {@link FinBar#shortenBy|shortenBy}.\n     * @param {FinBar|null} otherFinBar - Other scrollbar to avoid by shortening this one; `null` removes the trailing space\n     * @returns {FinBar} For chaining\n     */\n    foreshortenBy: function (otherFinBar) { return this.shortenEndBy('leading', otherFinBar); },\n\n    /**\n     * @summary Generalized shortening function.\n     * @see {@link FinBar#shortenBy|shortenBy}.\n     * @see {@link FinBar#foreshortenBy|foreshortenBy}.\n     * @param {string} whichEnd - a CSS style property name or an orientation hash name that translates to a CSS style property name.\n     * @param {FinBar|null} otherFinBar - Other scrollbar to avoid by shortening this one; `null` removes the trailing space\n     * @returns {FinBar} For chaining\n     */\n    shortenEndBy: function (whichEnd, otherFinBar) {\n        if (!otherFinBar) {\n            delete this._auxStyles;\n        } else if (otherFinBar instanceof FinBar && otherFinBar.orientation !== this.orientation) {\n            var otherStyle = window.getComputedStyle(otherFinBar.bar),\n                ooh = orientationHashes[otherFinBar.orientation];\n            this._auxStyles = {};\n            this._auxStyles[whichEnd] = otherStyle[ooh.thickness];\n        }\n        return this; // for chaining\n    },\n\n    /**\n     * @private\n     * @summary Sets the proportional thumb size and hides thumb when 100%.\n     * @desc The thumb size has an absolute minimum of 20 (pixels).\n     * @memberOf FinBar.prototype\n     */\n    _setThumbSize: function () {\n        var oh = this.oh,\n            thumbComp = window.getComputedStyle(this.thumb),\n            thumbMarginLeading = parseInt(thumbComp[oh.marginLeading]),\n            thumbMarginTrailing = parseInt(thumbComp[oh.marginTrailing]),\n            thumbMargins = thumbMarginLeading + thumbMarginTrailing,\n            barSize = this.bar.getBoundingClientRect()[oh.size],\n            thumbSize = Math.max(20, barSize * this.containerSize / this.contentSize);\n\n        if (this.containerSize < this.contentSize) {\n            this.bar.style.visibility = 'visible';\n            this.thumb.style[oh.size] = thumbSize + 'px';\n        } else {\n            this.bar.style.visibility = 'hidden';\n        }\n\n        /**\n         * @private\n         * @name _thumbMax\n         * @summary Maximum offset of thumb's leading edge.\n         * @desc This is the pixel offset within the scrollbar of the thumb when it is at its maximum position at the extreme end of its range.\n         *\n         * This value takes into account the newly calculated size of the thumb element (including its margins) and the inner size of the scrollbar (the thumb's containing element, including _its_ margins).\n         *\n         * NOTE: Scrollbar padding is not taken into account and assumed to be 0 in the current implementation and is assumed to be `0`; use thumb margins in place of scrollbar padding.\n         * @type {number}\n         * @memberOf FinBar.prototype\n         */\n        this._thumbMax = barSize - thumbSize - thumbMargins;\n\n        this._thumbMarginLeading = thumbMarginLeading; // used in mousedown\n    },\n\n    /**\n     * @summary Remove the scrollbar.\n     * @desc Unhooks all the event handlers and then removes the element from the DOM. Always call this method prior to disposing of the scrollbar object.\n     * @memberOf FinBar.prototype\n     */\n    remove: function () {\n        this.bar.onmousedown = null;\n        this._removeEvt('mousemove');\n        this._removeEvt('mouseup');\n\n        (this.container || this.bar.parentElement)._removeEvt('wheel');\n\n        this.bar.onclick =\n            this.thumb.onclick =\n                this.thumb.onmouseover =\n                    this.thumb.transitionend =\n                        this.thumb.onmouseout = null;\n\n        this.bar.remove();\n    },\n\n    /**\n     * @private\n     * @function _addTestPanelItem\n     * @summary Append a test panel element.\n     * @desc If there is a test panel in the DOM (typically an `<ol>...</ol>` element) with class names of both `this.classPrefix` and `'test-panel'` (or, barring that, any element with class name `'test-panel'`), an `<li>...</li>` element will be created and appended to it. This new element will contain a span for each class name given.\n     *\n     * You should define a CSS selector `.listening` for these spans. This class will be added to the spans to alter their appearance when a listener is added with that class name (prefixed with 'on').\n     *\n     * (This is an internal function that is called once by the constructor on every instantiation.)\n     * @returns {Element|undefined} The appended `<li>...</li>` element or `undefined` if there is no test panel.\n     * @memberOf FinBar.prototype\n     */\n    _addTestPanelItem: function () {\n        var testPanelItem,\n            testPanelElement = document.querySelector('.' + this._classPrefix + '.test-panel') || document.querySelector('.test-panel');\n\n        if (testPanelElement) {\n            var testPanelItemPartNames = [ 'mousedown', 'mousemove', 'mouseup', 'index' ],\n                item = document.createElement('li');\n\n            testPanelItemPartNames.forEach(function (partName) {\n                item.innerHTML += '<span class=\"' + partName + '\">' + partName.replace('mouse', '') + '</span>';\n            });\n\n            testPanelElement.appendChild(item);\n\n            testPanelItem = {};\n            testPanelItemPartNames.forEach(function (partName) {\n                testPanelItem[partName] = item.getElementsByClassName(partName)[0];\n            });\n        }\n\n        return testPanelItem;\n    },\n\n    _addEvt: function (evtName) {\n        var spy = this.testPanelItem && this.testPanelItem[evtName];\n        if (spy) { spy.classList.add('listening'); }\n        window.addEventListener(evtName, this._bound['on' + evtName]);\n    },\n\n    _removeEvt: function (evtName) {\n        var spy = this.testPanelItem && this.testPanelItem[evtName];\n        if (spy) { spy.classList.remove('listening'); }\n        window.removeEventListener(evtName, this._bound['on' + evtName]);\n    }\n};\n\nfunction extend(obj) {\n    for (var i = 1; i < arguments.length; ++i) {\n        var objn = arguments[i];\n        if (objn) {\n            for (var key in objn) {\n                obj[key] = objn[key];\n            }\n        }\n    }\n    return obj;\n}\n\nfunction validRange(range) {\n    var keys = Object.keys(range),\n        valid =  keys.length === 2 &&\n            typeof range.min === 'number' &&\n            typeof range.max === 'number' &&\n            range.min <= range.max;\n\n    if (!valid) {\n        error('Invalid .range object.');\n    }\n}\n\n/**\n * @private\n * @name handlersToBeBound\n * @type {object}\n * @desc The functions defined in this object are all DOM event handlers that are bound by the FinBar constructor to each new instance. In other words, the `this` value of these handlers, once bound, refer to the FinBar object and not to the event emitter. \"Do not consume raw.\"\n */\nvar handlersToBeBound = {\n    shortStop: function (evt) {\n        evt.stopPropagation();\n    },\n\n    onwheel: function (evt) {\n        this.index += evt[this.deltaProp] * this[this.deltaProp + 'Factor'] * this.normal;\n        evt.stopPropagation();\n        evt.preventDefault();\n    },\n\n    onclick: function (evt) {\n        var thumbBox = this.thumb.getBoundingClientRect(),\n            goingUp = evt[this.oh.coordinate] < thumbBox[this.oh.leading];\n\n        if (typeof this.paging === 'object') {\n            this.index = this.paging[goingUp ? 'up' : 'down'](Math.round(this.index));\n        } else {\n            this.index += goingUp ? -this.increment : this.increment;\n        }\n\n        // make the thumb glow momentarily\n        this.thumb.classList.add('hover');\n        var self = this;\n        this.thumb.addEventListener('transitionend', function waitForIt() {\n            this.removeEventListener('transitionend', waitForIt);\n            self._bound.onmouseup(evt);\n        });\n\n        evt.stopPropagation();\n    },\n\n    onmouseover: function () {\n        this.thumb.classList.add('hover');\n    },\n\n    onmouseout: function () {\n        if (!this.dragging) {\n            this.thumb.classList.remove('hover');\n        }\n    },\n\n    onmousedown: function (evt) {\n        var thumbBox = this.thumb.getBoundingClientRect();\n        this.pinOffset = evt[this.oh.axis] - thumbBox[this.oh.leading] + this.bar.getBoundingClientRect()[this.oh.leading] + this._thumbMarginLeading;\n        document.documentElement.style.cursor = 'default';\n\n        this.dragging = true;\n\n        this._addEvt('mousemove');\n        this._addEvt('mouseup');\n\n        evt.stopPropagation();\n        evt.preventDefault();\n    },\n\n    onmousemove: function (evt) {\n        if (!(evt.buttons & 1)) {\n            // mouse button may have been released without `onmouseup` triggering (see\n            window.dispatchEvent(new MouseEvent('mouseup', evt));\n            return;\n        }\n\n        var scaled = Math.min(this._thumbMax, Math.max(0, evt[this.oh.axis] - this.pinOffset));\n        var idx = scaled / this._thumbMax * (this._max - this._min) + this._min;\n\n        this._setScroll(idx, scaled);\n\n        evt.stopPropagation();\n        evt.preventDefault();\n    },\n\n    onmouseup: function (evt) {\n        this._removeEvt('mousemove');\n        this._removeEvt('mouseup');\n\n        this.dragging = false;\n\n        document.documentElement.style.cursor = 'auto';\n\n        var thumbBox = this.thumb.getBoundingClientRect();\n        if (\n            thumbBox.left <= evt.clientX && evt.clientX <= thumbBox.right &&\n            thumbBox.top <= evt.clientY && evt.clientY <= thumbBox.bottom\n        ) {\n            this._bound.onmouseover(evt);\n        } else {\n            this._bound.onmouseout(evt);\n        }\n\n        evt.stopPropagation();\n        evt.preventDefault();\n    }\n};\n\n/**\n * Table of wheel normals to webkit.\n *\n * This object is a dictionary of platform dictionaries, keyed by:\n * * `mac` — macOS\n * * `win` — Window\n *\n * Each platform dictionary is keyed by:\n * * `webkit` — Chrome, Opera, Safari\n * * `moz` — Firefox\n * * `ms` — IE 11 _(Windows only)_\n * * `edge` — Edge _(Windows only)_\n *\n * @todo add `linux` platform\n * @type {object}\n */\nFinBar.normals = {\n    mac: {\n        webkit: 1.0,\n        moz: 35\n    },\n    win: {\n        webkit: 2.6,\n        moz: 85,\n        ms: 2.9,\n        edge: 2\n    }\n};\n\nfunction getNormal() {\n    var nav = window.navigator, ua = nav.userAgent;\n    var platform = nav.platform.substr(0, 3).toLowerCase();\n    var browser = /Edge/.test(ua) ? 'edge' :\n        /Opera|OPR|Chrome|Safari/.test(ua) ? 'webkit' :\n            /Firefox/.test(ua) ? 'moz' :\n                document.documentMode ? 'ms' : // internet explorer\n                    undefined;\n    var platformDictionary = FinBar.normals[platform] || {};\n    return platformDictionary[browser];\n}\n\nvar orientationHashes = {\n    vertical: {\n        coordinate:     'clientY',\n        axis:           'pageY',\n        size:           'height',\n        outside:        'right',\n        inside:         'left',\n        leading:        'top',\n        trailing:       'bottom',\n        marginLeading:  'marginTop',\n        marginTrailing: 'marginBottom',\n        thickness:      'width',\n        delta:          'deltaY'\n    },\n    horizontal: {\n        coordinate:     'clientX',\n        axis:           'pageX',\n        size:           'width',\n        outside:        'bottom',\n        inside:         'top',\n        leading:        'left',\n        trailing:       'right',\n        marginLeading:  'marginLeft',\n        marginTrailing: 'marginRight',\n        thickness:      'height',\n        delta:          'deltaX'\n    }\n};\n\nvar axis = {\n    top:    'vertical',\n    bottom: 'vertical',\n    height: 'vertical',\n    left:   'horizontal',\n    right:  'horizontal',\n    width:  'horizontal'\n};\n\nvar cssFinBars; // definition inserted by gulpfile between following comments\n/* inject:css */\ncssFinBars = 'div.finbar-horizontal,div.finbar-vertical{margin:3px}div.finbar-horizontal>.thumb,div.finbar-vertical>.thumb{background-color:#d3d3d3;-webkit-box-shadow:0 0 1px #000;-moz-box-shadow:0 0 1px #000;box-shadow:0 0 1px #000;border-radius:4px;margin:2px;opacity:.4;transition:opacity .5s}div.finbar-horizontal>.thumb.hover,div.finbar-vertical>.thumb.hover{opacity:1;transition:opacity .5s}div.finbar-vertical{top:0;bottom:0;right:0;width:11px}div.finbar-vertical>.thumb{top:0;right:0;width:7px}div.finbar-horizontal{left:0;right:0;bottom:0;height:11px}div.finbar-horizontal>.thumb{left:0;bottom:0;height:7px}';\n/* endinject */\n\nfunction error(msg) {\n    throw 'finbars: ' + msg;\n}\n\n// Interface\nmodule.exports = FinBar;\n"]}
|