Moving to node_modules folder to make easier to upgrade

trying to move from Bootstrap 3 to Bootstrap 5

node_modules/infinite-scroll/README.md

@@ -0,0 +1,177 @@
+# Infinite Scroll
+
+_Automatically add next page_
+
+See [infinite-scroll.com](https://infinite-scroll.com) for complete docs and demos.
+
+## Install
+
+### Download
+
+- [infinite-scroll.pkgd.min.js](https://unpkg.com/infinite-scroll@4/dist/infinite-scroll.pkgd.min.js) minified, or
+- [infinite-scroll.pkgd.js](https://unpkg.com/infinite-scroll@4/dist/infinite-scroll.pkgd.js) un-minified
+
+### CDN
+
+Link directly to Infinite Scroll files on [unpkg](https://unpkg.com).
+
+``` html
+<script src="https://unpkg.com/infinite-scroll@4/dist/infinite-scroll.pkgd.min.js"></script>
+<!-- or -->
+<script src="https://unpkg.com/infinite-scroll@4/dist/infinite-scroll.pkgd.js"></script>
+```
+
+### Package managers
+
+npm: `npm install infinite-scroll`
+
+Yarn: `yarn add infinite-scroll`
+
+## License
+
+### Commercial license
+
+If you want to use Infinite Scroll to develop commercial sites, themes, projects, and applications, the Commercial license is the appropriate license. With this option, your source code is kept proprietary. Purchase an Infinite Scroll Commercial License at [infinite-scroll.com](https://infinite-scroll.com/#commercial-license)
+
+### Open source license
+
+If you are creating an open source application under a license compatible with the [GNU GPL license v3](https://www.gnu.org/licenses/gpl-3.0.html), you may use Infinite Scroll under the terms of the GPLv3.
+
+[Read more about Infinite Scroll's license](https://infinite-scroll.com/license.html).
+
+## Usage
+
+Infinite Scroll works on a container element with its child item elements
+
+``` html
+<div class="container">
+  <article class="post">...</article>
+  <article class="post">...</article>
+  <article class="post">...</article>
+  ...
+</div>
+```
+
+### Options
+
+``` js
+let infScroll = new InfiniteScroll( '.container', {
+  // defaults listed
+
+  path: undefined,
+  // REQUIRED. Determines the URL for the next page
+  // Set to selector string to use the href of the next page's link
+  // path: '.pagination__next'
+  // Or set with {{#}} in place of the page number in the url
+  // path: '/blog/page/{{#}}'
+  // or set with function
+  // path: function() {
+  //   return return '/articles/P' + ( ( this.loadCount + 1 ) * 10 );
+  // }
+
+  append: undefined,
+  // REQUIRED for appending content
+  // Appends selected elements from loaded page to the container
+
+  checkLastPage: true,
+  // Checks if page has path selector element
+  // Set to string if path is not set as selector string:
+  //   checkLastPage: '.pagination__next'
+
+  prefill: false,
+  // Loads and appends pages on intialization until scroll requirement is met.
+
+  responseBody: 'text',
+  // Sets the method used on the response.
+  // Set to 'json' to load JSON.
+
+  domParseResponse: true,
+  // enables parsing response body into a DOM
+  // disable to load flat text
+
+  fetchOptions: undefined,
+  // sets custom settings for the fetch() request
+  // for setting headers, cors, or POST method
+  // can be set to an object, or a function that returns an object
+
+  outlayer: false,
+  // Integrates Masonry, Isotope or Packery
+  // Appended items will be added to the layout
+
+  scrollThreshold: 400,
+  // Sets the distance between the viewport to scroll area
+  // for scrollThreshold event to be triggered.
+
+  elementScroll: false,
+  // Sets scroller to an element for overflow element scrolling
+
+  loadOnScroll: true,
+  // Loads next page when scroll crosses over scrollThreshold
+
+  history: 'replace',
+  // Changes the browser history and URL.
+  // Set to 'push' to use history.pushState()
+  //    to create new history entries for each page change.
+
+  historyTitle: true,
+  // Updates the window title. Requires history enabled.
+
+  hideNav: undefined,
+  // Hides navigation element
+
+  status: undefined,
+  // Displays status elements indicating state of page loading:
+  // .infinite-scroll-request, .infinite-scroll-load, .infinite-scroll-error
+  // status: '.page-load-status'
+
+  button: undefined,
+  // Enables a button to load pages on click
+  // button: '.load-next-button'
+
+  onInit: undefined,
+  // called on initialization
+  // useful for binding events on init
+  // onInit: function() {
+  //   this.on( 'append', function() {...})
+  // }
+
+  debug: false,
+  // Logs events and state changes to the console.
+})
+```
+
+## Browser support
+
+Infinite Scroll v4 supports Chrome 60+, Edge 79+, Firefox 55+, Safari 11+.
+
+For IE10 and Android 4 support, try [Infinite Scroll v3](https://v3.infinite-scroll.com/).
+
+## Development
+
+This package is developed with Node.js v14 and npm v6. Manage Node and npm version with [nvm](https://github.com/nvm-sh/nvm).
+
+``` sh
+nvm use
+```
+
+Install dependencies
+
+``` sh
+npm install
+```
+
+Lint
+
+``` sh
+npm run lint
+```
+
+Run tests
+
+``` sh
+npm test
+```
+
+---
+
+By [Metafizzy 🌈🐻](https://metafizzy.co)

node_modules/infinite-scroll/js/button.js

@@ -0,0 +1,81 @@
+// button
+( function( window, factory ) {
+  // universal module definition
+  if ( typeof module == 'object' && module.exports ) {
+    // CommonJS
+    module.exports = factory(
+        window,
+        require('./core'),
+        require('fizzy-ui-utils'),
+    );
+  } else {
+    // browser global
+    factory(
+        window,
+        window.InfiniteScroll,
+        window.fizzyUIUtils,
+    );
+  }
+
+}( window, function factory( window, InfiniteScroll, utils ) {
+
+// -------------------------- InfiniteScrollButton -------------------------- //
+
+class InfiniteScrollButton {
+  constructor( element, infScroll ) {
+    this.element = element;
+    this.infScroll = infScroll;
+    // events
+    this.clickHandler = this.onClick.bind( this );
+    this.element.addEventListener( 'click', this.clickHandler );
+    infScroll.on( 'request', this.disable.bind( this ) );
+    infScroll.on( 'load', this.enable.bind( this ) );
+    infScroll.on( 'error', this.hide.bind( this ) );
+    infScroll.on( 'last', this.hide.bind( this ) );
+  }
+
+  onClick( event ) {
+    event.preventDefault();
+    this.infScroll.loadNextPage();
+  }
+
+  enable() {
+    this.element.removeAttribute('disabled');
+  }
+
+  disable() {
+    this.element.disabled = 'disabled';
+  }
+
+  hide() {
+    this.element.style.display = 'none';
+  }
+
+  destroy() {
+    this.element.removeEventListener( 'click', this.clickHandler );
+  }
+
+}
+
+// -------------------------- InfiniteScroll methods -------------------------- //
+
+// InfiniteScroll.defaults.button = null;
+
+InfiniteScroll.create.button = function() {
+  let buttonElem = utils.getQueryElement( this.options.button );
+  if ( buttonElem ) {
+    this.button = new InfiniteScrollButton( buttonElem, this );
+  }
+};
+
+InfiniteScroll.destroy.button = function() {
+  if ( this.button ) this.button.destroy();
+};
+
+// --------------------------  -------------------------- //
+
+InfiniteScroll.Button = InfiniteScrollButton;
+
+return InfiniteScroll;
+
+} ) );

node_modules/infinite-scroll/js/core.js

@@ -0,0 +1,371 @@
+// core
+( function( window, factory ) {
+  // universal module definition
+  if ( typeof module == 'object' && module.exports ) {
+    // CommonJS
+    module.exports = factory(
+        window,
+        require('ev-emitter'),
+        require('fizzy-ui-utils'),
+    );
+  } else {
+    // browser global
+    window.InfiniteScroll = factory(
+        window,
+        window.EvEmitter,
+        window.fizzyUIUtils,
+    );
+  }
+
+}( window, function factory( window, EvEmitter, utils ) {
+
+let jQuery = window.jQuery;
+// internal store of all InfiniteScroll intances
+let instances = {};
+
+function InfiniteScroll( element, options ) {
+  let queryElem = utils.getQueryElement( element );
+
+  if ( !queryElem ) {
+    console.error( 'Bad element for InfiniteScroll: ' + ( queryElem || element ) );
+    return;
+  }
+  element = queryElem;
+  // do not initialize twice on same element
+  if ( element.infiniteScrollGUID ) {
+    let instance = instances[ element.infiniteScrollGUID ];
+    instance.option( options );
+    return instance;
+  }
+
+  this.element = element;
+  // options
+  this.options = { ...InfiniteScroll.defaults };
+  this.option( options );
+  // add jQuery
+  if ( jQuery ) {
+    this.$element = jQuery( this.element );
+  }
+
+  this.create();
+}
+
+// defaults
+InfiniteScroll.defaults = {
+  // path: null,
+  // hideNav: null,
+  // debug: false,
+};
+
+// create & destroy methods
+InfiniteScroll.create = {};
+InfiniteScroll.destroy = {};
+
+let proto = InfiniteScroll.prototype;
+// inherit EvEmitter
+Object.assign( proto, EvEmitter.prototype );
+
+// --------------------------  -------------------------- //
+
+// globally unique identifiers
+let GUID = 0;
+
+proto.create = function() {
+  // create core
+  // add id for InfiniteScroll.data
+  let id = this.guid = ++GUID;
+  this.element.infiniteScrollGUID = id; // expando
+  instances[ id ] = this; // associate via id
+  // properties
+  this.pageIndex = 1; // default to first page
+  this.loadCount = 0;
+  this.updateGetPath();
+  // bail if getPath not set, or returns falsey #776
+  let hasPath = this.getPath && this.getPath();
+  if ( !hasPath ) {
+    console.error('Disabling InfiniteScroll');
+    return;
+  }
+  this.updateGetAbsolutePath();
+  this.log( 'initialized', [ this.element.className ] );
+  this.callOnInit();
+  // create features
+  for ( let method in InfiniteScroll.create ) {
+    InfiniteScroll.create[ method ].call( this );
+  }
+};
+
+proto.option = function( opts ) {
+  Object.assign( this.options, opts );
+};
+
+// call onInit option, used for binding events on init
+proto.callOnInit = function() {
+  let onInit = this.options.onInit;
+  if ( onInit ) {
+    onInit.call( this, this );
+  }
+};
+
+// ----- events ----- //
+
+proto.dispatchEvent = function( type, event, args ) {
+  this.log( type, args );
+  let emitArgs = event ? [ event ].concat( args ) : args;
+  this.emitEvent( type, emitArgs );
+  // trigger jQuery event
+  if ( !jQuery || !this.$element ) {
+    return;
+  }
+  // namespace jQuery event
+  type += '.infiniteScroll';
+  let $event = type;
+  if ( event ) {
+    // create jQuery event
+    /* eslint-disable-next-line new-cap */
+    let jQEvent = jQuery.Event( event );
+    jQEvent.type = type;
+    $event = jQEvent;
+  }
+  this.$element.trigger( $event, args );
+};
+
+let loggers = {
+  initialized: ( className ) => `on ${className}`,
+  request: ( path ) => `URL: ${path}`,
+  load: ( response, path ) => `${response.title || ''}. URL: ${path}`,
+  error: ( error, path ) => `${error}. URL: ${path}`,
+  append: ( response, path, items ) => `${items.length} items. URL: ${path}`,
+  last: ( response, path ) => `URL: ${path}`,
+  history: ( title, path ) => `URL: ${path}`,
+  pageIndex: function( index, origin ) {
+    return `current page determined to be: ${index} from ${origin}`;
+  },
+};
+
+// log events
+proto.log = function( type, args ) {
+  if ( !this.options.debug ) return;
+
+  let message = `[InfiniteScroll] ${type}`;
+  let logger = loggers[ type ];
+  if ( logger ) message += '. ' + logger.apply( this, args );
+  console.log( message );
+};
+
+// -------------------------- methods used amoung features -------------------------- //
+
+proto.updateMeasurements = function() {
+  this.windowHeight = window.innerHeight;
+  let rect = this.element.getBoundingClientRect();
+  this.top = rect.top + window.scrollY;
+};
+
+proto.updateScroller = function() {
+  let elementScroll = this.options.elementScroll;
+  if ( !elementScroll ) {
+    // default, use window
+    this.scroller = window;
+    return;
+  }
+  // if true, set to element, otherwise use option
+  this.scroller = elementScroll === true ? this.element :
+    utils.getQueryElement( elementScroll );
+  if ( !this.scroller ) {
+    throw new Error(`Unable to find elementScroll: ${elementScroll}`);
+  }
+};
+
+// -------------------------- page path -------------------------- //
+
+proto.updateGetPath = function() {
+  let optPath = this.options.path;
+  if ( !optPath ) {
+    console.error(`InfiniteScroll path option required. Set as: ${optPath}`);
+    return;
+  }
+  // function
+  let type = typeof optPath;
+  if ( type == 'function' ) {
+    this.getPath = optPath;
+    return;
+  }
+  // template string: '/pages/{{#}}.html'
+  let templateMatch = type == 'string' && optPath.match('{{#}}');
+  if ( templateMatch ) {
+    this.updateGetPathTemplate( optPath );
+    return;
+  }
+  // selector: '.next-page-selector'
+  this.updateGetPathSelector( optPath );
+};
+
+proto.updateGetPathTemplate = function( optPath ) {
+  // set getPath with template string
+  this.getPath = () => {
+    let nextIndex = this.pageIndex + 1;
+    return optPath.replace( '{{#}}', nextIndex );
+  };
+  // get pageIndex from location
+  // convert path option into regex to look for pattern in location
+  // escape query (?) in url, allows for parsing GET parameters
+  let regexString = optPath
+    .replace( /(\\\?|\?)/, '\\?' )
+    .replace( '{{#}}', '(\\d\\d?\\d?)' );
+  let templateRe = new RegExp( regexString );
+  let match = location.href.match( templateRe );
+
+  if ( match ) {
+    this.pageIndex = parseInt( match[1], 10 );
+    this.log( 'pageIndex', [ this.pageIndex, 'template string' ] );
+  }
+};
+
+let pathRegexes = [
+  // WordPress & Tumblr - example.com/page/2
+  // Jekyll - example.com/page2
+  /^(.*?\/?page\/?)(\d\d?\d?)(.*?$)/,
+  // Drupal - example.com/?page=1
+  /^(.*?\/?\?page=)(\d\d?\d?)(.*?$)/,
+  // catch all, last occurence of a number
+  /(.*?)(\d\d?\d?)(?!.*\d)(.*?$)/,
+];
+
+// try matching href to pathRegexes patterns
+let getPathParts = InfiniteScroll.getPathParts = function( href ) {
+  if ( !href ) return;
+  for ( let regex of pathRegexes ) {
+    let match = href.match( regex );
+    if ( match ) {
+      let [ , begin, index, end ] = match;
+      return { begin, index, end };
+    }
+  }
+};
+
+proto.updateGetPathSelector = function( optPath ) {
+  // parse href of link: '.next-page-link'
+  let hrefElem = document.querySelector( optPath );
+  if ( !hrefElem ) {
+    console.error(`Bad InfiniteScroll path option. Next link not found: ${optPath}`);
+    return;
+  }
+
+  let href = hrefElem.getAttribute('href');
+  let pathParts = getPathParts( href );
+  if ( !pathParts ) {
+    console.error(`InfiniteScroll unable to parse next link href: ${href}`);
+    return;
+  }
+
+  let { begin, index, end } = pathParts;
+  this.isPathSelector = true; // flag for checkLastPage()
+  this.getPath = () => begin + ( this.pageIndex + 1 ) + end;
+  // get pageIndex from href
+  this.pageIndex = parseInt( index, 10 ) - 1;
+  this.log( 'pageIndex', [ this.pageIndex, 'next link' ] );
+};
+
+proto.updateGetAbsolutePath = function() {
+  let path = this.getPath();
+  // path doesn't start with http or /
+  let isAbsolute = path.match( /^http/ ) || path.match( /^\// );
+  if ( isAbsolute ) {
+    this.getAbsolutePath = this.getPath;
+    return;
+  }
+
+  let { pathname } = location;
+  // query parameter #829. example.com/?pg=2
+  let isQuery = path.match( /^\?/ );
+  // /foo/bar/index.html => /foo/bar
+  let directory = pathname.substring( 0, pathname.lastIndexOf('/') );
+  let pathStart = isQuery ? pathname : directory + '/';
+
+  this.getAbsolutePath = () => pathStart + this.getPath();
+};
+
+// -------------------------- nav -------------------------- //
+
+// hide navigation
+InfiniteScroll.create.hideNav = function() {
+  let nav = utils.getQueryElement( this.options.hideNav );
+  if ( !nav ) return;
+
+  nav.style.display = 'none';
+  this.nav = nav;
+};
+
+InfiniteScroll.destroy.hideNav = function() {
+  if ( this.nav ) this.nav.style.display = '';
+};
+
+// -------------------------- destroy -------------------------- //
+
+proto.destroy = function() {
+  this.allOff(); // remove all event listeners
+  // call destroy methods
+  for ( let method in InfiniteScroll.destroy ) {
+    InfiniteScroll.destroy[ method ].call( this );
+  }
+
+  delete this.element.infiniteScrollGUID;
+  delete instances[ this.guid ];
+  // remove jQuery data. #807
+  if ( jQuery && this.$element ) {
+    jQuery.removeData( this.element, 'infiniteScroll' );
+  }
+};
+
+// -------------------------- utilities -------------------------- //
+
+// https://remysharp.com/2010/07/21/throttling-function-calls
+InfiniteScroll.throttle = function( fn, threshold ) {
+  threshold = threshold || 200;
+  let last, timeout;
+
+  return function() {
+    let now = +new Date();
+    let args = arguments;
+    let trigger = () => {
+      last = now;
+      fn.apply( this, args );
+    };
+    if ( last && now < last + threshold ) {
+      // hold on to it
+      clearTimeout( timeout );
+      timeout = setTimeout( trigger, threshold );
+    } else {
+      trigger();
+    }
+  };
+};
+
+InfiniteScroll.data = function( elem ) {
+  elem = utils.getQueryElement( elem );
+  let id = elem && elem.infiniteScrollGUID;
+  return id && instances[ id ];
+};
+
+// set internal jQuery, for Webpack + jQuery v3
+InfiniteScroll.setJQuery = function( jqry ) {
+  jQuery = jqry;
+};
+
+// -------------------------- setup -------------------------- //
+
+utils.htmlInit( InfiniteScroll, 'infinite-scroll' );
+
+// add noop _init method for jQuery Bridget. #768
+proto._init = function() {};
+
+let { jQueryBridget } = window;
+if ( jQuery && jQueryBridget ) {
+  jQueryBridget( 'infiniteScroll', InfiniteScroll, jQuery );
+}
+
+// --------------------------  -------------------------- //
+
+return InfiniteScroll;
+
+} ) );

node_modules/infinite-scroll/js/history.js

@@ -0,0 +1,184 @@
+// history
+( function( window, factory ) {
+  // universal module definition
+  if ( typeof module == 'object' && module.exports ) {
+    // CommonJS
+    module.exports = factory(
+        window,
+        require('./core'),
+        require('fizzy-ui-utils'),
+    );
+  } else {
+    // browser global
+    factory(
+        window,
+        window.InfiniteScroll,
+        window.fizzyUIUtils,
+    );
+  }
+
+}( window, function factory( window, InfiniteScroll, utils ) {
+
+let proto = InfiniteScroll.prototype;
+
+Object.assign( InfiniteScroll.defaults, {
+  history: 'replace',
+  // historyTitle: false,
+} );
+
+let link = document.createElement('a');
+
+// ----- create/destroy ----- //
+
+InfiniteScroll.create.history = function() {
+  if ( !this.options.history ) return;
+
+  // check for same origin
+  link.href = this.getAbsolutePath();
+  // MS Edge does not have origin on link
+  // https://developer.microsoft.com/en-us/microsoft-edge/platform/issues/12236493/
+  let linkOrigin = link.origin || link.protocol + '//' + link.host;
+  let isSameOrigin = linkOrigin == location.origin;
+  if ( !isSameOrigin ) {
+    console.error( '[InfiniteScroll] cannot set history with different origin: ' +
+      `${link.origin} on ${location.origin} . History behavior disabled.` );
+    return;
+  }
+
+  // two ways to handle changing history
+  if ( this.options.append ) {
+    this.createHistoryAppend();
+  } else {
+    this.createHistoryPageLoad();
+  }
+};
+
+proto.createHistoryAppend = function() {
+  this.updateMeasurements();
+  this.updateScroller();
+  // array of scroll positions of appended pages
+  this.scrollPages = [
+    // first page
+    {
+      top: 0,
+      path: location.href,
+      title: document.title,
+    },
+  ];
+  this.scrollPage = this.scrollPages[0];
+  // events
+  this.scrollHistoryHandler = this.onScrollHistory.bind( this );
+  this.unloadHandler = this.onUnload.bind( this );
+  this.scroller.addEventListener( 'scroll', this.scrollHistoryHandler );
+  this.on( 'append', this.onAppendHistory );
+  this.bindHistoryAppendEvents( true );
+};
+
+proto.bindHistoryAppendEvents = function( isBind ) {
+  let addRemove = isBind ? 'addEventListener' : 'removeEventListener';
+  this.scroller[ addRemove ]( 'scroll', this.scrollHistoryHandler );
+  window[ addRemove ]( 'unload', this.unloadHandler );
+};
+
+proto.createHistoryPageLoad = function() {
+  this.on( 'load', this.onPageLoadHistory );
+};
+
+InfiniteScroll.destroy.history =
+proto.destroyHistory = function() {
+  let isHistoryAppend = this.options.history && this.options.append;
+  if ( isHistoryAppend ) {
+    this.bindHistoryAppendEvents( false );
+  }
+};
+
+// ----- append history ----- //
+
+proto.onAppendHistory = function( response, path, items ) {
+  // do not proceed if no items. #779
+  if ( !items || !items.length ) return;
+
+  let firstItem = items[0];
+  let elemScrollY = this.getElementScrollY( firstItem );
+  // resolve path
+  link.href = path;
+  // add page data to hash
+  this.scrollPages.push({
+    top: elemScrollY,
+    path: link.href,
+    title: response.title,
+  });
+};
+
+proto.getElementScrollY = function( elem ) {
+  if ( this.options.elementScroll ) {
+    return elem.offsetTop - this.top;
+  } else {
+    let rect = elem.getBoundingClientRect();
+    return rect.top + window.scrollY;
+  }
+};
+
+proto.onScrollHistory = function() {
+  // cycle through positions, find biggest without going over
+  let scrollPage = this.getClosestScrollPage();
+  // set history if changed
+  if ( scrollPage != this.scrollPage ) {
+    this.scrollPage = scrollPage;
+    this.setHistory( scrollPage.title, scrollPage.path );
+  }
+};
+
+utils.debounceMethod( InfiniteScroll, 'onScrollHistory', 150 );
+
+proto.getClosestScrollPage = function() {
+  let scrollViewY;
+  if ( this.options.elementScroll ) {
+    scrollViewY = this.scroller.scrollTop + this.scroller.clientHeight / 2;
+  } else {
+    scrollViewY = window.scrollY + this.windowHeight / 2;
+  }
+
+  let scrollPage;
+  for ( let page of this.scrollPages ) {
+    if ( page.top >= scrollViewY ) break;
+
+    scrollPage = page;
+  }
+  return scrollPage;
+};
+
+proto.setHistory = function( title, path ) {
+  let optHistory = this.options.history;
+  let historyMethod = optHistory && history[ optHistory + 'State' ];
+  if ( !historyMethod ) return;
+
+  history[ optHistory + 'State' ]( null, title, path );
+  if ( this.options.historyTitle ) document.title = title;
+  this.dispatchEvent( 'history', null, [ title, path ] );
+};
+
+// scroll to top to prevent initial scroll-reset after page refresh
+// https://stackoverflow.com/a/18633915/182183
+proto.onUnload = function() {
+  if ( this.scrollPage.top === 0 ) return;
+
+  // calculate where scroll position would be on refresh
+  let scrollY = window.scrollY - this.scrollPage.top + this.top;
+  // disable scroll event before setting scroll #679
+  this.destroyHistory();
+  scrollTo( 0, scrollY );
+};
+
+// ----- load history ----- //
+
+// update URL
+proto.onPageLoadHistory = function( response, path ) {
+  this.setHistory( response.title, path );
+};
+
+// --------------------------  -------------------------- //
+
+return InfiniteScroll;
+
+} ) );

node_modules/infinite-scroll/js/index.js

@@ -0,0 +1,28 @@
+/*!
+ * Infinite Scroll v4.0.1
+ * Automatically add next page
+ *
+ * Licensed GPLv3 for open source use
+ * or Infinite Scroll Commercial License for commercial use
+ *
+ * https://infinite-scroll.com
+ * Copyright 2018-2020 Metafizzy
+ */
+
+( function( window, factory ) {
+  // universal module definition
+  if ( typeof module == 'object' && module.exports ) {
+    // CommonJS
+    module.exports = factory(
+        require('./core'),
+        require('./page-load'),
+        require('./scroll-watch'),
+        require('./history'),
+        require('./button'),
+        require('./status'),
+    );
+  }
+
+} )( window, function factory( InfiniteScroll ) {
+  return InfiniteScroll;
+} );

node_modules/infinite-scroll/js/page-load.js

@@ -0,0 +1,276 @@
+// page-load
+( function( window, factory ) {
+  // universal module definition
+  if ( typeof module == 'object' && module.exports ) {
+    // CommonJS
+    module.exports = factory(
+        window,
+        require('./core'),
+    );
+  } else {
+    // browser global
+    factory(
+        window,
+        window.InfiniteScroll,
+    );
+  }
+
+}( window, function factory( window, InfiniteScroll ) {
+
+let proto = InfiniteScroll.prototype;
+
+Object.assign( InfiniteScroll.defaults, {
+  // append: false,
+  loadOnScroll: true,
+  checkLastPage: true,
+  responseBody: 'text',
+  domParseResponse: true,
+  // prefill: false,
+  // outlayer: null,
+} );
+
+InfiniteScroll.create.pageLoad = function() {
+  this.canLoad = true;
+  this.on( 'scrollThreshold', this.onScrollThresholdLoad );
+  this.on( 'load', this.checkLastPage );
+  if ( this.options.outlayer ) {
+    this.on( 'append', this.onAppendOutlayer );
+  }
+};
+
+proto.onScrollThresholdLoad = function() {
+  if ( this.options.loadOnScroll ) this.loadNextPage();
+};
+
+let domParser = new DOMParser();
+
+proto.loadNextPage = function() {
+  if ( this.isLoading || !this.canLoad ) return;
+
+  let { responseBody, domParseResponse, fetchOptions } = this.options;
+  let path = this.getAbsolutePath();
+  this.isLoading = true;
+  if ( typeof fetchOptions == 'function' ) fetchOptions = fetchOptions();
+
+  let fetchPromise = fetch( path, fetchOptions )
+    .then( ( response ) => {
+      if ( !response.ok ) {
+        let error = new Error( response.statusText );
+        this.onPageError( error, path, response );
+        return { response };
+      }
+
+      return response[ responseBody ]().then( ( body ) => {
+        let canDomParse = responseBody == 'text' && domParseResponse;
+        if ( canDomParse ) {
+          body = domParser.parseFromString( body, 'text/html' );
+        }
+        if ( response.status == 204 ) {
+          this.lastPageReached( body, path );
+          return { body, response };
+        } else {
+          return this.onPageLoad( body, path, response );
+        }
+      } );
+    } )
+    .catch( ( error ) => {
+      this.onPageError( error, path );
+    } );
+
+  this.dispatchEvent( 'request', null, [ path, fetchPromise ] );
+
+  return fetchPromise;
+};
+
+proto.onPageLoad = function( body, path, response ) {
+  // done loading if not appending
+  if ( !this.options.append ) {
+    this.isLoading = false;
+  }
+  this.pageIndex++;
+  this.loadCount++;
+  this.dispatchEvent( 'load', null, [ body, path, response ] );
+  return this.appendNextPage( body, path, response );
+};
+
+proto.appendNextPage = function( body, path, response ) {
+  let { append, responseBody, domParseResponse } = this.options;
+  // do not append json
+  let isDocument = responseBody == 'text' && domParseResponse;
+  if ( !isDocument || !append ) return { body, response };
+
+  let items = body.querySelectorAll( append );
+  let promiseValue = { body, response, items };
+  // last page hit if no items. #840
+  if ( !items || !items.length ) {
+    this.lastPageReached( body, path );
+    return promiseValue;
+  }
+
+  let fragment = getItemsFragment( items );
+  let appendReady = () => {
+    this.appendItems( items, fragment );
+    this.isLoading = false;
+    this.dispatchEvent( 'append', null, [ body, path, items, response ] );
+    return promiseValue;
+  };
+
+  // TODO add hook for option to trigger appendReady
+  if ( this.options.outlayer ) {
+    return this.appendOutlayerItems( fragment, appendReady );
+  } else {
+    return appendReady();
+  }
+};
+
+proto.appendItems = function( items, fragment ) {
+  if ( !items || !items.length ) return;
+
+  // get fragment if not provided
+  fragment = fragment || getItemsFragment( items );
+  refreshScripts( fragment );
+  this.element.appendChild( fragment );
+};
+
+function getItemsFragment( items ) {
+  // add items to fragment
+  let fragment = document.createDocumentFragment();
+  if ( items ) fragment.append( ...items );
+  return fragment;
+}
+
+// replace <script>s with copies so they load
+// <script>s added by InfiniteScroll will not load
+// similar to https://stackoverflow.com/questions/610995
+function refreshScripts( fragment ) {
+  let scripts = fragment.querySelectorAll('script');
+  for ( let script of scripts ) {
+    let freshScript = document.createElement('script');
+    // copy attributes
+    let attrs = script.attributes;
+    for ( let attr of attrs ) {
+      freshScript.setAttribute( attr.name, attr.value );
+    }
+    // copy inner script code. #718, #782
+    freshScript.innerHTML = script.innerHTML;
+    script.parentNode.replaceChild( freshScript, script );
+  }
+}
+
+// ----- outlayer ----- //
+
+proto.appendOutlayerItems = function( fragment, appendReady ) {
+  let imagesLoaded = InfiniteScroll.imagesLoaded || window.imagesLoaded;
+  if ( !imagesLoaded ) {
+    console.error('[InfiniteScroll] imagesLoaded required for outlayer option');
+    this.isLoading = false;
+    return;
+  }
+  // append once images loaded
+  return new Promise( function( resolve ) {
+    imagesLoaded( fragment, function() {
+      let bodyResponse = appendReady();
+      resolve( bodyResponse );
+    } );
+  } );
+};
+
+proto.onAppendOutlayer = function( response, path, items ) {
+  this.options.outlayer.appended( items );
+};
+
+// ----- checkLastPage ----- //
+
+// check response for next element
+proto.checkLastPage = function( body, path ) {
+  let { checkLastPage, path: pathOpt } = this.options;
+  if ( !checkLastPage ) return;
+
+  // if path is function, check if next path is truthy
+  if ( typeof pathOpt == 'function' ) {
+    let nextPath = this.getPath();
+    if ( !nextPath ) {
+      this.lastPageReached( body, path );
+      return;
+    }
+  }
+  // get selector from checkLastPage or path option
+  let selector;
+  if ( typeof checkLastPage == 'string' ) {
+    selector = checkLastPage;
+  } else if ( this.isPathSelector ) {
+    // path option is selector string
+    selector = pathOpt;
+  }
+  // check last page for selector
+  // bail if no selector or not document response
+  if ( !selector || !body.querySelector ) return;
+
+  // check if response has selector
+  let nextElem = body.querySelector( selector );
+  if ( !nextElem ) this.lastPageReached( body, path );
+};
+
+proto.lastPageReached = function( body, path ) {
+  this.canLoad = false;
+  this.dispatchEvent( 'last', null, [ body, path ] );
+};
+
+// ----- error ----- //
+
+proto.onPageError = function( error, path, response ) {
+  this.isLoading = false;
+  this.canLoad = false;
+  this.dispatchEvent( 'error', null, [ error, path, response ] );
+  return error;
+};
+
+// -------------------------- prefill -------------------------- //
+
+InfiniteScroll.create.prefill = function() {
+  if ( !this.options.prefill ) return;
+
+  let append = this.options.append;
+  if ( !append ) {
+    console.error(`append option required for prefill. Set as :${append}`);
+    return;
+  }
+  this.updateMeasurements();
+  this.updateScroller();
+  this.isPrefilling = true;
+  this.on( 'append', this.prefill );
+  this.once( 'error', this.stopPrefill );
+  this.once( 'last', this.stopPrefill );
+  this.prefill();
+};
+
+proto.prefill = function() {
+  let distance = this.getPrefillDistance();
+  this.isPrefilling = distance >= 0;
+  if ( this.isPrefilling ) {
+    this.log('prefill');
+    this.loadNextPage();
+  } else {
+    this.stopPrefill();
+  }
+};
+
+proto.getPrefillDistance = function() {
+  // element scroll
+  if ( this.options.elementScroll ) {
+    return this.scroller.clientHeight - this.scroller.scrollHeight;
+  }
+  // window
+  return this.windowHeight - this.element.clientHeight;
+};
+
+proto.stopPrefill = function() {
+  this.log('stopPrefill');
+  this.off( 'append', this.prefill );
+};
+
+// --------------------------  -------------------------- //
+
+return InfiniteScroll;
+
+} ) );

node_modules/infinite-scroll/js/scroll-watch.js

@@ -0,0 +1,97 @@
+// scroll-watch
+( function( window, factory ) {
+  // universal module definition
+  if ( typeof module == 'object' && module.exports ) {
+    // CommonJS
+    module.exports = factory(
+        window,
+        require('./core'),
+        require('fizzy-ui-utils'),
+    );
+  } else {
+    // browser global
+    factory(
+        window,
+        window.InfiniteScroll,
+        window.fizzyUIUtils,
+    );
+  }
+
+}( window, function factory( window, InfiniteScroll, utils ) {
+
+let proto = InfiniteScroll.prototype;
+
+// default options
+Object.assign( InfiniteScroll.defaults, {
+  scrollThreshold: 400,
+  // elementScroll: null,
+} );
+
+InfiniteScroll.create.scrollWatch = function() {
+  // events
+  this.pageScrollHandler = this.onPageScroll.bind( this );
+  this.resizeHandler = this.onResize.bind( this );
+
+  let scrollThreshold = this.options.scrollThreshold;
+  let isEnable = scrollThreshold || scrollThreshold === 0;
+  if ( isEnable ) this.enableScrollWatch();
+};
+
+InfiniteScroll.destroy.scrollWatch = function() {
+  this.disableScrollWatch();
+};
+
+proto.enableScrollWatch = function() {
+  if ( this.isScrollWatching ) return;
+
+  this.isScrollWatching = true;
+  this.updateMeasurements();
+  this.updateScroller();
+  // TODO disable after error?
+  this.on( 'last', this.disableScrollWatch );
+  this.bindScrollWatchEvents( true );
+};
+
+proto.disableScrollWatch = function() {
+  if ( !this.isScrollWatching ) return;
+
+  this.bindScrollWatchEvents( false );
+  delete this.isScrollWatching;
+};
+
+proto.bindScrollWatchEvents = function( isBind ) {
+  let addRemove = isBind ? 'addEventListener' : 'removeEventListener';
+  this.scroller[ addRemove ]( 'scroll', this.pageScrollHandler );
+  window[ addRemove ]( 'resize', this.resizeHandler );
+};
+
+proto.onPageScroll = InfiniteScroll.throttle( function() {
+  let distance = this.getBottomDistance();
+  if ( distance <= this.options.scrollThreshold ) {
+    this.dispatchEvent('scrollThreshold');
+  }
+} );
+
+proto.getBottomDistance = function() {
+  let bottom, scrollY;
+  if ( this.options.elementScroll ) {
+    bottom = this.scroller.scrollHeight;
+    scrollY = this.scroller.scrollTop + this.scroller.clientHeight;
+  } else {
+    bottom = this.top + this.element.clientHeight;
+    scrollY = window.scrollY + this.windowHeight;
+  }
+  return bottom - scrollY;
+};
+
+proto.onResize = function() {
+  this.updateMeasurements();
+};
+
+utils.debounceMethod( InfiniteScroll, 'onResize', 150 );
+
+// --------------------------  -------------------------- //
+
+return InfiniteScroll;
+
+} ) );

node_modules/infinite-scroll/js/status.js

@@ -0,0 +1,102 @@
+// status
+( function( window, factory ) {
+  // universal module definition
+  if ( typeof module == 'object' && module.exports ) {
+    // CommonJS
+    module.exports = factory(
+        window,
+        require('./core'),
+        require('fizzy-ui-utils'),
+    );
+  } else {
+    // browser global
+    factory(
+        window,
+        window.InfiniteScroll,
+        window.fizzyUIUtils,
+    );
+  }
+
+}( window, function factory( window, InfiniteScroll, utils ) {
+
+let proto = InfiniteScroll.prototype;
+
+// InfiniteScroll.defaults.status = null;
+
+InfiniteScroll.create.status = function() {
+  let statusElem = utils.getQueryElement( this.options.status );
+  if ( !statusElem ) return;
+
+  // elements
+  this.statusElement = statusElem;
+  this.statusEventElements = {
+    request: statusElem.querySelector('.infinite-scroll-request'),
+    error: statusElem.querySelector('.infinite-scroll-error'),
+    last: statusElem.querySelector('.infinite-scroll-last'),
+  };
+  // events
+  this.on( 'request', this.showRequestStatus );
+  this.on( 'error', this.showErrorStatus );
+  this.on( 'last', this.showLastStatus );
+  this.bindHideStatus('on');
+};
+
+proto.bindHideStatus = function( bindMethod ) {
+  let hideEvent = this.options.append ? 'append' : 'load';
+  this[ bindMethod ]( hideEvent, this.hideAllStatus );
+};
+
+proto.showRequestStatus = function() {
+  this.showStatus('request');
+};
+
+proto.showErrorStatus = function() {
+  this.showStatus('error');
+};
+
+proto.showLastStatus = function() {
+  this.showStatus('last');
+  // prevent last then append event race condition from showing last status #706
+  this.bindHideStatus('off');
+};
+
+proto.showStatus = function( eventName ) {
+  show( this.statusElement );
+  this.hideStatusEventElements();
+  let eventElem = this.statusEventElements[ eventName ];
+  show( eventElem );
+};
+
+proto.hideAllStatus = function() {
+  hide( this.statusElement );
+  this.hideStatusEventElements();
+};
+
+proto.hideStatusEventElements = function() {
+  for ( let type in this.statusEventElements ) {
+    let eventElem = this.statusEventElements[ type ];
+    hide( eventElem );
+  }
+};
+
+// --------------------------  -------------------------- //
+
+function hide( elem ) {
+  setDisplay( elem, 'none' );
+}
+
+function show( elem ) {
+  setDisplay( elem, 'block' );
+}
+
+function setDisplay( elem, value ) {
+  if ( elem ) {
+    elem.style.display = value;
+  }
+}
+
+// --------------------------  -------------------------- //
+
+return InfiniteScroll;
+
+} ) );

node_modules/infinite-scroll/package.json

@@ -0,0 +1,78 @@
+{
+  "_from": "infinite-scroll",
+  "_id": "infinite-scroll@4.0.1",
+  "_inBundle": false,
+  "_integrity": "sha512-14Utu6d8g6mO5PmwUxfAUK5uaKdClIkrJqLmBYXj/AMBRy5ApsCWkkY84HvsSq4MM1A062gtf58S9OiD5WBfRA==",
+  "_location": "/infinite-scroll",
+  "_phantomChildren": {},
+  "_requested": {
+    "type": "tag",
+    "registry": true,
+    "raw": "infinite-scroll",
+    "name": "infinite-scroll",
+    "escapedName": "infinite-scroll",
+    "rawSpec": "",
+    "saveSpec": null,
+    "fetchSpec": "latest"
+  },
+  "_requiredBy": [
+    "#USER",
+    "/"
+  ],
+  "_resolved": "https://registry.npmjs.org/infinite-scroll/-/infinite-scroll-4.0.1.tgz",
+  "_shasum": "093dafe2d86bf4cd27da3b920a46f898f22c939f",
+  "_spec": "infinite-scroll",
+  "_where": "G:\\GDrive\\htdocs\\YouPHPTube",
+  "author": {
+    "name": "Metafizzy"
+  },
+  "bugs": {
+    "url": "https://github.com/metafizzy/infinite-scroll/issues"
+  },
+  "bundleDependencies": false,
+  "dependencies": {
+    "ev-emitter": "^2.1.0",
+    "fizzy-ui-utils": "^3.0.0"
+  },
+  "deprecated": false,
+  "description": "Automatically add next page",
+  "devDependencies": {
+    "ava": "^3.13.0",
+    "eslint": "^7.15.0",
+    "eslint-plugin-metafizzy": "^1.2.1",
+    "imagesloaded": "^4.1.4",
+    "jquery": "^3.5.1",
+    "jquery-bridget": "^3.0.0",
+    "masonry-layout": "^4.2.2",
+    "puppeteer": "^5.5.0",
+    "terser": "^5.5.1"
+  },
+  "directories": {
+    "test": "test"
+  },
+  "files": [
+    "dist",
+    "js"
+  ],
+  "homepage": "https://infinite-scroll.com",
+  "keywords": [
+    "plugin",
+    "ui",
+    "DOM",
+    "browser"
+  ],
+  "license": "GPL-3.0",
+  "main": "js/index.js",
+  "name": "infinite-scroll",
+  "repository": {
+    "type": "git",
+    "url": "git://github.com/metafizzy/infinite-scroll.git"
+  },
+  "scripts": {
+    "dist": "node bin/build-dist.js",
+    "lint": "npx eslint .",
+    "test": "npm run lint && ava",
+    "version": "node bin/version.js && npm run dist && git add -A . dist"
+  },
+  "version": "4.0.1"
+}