jekyll-theme-prettydocs 0.0.6 → 1.0.0

data/assets/plugins/stickyfill/.editorconfig

@@ -0,0 +1,9 @@
+# top-most EditorConfig file
+root = true
+
+# Unix-style newlines with a newline ending every file
+[*]
+end_of_line = lf
+insert_final_newline = true
+indent_style = space
+indent_size = 4

data/assets/plugins/stickyfill/.gitignore

@@ -0,0 +1 @@
+node_modules

data/assets/plugins/stickyfill/Gruntfile.js

@@ -0,0 +1,106 @@
+module.exports = function(grunt) {
+    'use strict';
+
+    grunt.initConfig({
+        pkg: grunt.file.readJSON('package.json'),
+        banner:
+`/*!
+  * Stickyfill – \`position: sticky\` polyfill
+  * v. <%= pkg.version %> | <%= pkg.homepage %>
+  * MIT License
+  */
+`,
+
+        babel: {
+            options: {
+                presets: ['es2015']
+            },
+            dist: {
+                files: {
+                    'dist/stickyfill.js': 'src/stickyfill.js'
+                }
+            }
+        },
+
+        wrap: {
+            es5: {
+                options: {
+                    wrapper: [
+                        '<%= banner %>\n;(function(window, document) {',
+                        '})(window, document);'
+                    ],
+                    indent: '    '
+                },
+                files: {
+                    'dist/stickyfill.js': ['dist/stickyfill.js']
+                }
+            },
+            es6: {
+                options: {
+                    wrapper: [
+                        '<%= banner %>',
+                        ''
+                    ]
+                },
+                files: {
+                    'dist/stickyfill.es6.js': ['src/stickyfill.js']
+                }
+            }
+        },
+
+        uglify: {
+            options: {
+                banner: '<%= banner %>',
+                mangle: true
+            },
+            dist: {
+                files: {
+                    'dist/stickyfill.min.js': ['dist/stickyfill.js']
+                }
+            }
+        },
+
+        bump: {
+            options: {
+                files: ['package.json'],
+                updateConfigs: ['pkg'],
+                commit: true,
+                commitMessage: 'v %VERSION%',
+                commitFiles: ['.'],
+                createTag: true,
+                tagName: '%VERSION%',
+                tagMessage: 'v %VERSION%',
+                push: false
+            }
+        },
+
+        shell: {
+            push: {
+                command: 'git push'
+            },
+
+            pushTags: {
+                command: 'git push --tags'
+            },
+
+            publishToNpm: {
+                command: 'npm publish'
+            }
+        },
+
+        watch: {
+            files: ['src/**/*.js'],
+            tasks: ['build']
+        }
+    });
+
+    grunt.loadNpmTasks('grunt-wrap');
+    grunt.loadNpmTasks('grunt-babel');
+    grunt.loadNpmTasks('grunt-contrib-uglify');
+    grunt.loadNpmTasks('grunt-contrib-watch');
+    grunt.loadNpmTasks('grunt-bump');
+    grunt.loadNpmTasks('grunt-shell');
+    grunt.registerTask('build', ['babel', 'wrap', 'uglify']);
+    grunt.registerTask('release', ['bump-only:patch', 'build', 'bump-commit', 'shell:push', 'shell:pushTags', 'shell:publishToNpm']);
+    grunt.registerTask('default', ['build', 'watch']);
+};

data/assets/plugins/stickyfill/LICENSE

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

data/assets/plugins/stickyfill/README.md

