/*
 # -----------------------------------------------------------------------------
 #  ~/assets/themes/j1/modules/mmenu_light/js/mmenu.js
 #  Tablesaw v3.1.2 implementation for J1 Template
 #
 #  Product/Info:
 #  https://jekyll.one
 #  https://github.com/filamentgroup/tablesaw
 #
 #  Copyright (C) 2021 Juergen Adams
 #  Copyright (c) 2013 Filament Group
 #
 #  J1 Template is licensed under the MIT License.
 #  See: https://github.com/jekyll-one-org/J1 Template/blob/master/LICENSE
 #  Tablesaw is licensed under the MIT License.
 #  See: https://github.com/filamentgroup/tablesaw/blob/master/LICENSE
 # -----------------------------------------------------------------------------
*/

/*! Tablesaw - v3.1.2 - 2019-03-19
* https://github.com/filamentgroup/tablesaw
* Copyright (c) 2019 Filament Group; Licensed MIT */

(function (root, factory) {
  if (typeof define === 'function' && define.amd) {
    define(["jquery"], function (jQuery) {
      return (root.Tablesaw = factory(jQuery, root));
    });
  } else if (typeof exports === 'object') {
    if( "document" in root ) {
      module.exports = factory(require('jquery'), root);
    } else {
      // special jQuery case for CommonJS (pass in a window)
      module.exports = factory(require('jquery')(root), root);
    }
  } else {
    root.Tablesaw = factory(jQuery, root);
  }
}(typeof window !== "undefined" ? window : this, function ($, window) {
	"use strict";

  var document = window.document;

  // Account for Tablesaw being loaded either before or after the DOMContentLoaded event is fired.
  var domContentLoadedTriggered = /complete|loaded/.test(document.readyState);
  document.addEventListener("DOMContentLoaded", function() {
  	domContentLoadedTriggered = true;
  });

  var Tablesaw = {
  	i18n: {
  		modeStack: "Stack",
  		modeSwipe: "Swipe",
  		modeToggle: "Toggle",
  		modeSwitchColumnsAbbreviated: "Cols",
  		modeSwitchColumns: "Columns",
  		columnToggleButton: "Columns",
  		columnToggleError: "No eligible columns.",
  		sort: "Sort",
  		swipePreviousColumn: "Previous column",
  		swipeNextColumn: "Next column"
  	},
  	// cut the mustard
  	mustard:
  		"head" in document && // IE9+, Firefox 4+, Safari 5.1+, Mobile Safari 4.1+, Opera 11.5+, Android 2.3+
  		(!window.blackberry || window.WebKitPoint) && // only WebKit Blackberry (OS 6+)
  		!window.operamini,
  	$: $,
  	_init: function(element) {
  		Tablesaw.$(element || document).trigger("enhance.tablesaw");
  	},
  	init: function(element) {
  		// Account for Tablesaw being loaded either before or after the DOMContentLoaded event is fired.
  		domContentLoadedTriggered =
  			domContentLoadedTriggered || /complete|loaded/.test(document.readyState);
  		if (!domContentLoadedTriggered) {
  			if ("addEventListener" in document) {
  				// Use raw DOMContentLoaded instead of shoestring (may have issues in Android 2.3, exhibited by stack table)
  				document.addEventListener("DOMContentLoaded", function() {
  					Tablesaw._init(element);
  				});
  			}
  		} else {
  			Tablesaw._init(element);
  		}
  	}
  };

  $(document).on("enhance.tablesaw", function() {
  	// Extend i18n config, if one exists.
  	if (typeof TablesawConfig !== "undefined" && TablesawConfig.i18n) {
  		Tablesaw.i18n = $.extend(Tablesaw.i18n, TablesawConfig.i18n || {});
  	}

  	Tablesaw.i18n.modes = [
  		Tablesaw.i18n.modeStack,
  		Tablesaw.i18n.modeSwipe,
  		Tablesaw.i18n.modeToggle
  	];
  });

  if (Tablesaw.mustard) {
  	$(document.documentElement).addClass("tablesaw-enhanced");
  }

  (function() {
  	var pluginName = "tablesaw";
  	var classes = {
  		toolbar: "tablesaw-bar"
  	};
  	var events = {
  		create: "tablesawcreate",
  		destroy: "tablesawdestroy",
  		refresh: "tablesawrefresh",
  		resize: "tablesawresize"
  	};
  	var defaultMode = "stack";
  	var initSelector = "table";
  	var initFilterSelector = "[data-tablesaw],[data-tablesaw-mode],[data-tablesaw-sortable]";
  	var defaultConfig = {};

  	Tablesaw.events = events;

  	var Table = function(element) {
  		if (!element) {
  			throw new Error("Tablesaw requires an element.");
  		}

  		this.table = element;
  		this.$table = $(element);

  		// only one <thead> and <tfoot> are allowed, per the specification
  		this.$thead = this.$table
  			.children()
  			.filter("thead")
  			.eq(0);

  		// multiple <tbody> are allowed, per the specification
  		this.$tbody = this.$table.children().filter("tbody");

  		this.mode = this.$table.attr("data-tablesaw-mode") || defaultMode;

  		this.$toolbar = null;

  		this.attributes = {
  			subrow: "data-tablesaw-subrow",
  			ignorerow: "data-tablesaw-ignorerow"
  		};

  		this.init();
  	};

  	Table.prototype.init = function() {
  		if (!this.$thead.length) {
  			throw new Error("tablesaw: a <thead> is required, but none was found.");
  		}

  		if (!this.$thead.find("th").length) {
  			throw new Error("tablesaw: no header cells found. Are you using <th> inside of <thead>?");
  		}

  		// assign an id if there is none
  		if (!this.$table.attr("id")) {
  			this.$table.attr("id", pluginName + "-" + Math.round(Math.random() * 10000));
  		}

  		this.createToolbar();

  		this._initCells();

  		this.$table.data(pluginName, this);

  		this.$table.trigger(events.create, [this]);
  	};

  	Table.prototype.getConfig = function(pluginSpecificConfig) {
  		// shoestring extend doesn’t support arbitrary args
  		var configs = $.extend(defaultConfig, pluginSpecificConfig || {});
  		return $.extend(configs, typeof TablesawConfig !== "undefined" ? TablesawConfig : {});
  	};

  	Table.prototype._getPrimaryHeaderRow = function() {
  		return this._getHeaderRows().eq(0);
  	};

  	Table.prototype._getHeaderRows = function() {
  		return this.$thead
  			.children()
  			.filter("tr")
  			.filter(function() {
  				return !$(this).is("[data-tablesaw-ignorerow]");
  			});
  	};

  	Table.prototype._getRowIndex = function($row) {
  		return $row.prevAll().length;
  	};

  	Table.prototype._getHeaderRowIndeces = function() {
  		var self = this;
  		var indeces = [];
  		this._getHeaderRows().each(function() {
  			indeces.push(self._getRowIndex($(this)));
  		});
  		return indeces;
  	};

  	Table.prototype._getPrimaryHeaderCells = function($row) {
  		return ($row || this._getPrimaryHeaderRow()).find("th");
  	};

  	Table.prototype._$getCells = function(th) {
  		var self = this;
  		return $(th)
  			.add(th.cells)
  			.filter(function() {
  				var $t = $(this);
  				var $row = $t.parent();
  				var hasColspan = $t.is("[colspan]");
  				// no subrows or ignored rows (keep cells in ignored rows that do not have a colspan)
  				return (
  					!$row.is("[" + self.attributes.subrow + "]") &&
  					(!$row.is("[" + self.attributes.ignorerow + "]") || !hasColspan)
  				);
  			});
  	};

  	Table.prototype._getVisibleColspan = function() {
  		var colspan = 0;
  		this._getPrimaryHeaderCells().each(function() {
  			var $t = $(this);
  			if ($t.css("display") !== "none") {
  				colspan += parseInt($t.attr("colspan"), 10) || 1;
  			}
  		});
  		return colspan;
  	};

  	Table.prototype.getColspanForCell = function($cell) {
  		var visibleColspan = this._getVisibleColspan();
  		var visibleSiblingColumns = 0;
  		if ($cell.closest("tr").data("tablesaw-rowspanned")) {
  			visibleSiblingColumns++;
  		}

  		$cell.siblings().each(function() {
  			var $t = $(this);
  			var colColspan = parseInt($t.attr("colspan"), 10) || 1;

  			if ($t.css("display") !== "none") {
  				visibleSiblingColumns += colColspan;
  			}
  		});
  		// console.log( $cell[ 0 ], visibleColspan, visibleSiblingColumns );

  		return visibleColspan - visibleSiblingColumns;
  	};

  	Table.prototype.isCellInColumn = function(header, cell) {
  		return $(header)
  			.add(header.cells)
  			.filter(function() {
  				return this === cell;
  			}).length;
  	};

  	Table.prototype.updateColspanCells = function(cls, header, userAction) {
  		var self = this;
  		var primaryHeaderRow = self._getPrimaryHeaderRow();

  		// find persistent column rowspans
  		this.$table.find("[rowspan][data-tablesaw-priority]").each(function() {
  			var $t = $(this);
  			if ($t.attr("data-tablesaw-priority") !== "persist") {
  				return;
  			}

  			var $row = $t.closest("tr");
  			var rowspan = parseInt($t.attr("rowspan"), 10);
  			if (rowspan > 1) {
  				$row = $row.next();

  				$row.data("tablesaw-rowspanned", true);

  				rowspan--;
  			}
  		});

  		this.$table
  			.find("[colspan],[data-tablesaw-maxcolspan]")
  			.filter(function() {
  				// is not in primary header row
  				return $(this).closest("tr")[0] !== primaryHeaderRow[0];
  			})
  			.each(function() {
  				var $cell = $(this);

  				if (userAction === undefined || self.isCellInColumn(header, this)) {
  				} else {
  					// if is not a user action AND the cell is not in the updating column, kill it
  					return;
  				}

  				var colspan = self.getColspanForCell($cell);

  				if (cls && userAction !== undefined) {
  					// console.log( colspan === 0 ? "addClass" : "removeClass", $cell );
  					$cell[colspan === 0 ? "addClass" : "removeClass"](cls);
  				}

  				// cache original colspan
  				var maxColspan = parseInt($cell.attr("data-tablesaw-maxcolspan"), 10);
  				if (!maxColspan) {
  					$cell.attr("data-tablesaw-maxcolspan", $cell.attr("colspan"));
  				} else if (colspan > maxColspan) {
  					colspan = maxColspan;
  				}

  				// console.log( this, "setting colspan to ", colspan );
  				$cell.attr("colspan", colspan);
  			});
  	};

  	Table.prototype._findPrimaryHeadersForCell = function(cell) {
  		var $headerRow = this._getPrimaryHeaderRow();
  		var headerRowIndex = this._getRowIndex($headerRow);
  		var results = [];

  		for (var rowNumber = 0; rowNumber < this.headerMapping.length; rowNumber++) {
  			if (rowNumber === headerRowIndex) {
  				continue;
  			}

  			for (var colNumber = 0; colNumber < this.headerMapping[rowNumber].length; colNumber++) {
  				if (this.headerMapping[rowNumber][colNumber] === cell) {
  					results.push(this.headerMapping[headerRowIndex][colNumber]);
  				}
  			}
  		}

  		return results;
  	};

  	// used by init cells
  	Table.prototype.getRows = function() {
  		var self = this;
  		return this.$table.find("tr").filter(function() {
  			return $(this)
  				.closest("table")
  				.is(self.$table);
  		});
  	};

  	// used by sortable
  	Table.prototype.getBodyRows = function(tbody) {
  		return (tbody ? $(tbody) : this.$tbody).children().filter("tr");
  	};

  	Table.prototype.getHeaderCellIndex = function(cell) {
  		var lookup = this.headerMapping[0];
  		for (var colIndex = 0; colIndex < lookup.length; colIndex++) {
  			if (lookup[colIndex] === cell) {
  				return colIndex;
  			}
  		}

  		return -1;
  	};

  	Table.prototype._initCells = function() {
  		// re-establish original colspans
  		this.$table.find("[data-tablesaw-maxcolspan]").each(function() {
  			var $t = $(this);
  			$t.attr("colspan", $t.attr("data-tablesaw-maxcolspan"));
  		});

  		var $rows = this.getRows();
  		var columnLookup = [];

  		$rows.each(function(rowNumber) {
  			columnLookup[rowNumber] = [];
  		});

  		$rows.each(function(rowNumber) {
  			var coltally = 0;
  			var $t = $(this);
  			var children = $t.children();

  			children.each(function() {
  				var colspan = parseInt(
  					this.getAttribute("data-tablesaw-maxcolspan") || this.getAttribute("colspan"),
  					10
  				);
  				var rowspan = parseInt(this.getAttribute("rowspan"), 10);

  				// set in a previous rowspan
  				while (columnLookup[rowNumber][coltally]) {
  					coltally++;
  				}

  				columnLookup[rowNumber][coltally] = this;

  				// TODO? both colspan and rowspan
  				if (colspan) {
  					for (var k = 0; k < colspan - 1; k++) {
  						coltally++;
  						columnLookup[rowNumber][coltally] = this;
  					}
  				}
  				if (rowspan) {
  					for (var j = 1; j < rowspan; j++) {
  						columnLookup[rowNumber + j][coltally] = this;
  					}
  				}

  				coltally++;
  			});
  		});

  		var headerRowIndeces = this._getHeaderRowIndeces();
  		for (var colNumber = 0; colNumber < columnLookup[0].length; colNumber++) {
  			for (var headerIndex = 0, k = headerRowIndeces.length; headerIndex < k; headerIndex++) {
  				var headerCol = columnLookup[headerRowIndeces[headerIndex]][colNumber];

  				var rowNumber = headerRowIndeces[headerIndex];
  				var rowCell;

  				if (!headerCol.cells) {
  					headerCol.cells = [];
  				}

  				while (rowNumber < columnLookup.length) {
  					rowCell = columnLookup[rowNumber][colNumber];

  					if (headerCol !== rowCell) {
  						headerCol.cells.push(rowCell);
  					}

  					rowNumber++;
  				}
  			}
  		}

  		this.headerMapping = columnLookup;
  	};

  	Table.prototype.refresh = function() {
  		this._initCells();

  		this.$table.trigger(events.refresh, [this]);
  	};

  	Table.prototype._getToolbarAnchor = function() {
  		var $parent = this.$table.parent();
  		if ($parent.is(".tablesaw-overflow")) {
  			return $parent;
  		}
  		return this.$table;
  	};

  	Table.prototype._getToolbar = function($anchor) {
  		if (!$anchor) {
  			$anchor = this._getToolbarAnchor();
  		}
  		return $anchor.prev().filter("." + classes.toolbar);
  	};

  	Table.prototype.createToolbar = function() {
  		// Insert the toolbar
  		// TODO move this into a separate component
  		var $anchor = this._getToolbarAnchor();
  		var $toolbar = this._getToolbar($anchor);
  		if (!$toolbar.length) {
  			$toolbar = $("<div>")
  				.addClass(classes.toolbar)
  				.insertBefore($anchor);
  		}
  		this.$toolbar = $toolbar;

  		if (this.mode) {
  			this.$toolbar.addClass("tablesaw-mode-" + this.mode);
  		}
  	};

  	Table.prototype.destroy = function() {
  		// Don’t remove the toolbar, just erase the classes on it.
  		// Some of the table features are not yet destroy-friendly.
  		this._getToolbar().each(function() {
  			this.className = this.className.replace(/\btablesaw-mode\-\w*\b/gi, "");
  		});

  		var tableId = this.$table.attr("id");
  		$(document).off("." + tableId);
  		$(window).off("." + tableId);

  		// other plugins
  		this.$table.trigger(events.destroy, [this]);

  		this.$table.removeData(pluginName);
  	};

  	// Collection method.
  	$.fn[pluginName] = function() {
  		return this.each(function() {
  			var $t = $(this);

  			if ($t.data(pluginName)) {
  				return;
  			}

  			new Table(this);
  		});
  	};

  	var $doc = $(document);
  	$doc.on("enhance.tablesaw", function(e) {
  		// Cut the mustard
  		if (Tablesaw.mustard) {
  			var $target = $(e.target);
  			if ($target.parent().length) {
  				$target = $target.parent();
  			}

  			$target
  				.find(initSelector)
  				.filter(initFilterSelector)
  				[pluginName]();
  		}
  	});

  	// Avoid a resize during scroll:
  	// Some Mobile devices trigger a resize during scroll (sometimes when
  	// doing elastic stretch at the end of the document or from the
  	// location bar hide)
  	var isScrolling = false;
  	var scrollTimeout;
  	$doc.on("scroll.tablesaw", function() {
  		isScrolling = true;

  		window.clearTimeout(scrollTimeout);
  		scrollTimeout = window.setTimeout(function() {
  			isScrolling = false;
  		}, 300); // must be greater than the resize timeout below
  	});

  	var resizeTimeout;
  	$(window).on("resize", function() {
  		if (!isScrolling) {
  			window.clearTimeout(resizeTimeout);
  			resizeTimeout = window.setTimeout(function() {
  				$doc.trigger(events.resize);
  			}, 150); // must be less than the scrolling timeout above.
  		}
  	});

  	Tablesaw.Table = Table;
  })();

  (function() {
  	var classes = {
  		stackTable: "tablesaw-stack",
  		cellLabels: "tablesaw-cell-label",
  		cellContentLabels: "tablesaw-cell-content"
  	};

  	var data = {
  		key: "tablesaw-stack"
  	};

  	var attrs = {
  		labelless: "data-tablesaw-no-labels",
  		hideempty: "data-tablesaw-hide-empty"
  	};

  	var Stack = function(element, tablesaw) {
  		this.tablesaw = tablesaw;
  		this.$table = $(element);

  		this.labelless = this.$table.is("[" + attrs.labelless + "]");
  		this.hideempty = this.$table.is("[" + attrs.hideempty + "]");

  		this.$table.data(data.key, this);
  	};

  	Stack.prototype.init = function() {
  		this.$table.addClass(classes.stackTable);

  		if (this.labelless) {
  			return;
  		}

  		var self = this;

  		this.$table
  			.find("th, td")
  			.filter(function() {
  				return !$(this).closest("thead").length;
  			})
  			.filter(function() {
  				return (
  					!$(this).is("[" + attrs.labelless + "]") &&
  					!$(this)
  						.closest("tr")
  						.is("[" + attrs.labelless + "]") &&
  					(!self.hideempty || !!$(this).html())
  				);
  			})
  			.each(function() {
  				var $newHeader = $(document.createElement("b")).addClass(classes.cellLabels);
  				var $cell = $(this);

  				$(self.tablesaw._findPrimaryHeadersForCell(this)).each(function(index) {
  					var $header = $(this.cloneNode(true));
  					// TODO decouple from sortable better
  					// Changed from .text() in https://github.com/filamentgroup/tablesaw/commit/b9c12a8f893ec192830ec3ba2d75f062642f935b
  					// to preserve structural html in headers, like <a>
  					var $sortableButton = $header.find(".tablesaw-sortable-btn");
  					$header.find(".tablesaw-sortable-arrow").remove();

  					// TODO decouple from checkall better
  					var $checkall = $header.find("[data-tablesaw-checkall]");
  					$checkall.closest("label").remove();
  					if ($checkall.length) {
  						$newHeader = $([]);
  						return;
  					}

  					if (index > 0) {
  						$newHeader.append(document.createTextNode(", "));
  					}

  					var parentNode = $sortableButton.length ? $sortableButton[0] : $header[0];
  					var el;
  					while ((el = parentNode.firstChild)) {
  						$newHeader[0].appendChild(el);
  					}
  				});

  				if ($newHeader.length && !$cell.find("." + classes.cellContentLabels).length) {
  					$cell.wrapInner("<span class='" + classes.cellContentLabels + "'></span>");
  				}

  				// Update if already exists.
  				var $label = $cell.find("." + classes.cellLabels);
  				if (!$label.length) {
  					$cell.prepend(document.createTextNode(" "));
  					$cell.prepend($newHeader);
  				} else {
  					// only if changed
  					$label.replaceWith($newHeader);
  				}
  			});
  	};

  	Stack.prototype.destroy = function() {
  		this.$table.removeClass(classes.stackTable);
  		this.$table.find("." + classes.cellLabels).remove();
  		this.$table.find("." + classes.cellContentLabels).each(function() {
  			$(this).replaceWith($(this.childNodes));
  		});
  	};

  	// on tablecreate, init
  	$(document)
  		.on(Tablesaw.events.create, function(e, tablesaw) {
  			if (tablesaw.mode === "stack") {
  				var table = new Stack(tablesaw.table, tablesaw);
  				table.init();
  			}
  		})
  		.on(Tablesaw.events.refresh, function(e, tablesaw) {
  			if (tablesaw.mode === "stack") {
  				$(tablesaw.table)
  					.data(data.key)
  					.init();
  			}
  		})
  		.on(Tablesaw.events.destroy, function(e, tablesaw) {
  			if (tablesaw.mode === "stack") {
  				$(tablesaw.table)
  					.data(data.key)
  					.destroy();
  			}
  		});

  	Tablesaw.Stack = Stack;
  })();
	return Tablesaw;

}));