@@ -0,0 +1,229 @@
+# Polyfill for CSS `position: sticky`
+
+The most accurate sticky polyfill out in the wild.
+
+Check out [the demo](http://wd.dizaina.net/en/scripts/stickyfill/) and [use cases test page](http://wilddeer.github.io/stickyfill/test/).
+
+## What it does
+
+- supports top-positioned stickies,
+- works in IE9+,
+- disables itself in older IEs and in browsers with native `position: sticky` support,
+- mimics original `position: sticky` behavior:
+
+    - uses parent node as a boundary box,
+    - behaves nicely with horizontal page scrolling,
+    - only works on elements with specified `top`,
+    - mimics native `top` and `margin-bottom` behavior,
+    - ~~works with table cells~~ removed for consistency until Firefox [makes a native implementation](https://bugzilla.mozilla.org/show_bug.cgi?id=975644)
+
+## What it doesn't
+
+- doesn't support left, right, bottom or combined stickies,
+- doesn't work in overflowed blocks,
+- doesn't parse your CSS! Launch it manually.
+
+## Installation
+
+### NPM
+
+```
+npm install stickyfilljs --save
+```
+
+### Yarn
+
+```
+yarn add stickyfilljs
+```
+
+### Raw ES6 module
+
+[stickyfill.es6.js](https://raw.github.com/wilddeer/stickyfill/master/dist/stickyfill.es6.js)
+
+### Old fashioned
+
+Download minified production ES5 script:
+
+[stickyfill.min.js](https://raw.github.com/wilddeer/stickyfill/master/dist/stickyfill.min.js)
+
+Include it on your page:
+
+```html
+<script src="path/to/stickyfill.min.js"></script>
+```
+
+## Usage
+
+First things first, make sure your stickies work in the [browsers that support them natively](http://caniuse.com/#feat=css-sticky), e.g.:
+
+```html
+<div class="sticky">
+    ...
+</div>
+```
+
+```css
+.sticky {
+    position: -webkit-sticky;
+    position: sticky;
+    top: 0;
+}
+```
+
+Then apply the polyfill:
+
+JS:
+
+```js
+var elements = document.querySelectorAll('.sticky');
+Stickyfill.add(elements);
+```
+
+or JS + jQuery:
+
+```js
+var elements = $('.sticky');
+Stickyfill.add(elements);
+```
+
+Also worth having a clearfix:
+
+```css
+.sticky:before,
+.sticky:after {
+    content: '';
+    display: table;
+}
+```
+
+## Pro tips
+
+- `top` specifies sticky’s position relatively to the top edge of the viewport. It accepts negative values, too.
+- You can push sticky’s bottom limit up or down by specifying positive or negative `margin-bottom`.
+- Any non-default value (not `visible`) for `overflow`, `overflow-x`, or `overflow-y` on any of the ancestor elements anchors the sticky to the overflow context of that ancestor. Simply put, scrolling the ancestor will cause the sticky to stick, scrolling the window will not. This is expected with `overflow: auto` and `overflow: scroll`, but often causes confusion with `overflow: hidden`. Keep this in mind, folks!
+
+Check out [the test page](http://wilddeer.github.io/stickyfill/test/) to understand stickies better.
+
+## API
+
+### `Stickyfill`
+
+#### `Stickyfill.addOne(element)`
+
+`element` – `HTMLElement` or iterable element list ([`NodeList`](https://developer.mozilla.org/en/docs/Web/API/NodeList), jQuery collection, etc.). First element of the list is used.
+
+Adds the element as a sticky. Returns new [Sticky](#stickyfillsticky) instance associated with the element.
+
+If there’s a sticky associated with the element, returns existing [Sticky](#stickyfillsticky) instance instead.
+
+#### `Stickyfill.add(elementList)`
+
+`elementList` – iterable element list ([`NodeList`](https://developer.mozilla.org/en/docs/Web/API/NodeList), jQuery collection, etc.) or single `HTMLElement`.
+
+Adds the elements as stickies. Skips the elements that have stickies associated with them.
+
+Returns an array of [Sticky](#stickyfillsticky) instances associated with the elements (both existing and new ones).
+
+#### `Stickyfill.refreshAll()`
+
+Refreshes all existing stickies, updates their parameters and positions.
+
+All stickies are automatically refreshed after window resizes and device orientations changes.
+
+There’s also a fast but not very accurate layout change detection that triggers this method. Call this method manually in case automatic detection fails.
+
+#### `Stickyfill.removeOne(element)`
+
+`element` – `HTMLElement` or iterable element list ([`NodeList`](https://developer.mozilla.org/en/docs/Web/API/NodeList), jQuery collection, etc.). First element of the list is used.
+
+Removes sticky associated with the element.
+
+#### `Stickyfill.remove(elementList)`
+
+`elementList` – iterable element list ([`NodeList`](https://developer.mozilla.org/en/docs/Web/API/NodeList), jQuery collection, etc.) or single `HTMLElement`.
+
+Removes stickies associated with the elements in the list.
+
+#### `Stickyfill.removeAll()`
+
+Removes all existing stickies.
+
+#### `Stickyfill.stickies`
+
+Array of existing [Sticky](#Stickyfill.Sticky) instances.
+
+### `Stickyfill.Sticky`
+
+Sticky class. You can use it directly if you want:
+
+```js
+const sticky = new Stickyfill.Sticky(element);
+```
+
+Throws an error if there’s a sticky already bound to the element.
+
+#### `Sticky.refresh()`
+
+Refreshes the sticky, updates its parameters and position.
+
+#### `Sticky.remove()`
+
+Removes the sticky. Restores the element to its original state.
+
+## Feature requests
+
+### TL;DR
+
+These features will never be implemented in Stickyfill:
+
+- Callbacks for sticky state changes
+- Switching classes between different sticky states
+- Other features that add non-standard functionality
+
+If your request isn’t about one of these, you are welcome to [create an issue](https://github.com/wilddeer/stickyfill/issues/new). Please check [existing issues](https://github.com/wilddeer/stickyfill/issues) before creating new one.
+
+### Some reasoning
+
+Stickyfill is a [polyfill](https://en.wikipedia.org/wiki/Polyfill). This means that it implements a feature (sticky positioning in this case) that already exists in some browsers natively, and allows to use this feature in the browsers that don’t support it yet and older versions of the browsers that didn’t support it at the time. This is its only purpose.
+
+This also means that Stickyfill does nothing in the browsers that _do_ support sticky positioning. Which, in turn, means that those browsers won’t support any additional non-standard features.
+
+## Bug reports
+
+Check [existing issues](https://github.com/wilddeer/stickyfill/issues) before creating new one. **Please provide a live reproduction of a bug.**
+
+## Contributing
+
+### Prerequisites
+
+- Install Git 😱
+- Install [node](https://nodejs.org/en/)
+- Install [grunt-cli](http://gruntjs.com/getting-started#installing-the-cli)
+- Clone the repo, `cd` into the repo folder, run `npm install` (or `yarn` if you are fancy).
+
+Ok, you are all set.
+
+### Building and testing
+
+`cd` into the repo folder and run `grunt`. It will build the project from `/src/strickyfill.js` into `/dist` and run the watcher that will rebuild the project every time you change something in the source file.
+
+Make changes to the source file. Stick to ES6 syntax.
+
+Open `/test/index.html` in a browser that [doesn’t support](http://caniuse.com/#feat=css-sticky) `position: sticky` to check that everything works as expected. Compare the results to the same page in a browser that supports `position: sticky`.
+
+Commit the changes. **DO NOT** commit the files in the `/dist` folder. **DO NOT** change the version in `package.json`.
+
+Make a pull request 👍
+
+### Adding / removing / updating npm packages
+
+Use [Yarn](https://yarnpkg.com/), dont’t forget to commit `yarn.lock`.
+
+## Using Stickyfill?
+
+🍻 [Buy me a beer](https://www.paypal.me/wilddeer/0usd)
+
+## License
+
+[MIT license](LICENSE).

data/assets/plugins/stickyfill/dist/stickyfill.es6.js

@@ -0,0 +1,507 @@
+/*!
+  * Stickyfill – `position: sticky` polyfill
+  * v. 2.0.5 | https://github.com/wilddeer/stickyfill
+  * MIT License
+  */
+
+'use strict';
+
+/*
+ * 1. Check if the browser supports `position: sticky` natively or is too old to run the polyfill.
+ *    If either of these is the case set `seppuku` flag. It will be checked later to disable key features
+ *    of the polyfill, but the API will remain functional to avoid breaking things.
+ */
+let seppuku = false;
+
+// The polyfill cant’t function properly without `getComputedStyle`.
+if (!window.getComputedStyle) seppuku = true;
+// Dont’t get in a way if the browser supports `position: sticky` natively.
+else {
+    const testNode = document.createElement('div');
+
+    if (
+        ['', '-webkit-', '-moz-', '-ms-'].some(prefix => {
+            try {
+                testNode.style.position = prefix + 'sticky';
+            }
+            catch(e) {}
+
+            return testNode.style.position != '';
+        })
+    ) seppuku = true;
+}
+
+
+/*
+ * 2. “Global” vars used across the polyfill
+ */
+
+// Check if Shadow Root constructor exists to make further checks simpler
+const shadowRootExists = typeof ShadowRoot !== 'undefined';
+
+// Last saved scroll position
+const scroll = {
+    top: null,
+    left: null
+};
+
+// Array of created Sticky instances
+const stickies = [];
+
+
+/*
+ * 3. Utility functions
+ */
+function extend (targetObj, sourceObject) {
+    for (var key in sourceObject) {
+        if (sourceObject.hasOwnProperty(key)) {
+            targetObj[key] = sourceObject[key];
+        }
+    }
+}
+
+function parseNumeric (val) {
+    return parseFloat(val) || 0;
+}
+
+function getDocOffsetTop (node) {
+    let docOffsetTop = 0;
+
+    while (node) {
+        docOffsetTop += node.offsetTop;
+        node = node.offsetParent;
+    }
+
+    return docOffsetTop;
+}
+
+
+/*
+ * 4. Sticky class
+ */
+class Sticky {
+    constructor (node) {
+        if (!(node instanceof HTMLElement))
+            throw new Error('First argument must be HTMLElement');
+        if (stickies.some(sticky => sticky._node === node))
+            throw new Error('Stickyfill is already applied to this node');
+
+        this._node = node;
+        this._stickyMode = null;
+        this._active = false;
+
+        stickies.push(this);
+
+        this.refresh();
+    }
+
+    refresh () {
+        if (seppuku || this._removed) return;
+        if (this._active) this._deactivate();
+
+        const node = this._node;
+
+        /*
+         * 1. Save node computed props
+         */
+        const nodeComputedStyle = getComputedStyle(node);
+        const nodeComputedProps = {
+            top: nodeComputedStyle.top,
+            display: nodeComputedStyle.display,
+            marginTop: nodeComputedStyle.marginTop,
+            marginBottom: nodeComputedStyle.marginBottom,
+            marginLeft: nodeComputedStyle.marginLeft,
+            marginRight: nodeComputedStyle.marginRight,
+            cssFloat: nodeComputedStyle.cssFloat
+        };
+
+        /*
+         * 2. Check if the node can be activated
+         */
+        if (
+            isNaN(parseFloat(nodeComputedProps.top)) ||
+            nodeComputedProps.display == 'table-cell' ||
+            nodeComputedProps.display == 'none'
+        ) return;
+
+        this._active = true;
+
+        /*
+         * 3. Get necessary node parameters
+         */
+        const referenceNode = node.parentNode;
+        const parentNode = shadowRootExists && referenceNode instanceof ShadowRoot? referenceNode.host: referenceNode;
+        const nodeWinOffset = node.getBoundingClientRect();
+        const parentWinOffset = parentNode.getBoundingClientRect();
+        const parentComputedStyle = getComputedStyle(parentNode);
+
+        this._parent = {
+            node: parentNode,
+            styles: {
+                position: parentNode.style.position
+            },
+            offsetHeight: parentNode.offsetHeight
+        };
+        this._offsetToWindow = {
+            left: nodeWinOffset.left,
+            right: document.documentElement.clientWidth - nodeWinOffset.right
+        };
+        this._offsetToParent = {
+            top: nodeWinOffset.top - parentWinOffset.top - parseNumeric(parentComputedStyle.borderTopWidth),
+            left: nodeWinOffset.left - parentWinOffset.left - parseNumeric(parentComputedStyle.borderLeftWidth),
+            right: -nodeWinOffset.right + parentWinOffset.right - parseNumeric(parentComputedStyle.borderRightWidth)
+        };
+        this._styles = {
+            position: node.style.position,
+            top: node.style.top,
+            bottom: node.style.bottom,
+            left: node.style.left,
+            right: node.style.right,
+            width: node.style.width,
+            marginTop: node.style.marginTop,
+            marginLeft: node.style.marginLeft,
+            marginRight: node.style.marginRight
+        };
+
+        const nodeTopValue = parseNumeric(nodeComputedProps.top);
+        this._limits = {
+            start: nodeWinOffset.top + window.pageYOffset - nodeTopValue,
+            end: parentWinOffset.top + window.pageYOffset + parentNode.offsetHeight -
+                parseNumeric(parentComputedStyle.borderBottomWidth) - node.offsetHeight -
+                nodeTopValue - parseNumeric(nodeComputedProps.marginBottom)
+        };
+
+        /*
+         * 4. Ensure that the node will be positioned relatively to the parent node
+         */
+        const parentPosition = parentComputedStyle.position;
+
+        if (
+            parentPosition != 'absolute' &&
+            parentPosition != 'relative'
+        ) {
+            parentNode.style.position = 'relative';
+        }
+
+        /*
+         * 5. Recalc node position.
+         *    It’s important to do this before clone injection to avoid scrolling bug in Chrome.
+         */
+        this._recalcPosition();
+
+        /*
+         * 6. Create a clone
+         */
+        const clone = this._clone = {};
+        clone.node = document.createElement('div');
+
+        // Apply styles to the clone
+        extend(clone.node.style, {
+            width: nodeWinOffset.right - nodeWinOffset.left + 'px',
+            height: nodeWinOffset.bottom - nodeWinOffset.top + 'px',
+            marginTop: nodeComputedProps.marginTop,
+            marginBottom: nodeComputedProps.marginBottom,
+            marginLeft: nodeComputedProps.marginLeft,
+            marginRight: nodeComputedProps.marginRight,
+            cssFloat: nodeComputedProps.cssFloat,
+            padding: 0,
+            border: 0,
+            borderSpacing: 0,
+            fontSize: '1em',
+            position: 'static'
+        });
+
+        referenceNode.insertBefore(clone.node, node);
+        clone.docOffsetTop = getDocOffsetTop(clone.node);
+    }
+
+    _recalcPosition () {
+        if (!this._active || this._removed) return;
+
+        const stickyMode = scroll.top <= this._limits.start? 'start': scroll.top >= this._limits.end? 'end': 'middle';
+
+        if (this._stickyMode == stickyMode) return;
+
+        switch (stickyMode) {
+            case 'start':
+                extend(this._node.style, {
+                    position: 'absolute',
+                    left: this._offsetToParent.left + 'px',
+                    right: this._offsetToParent.right + 'px',
+                    top: this._offsetToParent.top + 'px',
+                    bottom: 'auto',
+                    width: 'auto',
+                    marginLeft: 0,
+                    marginRight: 0,
+                    marginTop: 0
+                });
+                break;
+
+            case 'middle':
+                extend(this._node.style, {
+                    position: 'fixed',
+                    left: this._offsetToWindow.left + 'px',
+                    right: this._offsetToWindow.right + 'px',
+                    top: this._styles.top,
+                    bottom: 'auto',
+                    width: 'auto',
+                    marginLeft: 0,
+                    marginRight: 0,
+                    marginTop: 0
+                });
+                break;
+
+            case 'end':
+                extend(this._node.style, {
+                    position: 'absolute',
+                    left: this._offsetToParent.left + 'px',
+                    right: this._offsetToParent.right + 'px',
+                    top: 'auto',
+                    bottom: 0,
+                    width: 'auto',
+                    marginLeft: 0,
+                    marginRight: 0
+                });
+                break;
+        }
+
+        this._stickyMode = stickyMode;
+    }
+
+    _fastCheck () {
+        if (!this._active || this._removed) return;
+
+        if (
+            Math.abs(getDocOffsetTop(this._clone.node) - this._clone.docOffsetTop) > 1 ||
+            Math.abs(this._parent.node.offsetHeight - this._parent.offsetHeight) > 1
+        ) this.refresh();
+    }
+
+    _deactivate () {
+        if (!this._active || this._removed) return;
+
+        this._clone.node.parentNode.removeChild(this._clone.node);
+        delete this._clone;
+
+        extend(this._node.style, this._styles);
+        delete this._styles;
+
+        // Check whether element’s parent node is used by other stickies.
+        // If not, restore parent node’s styles.
+        if (!stickies.some(sticky => sticky !== this && sticky._parent && sticky._parent.node === this._parent.node)) {
+            extend(this._parent.node.style, this._parent.styles);
+        }
+        delete this._parent;
+
+        this._stickyMode = null;
+        this._active = false;
+
+        delete this._offsetToWindow;
+        delete this._offsetToParent;
+        delete this._limits;
+    }
+
+    remove () {
+        this._deactivate();
+
+        stickies.some((sticky, index) => {
+            if (sticky._node === this._node) {
+                stickies.splice(index, 1);
+                return true;
+            }
+        });
+
+        this._removed = true;
+    }
+}
+
+
+/*
+ * 5. Stickyfill API
+ */
+const Stickyfill = {
+    stickies,
+    Sticky,
+
+    addOne (node) {
+        // Check whether it’s a node
+        if (!(node instanceof HTMLElement)) {
+            // Maybe it’s a node list of some sort?
+            // Take first node from the list then
+            if (node.length && node[0]) node = node[0];
+            else return;
+        }
+
+        // Check if Stickyfill is already applied to the node
+        // and return existing sticky
+        for (var i = 0; i < stickies.length; i++) {
+            if (stickies[i]._node === node) return stickies[i];
+        }
+
+        // Create and return new sticky
+        return new Sticky(node);
+    },
+
+    add (nodeList) {
+        // If it’s a node make an array of one node
+        if (nodeList instanceof HTMLElement) nodeList = [nodeList];
+        // Check if the argument is an iterable of some sort
+        if (!nodeList.length) return;
+
+        // Add every element as a sticky and return an array of created Sticky instances
+        const addedStickies = [];
+
+        for (let i = 0; i < nodeList.length; i++) {
+            const node = nodeList[i];
+
+            // If it’s not an HTMLElement – create an empty element to preserve 1-to-1
+            // correlation with input list
+            if (!(node instanceof HTMLElement)) {
+                addedStickies.push(void 0);
+                continue;
+            }
+
+            // If Stickyfill is already applied to the node
+            // add existing sticky
+            if (stickies.some(sticky => {
+                if (sticky._node === node) {
+                    addedStickies.push(sticky);
+                    return true;
+                }
+            })) continue;
+
+            // Create and add new sticky
+            addedStickies.push(new Sticky(node));
+        }
+
+        return addedStickies;
+    },
+
+    refreshAll () {
+        stickies.forEach(sticky => sticky.refresh());
+    },
+
+    removeOne (node) {
+        // Check whether it’s a node
+        if (!(node instanceof HTMLElement)) {
+            // Maybe it’s a node list of some sort?
+            // Take first node from the list then
+            if (node.length && node[0]) node = node[0];
+            else return;
+        }
+
+        // Remove the stickies bound to the nodes in the list
+        stickies.some(sticky => {
+            if (sticky._node === node) {
+                sticky.remove();
+                return true;
+            }
+        });
+    },
+
+    remove (nodeList) {
+        // If it’s a node make an array of one node
+        if (nodeList instanceof HTMLElement) nodeList = [nodeList];
+        // Check if the argument is an iterable of some sort
+        if (!nodeList.length) return;
+
+        // Remove the stickies bound to the nodes in the list
+        for (let i = 0; i < nodeList.length; i++) {
+            const node = nodeList[i];
+
+            stickies.some(sticky => {
+                if (sticky._node === node) {
+                    sticky.remove();
+                    return true;
+                }
+            });
+        }
+    },
+
+    removeAll () {
+        while (stickies.length) stickies[0].remove();
+    }
+};
+
+
+/*
+ * 6. Setup events (unless the polyfill was disabled)
+ */
+function init () {
+    // Watch for scroll position changes and trigger recalc/refresh if needed
+    function checkScroll () {
+        if (window.pageXOffset != scroll.left) {
+            scroll.top = window.pageYOffset;
+            scroll.left = window.pageXOffset;
+
+            Stickyfill.refreshAll();
+        }
+        else if (window.pageYOffset != scroll.top) {
+            scroll.top = window.pageYOffset;
+            scroll.left = window.pageXOffset;
+
+            // recalc position for all stickies
+            stickies.forEach(sticky => sticky._recalcPosition());
+        }
+    }
+
+    checkScroll();
+    window.addEventListener('scroll', checkScroll);
+
+    // Watch for window resizes and device orientation changes and trigger refresh
+    window.addEventListener('resize', Stickyfill.refreshAll);
+    window.addEventListener('orientationchange', Stickyfill.refreshAll);
+
+    //Fast dirty check for layout changes every 500ms
+    let fastCheckTimer;
+
+    function startFastCheckTimer () {
+        fastCheckTimer = setInterval(function () {
+            stickies.forEach(sticky => sticky._fastCheck());
+        }, 500);
+    }
+
+    function stopFastCheckTimer () {
+        clearInterval(fastCheckTimer);
+    }
+
+    let docHiddenKey;
+    let visibilityChangeEventName;
+
+    if ('hidden' in document) {
+        docHiddenKey = 'hidden';
+        visibilityChangeEventName = 'visibilitychange';
+    }
+    else if ('webkitHidden' in document) {
+        docHiddenKey = 'webkitHidden';
+        visibilityChangeEventName = 'webkitvisibilitychange';
+    }
+
+    if (visibilityChangeEventName) {
+        if (!document[docHiddenKey]) startFastCheckTimer();
+
+        document.addEventListener(visibilityChangeEventName, () => {
+            if (document[docHiddenKey]) {
+                stopFastCheckTimer();
+            }
+            else {
+                startFastCheckTimer();
+            }
+        });
+    }
+    else startFastCheckTimer();
+}
+
+if (!seppuku) init();
+
+
+/*
+ * 7. Expose Stickyfill
+ */
+if (typeof module != 'undefined' && module.exports) {
+    module.exports = Stickyfill;
+}
+else {
+    window.Stickyfill = Stickyfill;
+}
+