@teipublisher/pb-components 2.10.1 → 2.10.2

package/lib/paged.polyfill.js

@@ -1,5 +1,5 @@
 /**
- * @license Paged.js v0.4.0 | MIT | https://gitlab.pagedmedia.org/tools/pagedjs
+ * @license Paged.js v0.4.3 | MIT | https://gitlab.coko.foundation/pagedjs/pagedjs
  */
 
 (function (global, factory) {
@@ -8,9 +8,13 @@
 	(global = typeof globalThis !== 'undefined' ? globalThis : global || self, global.PagedPolyfill = factory());
 })(this, (function () { 'use strict';
 
+	function getDefaultExportFromCjs (x) {
+		return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, 'default') ? x['default'] : x;
+	}
+
 	var eventEmitter = {exports: {}};
 
-	var d$3 = {exports: {}};
+	var d$2 = {exports: {}};
 
 	var isImplemented$6 = function () {
 		var assign = Object.assign, obj;
@@ -20,72 +24,108 @@
 		return (obj.foo + obj.bar + obj.trzy) === "razdwatrzy";
 	};
 
-	var isImplemented$5 = function () {
-		try {
-			Object.keys("primitive");
-			return true;
-		} catch (e) {
-	 return false;
+	var isImplemented$5;
+	var hasRequiredIsImplemented$1;
+
+	function requireIsImplemented$1 () {
+		if (hasRequiredIsImplemented$1) return isImplemented$5;
+		hasRequiredIsImplemented$1 = 1;
+
+		isImplemented$5 = function () {
+			try {
+				Object.keys("primitive");
+				return true;
+			} catch (e) {
+		 return false;
+		}
+		};
+		return isImplemented$5;
 	}
-	};
 
 	// eslint-disable-next-line no-empty-function
 	var noop$4 = function () {};
 
 	var _undefined = noop$4(); // Support ES3 engines
 
-	var isValue$5 = function (val) {
+	var isValue$3 = function (val) {
 	 return (val !== _undefined) && (val !== null);
 	};
 
-	var isValue$4 = isValue$5;
+	var shim$5;
+	var hasRequiredShim$5;
 
-	var keys$2 = Object.keys;
+	function requireShim$5 () {
+		if (hasRequiredShim$5) return shim$5;
+		hasRequiredShim$5 = 1;
 
-	var shim$5 = function (object) {
-		return keys$2(isValue$4(object) ? Object(object) : object);
-	};
+		var isValue = isValue$3;
+
+		var keys = Object.keys;
+
+		shim$5 = function (object) {
+			return keys(isValue(object) ? Object(object) : object);
+		};
+		return shim$5;
+	}
 
-	var keys$1 = isImplemented$5()
-		? Object.keys
-		: shim$5;
+	var keys;
+	var hasRequiredKeys;
 
-	var isValue$3 = isValue$5;
+	function requireKeys () {
+		if (hasRequiredKeys) return keys;
+		hasRequiredKeys = 1;
+
+		keys = requireIsImplemented$1()()
+			? Object.keys
+			: requireShim$5();
+		return keys;
+	}
 
-	var validValue$1 = function (value) {
-		if (!isValue$3(value)) throw new TypeError("Cannot use null or undefined");
+	var isValue$2 = isValue$3;
+
+	var validValue = function (value) {
+		if (!isValue$2(value)) throw new TypeError("Cannot use null or undefined");
 		return value;
 	};
 
-	var keys  = keys$1
-	  , value$3 = validValue$1
-	  , max$1   = Math.max;
+	var shim$4;
+	var hasRequiredShim$4;
 
-	var shim$4 = function (dest, src /*, …srcn*/) {
-		var error, i, length = max$1(arguments.length, 2), assign;
-		dest = Object(value$3(dest));
-		assign = function (key) {
-			try {
-				dest[key] = src[key];
-			} catch (e) {
-				if (!error) error = e;
+	function requireShim$4 () {
+		if (hasRequiredShim$4) return shim$4;
+		hasRequiredShim$4 = 1;
+
+		var keys  = requireKeys()
+		  , value = validValue
+		  , max   = Math.max;
+
+		shim$4 = function (dest, src /*, …srcn*/) {
+			var error, i, length = max(arguments.length, 2), assign;
+			dest = Object(value(dest));
+			assign = function (key) {
+				try {
+					dest[key] = src[key];
+				} catch (e) {
+					if (!error) error = e;
+				}
+			};
+			for (i = 1; i < length; ++i) {
+				src = arguments[i];
+				keys(src).forEach(assign);
 			}
+			if (error !== undefined) throw error;
+			return dest;
 		};
-		for (i = 1; i < length; ++i) {
-			src = arguments[i];
-			keys(src).forEach(assign);
-		}
-		if (error !== undefined) throw error;
-		return dest;
-	};
+		return shim$4;
+	}
 
 	var assign$2 = isImplemented$6()
 		? Object.assign
-		: shim$4;
+		: requireShim$4();
 
-	var isValue$2 = isValue$5;
+	var isValue$1 = isValue$3;
 
-	var forEach$1 = Array.prototype.forEach, create$6 = Object.create;
+	var forEach$1 = Array.prototype.forEach, create$5 = Object.create;
 
 	var process = function (src, obj) {
 		var key;
@@ -94,9 +134,9 @@
 
 	// eslint-disable-next-line no-unused-vars
 	var normalizeOptions = function (opts1 /*, …options*/) {
-		var result = create$6(null);
+		var result = create$5(null);
 		forEach$1.call(arguments, function (options) {
-			if (!isValue$2(options)) return;
+			if (!isValue$1(options)) return;
 			process(Object(options), result);
 		});
 		return result;
@@ -113,24 +153,33 @@
 		return (str.contains("dwa") === true) && (str.contains("foo") === false);
 	};
 
-	var indexOf$3 = String.prototype.indexOf;
+	var shim$3;
+	var hasRequiredShim$3;
 
-	var shim$3 = function (searchString/*, position*/) {
-		return indexOf$3.call(this, searchString, arguments[1]) > -1;
-	};
+	function requireShim$3 () {
+		if (hasRequiredShim$3) return shim$3;
+		hasRequiredShim$3 = 1;
+
+		var indexOf = String.prototype.indexOf;
+
+		shim$3 = function (searchString/*, position*/) {
+			return indexOf.call(this, searchString, arguments[1]) > -1;
+		};
+		return shim$3;
+	}
 
 	var contains$1 = isImplemented$4()
 		? String.prototype.contains
-		: shim$3;
+		: requireShim$3();
 
 	var assign$1        = assign$2
 	  , normalizeOpts = normalizeOptions
 	  , isCallable    = isCallable$1
 	  , contains      = contains$1
 
-	  , d$2;
+	  , d$1;
 
-	d$2 = d$3.exports = function (dscr, value/*, options*/) {
+	d$1 = d$2.exports = function (dscr, value/*, options*/) {
 		var c, e, w, options, desc;
 		if ((arguments.length < 2) || (typeof dscr !== 'string')) {
 			options = value;
@@ -152,7 +201,7 @@
 		return !options ? desc : assign$1(normalizeOpts(options), desc);
 	};
 
-	d$2.gs = function (dscr, get, set/*, options*/) {
+	d$1.gs = function (dscr, get, set/*, options*/) {
 		var c, e, options, desc;
 		if (typeof dscr !== 'string') {
 			options = set;
@@ -185,6 +234,8 @@
 		return !options ? desc : assign$1(normalizeOpts(options), desc);
 	};
 
+	var dExports = d$2.exports;
+
 	var validCallable = function (fn) {
 		if (typeof fn !== "function") throw new TypeError(fn + " is not a function");
 		return fn;
@@ -192,139 +243,140 @@
 
 	(function (module, exports) {
 
-	var d        = d$3.exports
-	  , callable = validCallable
-
-	  , apply = Function.prototype.apply, call = Function.prototype.call
-	  , create = Object.create, defineProperty = Object.defineProperty
-	  , defineProperties = Object.defineProperties
-	  , hasOwnProperty = Object.prototype.hasOwnProperty
-	  , descriptor = { configurable: true, enumerable: false, writable: true }
+		var d        = dExports
+		  , callable = validCallable
 
-	  , on, once, off, emit, methods, descriptors, base;
+		  , apply = Function.prototype.apply, call = Function.prototype.call
+		  , create = Object.create, defineProperty = Object.defineProperty
+		  , defineProperties = Object.defineProperties
+		  , hasOwnProperty = Object.prototype.hasOwnProperty
+		  , descriptor = { configurable: true, enumerable: false, writable: true }
 
-	on = function (type, listener) {
-		var data;
+		  , on, once, off, emit, methods, descriptors, base;
 
-		callable(listener);
+		on = function (type, listener) {
+			var data;
 
-		if (!hasOwnProperty.call(this, '__ee__')) {
-			data = descriptor.value = create(null);
-			defineProperty(this, '__ee__', descriptor);
-			descriptor.value = null;
-		} else {
-			data = this.__ee__;
-		}
-		if (!data[type]) data[type] = listener;
-		else if (typeof data[type] === 'object') data[type].push(listener);
-		else data[type] = [data[type], listener];
+			callable(listener);
 
-		return this;
-	};
+			if (!hasOwnProperty.call(this, '__ee__')) {
+				data = descriptor.value = create(null);
+				defineProperty(this, '__ee__', descriptor);
+				descriptor.value = null;
+			} else {
+				data = this.__ee__;
+			}
+			if (!data[type]) data[type] = listener;
+			else if (typeof data[type] === 'object') data[type].push(listener);
+			else data[type] = [data[type], listener];
 
-	once = function (type, listener) {
-		var once, self;
+			return this;
+		};
 
-		callable(listener);
-		self = this;
-		on.call(this, type, once = function () {
-			off.call(self, type, once);
-			apply.call(listener, this, arguments);
-		});
+		once = function (type, listener) {
+			var once, self;
 
-		once.__eeOnceListener__ = listener;
-		return this;
-	};
+			callable(listener);
+			self = this;
+			on.call(this, type, once = function () {
+				off.call(self, type, once);
+				apply.call(listener, this, arguments);
+			});
 
-	off = function (type, listener) {
-		var data, listeners, candidate, i;
+			once.__eeOnceListener__ = listener;
+			return this;
+		};
 
-		callable(listener);
+		off = function (type, listener) {
+			var data, listeners, candidate, i;
 
-		if (!hasOwnProperty.call(this, '__ee__')) return this;
-		data = this.__ee__;
-		if (!data[type]) return this;
-		listeners = data[type];
+			callable(listener);
 
-		if (typeof listeners === 'object') {
-			for (i = 0; (candidate = listeners[i]); ++i) {
-				if ((candidate === listener) ||
-						(candidate.__eeOnceListener__ === listener)) {
-					if (listeners.length === 2) data[type] = listeners[i ? 0 : 1];
-					else listeners.splice(i, 1);
+			if (!hasOwnProperty.call(this, '__ee__')) return this;
+			data = this.__ee__;
+			if (!data[type]) return this;
+			listeners = data[type];
+
+			if (typeof listeners === 'object') {
+				for (i = 0; (candidate = listeners[i]); ++i) {
+					if ((candidate === listener) ||
+							(candidate.__eeOnceListener__ === listener)) {
+						if (listeners.length === 2) data[type] = listeners[i ? 0 : 1];
+						else listeners.splice(i, 1);
+					}
+				}
+			} else {
+				if ((listeners === listener) ||
+						(listeners.__eeOnceListener__ === listener)) {
+					delete data[type];
 				}
 			}
-		} else {
-			if ((listeners === listener) ||
-					(listeners.__eeOnceListener__ === listener)) {
-				delete data[type];
-			}
-		}
-
-		return this;
-	};
 
-	emit = function (type) {
-		var i, l, listener, listeners, args;
+			return this;
+		};
 
-		if (!hasOwnProperty.call(this, '__ee__')) return;
-		listeners = this.__ee__[type];
-		if (!listeners) return;
+		emit = function (type) {
+			var i, l, listener, listeners, args;
 
-		if (typeof listeners === 'object') {
-			l = arguments.length;
-			args = new Array(l - 1);
-			for (i = 1; i < l; ++i) args[i - 1] = arguments[i];
+			if (!hasOwnProperty.call(this, '__ee__')) return;
+			listeners = this.__ee__[type];
+			if (!listeners) return;
 
-			listeners = listeners.slice();
-			for (i = 0; (listener = listeners[i]); ++i) {
-				apply.call(listener, this, args);
-			}
-		} else {
-			switch (arguments.length) {
-			case 1:
-				call.call(listeners, this);
-				break;
-			case 2:
-				call.call(listeners, this, arguments[1]);
-				break;
-			case 3:
-				call.call(listeners, this, arguments[1], arguments[2]);
-				break;
-			default:
+			if (typeof listeners === 'object') {
 				l = arguments.length;
 				args = new Array(l - 1);
-				for (i = 1; i < l; ++i) {
-					args[i - 1] = arguments[i];
+				for (i = 1; i < l; ++i) args[i - 1] = arguments[i];
+
+				listeners = listeners.slice();
+				for (i = 0; (listener = listeners[i]); ++i) {
+					apply.call(listener, this, args);
+				}
+			} else {
+				switch (arguments.length) {
+				case 1:
+					call.call(listeners, this);
+					break;
+				case 2:
+					call.call(listeners, this, arguments[1]);
+					break;
+				case 3:
+					call.call(listeners, this, arguments[1], arguments[2]);
+					break;
+				default:
+					l = arguments.length;
+					args = new Array(l - 1);
+					for (i = 1; i < l; ++i) {
+						args[i - 1] = arguments[i];
+					}
+					apply.call(listeners, this, args);
 				}
-				apply.call(listeners, this, args);
 			}
-		}
-	};
+		};
 
-	methods = {
-		on: on,
-		once: once,
-		off: off,
-		emit: emit
-	};
+		methods = {
+			on: on,
+			once: once,
+			off: off,
+			emit: emit
+		};
 
-	descriptors = {
-		on: d(on),
-		once: d(once),
-		off: d(off),
-		emit: d(emit)
-	};
+		descriptors = {
+			on: d(on),
+			once: d(once),
+			off: d(off),
+			emit: d(emit)
+		};
 
-	base = defineProperties({}, descriptors);
+		base = defineProperties({}, descriptors);
 
-	module.exports = exports = function (o) {
-		return (o == null) ? create(base) : defineProperties(Object(o), descriptors);
-	};
-	exports.methods = methods;
-	}(eventEmitter, eventEmitter.exports));
+		module.exports = exports = function (o) {
+			return (o == null) ? create(base) : defineProperties(Object(o), descriptors);
+		};
+		exports.methods = methods; 
+	} (eventEmitter, eventEmitter.exports));
 
-	var EventEmitter = eventEmitter.exports;
+	var eventEmitterExports = eventEmitter.exports;
+	var EventEmitter = /*@__PURE__*/getDefaultExportFromCjs(eventEmitterExports);
 
 	/**
 	 * Hooks allow for injecting functions that must all complete in order before finishing
@@ -1366,6 +1418,7 @@
 				this.hooks = hooks;
 			} else {
 				this.hooks = {};
+				this.hooks.onPageLayout = new Hook();
 				this.hooks.layout = new Hook();
 				this.hooks.renderNode = new Hook();
 				this.hooks.layoutNode = new Hook();
@@ -1373,6 +1426,7 @@
 				this.hooks.onOverflow = new Hook();
 				this.hooks.afterOverflowRemoved = new Hook();
 				this.hooks.onBreakToken = new Hook();
+				this.hooks.beforeRenderResult = new Hook();
 			}
 
 			this.settings = options || {};
@@ -1397,6 +1451,8 @@
 
 			let prevBreakToken = breakToken || new BreakToken(start);
 
+			this.hooks && this.hooks.onPageLayout.trigger(wrapper, prevBreakToken, this);
+
 			while (!done && !newBreakToken) {
 				next = walker.next();
 				prevNode = node;
@@ -1415,11 +1471,13 @@
 
 					if (newBreakToken && newBreakToken.equals(prevBreakToken)) {
 						console.warn("Unable to layout item: ", prevNode);
+						this.hooks && this.hooks.beforeRenderResult.trigger(undefined, wrapper, this);
 						return new RenderResult(undefined, new OverflowContentError("Unable to layout item", [prevNode]));
 					}
 
 					this.rebuildTableFromBreakToken(newBreakToken, wrapper);
 
+					this.hooks && this.hooks.beforeRenderResult.trigger(newBreakToken, wrapper, this);
 					return new RenderResult(newBreakToken);
 				}
 
@@ -1525,6 +1583,7 @@
 						if (after) {
 							newBreakToken = new BreakToken(after);
 						} else {
+							this.hooks && this.hooks.beforeRenderResult.trigger(undefined, wrapper, this);
 							return new RenderResult(undefined, new OverflowContentError("Unable to layout item", [node]));
 						}
 					}
@@ -1532,6 +1591,7 @@
 
 			}
 
+			this.hooks && this.hooks.beforeRenderResult.trigger(newBreakToken, wrapper, this);
 			return new RenderResult(newBreakToken);
 		}
 
@@ -2788,12 +2848,14 @@
 			this.hooks.filter = new Hook(this);
 			this.hooks.afterParsed = new Hook(this);
 			this.hooks.beforePageLayout = new Hook(this);
+			this.hooks.onPageLayout = new Hook(this);
 			this.hooks.layout = new Hook(this);
 			this.hooks.renderNode = new Hook(this);
 			this.hooks.layoutNode = new Hook(this);
 			this.hooks.onOverflow = new Hook(this);
 			this.hooks.afterOverflowRemoved = new Hook(this);
 			this.hooks.onBreakToken = new Hook();
+			this.hooks.beforeRenderResult = new Hook(this);
 			this.hooks.afterPageLayout = new Hook(this);
 			this.hooks.finalizePage = new Hook(this);
 			this.hooks.afterRendered = new Hook(this);
@@ -3244,7 +3306,7 @@
 
 	var syntax = {exports: {}};
 
-	var create$5 = {};
+	var create$4 = {};
 
 	//
 	//                              list
@@ -9502,7 +9564,7 @@
 	    return parserConfig;
 	}
 
-	var create$4 = function createParser(config) {
+	var create$3 = function createParser(config) {
 	    var parser = {
 	        scanner: new TokenStream$1(),
 	        locationMap: new OffsetToLocation(),
@@ -9943,494 +10005,494 @@
 	/* -*- Mode: js; js-indent-level: 2; -*- */
 
 	(function (exports) {
-	/*
-	 * Copyright 2011 Mozilla Foundation and contributors
-	 * Licensed under the New BSD license. See LICENSE or:
-	 * http://opensource.org/licenses/BSD-3-Clause
-	 */
-
-	/**
-	 * This is a helper function for getting values from parameter/options
-	 * objects.
-	 *
-	 * @param args The object we are extracting values from
-	 * @param name The name of the property we are getting.
-	 * @param defaultValue An optional value to return if the property is missing
-	 * from the object. If this is not specified and the property is missing, an
-	 * error will be thrown.
-	 */
-	function getArg(aArgs, aName, aDefaultValue) {
-	  if (aName in aArgs) {
-	    return aArgs[aName];
-	  } else if (arguments.length === 3) {
-	    return aDefaultValue;
-	  } else {
-	    throw new Error('"' + aName + '" is a required argument.');
-	  }
-	}
-	exports.getArg = getArg;
-
-	var urlRegexp = /^(?:([\w+\-.]+):)?\/\/(?:(\w+:\w+)@)?([\w.-]*)(?::(\d+))?(.*)$/;
-	var dataUrlRegexp = /^data:.+\,.+$/;
-
-	function urlParse(aUrl) {
-	  var match = aUrl.match(urlRegexp);
-	  if (!match) {
-	    return null;
-	  }
-	  return {
-	    scheme: match[1],
-	    auth: match[2],
-	    host: match[3],
-	    port: match[4],
-	    path: match[5]
-	  };
-	}
-	exports.urlParse = urlParse;
-
-	function urlGenerate(aParsedUrl) {
-	  var url = '';
-	  if (aParsedUrl.scheme) {
-	    url += aParsedUrl.scheme + ':';
-	  }
-	  url += '//';
-	  if (aParsedUrl.auth) {
-	    url += aParsedUrl.auth + '@';
-	  }
-	  if (aParsedUrl.host) {
-	    url += aParsedUrl.host;
-	  }
-	  if (aParsedUrl.port) {
-	    url += ":" + aParsedUrl.port;
-	  }
-	  if (aParsedUrl.path) {
-	    url += aParsedUrl.path;
-	  }
-	  return url;
-	}
-	exports.urlGenerate = urlGenerate;
-
-	/**
-	 * Normalizes a path, or the path portion of a URL:
-	 *
-	 * - Replaces consecutive slashes with one slash.
-	 * - Removes unnecessary '.' parts.
-	 * - Removes unnecessary '<dir>/..' parts.
-	 *
-	 * Based on code in the Node.js 'path' core module.
-	 *
-	 * @param aPath The path or url to normalize.
-	 */
-	function normalize(aPath) {
-	  var path = aPath;
-	  var url = urlParse(aPath);
-	  if (url) {
-	    if (!url.path) {
-	      return aPath;
-	    }
-	    path = url.path;
-	  }
-	  var isAbsolute = exports.isAbsolute(path);
-
-	  var parts = path.split(/\/+/);
-	  for (var part, up = 0, i = parts.length - 1; i >= 0; i--) {
-	    part = parts[i];
-	    if (part === '.') {
-	      parts.splice(i, 1);
-	    } else if (part === '..') {
-	      up++;
-	    } else if (up > 0) {
-	      if (part === '') {
-	        // The first part is blank if the path is absolute. Trying to go
-	        // above the root is a no-op. Therefore we can remove all '..' parts
-	        // directly after the root.
-	        parts.splice(i + 1, up);
-	        up = 0;
-	      } else {
-	        parts.splice(i, 2);
-	        up--;
-	      }
-	    }
-	  }
-	  path = parts.join('/');
-
-	  if (path === '') {
-	    path = isAbsolute ? '/' : '.';
-	  }
-
-	  if (url) {
-	    url.path = path;
-	    return urlGenerate(url);
-	  }
-	  return path;
-	}
-	exports.normalize = normalize;
-
-	/**
-	 * Joins two paths/URLs.
-	 *
-	 * @param aRoot The root path or URL.
-	 * @param aPath The path or URL to be joined with the root.
-	 *
-	 * - If aPath is a URL or a data URI, aPath is returned, unless aPath is a
-	 *   scheme-relative URL: Then the scheme of aRoot, if any, is prepended
-	 *   first.
-	 * - Otherwise aPath is a path. If aRoot is a URL, then its path portion
-	 *   is updated with the result and aRoot is returned. Otherwise the result
-	 *   is returned.
-	 *   - If aPath is absolute, the result is aPath.
-	 *   - Otherwise the two paths are joined with a slash.
-	 * - Joining for example 'http://' and 'www.example.com' is also supported.
-	 */
-	function join(aRoot, aPath) {
-	  if (aRoot === "") {
-	    aRoot = ".";
-	  }
-	  if (aPath === "") {
-	    aPath = ".";
-	  }
-	  var aPathUrl = urlParse(aPath);
-	  var aRootUrl = urlParse(aRoot);
-	  if (aRootUrl) {
-	    aRoot = aRootUrl.path || '/';
-	  }
-
-	  // `join(foo, '//www.example.org')`
-	  if (aPathUrl && !aPathUrl.scheme) {
-	    if (aRootUrl) {
-	      aPathUrl.scheme = aRootUrl.scheme;
-	    }
-	    return urlGenerate(aPathUrl);
-	  }
-
-	  if (aPathUrl || aPath.match(dataUrlRegexp)) {
-	    return aPath;
-	  }
-
-	  // `join('http://', 'www.example.com')`
-	  if (aRootUrl && !aRootUrl.host && !aRootUrl.path) {
-	    aRootUrl.host = aPath;
-	    return urlGenerate(aRootUrl);
-	  }
-
-	  var joined = aPath.charAt(0) === '/'
-	    ? aPath
-	    : normalize(aRoot.replace(/\/+$/, '') + '/' + aPath);
-
-	  if (aRootUrl) {
-	    aRootUrl.path = joined;
-	    return urlGenerate(aRootUrl);
-	  }
-	  return joined;
-	}
-	exports.join = join;
+		/*
+		 * Copyright 2011 Mozilla Foundation and contributors
+		 * Licensed under the New BSD license. See LICENSE or:
+		 * http://opensource.org/licenses/BSD-3-Clause
+		 */
 
-	exports.isAbsolute = function (aPath) {
-	  return aPath.charAt(0) === '/' || urlRegexp.test(aPath);
-	};
+		/**
+		 * This is a helper function for getting values from parameter/options
+		 * objects.
+		 *
+		 * @param args The object we are extracting values from
+		 * @param name The name of the property we are getting.
+		 * @param defaultValue An optional value to return if the property is missing
+		 * from the object. If this is not specified and the property is missing, an
+		 * error will be thrown.
+		 */
+		function getArg(aArgs, aName, aDefaultValue) {
+		  if (aName in aArgs) {
+		    return aArgs[aName];
+		  } else if (arguments.length === 3) {
+		    return aDefaultValue;
+		  } else {
+		    throw new Error('"' + aName + '" is a required argument.');
+		  }
+		}
+		exports.getArg = getArg;
+
+		var urlRegexp = /^(?:([\w+\-.]+):)?\/\/(?:(\w+:\w+)@)?([\w.-]*)(?::(\d+))?(.*)$/;
+		var dataUrlRegexp = /^data:.+\,.+$/;
+
+		function urlParse(aUrl) {
+		  var match = aUrl.match(urlRegexp);
+		  if (!match) {
+		    return null;
+		  }
+		  return {
+		    scheme: match[1],
+		    auth: match[2],
+		    host: match[3],
+		    port: match[4],
+		    path: match[5]
+		  };
+		}
+		exports.urlParse = urlParse;
+
+		function urlGenerate(aParsedUrl) {
+		  var url = '';
+		  if (aParsedUrl.scheme) {
+		    url += aParsedUrl.scheme + ':';
+		  }
+		  url += '//';
+		  if (aParsedUrl.auth) {
+		    url += aParsedUrl.auth + '@';
+		  }
+		  if (aParsedUrl.host) {
+		    url += aParsedUrl.host;
+		  }
+		  if (aParsedUrl.port) {
+		    url += ":" + aParsedUrl.port;
+		  }
+		  if (aParsedUrl.path) {
+		    url += aParsedUrl.path;
+		  }
+		  return url;
+		}
+		exports.urlGenerate = urlGenerate;
 
-	/**
-	 * Make a path relative to a URL or another path.
-	 *
-	 * @param aRoot The root path or URL.
-	 * @param aPath The path or URL to be made relative to aRoot.
-	 */
-	function relative(aRoot, aPath) {
-	  if (aRoot === "") {
-	    aRoot = ".";
-	  }
+		/**
+		 * Normalizes a path, or the path portion of a URL:
+		 *
+		 * - Replaces consecutive slashes with one slash.
+		 * - Removes unnecessary '.' parts.
+		 * - Removes unnecessary '<dir>/..' parts.
+		 *
+		 * Based on code in the Node.js 'path' core module.
+		 *
+		 * @param aPath The path or url to normalize.
+		 */
+		function normalize(aPath) {
+		  var path = aPath;
+		  var url = urlParse(aPath);
+		  if (url) {
+		    if (!url.path) {
+		      return aPath;
+		    }
+		    path = url.path;
+		  }
+		  var isAbsolute = exports.isAbsolute(path);
+
+		  var parts = path.split(/\/+/);
+		  for (var part, up = 0, i = parts.length - 1; i >= 0; i--) {
+		    part = parts[i];
+		    if (part === '.') {
+		      parts.splice(i, 1);
+		    } else if (part === '..') {
+		      up++;
+		    } else if (up > 0) {
+		      if (part === '') {
+		        // The first part is blank if the path is absolute. Trying to go
+		        // above the root is a no-op. Therefore we can remove all '..' parts
+		        // directly after the root.
+		        parts.splice(i + 1, up);
+		        up = 0;
+		      } else {
+		        parts.splice(i, 2);
+		        up--;
+		      }
+		    }
+		  }
+		  path = parts.join('/');
+
+		  if (path === '') {
+		    path = isAbsolute ? '/' : '.';
+		  }
+
+		  if (url) {
+		    url.path = path;
+		    return urlGenerate(url);
+		  }
+		  return path;
+		}
+		exports.normalize = normalize;
 
-	  aRoot = aRoot.replace(/\/$/, '');
+		/**
+		 * Joins two paths/URLs.
+		 *
+		 * @param aRoot The root path or URL.
+		 * @param aPath The path or URL to be joined with the root.
+		 *
+		 * - If aPath is a URL or a data URI, aPath is returned, unless aPath is a
+		 *   scheme-relative URL: Then the scheme of aRoot, if any, is prepended
+		 *   first.
+		 * - Otherwise aPath is a path. If aRoot is a URL, then its path portion
+		 *   is updated with the result and aRoot is returned. Otherwise the result
+		 *   is returned.
+		 *   - If aPath is absolute, the result is aPath.
+		 *   - Otherwise the two paths are joined with a slash.
+		 * - Joining for example 'http://' and 'www.example.com' is also supported.
+		 */
+		function join(aRoot, aPath) {
+		  if (aRoot === "") {
+		    aRoot = ".";
+		  }
+		  if (aPath === "") {
+		    aPath = ".";
+		  }
+		  var aPathUrl = urlParse(aPath);
+		  var aRootUrl = urlParse(aRoot);
+		  if (aRootUrl) {
+		    aRoot = aRootUrl.path || '/';
+		  }
+
+		  // `join(foo, '//www.example.org')`
+		  if (aPathUrl && !aPathUrl.scheme) {
+		    if (aRootUrl) {
+		      aPathUrl.scheme = aRootUrl.scheme;
+		    }
+		    return urlGenerate(aPathUrl);
+		  }
+
+		  if (aPathUrl || aPath.match(dataUrlRegexp)) {
+		    return aPath;
+		  }
+
+		  // `join('http://', 'www.example.com')`
+		  if (aRootUrl && !aRootUrl.host && !aRootUrl.path) {
+		    aRootUrl.host = aPath;
+		    return urlGenerate(aRootUrl);
+		  }
+
+		  var joined = aPath.charAt(0) === '/'
+		    ? aPath
+		    : normalize(aRoot.replace(/\/+$/, '') + '/' + aPath);
+
+		  if (aRootUrl) {
+		    aRootUrl.path = joined;
+		    return urlGenerate(aRootUrl);
+		  }
+		  return joined;
+		}
+		exports.join = join;
+
+		exports.isAbsolute = function (aPath) {
+		  return aPath.charAt(0) === '/' || urlRegexp.test(aPath);
+		};
 
-	  // It is possible for the path to be above the root. In this case, simply
-	  // checking whether the root is a prefix of the path won't work. Instead, we
-	  // need to remove components from the root one by one, until either we find
-	  // a prefix that fits, or we run out of components to remove.
-	  var level = 0;
-	  while (aPath.indexOf(aRoot + '/') !== 0) {
-	    var index = aRoot.lastIndexOf("/");
-	    if (index < 0) {
-	      return aPath;
-	    }
+		/**
+		 * Make a path relative to a URL or another path.
+		 *
+		 * @param aRoot The root path or URL.
+		 * @param aPath The path or URL to be made relative to aRoot.
+		 */
+		function relative(aRoot, aPath) {
+		  if (aRoot === "") {
+		    aRoot = ".";
+		  }
 
-	    // If the only part of the root that is left is the scheme (i.e. http://,
-	    // file:///, etc.), one or more slashes (/), or simply nothing at all, we
-	    // have exhausted all components, so the path is not relative to the root.
-	    aRoot = aRoot.slice(0, index);
-	    if (aRoot.match(/^([^\/]+:\/)?\/*$/)) {
-	      return aPath;
-	    }
+		  aRoot = aRoot.replace(/\/$/, '');
 
-	    ++level;
-	  }
+		  // It is possible for the path to be above the root. In this case, simply
+		  // checking whether the root is a prefix of the path won't work. Instead, we
+		  // need to remove components from the root one by one, until either we find
+		  // a prefix that fits, or we run out of components to remove.
+		  var level = 0;
+		  while (aPath.indexOf(aRoot + '/') !== 0) {
+		    var index = aRoot.lastIndexOf("/");
+		    if (index < 0) {
+		      return aPath;
+		    }
 
-	  // Make sure we add a "../" for each component we removed from the root.
-	  return Array(level + 1).join("../") + aPath.substr(aRoot.length + 1);
-	}
-	exports.relative = relative;
+		    // If the only part of the root that is left is the scheme (i.e. http://,
+		    // file:///, etc.), one or more slashes (/), or simply nothing at all, we
+		    // have exhausted all components, so the path is not relative to the root.
+		    aRoot = aRoot.slice(0, index);
+		    if (aRoot.match(/^([^\/]+:\/)?\/*$/)) {
+		      return aPath;
+		    }
 
-	var supportsNullProto = (function () {
-	  var obj = Object.create(null);
-	  return !('__proto__' in obj);
-	}());
+		    ++level;
+		  }
 
-	function identity (s) {
-	  return s;
-	}
+		  // Make sure we add a "../" for each component we removed from the root.
+		  return Array(level + 1).join("../") + aPath.substr(aRoot.length + 1);
+		}
+		exports.relative = relative;
 
-	/**
-	 * Because behavior goes wacky when you set `__proto__` on objects, we
-	 * have to prefix all the strings in our set with an arbitrary character.
-	 *
-	 * See https://github.com/mozilla/source-map/pull/31 and
-	 * https://github.com/mozilla/source-map/issues/30
-	 *
-	 * @param String aStr
-	 */
-	function toSetString(aStr) {
-	  if (isProtoString(aStr)) {
-	    return '$' + aStr;
-	  }
+		var supportsNullProto = (function () {
+		  var obj = Object.create(null);
+		  return !('__proto__' in obj);
+		}());
 
-	  return aStr;
-	}
-	exports.toSetString = supportsNullProto ? identity : toSetString;
+		function identity (s) {
+		  return s;
+		}
 
-	function fromSetString(aStr) {
-	  if (isProtoString(aStr)) {
-	    return aStr.slice(1);
-	  }
+		/**
+		 * Because behavior goes wacky when you set `__proto__` on objects, we
+		 * have to prefix all the strings in our set with an arbitrary character.
+		 *
+		 * See https://github.com/mozilla/source-map/pull/31 and
+		 * https://github.com/mozilla/source-map/issues/30
+		 *
+		 * @param String aStr
+		 */
+		function toSetString(aStr) {
+		  if (isProtoString(aStr)) {
+		    return '$' + aStr;
+		  }
 
-	  return aStr;
-	}
-	exports.fromSetString = supportsNullProto ? identity : fromSetString;
+		  return aStr;
+		}
+		exports.toSetString = supportsNullProto ? identity : toSetString;
 
-	function isProtoString(s) {
-	  if (!s) {
-	    return false;
-	  }
+		function fromSetString(aStr) {
+		  if (isProtoString(aStr)) {
+		    return aStr.slice(1);
+		  }
 
-	  var length = s.length;
+		  return aStr;
+		}
+		exports.fromSetString = supportsNullProto ? identity : fromSetString;
 
-	  if (length < 9 /* "__proto__".length */) {
-	    return false;
-	  }
+		function isProtoString(s) {
+		  if (!s) {
+		    return false;
+		  }
 
-	  if (s.charCodeAt(length - 1) !== 95  /* '_' */ ||
-	      s.charCodeAt(length - 2) !== 95  /* '_' */ ||
-	      s.charCodeAt(length - 3) !== 111 /* 'o' */ ||
-	      s.charCodeAt(length - 4) !== 116 /* 't' */ ||
-	      s.charCodeAt(length - 5) !== 111 /* 'o' */ ||
-	      s.charCodeAt(length - 6) !== 114 /* 'r' */ ||
-	      s.charCodeAt(length - 7) !== 112 /* 'p' */ ||
-	      s.charCodeAt(length - 8) !== 95  /* '_' */ ||
-	      s.charCodeAt(length - 9) !== 95  /* '_' */) {
-	    return false;
-	  }
+		  var length = s.length;
 
-	  for (var i = length - 10; i >= 0; i--) {
-	    if (s.charCodeAt(i) !== 36 /* '$' */) {
-	      return false;
-	    }
-	  }
+		  if (length < 9 /* "__proto__".length */) {
+		    return false;
+		  }
 
-	  return true;
-	}
+		  if (s.charCodeAt(length - 1) !== 95  /* '_' */ ||
+		      s.charCodeAt(length - 2) !== 95  /* '_' */ ||
+		      s.charCodeAt(length - 3) !== 111 /* 'o' */ ||
+		      s.charCodeAt(length - 4) !== 116 /* 't' */ ||
+		      s.charCodeAt(length - 5) !== 111 /* 'o' */ ||
+		      s.charCodeAt(length - 6) !== 114 /* 'r' */ ||
+		      s.charCodeAt(length - 7) !== 112 /* 'p' */ ||
+		      s.charCodeAt(length - 8) !== 95  /* '_' */ ||
+		      s.charCodeAt(length - 9) !== 95  /* '_' */) {
+		    return false;
+		  }
 
-	/**
-	 * Comparator between two mappings where the original positions are compared.
-	 *
-	 * Optionally pass in `true` as `onlyCompareGenerated` to consider two
-	 * mappings with the same original source/line/column, but different generated
-	 * line and column the same. Useful when searching for a mapping with a
-	 * stubbed out mapping.
-	 */
-	function compareByOriginalPositions(mappingA, mappingB, onlyCompareOriginal) {
-	  var cmp = strcmp(mappingA.source, mappingB.source);
-	  if (cmp !== 0) {
-	    return cmp;
-	  }
+		  for (var i = length - 10; i >= 0; i--) {
+		    if (s.charCodeAt(i) !== 36 /* '$' */) {
+		      return false;
+		    }
+		  }
 
-	  cmp = mappingA.originalLine - mappingB.originalLine;
-	  if (cmp !== 0) {
-	    return cmp;
-	  }
+		  return true;
+		}
 
-	  cmp = mappingA.originalColumn - mappingB.originalColumn;
-	  if (cmp !== 0 || onlyCompareOriginal) {
-	    return cmp;
-	  }
+		/**
+		 * Comparator between two mappings where the original positions are compared.
+		 *
+		 * Optionally pass in `true` as `onlyCompareGenerated` to consider two
+		 * mappings with the same original source/line/column, but different generated
+		 * line and column the same. Useful when searching for a mapping with a
+		 * stubbed out mapping.
+		 */
+		function compareByOriginalPositions(mappingA, mappingB, onlyCompareOriginal) {
+		  var cmp = strcmp(mappingA.source, mappingB.source);
+		  if (cmp !== 0) {
+		    return cmp;
+		  }
 
-	  cmp = mappingA.generatedColumn - mappingB.generatedColumn;
-	  if (cmp !== 0) {
-	    return cmp;
-	  }
+		  cmp = mappingA.originalLine - mappingB.originalLine;
+		  if (cmp !== 0) {
+		    return cmp;
+		  }
 
-	  cmp = mappingA.generatedLine - mappingB.generatedLine;
-	  if (cmp !== 0) {
-	    return cmp;
-	  }
+		  cmp = mappingA.originalColumn - mappingB.originalColumn;
+		  if (cmp !== 0 || onlyCompareOriginal) {
+		    return cmp;
+		  }
 
-	  return strcmp(mappingA.name, mappingB.name);
-	}
-	exports.compareByOriginalPositions = compareByOriginalPositions;
+		  cmp = mappingA.generatedColumn - mappingB.generatedColumn;
+		  if (cmp !== 0) {
+		    return cmp;
+		  }
 
-	/**
-	 * Comparator between two mappings with deflated source and name indices where
-	 * the generated positions are compared.
-	 *
-	 * Optionally pass in `true` as `onlyCompareGenerated` to consider two
-	 * mappings with the same generated line and column, but different
-	 * source/name/original line and column the same. Useful when searching for a
-	 * mapping with a stubbed out mapping.
-	 */
-	function compareByGeneratedPositionsDeflated(mappingA, mappingB, onlyCompareGenerated) {
-	  var cmp = mappingA.generatedLine - mappingB.generatedLine;
-	  if (cmp !== 0) {
-	    return cmp;
-	  }
+		  cmp = mappingA.generatedLine - mappingB.generatedLine;
+		  if (cmp !== 0) {
+		    return cmp;
+		  }
 
-	  cmp = mappingA.generatedColumn - mappingB.generatedColumn;
-	  if (cmp !== 0 || onlyCompareGenerated) {
-	    return cmp;
-	  }
+		  return strcmp(mappingA.name, mappingB.name);
+		}
+		exports.compareByOriginalPositions = compareByOriginalPositions;
 
-	  cmp = strcmp(mappingA.source, mappingB.source);
-	  if (cmp !== 0) {
-	    return cmp;
-	  }
+		/**
+		 * Comparator between two mappings with deflated source and name indices where
+		 * the generated positions are compared.
+		 *
+		 * Optionally pass in `true` as `onlyCompareGenerated` to consider two
+		 * mappings with the same generated line and column, but different
+		 * source/name/original line and column the same. Useful when searching for a
+		 * mapping with a stubbed out mapping.
+		 */
+		function compareByGeneratedPositionsDeflated(mappingA, mappingB, onlyCompareGenerated) {
+		  var cmp = mappingA.generatedLine - mappingB.generatedLine;
+		  if (cmp !== 0) {
+		    return cmp;
+		  }
 
-	  cmp = mappingA.originalLine - mappingB.originalLine;
-	  if (cmp !== 0) {
-	    return cmp;
-	  }
+		  cmp = mappingA.generatedColumn - mappingB.generatedColumn;
+		  if (cmp !== 0 || onlyCompareGenerated) {
+		    return cmp;
+		  }
 
-	  cmp = mappingA.originalColumn - mappingB.originalColumn;
-	  if (cmp !== 0) {
-	    return cmp;
-	  }
+		  cmp = strcmp(mappingA.source, mappingB.source);
+		  if (cmp !== 0) {
+		    return cmp;
+		  }
 
-	  return strcmp(mappingA.name, mappingB.name);
-	}
-	exports.compareByGeneratedPositionsDeflated = compareByGeneratedPositionsDeflated;
+		  cmp = mappingA.originalLine - mappingB.originalLine;
+		  if (cmp !== 0) {
+		    return cmp;
+		  }
 
-	function strcmp(aStr1, aStr2) {
-	  if (aStr1 === aStr2) {
-	    return 0;
-	  }
+		  cmp = mappingA.originalColumn - mappingB.originalColumn;
+		  if (cmp !== 0) {
+		    return cmp;
+		  }
 
-	  if (aStr1 === null) {
-	    return 1; // aStr2 !== null
-	  }
+		  return strcmp(mappingA.name, mappingB.name);
+		}
+		exports.compareByGeneratedPositionsDeflated = compareByGeneratedPositionsDeflated;
 
-	  if (aStr2 === null) {
-	    return -1; // aStr1 !== null
-	  }
+		function strcmp(aStr1, aStr2) {
+		  if (aStr1 === aStr2) {
+		    return 0;
+		  }
 
-	  if (aStr1 > aStr2) {
-	    return 1;
-	  }
+		  if (aStr1 === null) {
+		    return 1; // aStr2 !== null
+		  }
 
-	  return -1;
-	}
+		  if (aStr2 === null) {
+		    return -1; // aStr1 !== null
+		  }
 
-	/**
-	 * Comparator between two mappings with inflated source and name strings where
-	 * the generated positions are compared.
-	 */
-	function compareByGeneratedPositionsInflated(mappingA, mappingB) {
-	  var cmp = mappingA.generatedLine - mappingB.generatedLine;
-	  if (cmp !== 0) {
-	    return cmp;
-	  }
+		  if (aStr1 > aStr2) {
+		    return 1;
+		  }
 
-	  cmp = mappingA.generatedColumn - mappingB.generatedColumn;
-	  if (cmp !== 0) {
-	    return cmp;
-	  }
+		  return -1;
+		}
 
-	  cmp = strcmp(mappingA.source, mappingB.source);
-	  if (cmp !== 0) {
-	    return cmp;
-	  }
+		/**
+		 * Comparator between two mappings with inflated source and name strings where
+		 * the generated positions are compared.
+		 */
+		function compareByGeneratedPositionsInflated(mappingA, mappingB) {
+		  var cmp = mappingA.generatedLine - mappingB.generatedLine;
+		  if (cmp !== 0) {
+		    return cmp;
+		  }
 
-	  cmp = mappingA.originalLine - mappingB.originalLine;
-	  if (cmp !== 0) {
-	    return cmp;
-	  }
+		  cmp = mappingA.generatedColumn - mappingB.generatedColumn;
+		  if (cmp !== 0) {
+		    return cmp;
+		  }
 
-	  cmp = mappingA.originalColumn - mappingB.originalColumn;
-	  if (cmp !== 0) {
-	    return cmp;
-	  }
+		  cmp = strcmp(mappingA.source, mappingB.source);
+		  if (cmp !== 0) {
+		    return cmp;
+		  }
 
-	  return strcmp(mappingA.name, mappingB.name);
-	}
-	exports.compareByGeneratedPositionsInflated = compareByGeneratedPositionsInflated;
+		  cmp = mappingA.originalLine - mappingB.originalLine;
+		  if (cmp !== 0) {
+		    return cmp;
+		  }
 
-	/**
-	 * Strip any JSON XSSI avoidance prefix from the string (as documented
-	 * in the source maps specification), and then parse the string as
-	 * JSON.
-	 */
-	function parseSourceMapInput(str) {
-	  return JSON.parse(str.replace(/^\)]}'[^\n]*\n/, ''));
-	}
-	exports.parseSourceMapInput = parseSourceMapInput;
+		  cmp = mappingA.originalColumn - mappingB.originalColumn;
+		  if (cmp !== 0) {
+		    return cmp;
+		  }
 
-	/**
-	 * Compute the URL of a source given the the source root, the source's
-	 * URL, and the source map's URL.
-	 */
-	function computeSourceURL(sourceRoot, sourceURL, sourceMapURL) {
-	  sourceURL = sourceURL || '';
-
-	  if (sourceRoot) {
-	    // This follows what Chrome does.
-	    if (sourceRoot[sourceRoot.length - 1] !== '/' && sourceURL[0] !== '/') {
-	      sourceRoot += '/';
-	    }
-	    // The spec says:
-	    //   Line 4: An optional source root, useful for relocating source
-	    //   files on a server or removing repeated values in the
-	    //   “sources” entry.  This value is prepended to the individual
-	    //   entries in the “source” field.
-	    sourceURL = sourceRoot + sourceURL;
-	  }
+		  return strcmp(mappingA.name, mappingB.name);
+		}
+		exports.compareByGeneratedPositionsInflated = compareByGeneratedPositionsInflated;
 
-	  // Historically, SourceMapConsumer did not take the sourceMapURL as
-	  // a parameter.  This mode is still somewhat supported, which is why
-	  // this code block is conditional.  However, it's preferable to pass
-	  // the source map URL to SourceMapConsumer, so that this function
-	  // can implement the source URL resolution algorithm as outlined in
-	  // the spec.  This block is basically the equivalent of:
-	  //    new URL(sourceURL, sourceMapURL).toString()
-	  // ... except it avoids using URL, which wasn't available in the
-	  // older releases of node still supported by this library.
-	  //
-	  // The spec says:
-	  //   If the sources are not absolute URLs after prepending of the
-	  //   “sourceRoot”, the sources are resolved relative to the
-	  //   SourceMap (like resolving script src in a html document).
-	  if (sourceMapURL) {
-	    var parsed = urlParse(sourceMapURL);
-	    if (!parsed) {
-	      throw new Error("sourceMapURL could not be parsed");
-	    }
-	    if (parsed.path) {
-	      // Strip the last path component, but keep the "/".
-	      var index = parsed.path.lastIndexOf('/');
-	      if (index >= 0) {
-	        parsed.path = parsed.path.substring(0, index + 1);
-	      }
-	    }
-	    sourceURL = join(urlGenerate(parsed), sourceURL);
-	  }
+		/**
+		 * Strip any JSON XSSI avoidance prefix from the string (as documented
+		 * in the source maps specification), and then parse the string as
+		 * JSON.
+		 */
+		function parseSourceMapInput(str) {
+		  return JSON.parse(str.replace(/^\)]}'[^\n]*\n/, ''));
+		}
+		exports.parseSourceMapInput = parseSourceMapInput;
 
-	  return normalize(sourceURL);
-	}
-	exports.computeSourceURL = computeSourceURL;
-	}(util$3));
+		/**
+		 * Compute the URL of a source given the the source root, the source's
+		 * URL, and the source map's URL.
+		 */
+		function computeSourceURL(sourceRoot, sourceURL, sourceMapURL) {
+		  sourceURL = sourceURL || '';
+
+		  if (sourceRoot) {
+		    // This follows what Chrome does.
+		    if (sourceRoot[sourceRoot.length - 1] !== '/' && sourceURL[0] !== '/') {
+		      sourceRoot += '/';
+		    }
+		    // The spec says:
+		    //   Line 4: An optional source root, useful for relocating source
+		    //   files on a server or removing repeated values in the
+		    //   “sources” entry.  This value is prepended to the individual
+		    //   entries in the “source” field.
+		    sourceURL = sourceRoot + sourceURL;
+		  }
+
+		  // Historically, SourceMapConsumer did not take the sourceMapURL as
+		  // a parameter.  This mode is still somewhat supported, which is why
+		  // this code block is conditional.  However, it's preferable to pass
+		  // the source map URL to SourceMapConsumer, so that this function
+		  // can implement the source URL resolution algorithm as outlined in
+		  // the spec.  This block is basically the equivalent of:
+		  //    new URL(sourceURL, sourceMapURL).toString()
+		  // ... except it avoids using URL, which wasn't available in the
+		  // older releases of node still supported by this library.
+		  //
+		  // The spec says:
+		  //   If the sources are not absolute URLs after prepending of the
+		  //   “sourceRoot”, the sources are resolved relative to the
+		  //   SourceMap (like resolving script src in a html document).
+		  if (sourceMapURL) {
+		    var parsed = urlParse(sourceMapURL);
+		    if (!parsed) {
+		      throw new Error("sourceMapURL could not be parsed");
+		    }
+		    if (parsed.path) {
+		      // Strip the last path component, but keep the "/".
+		      var index = parsed.path.lastIndexOf('/');
+		      if (index >= 0) {
+		        parsed.path = parsed.path.substring(0, index + 1);
+		      }
+		    }
+		    sourceURL = join(urlGenerate(parsed), sourceURL);
+		  }
+
+		  return normalize(sourceURL);
+		}
+		exports.computeSourceURL = computeSourceURL; 
+	} (util$3));
 
 	var arraySet = {};
 
@@ -11184,7 +11246,7 @@
 	    }
 	}
 
-	var create$3 = function createGenerator(config) {
+	var create$2 = function createGenerator(config) {
 	    function processNode(node) {
 	        if (hasOwnProperty$4.call(types, node.type)) {
 	            types[node.type].call(this, node);
@@ -11232,7 +11294,7 @@
 
 	var List$2 = List_1;
 
-	var create$2 = function createConvertors(walk) {
+	var create$1 = function createConvertors(walk) {
 	    return {
 	        fromPlainObject: function(ast) {
 	            walk(ast, {
@@ -11404,7 +11466,7 @@
 	    };
 	}
 
-	var create$1 = function createWalker(config) {
+	var create = function createWalker(config) {
 	    var types = getTypesFromConfig(config);
 	    var iteratorsNatural = {};
 	    var iteratorsReverse = {};
@@ -11713,10 +11775,10 @@
 	var Lexer = Lexer_1;
 	var definitionSyntax = definitionSyntax$1;
 	var tokenize = tokenizer$3;
-	var createParser = create$4;
-	var createGenerator = create$3;
-	var createConvertor = create$2;
-	var createWalker = create$1;
+	var createParser = create$3;
+	var createGenerator = create$2;
+	var createConvertor = create$1;
+	var createWalker = create;
 	var clone = clone$1;
 	var names = names$2;
 	var mix = mix_1;
@@ -11780,7 +11842,7 @@
 
 	    return syntax;
 	}
-	create$5.create = function(config) {
+	create$4.create = function(config) {
 	    return createSyntax(mix({}, config));
 	};
 
@@ -26353,7 +26415,7 @@
 	    return dest;
 	}
 
-	syntax.exports = create$5.create(
+	syntax.exports = create$4.create(
 	    merge(
 	        lexer,
 	        parser,
@@ -26362,7 +26424,11 @@
 	);
 	syntax.exports.version = require$$4.version;
 
-	var lib = syntax.exports;
+	var syntaxExports = syntax.exports;
+
+	var lib = syntaxExports;
+
+	var csstree = /*@__PURE__*/getDefaultExportFromCjs(lib);
 
 	class Sheet {
 		constructor(url, hooks) {
@@ -26403,7 +26469,7 @@
 			await this.hooks.beforeTreeParse.trigger(this.text, this);
 
 			// send to csstree
-			this.ast = lib.parse(this._text);
+			this.ast = csstree.parse(this._text);
 
 			await this.hooks.beforeTreeWalk.trigger(this.ast);
 
@@ -26441,7 +26507,7 @@
 		}
 
 		urls(ast) {
-			lib.walk(ast, {
+			csstree.walk(ast, {
 				visit: "Url",
 				enter: (node, item, list) => {
 					this.hooks.onUrl.trigger(node, item, list);
@@ -26450,10 +26516,10 @@
 		}
 
 		atrules(ast) {
-			lib.walk(ast, {
+			csstree.walk(ast, {
 				visit: "Atrule",
 				enter: (node, item, list) => {
-					const basename = lib.keyword(node.name).basename;
+					const basename = csstree.keyword(node.name).basename;
 
 					if (basename === "page") {
 						this.hooks.onAtPage.trigger(node, item, list);
@@ -26475,7 +26541,7 @@
 
 
 		rules(ast) {
-			lib.walk(ast, {
+			csstree.walk(ast, {
 				visit: "Rule",
 				enter: (ruleNode, ruleItem, rulelist) => {
 
@@ -26488,14 +26554,14 @@
 		}
 
 		declarations(ruleNode, ruleItem, rulelist) {
-			lib.walk(ruleNode, {
+			csstree.walk(ruleNode, {
 				visit: "Declaration",
 				enter: (declarationNode, dItem, dList) => {
 
 					this.hooks.onDeclaration.trigger(declarationNode, dItem, dList, {ruleNode, ruleItem, rulelist});
 
 					if (declarationNode.property === "content") {
-						lib.walk(declarationNode, {
+						csstree.walk(declarationNode, {
 							visit: "Function",
 							enter: (funcNode, fItem, fList) => {
 								this.hooks.onContent.trigger(funcNode, fItem, fList, {declarationNode, dItem, dList}, {ruleNode, ruleItem, rulelist});
@@ -26509,13 +26575,13 @@
 
 		// add pseudo elements to parser
 		onSelector(ruleNode, ruleItem, rulelist) {
-			lib.walk(ruleNode, {
+			csstree.walk(ruleNode, {
 				visit: "Selector",
 				enter: (selectNode, selectItem, selectList) => {
 					this.hooks.onSelector.trigger(selectNode, selectItem, selectList, {ruleNode, ruleItem, rulelist});
 
 					if (selectNode.children.forEach(node => {if (node.type === "PseudoElementSelector") {
-						lib.walk(node, {
+						csstree.walk(node, {
 							visit: "PseudoElementSelector",
 							enter: (pseudoNode, pItem, pList) => {
 								this.hooks.onPseudoSelector.trigger(pseudoNode, pItem, pList, {selectNode, selectItem, selectList}, {ruleNode, ruleItem, rulelist});
@@ -26527,7 +26593,7 @@
 		}
 
 		replaceUrls(ast) {
-			lib.walk(ast, {
+			csstree.walk(ast, {
 				visit: "Url",
 				enter: (node, item, list) => {
 					let content = node.value.value;
@@ -26543,7 +26609,7 @@
 		addScope(ast, id) {
 			// Get all selector lists
 			// add an id
-			lib.walk(ast, {
+			csstree.walk(ast, {
 				visit: "Selector",
 				enter: (node, item, list) => {
 					let children = node.children;
@@ -26563,16 +26629,16 @@
 
 		getNamedPageSelectors(ast) {
 			let namedPageSelectors = {};
-			lib.walk(ast, {
+			csstree.walk(ast, {
 				visit: "Rule",
 				enter: (node, item, list) => {
-					lib.walk(node, {
+					csstree.walk(node, {
 						visit: "Declaration",
 						enter: (declaration, dItem, dList) => {
 							if (declaration.property === "page") {
 								let value = declaration.value.children.first();
 								let name = value.name;
-								let selector = lib.generate(node.prelude);
+								let selector = csstree.generate(node.prelude);
 								namedPageSelectors[name] = {
 									name: name,
 									selector: selector
@@ -26594,11 +26660,11 @@
 		}
 
 		replaceIds(ast) {
-			lib.walk(ast, {
+			csstree.walk(ast, {
 				visit: "Rule",
 				enter: (node, item, list) => {
 
-					lib.walk(node, {
+					csstree.walk(node, {
 						visit: "IdSelector",
 						enter: (idNode, idItem, idList) => {
 							let name = idNode.name;
@@ -26616,10 +26682,10 @@
 		imports(node, item, list) {
 			// console.log("import", node, item, list);
 			let queries = [];
-			lib.walk(node, {
+			csstree.walk(node, {
 				visit: "MediaQuery",
 				enter: (mqNode, mqItem, mqList) => {
-					lib.walk(mqNode, {
+					csstree.walk(mqNode, {
 						visit: "Identifier",
 						enter: (identNode, identItem, identList) => {
 							queries.push(identNode.name);
@@ -26643,7 +26709,7 @@
 				return;
 			}
 
-			lib.walk(node, {
+			csstree.walk(node, {
 				visit: "String",
 				enter: (urlNode, urlItem, urlList) => {
 					let href = urlNode.value.replace(/["']/g, "");
@@ -26668,7 +26734,7 @@
 
 		// generate string
 		toString(ast) {
-			return lib.generate(ast || this.ast);
+			return csstree.generate(ast || this.ast);
 		}
 	}
 
@@ -27116,13 +27182,20 @@
 	counter-reset: unset;
 }
 
-[data-footnote-marker]:not([data-split-from]) {
-	counter-increment: footnote-marker;
+[data-footnote-marker] {
 	text-indent: 0;
 	display: list-item;
 	list-style-position: inside;
 }
 
+[data-footnote-marker][data-split-from] {
+	list-style: none;
+}
+
+[data-footnote-marker]:not([data-split-from]) {
+	counter-increment: footnote-marker;
+}
+
 [data-footnote-marker]::marker {
 	content: counter(footnote-marker) ". ";
 }
@@ -27758,7 +27831,7 @@
 				named = this.getTypeSelector(node);
 				psuedo = this.getPsuedoSelector(node);
 				nth = this.getNthSelector(node);
-				selector = lib.generate(node.prelude);
+				selector = csstree.generate(node.prelude);
 			} else {
 				selector = "*";
 			}
@@ -27935,7 +28008,7 @@
 			// Find page name
 			let name;
 
-			lib.walk(ast, {
+			csstree.walk(ast, {
 				visit: "TypeSelector",
 				enter: (node, item, list) => {
 					name = node.name;
@@ -27948,7 +28021,7 @@
 		getPsuedoSelector(ast) {
 			// Find if it has :left & :right & :black & :first
 			let name;
-			lib.walk(ast, {
+			csstree.walk(ast, {
 				visit: "PseudoClassSelector",
 				enter: (node, item, list) => {
 					if (node.name !== "nth") {
@@ -27963,7 +28036,7 @@
 		getNthSelector(ast) {
 			// Find if it has :nth
 			let nth;
-			lib.walk(ast, {
+			csstree.walk(ast, {
 				visit: "PseudoClassSelector",
 				enter: (node, item, list) => {
 					if (node.name === "nth" && node.children) {
@@ -27984,7 +28057,7 @@
 				"left-top", "left-middle", "left", "left-bottom", "top-right-corner",
 				"right-top", "right-middle", "right", "right-bottom", "right-right-corner"
 			];
-			lib.walk(ast.block, {
+			csstree.walk(ast.block, {
 				visit: "Atrule",
 				enter: (node, item, list) => {
 					let name = node.name;
@@ -28013,7 +28086,7 @@
 		replaceNotes(ast) {
 			let parsed = {};
 
-			lib.walk(ast.block, {
+			csstree.walk(ast.block, {
 				visit: "Atrule",
 				enter: (node, item, list) => {
 					let name = node.name;
@@ -28030,15 +28103,15 @@
 		replaceDeclarations(ast) {
 			let parsed = {};
 
-			lib.walk(ast.block, {
+			csstree.walk(ast.block, {
 				visit: "Declaration",
 				enter: (declaration, dItem, dList) => {
-					let prop = lib.property(declaration.property).name;
+					let prop = csstree.property(declaration.property).name;
 					// let value = declaration.value;
 
 					if (prop === "marks") {
 						parsed.marks = [];
-						lib.walk(declaration, {
+						csstree.walk(declaration, {
 							visit: "Identifier",
 							enter: (ident) => {
 								parsed.marks.push(ident.name);
@@ -28089,10 +28162,10 @@
 								bottom: {}
 							};
 						}
-						parsed.border.top = lib.generate(declaration.value);
-						parsed.border.right = lib.generate(declaration.value);
-						parsed.border.left = lib.generate(declaration.value);
-						parsed.border.bottom = lib.generate(declaration.value);
+						parsed.border.top = csstree.generate(declaration.value);
+						parsed.border.right = csstree.generate(declaration.value);
+						parsed.border.left = csstree.generate(declaration.value);
+						parsed.border.bottom = csstree.generate(declaration.value);
 
 						dList.remove(dItem);
 
@@ -28109,7 +28182,7 @@
 						}
 						let p = prop.substring("border-".length);
 
-						parsed.border[p] = lib.generate(declaration.value);
+						parsed.border[p] = csstree.generate(declaration.value);
 						dList.remove(dItem);
 
 					}
@@ -28120,7 +28193,7 @@
 					} else if (prop === "bleed") {
 						parsed.bleed = [];
 
-						lib.walk(declaration, {
+						csstree.walk(declaration, {
 							enter: (subNode) => {
 								switch (subNode.type) {
 									case "String": // bleed: "auto"
@@ -28159,7 +28232,7 @@
 			let width, height, orientation, format;
 
 			// Get size: Xmm Ymm
-			lib.walk(declaration, {
+			csstree.walk(declaration, {
 				visit: "Dimension",
 				enter: (node, item, list) => {
 					let { value, unit } = node;
@@ -28172,7 +28245,7 @@
 			});
 
 			// Get size: "A4"
-			lib.walk(declaration, {
+			csstree.walk(declaration, {
 				visit: "String",
 				enter: (node, item, list) => {
 					let name = node.value.replace(/["|']/g, "");
@@ -28185,7 +28258,7 @@
 			});
 
 			// Get Format or Landscape or Portrait
-			lib.walk(declaration, {
+			csstree.walk(declaration, {
 				visit: "Identifier",
 				enter: (node, item, list) => {
 					let name = node.name;
@@ -28219,7 +28292,7 @@
 				bottom: {}
 			};
 
-			lib.walk(declaration, {
+			csstree.walk(declaration, {
 				enter: (node) => {
 					switch (node.type) {
 						case "Dimension": // margin: 1in 2in, margin: 20px, etc...
@@ -28266,7 +28339,7 @@
 				bottom: {}
 			};
 
-			lib.walk(declaration, {
+			csstree.walk(declaration, {
 				enter: (node) => {
 					switch (node.type) {
 						case "Dimension": // padding: 1in 2in, padding: 20px, etc...
@@ -28315,25 +28388,25 @@
 			};
 
 			if (declaration.prop == "border") {
-				border.top = lib.generate(declaration.value);
-				border.right = lib.generate(declaration.value);
-				border.bottom = lib.generate(declaration.value);
-				border.left = lib.generate(declaration.value);
+				border.top = csstree.generate(declaration.value);
+				border.right = csstree.generate(declaration.value);
+				border.bottom = csstree.generate(declaration.value);
+				border.left = csstree.generate(declaration.value);
 
 			}
 			else if (declaration.prop == "border-top") {
-				border.top = lib.generate(declaration.value);
+				border.top = csstree.generate(declaration.value);
 			}
 			else if (declaration.prop == "border-right") {
-				border.right = lib.generate(declaration.value);
+				border.right = csstree.generate(declaration.value);
 
 			}
 			else if (declaration.prop == "border-bottom") {
-				border.bottom = lib.generate(declaration.value);
+				border.bottom = csstree.generate(declaration.value);
 
 			}
 			else if (declaration.prop == "border-left") {
-				border.left = lib.generate(declaration.value);
+				border.left = csstree.generate(declaration.value);
 			}
 
 			return border;
@@ -28509,14 +28582,14 @@
 
 		addMarginaliaStyles(page, list, item, sheet) {
 			for (let loc in page.marginalia) {
-				let block = lib.clone(page.marginalia[loc]);
+				let block = csstree.clone(page.marginalia[loc]);
 				let hasContent = false;
 
 				if (block.children.isEmpty()) {
 					continue;
 				}
 
-				lib.walk(block, {
+				csstree.walk(block, {
 					visit: "Declaration",
 					enter: (node, item, list) => {
 						if (node.property === "content") {
@@ -28528,7 +28601,7 @@
 							list.remove(item);
 						}
 						if (node.property === "vertical-align") {
-							lib.walk(node, {
+							csstree.walk(node, {
 								visit: "Identifier",
 								enter: (identNode, identItem, identlist) => {
 									let name = identNode.name;
@@ -28551,7 +28624,7 @@
 								loc === "bottom-left" ||
 								loc === "bottom-center" ||
 								loc === "bottom-right")) {
-							let c = lib.clone(node);
+							let c = csstree.clone(node);
 							c.property = "max-width";
 							list.appendData(c);
 						}
@@ -28563,7 +28636,7 @@
 								loc === "right-top" ||
 								loc === "right-middle" ||
 								loc === "right-bottom")) {
-							let c = lib.clone(node);
+							let c = csstree.clone(node);
 							c.property = "max-height";
 							list.appendData(c);
 						}
@@ -28575,7 +28648,7 @@
 
 				list.appendData(marginRule);
 
-				let sel = lib.generate({
+				let sel = csstree.generate({
 					type: "Selector",
 					children: marginSelectors
 				});
@@ -28594,8 +28667,8 @@
 			let displayNone;
 			// Just content
 			for (let loc in page.marginalia) {
-				let content = lib.clone(page.marginalia[loc]);
-				lib.walk(content, {
+				let content = csstree.clone(page.marginalia[loc]);
+				csstree.walk(content, {
 					visit: "Declaration",
 					enter: (node, item, list) => {
 						if (node.property !== "content") {
@@ -28670,7 +28743,7 @@
 
 		addRootVars(ast, width, height, orientation, bleed, bleedrecto, bleedverso, marks) {
 			let rules = [];
-			let selectors = new lib.List();
+			let selectors = new csstree.List();
 			selectors.insertData({
 				type: "PseudoClassSelector",
 				name: "root",
@@ -28821,16 +28894,16 @@
 		*/
 		addRootPage(ast, size, bleed, bleedrecto, bleedverso) {
 			let { width, height, orientation, format } = size;
-			let children = new lib.List();
-			let childrenLeft = new lib.List();
-			let childrenRight = new lib.List();
-			let dimensions = new lib.List();
-			let dimensionsLeft = new lib.List();
-			let dimensionsRight = new lib.List();
+			let children = new csstree.List();
+			let childrenLeft = new csstree.List();
+			let childrenRight = new csstree.List();
+			let dimensions = new csstree.List();
+			let dimensionsLeft = new csstree.List();
+			let dimensionsRight = new csstree.List();
 
 			if (bleed) {
-				let widthCalculations = new lib.List();
-				let heightCalculations = new lib.List();
+				let widthCalculations = new csstree.List();
+				let heightCalculations = new csstree.List();
 
 				// width
 				widthCalculations.appendData({
@@ -29049,8 +29122,8 @@
 			ast.children.append(rule);
 
 			if (bleedverso) {
-				let widthCalculationsLeft = new lib.List();
-				let heightCalculationsLeft = new lib.List();
+				let widthCalculationsLeft = new csstree.List();
+				let heightCalculationsLeft = new csstree.List();
 
 				// width
 				widthCalculationsLeft.appendData({
@@ -29193,8 +29266,8 @@
 			}
 
 			if (bleedrecto) {
-				let widthCalculationsRight = new lib.List();
-				let heightCalculationsRight = new lib.List();
+				let widthCalculationsRight = new csstree.List();
+				let heightCalculationsRight = new csstree.List();
 
 				// width
 				widthCalculationsRight.appendData({
@@ -29675,7 +29748,7 @@
 			let nthlist;
 			let nth;
 
-			let selectors = new lib.List();
+			let selectors = new csstree.List();
 
 			selectors.insertData({
 				type: "ClassSelector",
@@ -29712,7 +29785,7 @@
 
 			// Nth
 			if (page.nth) {
-				nthlist = new lib.List();
+				nthlist = new csstree.List();
 				nth = this.getNth(page.nth);
 
 				nthlist.insertData(nth);
@@ -29744,7 +29817,7 @@
 		}
 
 		createDeclaration(property, value, important) {
-			let children = new lib.List();
+			let children = new csstree.List();
 
 			children.insertData({
 				type: "Identifier",
@@ -29778,8 +29851,8 @@
 		}
 
 		createCalculatedDimension(property, items, important, operator = "+") {
-			let children = new lib.List();
-			let calculations = new lib.List();
+			let children = new csstree.List();
+			let calculations = new csstree.List();
 
 			items.forEach((item, index) => {
 				calculations.appendData({
@@ -29827,7 +29900,7 @@
 		}
 
 		createDimension(property, cssValue, important) {
-			let children = new lib.List();
+			let children = new csstree.List();
 
 			children.insertData({
 				type: "Dimension",
@@ -29850,7 +29923,7 @@
 		}
 
 		createBlock(declarations) {
-			let block = new lib.List();
+			let block = new csstree.List();
 
 			declarations.forEach((declaration) => {
 				block.insertData(declaration);
@@ -29864,7 +29937,7 @@
 		}
 
 		createRule(selectors, block) {
-			let selectorList = new lib.List();
+			let selectorList = new csstree.List();
 			selectorList.insertData({
 				type: "Selector",
 				children: selectors
@@ -29899,7 +29972,7 @@
 			if (property === "page") {
 				let children = declaration.value.children.first();
 				let value = children.name;
-				let selector = lib.generate(rule.ruleNode.prelude);
+				let selector = csstree.generate(rule.ruleNode.prelude);
 				let name = value;
 
 				let breaker = {
@@ -29927,7 +30000,7 @@
 			) {
 				let child = declaration.value.children.first();
 				let value = child.name;
-				let selector = lib.generate(rule.ruleNode.prelude);
+				let selector = csstree.generate(rule.ruleNode.prelude);
 
 				if (property === "page-break-before") {
 					property = "break-before";
@@ -30105,7 +30178,7 @@
 				return;
 			}
 
-			lib.walk(node.prelude, {
+			csstree.walk(node.prelude, {
 				visit: "Identifier",
 				enter: (identNode, iItem, iList) => {
 					media.push(identNode.name);
@@ -30247,7 +30320,7 @@
 						value = parseInt(number.data.value);
 					}
 
-					let selector = lib.generate(rule.ruleNode.prelude);
+					let selector = csstree.generate(rule.ruleNode.prelude);
 
 					let counter;
 					if (!(name in this.counters)) {
@@ -30277,7 +30350,6 @@
 		}
 
 		handleReset(declaration, rule) {
-			let resets = [];
 			let children = declaration.value.children;
 
 			children.forEach((data, item) => {
@@ -30287,9 +30359,20 @@
 					if (item.next && item.next.data.type === "WhiteSpace") {
 						whitespace = item.next;
 					}
-					if (whitespace && whitespace.next && whitespace.next.data.type === "Number") {
-						number = whitespace.next;
-						value = parseInt(number.data.value);
+					if (whitespace && whitespace.next) {
+						if (whitespace.next.data.type === "Number") {
+							// The counter reset value is specified using a number. E.g. counter-reset: c2 5;
+							number = whitespace.next;
+							value = parseInt(number.data.value);
+						} else if (whitespace.next.data.type === "Function" && whitespace.next.data.name === "var") {
+							// The counter reset value is specified using a CSS variable (custom property).
+							// E.g. counter-reset: c2 var(--my-variable);
+							// See https://developer.mozilla.org/en-US/docs/Web/CSS/var
+							number = whitespace.next;
+							// Use the variable name (e.g. '--my-variable') as value for now. The actual value is resolved later by the
+							// processCounterResets function.
+							value = whitespace.next.data.children.head.data.name;
+						}
 					}
 
 					let counter;
@@ -30299,7 +30382,7 @@
 					if (rule.ruleNode.type === "Atrule" && rule.ruleNode.name === "page") {
 						selector = ".pagedjs_page";
 					} else {
-						selector = lib.generate(prelude || rule.ruleNode);
+						selector = csstree.generate(prelude || rule.ruleNode);
 					}
 
 					if (name === "footnote") {
@@ -30318,7 +30401,6 @@
 					};
 
 					counter.resets[selector] = reset;
-					resets.push(reset);
 
 					if (selector !== ".pagedjs_page") {
 						// Remove the parsed resets
@@ -30332,8 +30414,6 @@
 					}
 				}
 			});
-
-			return resets;
 		}
 
 		processCounters(parsed, counters) {
@@ -30389,7 +30469,19 @@
 				let resetElements = parsed.querySelectorAll(reset.selector);
 				// Add counter data
 				for (var i = 0; i < resetElements.length; i++) {
-					resetElements[i].setAttribute("data-counter-"+ counter.name +"-reset", reset.number);
+					let value = reset.number;
+					if (typeof value === "string" && value.startsWith("--")) {
+						// The value is specified using a CSS variable (custom property).
+						// FIXME: We get the variable value only from the inline style of the element because at this point the
+						// element is detached and thus using:
+						//
+						//		getComputedStyle(resetElements[i]).getPropertyValue(value)
+						//
+						// always returns an empty string. We could try to temporarily attach the element to get its computed style,
+						// but for now using the inline style is enough for us.
+						value = resetElements[i].style.getPropertyValue(value) || 0;
+					}
+					resetElements[i].setAttribute("data-counter-"+ counter.name +"-reset", value);
 					if (resetElements[i].getAttribute("data-counter-reset")) {
 						resetElements[i].setAttribute("data-counter-reset", resetElements[i].getAttribute("data-counter-reset") + " " + counter.name);
 					} else {
@@ -30451,7 +30543,7 @@
 
 		addFootnoteMarkerCounter(list) {
 			let markers = [];
-			lib.walk(list, {
+			csstree.walk(list, {
 				visit: "Identifier",
 				enter: (identNode, iItem, iList) => {
 					markers.push(identNode.name);
@@ -30488,22 +30580,40 @@
 			if (!element || !incrementArray || incrementArray.length === 0) return;
 
 			const ref = element.dataset.ref;
-			const prevIncrements = Array.from(this.styleSheet.cssRules).filter((rule) => {
+			const increments = Array.from(this.styleSheet.cssRules).filter((rule) => {
 				return rule.selectorText === `[data-ref="${element.dataset.ref}"]:not([data-split-from])`
 							 && rule.style[0] === "counter-increment";
-			});
+			}).map(rule => rule.style.counterIncrement);
+
+			// Merge the current increments by summing the values because we generate both a decrement and an increment when the
+			// element resets and increments the counter at the same time. E.g. ['c1 -7', 'c1 1'] should lead to 'c1 -6'.
+			increments.push(this.mergeIncrements(incrementArray,
+				(prev, next) => (parseInt(prev) || 0) + (parseInt(next) || 0)));
+
+			// Keep the last value for each counter when merging with the previous increments. E.g. ['c1 -7 c2 3', 'c1 1']
+			// should lead to 'c1 1 c2 3'.
+			const counterIncrement = this.mergeIncrements(increments, (prev, next) => next);
+			this.insertRule(`[data-ref="${ref}"]:not([data-split-from]) { counter-increment: ${counterIncrement} }`);
+		}
 
-			const increments = [];
-			for (let styleRule of prevIncrements) {
-				let values = styleRule.style.counterIncrement.split(" ");
+		/**
+		 * Merge multiple values of a counter-increment CSS rule, using the specified operator.
+		 *
+		 * @param {Array} incrementArray the values to merge, e.g. ['c1 1', 'c1 -7 c2 1']
+		 * @param {Function} operator the function used to merge counter values (e.g. keep the last value of a counter or sum
+		 *					the counter values)
+		 * @return {string} the merged value of the counter-increment CSS rule
+		 */
+		mergeIncrements(incrementArray, operator) {
+			const increments = {};
+			incrementArray.forEach(increment => {
+				let values = increment.split(" ");
 				for (let i = 0; i < values.length; i+=2) {
-					increments.push(values[i] + " " + values[i+1]);
+					increments[values[i]] = operator(increments[values[i]], values[i + 1]);
 				}
-			}
-
-			Array.prototype.push.apply(increments, incrementArray);
+			});
 
-			this.insertRule(`[data-ref="${ref}"]:not([data-split-from]) { counter-increment: ${increments.join(" ")} }`);
+			return Object.entries(increments).map(([key, value]) => `${key} ${value}`).join(" ");
 		}
 
 		afterPageLayout(pageElement, page) {
@@ -30582,7 +30692,7 @@
 
 		onDeclaration(declaration, dItem, dList, rule) {
 			if (declaration.property === "position" && declaration.value.children.first().name === "fixed") {
-				let selector = lib.generate(rule.ruleNode.prelude);
+				let selector = csstree.generate(rule.ruleNode.prelude);
 				this.fixedElementsSelector.push(selector);
 				dList.remove(dItem);
 			}
@@ -30654,7 +30764,7 @@
 			if (rule.ruleNode.name === "page" && rule.ruleNode.type === "Atrule") {
 				return;
 			}
-			const selector = lib.generate(rule.ruleNode.prelude);
+			const selector = csstree.generate(rule.ruleNode.prelude);
 			return this.pageCounter.increments[selector] = {
 				selector: selector,
 				number
@@ -30675,10 +30785,10 @@
 		}
 
 		onRule(ruleNode, ruleItem, rulelist) {
-			let selector = lib.generate(ruleNode.prelude);
+			let selector = csstree.generate(ruleNode.prelude);
 			if (selector.match(/:(first|last|nth)-of-type/)) {
 				
-				let declarations = lib.generate(ruleNode.block);
+				let declarations = csstree.generate(ruleNode.block);
 				declarations = declarations.replace(/[{}]/g,"");
 
 				let uuid = "nth-of-type-" + UUID();
@@ -30730,10 +30840,10 @@
 		}
 
 		onRule(ruleNode, ruleItem, rulelist) {
-			let selector = lib.generate(ruleNode.prelude);
+			let selector = csstree.generate(ruleNode.prelude);
 			if (selector.match(/\+/)) {
 				
-				let declarations = lib.generate(ruleNode.block);
+				let declarations = csstree.generate(ruleNode.block);
 				declarations = declarations.replace(/[{}]/g,"");
 
 				let uuid = "following-" + UUID();
@@ -30790,7 +30900,7 @@
 				let identifier = declaration.value.children && declaration.value.children.first();
 				let location = identifier && identifier.name;
 				if (location === "footnote") {
-					let selector = lib.generate(rule.ruleNode.prelude);
+					let selector = csstree.generate(rule.ruleNode.prelude);
 					this.footnotes[selector] = {
 						selector: selector,
 						policy: "auto",
@@ -30803,7 +30913,7 @@
 				let identifier = declaration.value.children && declaration.value.children.first();
 				let policy = identifier && identifier.name;
 				if (policy) {
-					let selector = lib.generate(rule.ruleNode.prelude);
+					let selector = csstree.generate(rule.ruleNode.prelude);
 					let note = this.footnotes[selector];
 					if (note) {
 						note.policy = policy;
@@ -30813,7 +30923,7 @@
 			if (property === "footnote-display") {
 				let identifier = declaration.value.children && declaration.value.children.first();
 				let display = identifier && identifier.name;
-				let selector = lib.generate(rule.ruleNode.prelude);
+				let selector = csstree.generate(rule.ruleNode.prelude);
 				if (display && this.footnotes[selector]) {
 					let note = this.footnotes[selector];
 					if (note) {
@@ -30828,7 +30938,7 @@
 			if (name === "footnote-marker") {
 				// switch ::footnote-marker to [data-footnote-marker]::before
 				let prelude = rule.ruleNode.prelude;
-				let newPrelude = new lib.List();
+				let newPrelude = new csstree.List();
 
 				// Can't get remove to work, so just copying everything else
 				prelude.children.first().children.each((node) => {
@@ -30865,7 +30975,7 @@
 				// switch ::footnote-call to [data-footnote-call]::after
 
 				let prelude = rule.ruleNode.prelude;
-				let newPrelude = new lib.List();
+				let newPrelude = new csstree.List();
 
 				// Can't get remove to work, so just copying everything else
 				prelude.children.first().children.each((node) => {
@@ -31342,12 +31452,12 @@
 
 		onDeclaration(declaration, dItem, dList, rule) {
 			if (declaration.property === "position") {
-				let selector = lib.generate(rule.ruleNode.prelude);
+				let selector = csstree.generate(rule.ruleNode.prelude);
 				let identifier = declaration.value.children.first().name;
 
 				if (identifier === "running") {
 					let value;
-					lib.walk(declaration, {
+					csstree.walk(declaration, {
 						visit: "Function",
 						enter: (node, item, list) => {
 							value = node.children.first().name;
@@ -31364,13 +31474,13 @@
 
 			if (declaration.property === "content") {
 
-				lib.walk(declaration, {
+				csstree.walk(declaration, {
 					visit: "Function",
 					enter: (funcNode, fItem, fList) => {
 
 						if (funcNode.name.indexOf("element") > -1) {
 
-							let selector = lib.generate(rule.ruleNode.prelude);
+							let selector = csstree.generate(rule.ruleNode.prelude);
 
 							let func = funcNode.name;
 
@@ -31585,7 +31695,7 @@
 		
 		onDeclaration(declaration, dItem, dList, rule) {
 			if (declaration.property === "string-set") {
-				let selector = lib.generate(rule.ruleNode.prelude);
+				let selector = csstree.generate(rule.ruleNode.prelude);
 
 				let identifiers = [];
 				let functions = [];
@@ -31625,7 +31735,7 @@
 				let identifier = funcNode.children && funcNode.children.first().name;
 				this.type = funcNode.children.last().name;
 				funcNode.name = "var";
-				funcNode.children = new lib.List();
+				funcNode.children = new csstree.List();
 
 	 
 				if(this.type === "first" || this.type === "last" || this.type === "start" || this.type === "first-except"){
@@ -31753,12 +31863,12 @@
 
 		onContent(funcNode, fItem, fList, declaration, rule) {
 			if (funcNode.name === "target-counter") {
-				let selector = lib.generate(rule.ruleNode.prelude);
+				let selector = csstree.generate(rule.ruleNode.prelude);
 
 				let first = funcNode.children.first();
 				let func = first.name;
 
-				let value = lib.generate(funcNode);
+				let value = csstree.generate(funcNode);
 
 				let args = [];
 
@@ -31778,7 +31888,7 @@
 						if (!counter) {
 							counter = child.name;
 						} else if (!style) {
-							styleIdentifier = lib.clone(child);
+							styleIdentifier = csstree.clone(child);
 							style = child.name;
 						}
 					}
@@ -31801,7 +31911,7 @@
 
 				// Replace with counter
 				funcNode.name = "counter";
-				funcNode.children = new lib.List();
+				funcNode.children = new csstree.List();
 				funcNode.children.appendData({
 					type: "Identifier",
 					loc: 0,
@@ -31895,12 +32005,12 @@
 
 		onContent(funcNode, fItem, fList, declaration, rule) {
 			if (funcNode.name === "target-text") {
-				this.selector = lib.generate(rule.ruleNode.prelude);
+				this.selector = csstree.generate(rule.ruleNode.prelude);
 				let first = funcNode.children.first();
 				let last = funcNode.children.last();
 				let func = first.name;
 
-				let value = lib.generate(funcNode);
+				let value = csstree.generate(funcNode);
 
 				let args = [];
 
@@ -31931,7 +32041,7 @@
 
 				// Replace with variable
 				funcNode.name = "var";
-				funcNode.children = new lib.List();
+				funcNode.children = new csstree.List();
 				funcNode.children.appendData({
 					type: "Identifier",
 					loc: 0,
@@ -32113,120 +32223,120 @@
 	 */
 
 	(function (exports) {
-	// The following regular expressions assume that selectors matching the preceding regular expressions have been removed
-	var attributeRegex = /(\[[^\]]+\])/g;
-	var idRegex = /(#[^\s\+>~\.\[:]+)/g;
-	var classRegex = /(\.[^\s\+>~\.\[:]+)/g;
-	var pseudoElementRegex = /(::[^\s\+>~\.\[:]+|:first-line|:first-letter|:before|:after)/g;
-	var pseudoClassRegex = /(:[^\s\+>~\.\[:]+)/g;
-	var elementRegex = /([^\s\+>~\.\[:]+)/g;
-	var notRegex = /:not\(([^\)]*)\)/g;
-	var ruleRegex = /\{[^]*/gm;
-	var separatorRegex = /[\*\s\+>~]/g;
-	var straysRegex = /[#\.]/g;
-
-	// Find matches for a regular expression in a string and push their details to parts
-	// Type is "a" for IDs, "b" for classes, attributes and pseudo-classes and "c" for elements and pseudo-elements
-	var findMatch = function(regex, type, types, selector) {
-	  var matches = selector.match(regex);
-	  if (matches) {
-	    for (var i = 0; i < matches.length; i++) {
-	      types[type]++;
-	      // Replace this simple selector with whitespace so it won't be counted in further simple selectors
-	      selector = selector.replace(matches[i], ' ');
-	    }
-	  }
-
-	  return selector;
-	};
-
-	// Calculate the specificity for a selector by dividing it into simple selectors and counting them
-	var calculate = function(selector) {
-	  var commaIndex = selector.indexOf(',');
-	  if (commaIndex !== -1) {
-	    selector = selector.substring(0, commaIndex);
-	  }
-
-	  var  types = {
-	    a: 0,
-	    b: 0,
-	    c: 0
-	  };
+		// The following regular expressions assume that selectors matching the preceding regular expressions have been removed
+		var attributeRegex = /(\[[^\]]+\])/g;
+		var idRegex = /(#[^\s\+>~\.\[:]+)/g;
+		var classRegex = /(\.[^\s\+>~\.\[:]+)/g;
+		var pseudoElementRegex = /(::[^\s\+>~\.\[:]+|:first-line|:first-letter|:before|:after)/g;
+		var pseudoClassRegex = /(:[^\s\+>~\.\[:]+)/g;
+		var elementRegex = /([^\s\+>~\.\[:]+)/g;
+		var notRegex = /:not\(([^\)]*)\)/g;
+		var ruleRegex = /\{[^]*/gm;
+		var separatorRegex = /[\*\s\+>~]/g;
+		var straysRegex = /[#\.]/g;
+
+		// Find matches for a regular expression in a string and push their details to parts
+		// Type is "a" for IDs, "b" for classes, attributes and pseudo-classes and "c" for elements and pseudo-elements
+		var findMatch = function(regex, type, types, selector) {
+		  var matches = selector.match(regex);
+		  if (matches) {
+		    for (var i = 0; i < matches.length; i++) {
+		      types[type]++;
+		      // Replace this simple selector with whitespace so it won't be counted in further simple selectors
+		      selector = selector.replace(matches[i], ' ');
+		    }
+		  }
+
+		  return selector;
+		};
 
-	  // Remove the negation psuedo-class (:not) but leave its argument because specificity is calculated on its argument
-	  selector = selector.replace(notRegex, ' $1 ');
+		// Calculate the specificity for a selector by dividing it into simple selectors and counting them
+		var calculate = function(selector) {
+		  var commaIndex = selector.indexOf(',');
+		  if (commaIndex !== -1) {
+		    selector = selector.substring(0, commaIndex);
+		  }
 
-	  // Remove anything after a left brace in case a user has pasted in a rule, not just a selector
-	  selector = selector.replace(ruleRegex, ' ');
+		  var  types = {
+		    a: 0,
+		    b: 0,
+		    c: 0
+		  };
 
-	  // Add attribute selectors to parts collection (type b)
-	  selector = findMatch(attributeRegex, 'b', types, selector);
+		  // Remove the negation psuedo-class (:not) but leave its argument because specificity is calculated on its argument
+		  selector = selector.replace(notRegex, ' $1 ');
 
-	  // Add ID selectors to parts collection (type a)
-	  selector = findMatch(idRegex, 'a', types, selector);
+		  // Remove anything after a left brace in case a user has pasted in a rule, not just a selector
+		  selector = selector.replace(ruleRegex, ' ');
 
-	  // Add class selectors to parts collection (type b)
-	  selector = findMatch(classRegex, 'b', types, selector);
+		  // Add attribute selectors to parts collection (type b)
+		  selector = findMatch(attributeRegex, 'b', types, selector);
 
-	  // Add pseudo-element selectors to parts collection (type c)
-	  selector = findMatch(pseudoElementRegex, 'c', types, selector);
+		  // Add ID selectors to parts collection (type a)
+		  selector = findMatch(idRegex, 'a', types, selector);
 
-	  // Add pseudo-class selectors to parts collection (type b)
-	  selector = findMatch(pseudoClassRegex, 'b', types, selector);
+		  // Add class selectors to parts collection (type b)
+		  selector = findMatch(classRegex, 'b', types, selector);
 
-	  // Remove universal selector and separator characters
-	  selector = selector.replace(separatorRegex, ' ');
+		  // Add pseudo-element selectors to parts collection (type c)
+		  selector = findMatch(pseudoElementRegex, 'c', types, selector);
 
-	  // Remove any stray dots or hashes which aren't attached to words
-	  // These may be present if the user is live-editing this selector
-	  selector = selector.replace(straysRegex, ' ');
+		  // Add pseudo-class selectors to parts collection (type b)
+		  selector = findMatch(pseudoClassRegex, 'b', types, selector);
 
-	  // The only things left should be element selectors (type c)
-	  findMatch(elementRegex, 'c', types, selector);
+		  // Remove universal selector and separator characters
+		  selector = selector.replace(separatorRegex, ' ');
 
-	  return (types.a * 100) + (types.b * 10) + (types.c * 1);
-	};
+		  // Remove any stray dots or hashes which aren't attached to words
+		  // These may be present if the user is live-editing this selector
+		  selector = selector.replace(straysRegex, ' ');
 
-	var specificityCache = {};
+		  // The only things left should be element selectors (type c)
+		  findMatch(elementRegex, 'c', types, selector);
 
-	exports.calculateSpecificity = function(selector) {
-	  var specificity = specificityCache[selector];
-	  if (specificity === undefined) {
-	    specificity = calculate(selector);
-	    specificityCache[selector] = specificity;
-	  }
-	  return specificity;
-	};
+		  return (types.a * 100) + (types.b * 10) + (types.c * 1);
+		};
 
-	var validSelectorCache = {};
-	var testSelectorElement = null;
+		var specificityCache = {};
 
-	exports.isSelectorValid = function(selector) {
-	  var valid = validSelectorCache[selector];
-	  if (valid === undefined) {
-	    if (testSelectorElement == null) {
-	      testSelectorElement = document.createElement('div');
-	    }
+		exports.calculateSpecificity = function(selector) {
+		  var specificity = specificityCache[selector];
+		  if (specificity === undefined) {
+		    specificity = calculate(selector);
+		    specificityCache[selector] = specificity;
+		  }
+		  return specificity;
+		};
 
-	    try {
-	      testSelectorElement.querySelector(selector);
-	      valid = true;
-	    } catch (error) {
-	      valid = false;
-	    }
-	    validSelectorCache[selector] = valid;
-	  }
-	  return valid;
-	};
+		var validSelectorCache = {};
+		var testSelectorElement = null;
+
+		exports.isSelectorValid = function(selector) {
+		  var valid = validSelectorCache[selector];
+		  if (valid === undefined) {
+		    if (testSelectorElement == null) {
+		      testSelectorElement = document.createElement('div');
+		    }
+
+		    try {
+		      testSelectorElement.querySelector(selector);
+		      valid = true;
+		    } catch (error) {
+		      valid = false;
+		    }
+		    validSelectorCache[selector] = valid;
+		  }
+		  return valid;
+		};
 
-	exports.validateSelector = function(selector) {
-	  if (!exports.isSelectorValid(selector)) {
-	    var error = new SyntaxError(selector + ' is not a valid selector');
-	    error.code = 'EBADSELECTOR';
-	    throw error;
-	  }
-	};
-	}(clearCut));
+		exports.validateSelector = function(selector) {
+		  if (!exports.isSelectorValid(selector)) {
+		    var error = new SyntaxError(selector + ' is not a valid selector');
+		    error.code = 'EBADSELECTOR';
+		    throw error;
+		  }
+		}; 
+	} (clearCut));
 
 	class UndisplayedFilter extends Handler {
 		constructor(chunker, polisher, caller) {
@@ -32236,7 +32346,7 @@
 
 		onDeclaration(declaration, dItem, dList, rule) {
 			if (declaration.property === "display") {
-				let selector = lib.generate(rule.ruleNode.prelude);
+				let selector = csstree.generate(rule.ruleNode.prelude);
 				let value = declaration.value.children.first().name;
 
 				selector.split(",").forEach((s) => {
@@ -32343,170 +32453,233 @@
 		return Boolean(result && (result !== arr) && (result[1] === "dwa"));
 	};
 
-	var validTypes = { object: true, symbol: true };
+	var isImplemented$2;
+	var hasRequiredIsImplemented;
 
-	var isImplemented$2 = function () {
-		var symbol;
-		if (typeof Symbol !== 'function') return false;
-		symbol = Symbol('test symbol');
-		try { String(symbol); } catch (e) { return false; }
+	function requireIsImplemented () {
+		if (hasRequiredIsImplemented) return isImplemented$2;
+		hasRequiredIsImplemented = 1;
 
-		// Return 'true' also for polyfills
-		if (!validTypes[typeof Symbol.iterator]) return false;
-		if (!validTypes[typeof Symbol.toPrimitive]) return false;
-		if (!validTypes[typeof Symbol.toStringTag]) return false;
+		var validTypes = { object: true, symbol: true };
 
-		return true;
-	};
+		isImplemented$2 = function () {
+			var symbol;
+			if (typeof Symbol !== 'function') return false;
+			symbol = Symbol('test symbol');
+			try { String(symbol); } catch (e) { return false; }
 
-	var isSymbol$1 = function (x) {
-		if (!x) return false;
-		if (typeof x === 'symbol') return true;
-		if (!x.constructor) return false;
-		if (x.constructor.name !== 'Symbol') return false;
-		return (x[x.constructor.toStringTag] === 'Symbol');
-	};
+			// Return 'true' also for polyfills
+			if (!validTypes[typeof Symbol.iterator]) return false;
+			if (!validTypes[typeof Symbol.toPrimitive]) return false;
+			if (!validTypes[typeof Symbol.toStringTag]) return false;
+
+			return true;
+		};
+		return isImplemented$2;
+	}
 
-	var isSymbol = isSymbol$1;
+	var isSymbol;
+	var hasRequiredIsSymbol;
 
-	var validateSymbol$1 = function (value) {
-		if (!isSymbol(value)) throw new TypeError(value + " is not a symbol");
-		return value;
-	};
+	function requireIsSymbol () {
+		if (hasRequiredIsSymbol) return isSymbol;
+		hasRequiredIsSymbol = 1;
 
-	var d$1              = d$3.exports
-	  , validateSymbol = validateSymbol$1
-
-	  , create = Object.create, defineProperties = Object.defineProperties
-	  , defineProperty$2 = Object.defineProperty, objPrototype = Object.prototype
-	  , NativeSymbol, SymbolPolyfill, HiddenSymbol, globalSymbols = create(null)
-	  , isNativeSafe;
-
-	if (typeof Symbol === 'function') {
-		NativeSymbol = Symbol;
-		try {
-			String(NativeSymbol());
-			isNativeSafe = true;
-		} catch (ignore) {}
-	}
-
-	var generateName = (function () {
-		var created = create(null);
-		return function (desc) {
-			var postfix = 0, name, ie11BugWorkaround;
-			while (created[desc + (postfix || '')]) ++postfix;
-			desc += (postfix || '');
-			created[desc] = true;
-			name = '@@' + desc;
-			defineProperty$2(objPrototype, name, d$1.gs(null, function (value) {
-				// For IE11 issue see:
-				// https://connect.microsoft.com/IE/feedbackdetail/view/1928508/
-				//    ie11-broken-getters-on-dom-objects
-				// https://github.com/medikoo/es6-symbol/issues/12
-				if (ie11BugWorkaround) return;
-				ie11BugWorkaround = true;
-				defineProperty$2(this, name, d$1(value));
-				ie11BugWorkaround = false;
-			}));
-			return name;
+		isSymbol = function (x) {
+			if (!x) return false;
+			if (typeof x === 'symbol') return true;
+			if (!x.constructor) return false;
+			if (x.constructor.name !== 'Symbol') return false;
+			return (x[x.constructor.toStringTag] === 'Symbol');
+		};
+		return isSymbol;
+	}
+
+	var validateSymbol;
+	var hasRequiredValidateSymbol;
+
+	function requireValidateSymbol () {
+		if (hasRequiredValidateSymbol) return validateSymbol;
+		hasRequiredValidateSymbol = 1;
+
+		var isSymbol = requireIsSymbol();
+
+		validateSymbol = function (value) {
+			if (!isSymbol(value)) throw new TypeError(value + " is not a symbol");
+			return value;
+		};
+		return validateSymbol;
+	}
+
+	var polyfill;
+	var hasRequiredPolyfill;
+
+	function requirePolyfill () {
+		if (hasRequiredPolyfill) return polyfill;
+		hasRequiredPolyfill = 1;
+
+		var d              = dExports
+		  , validateSymbol = requireValidateSymbol()
+
+		  , create = Object.create, defineProperties = Object.defineProperties
+		  , defineProperty = Object.defineProperty, objPrototype = Object.prototype
+		  , NativeSymbol, SymbolPolyfill, HiddenSymbol, globalSymbols = create(null)
+		  , isNativeSafe;
+
+		if (typeof Symbol === 'function') {
+			NativeSymbol = Symbol;
+			try {
+				String(NativeSymbol());
+				isNativeSafe = true;
+			} catch (ignore) {}
+		}
+
+		var generateName = (function () {
+			var created = create(null);
+			return function (desc) {
+				var postfix = 0, name, ie11BugWorkaround;
+				while (created[desc + (postfix || '')]) ++postfix;
+				desc += (postfix || '');
+				created[desc] = true;
+				name = '@@' + desc;
+				defineProperty(objPrototype, name, d.gs(null, function (value) {
+					// For IE11 issue see:
+					// https://connect.microsoft.com/IE/feedbackdetail/view/1928508/
+					//    ie11-broken-getters-on-dom-objects
+					// https://github.com/medikoo/es6-symbol/issues/12
+					if (ie11BugWorkaround) return;
+					ie11BugWorkaround = true;
+					defineProperty(this, name, d(value));
+					ie11BugWorkaround = false;
+				}));
+				return name;
+			};
+		}());
+
+		// Internal constructor (not one exposed) for creating Symbol instances.
+		// This one is used to ensure that `someSymbol instanceof Symbol` always return false
+		HiddenSymbol = function Symbol(description) {
+			if (this instanceof HiddenSymbol) throw new TypeError('Symbol is not a constructor');
+			return SymbolPolyfill(description);
 		};
-	}());
-
-	// Internal constructor (not one exposed) for creating Symbol instances.
-	// This one is used to ensure that `someSymbol instanceof Symbol` always return false
-	HiddenSymbol = function Symbol(description) {
-		if (this instanceof HiddenSymbol) throw new TypeError('Symbol is not a constructor');
-		return SymbolPolyfill(description);
-	};
-
-	// Exposed `Symbol` constructor
-	// (returns instances of HiddenSymbol)
-	var polyfill = SymbolPolyfill = function Symbol(description) {
-		var symbol;
-		if (this instanceof Symbol) throw new TypeError('Symbol is not a constructor');
-		if (isNativeSafe) return NativeSymbol(description);
-		symbol = create(HiddenSymbol.prototype);
-		description = (description === undefined ? '' : String(description));
-		return defineProperties(symbol, {
-			__description__: d$1('', description),
-			__name__: d$1('', generateName(description))
+
+		// Exposed `Symbol` constructor
+		// (returns instances of HiddenSymbol)
+		polyfill = SymbolPolyfill = function Symbol(description) {
+			var symbol;
+			if (this instanceof Symbol) throw new TypeError('Symbol is not a constructor');
+			if (isNativeSafe) return NativeSymbol(description);
+			symbol = create(HiddenSymbol.prototype);
+			description = (description === undefined ? '' : String(description));
+			return defineProperties(symbol, {
+				__description__: d('', description),
+				__name__: d('', generateName(description))
+			});
+		};
+		defineProperties(SymbolPolyfill, {
+			for: d(function (key) {
+				if (globalSymbols[key]) return globalSymbols[key];
+				return (globalSymbols[key] = SymbolPolyfill(String(key)));
+			}),
+			keyFor: d(function (s) {
+				var key;
+				validateSymbol(s);
+				for (key in globalSymbols) if (globalSymbols[key] === s) return key;
+			}),
+
+			// To ensure proper interoperability with other native functions (e.g. Array.from)
+			// fallback to eventual native implementation of given symbol
+			hasInstance: d('', (NativeSymbol && NativeSymbol.hasInstance) || SymbolPolyfill('hasInstance')),
+			isConcatSpreadable: d('', (NativeSymbol && NativeSymbol.isConcatSpreadable) ||
+				SymbolPolyfill('isConcatSpreadable')),
+			iterator: d('', (NativeSymbol && NativeSymbol.iterator) || SymbolPolyfill('iterator')),
+			match: d('', (NativeSymbol && NativeSymbol.match) || SymbolPolyfill('match')),
+			replace: d('', (NativeSymbol && NativeSymbol.replace) || SymbolPolyfill('replace')),
+			search: d('', (NativeSymbol && NativeSymbol.search) || SymbolPolyfill('search')),
+			species: d('', (NativeSymbol && NativeSymbol.species) || SymbolPolyfill('species')),
+			split: d('', (NativeSymbol && NativeSymbol.split) || SymbolPolyfill('split')),
+			toPrimitive: d('', (NativeSymbol && NativeSymbol.toPrimitive) || SymbolPolyfill('toPrimitive')),
+			toStringTag: d('', (NativeSymbol && NativeSymbol.toStringTag) || SymbolPolyfill('toStringTag')),
+			unscopables: d('', (NativeSymbol && NativeSymbol.unscopables) || SymbolPolyfill('unscopables'))
 		});
-	};
-	defineProperties(SymbolPolyfill, {
-		for: d$1(function (key) {
-			if (globalSymbols[key]) return globalSymbols[key];
-			return (globalSymbols[key] = SymbolPolyfill(String(key)));
-		}),
-		keyFor: d$1(function (s) {
-			var key;
-			validateSymbol(s);
-			for (key in globalSymbols) if (globalSymbols[key] === s) return key;
-		}),
-
-		// To ensure proper interoperability with other native functions (e.g. Array.from)
-		// fallback to eventual native implementation of given symbol
-		hasInstance: d$1('', (NativeSymbol && NativeSymbol.hasInstance) || SymbolPolyfill('hasInstance')),
-		isConcatSpreadable: d$1('', (NativeSymbol && NativeSymbol.isConcatSpreadable) ||
-			SymbolPolyfill('isConcatSpreadable')),
-		iterator: d$1('', (NativeSymbol && NativeSymbol.iterator) || SymbolPolyfill('iterator')),
-		match: d$1('', (NativeSymbol && NativeSymbol.match) || SymbolPolyfill('match')),
-		replace: d$1('', (NativeSymbol && NativeSymbol.replace) || SymbolPolyfill('replace')),
-		search: d$1('', (NativeSymbol && NativeSymbol.search) || SymbolPolyfill('search')),
-		species: d$1('', (NativeSymbol && NativeSymbol.species) || SymbolPolyfill('species')),
-		split: d$1('', (NativeSymbol && NativeSymbol.split) || SymbolPolyfill('split')),
-		toPrimitive: d$1('', (NativeSymbol && NativeSymbol.toPrimitive) || SymbolPolyfill('toPrimitive')),
-		toStringTag: d$1('', (NativeSymbol && NativeSymbol.toStringTag) || SymbolPolyfill('toStringTag')),
-		unscopables: d$1('', (NativeSymbol && NativeSymbol.unscopables) || SymbolPolyfill('unscopables'))
-	});
 
-	// Internal tweaks for real symbol producer
-	defineProperties(HiddenSymbol.prototype, {
-		constructor: d$1(SymbolPolyfill),
-		toString: d$1('', function () { return this.__name__; })
-	});
+		// Internal tweaks for real symbol producer
+		defineProperties(HiddenSymbol.prototype, {
+			constructor: d(SymbolPolyfill),
+			toString: d('', function () { return this.__name__; })
+		});
 
-	// Proper implementation of methods exposed on Symbol.prototype
-	// They won't be accessible on produced symbol instances as they derive from HiddenSymbol.prototype
-	defineProperties(SymbolPolyfill.prototype, {
-		toString: d$1(function () { return 'Symbol (' + validateSymbol(this).__description__ + ')'; }),
-		valueOf: d$1(function () { return validateSymbol(this); })
-	});
-	defineProperty$2(SymbolPolyfill.prototype, SymbolPolyfill.toPrimitive, d$1('', function () {
-		var symbol = validateSymbol(this);
-		if (typeof symbol === 'symbol') return symbol;
-		return symbol.toString();
-	}));
-	defineProperty$2(SymbolPolyfill.prototype, SymbolPolyfill.toStringTag, d$1('c', 'Symbol'));
-
-	// Proper implementaton of toPrimitive and toStringTag for returned symbol instances
-	defineProperty$2(HiddenSymbol.prototype, SymbolPolyfill.toStringTag,
-		d$1('c', SymbolPolyfill.prototype[SymbolPolyfill.toStringTag]));
-
-	// Note: It's important to define `toPrimitive` as last one, as some implementations
-	// implement `toPrimitive` natively without implementing `toStringTag` (or other specified symbols)
-	// And that may invoke error in definition flow:
-	// See: https://github.com/medikoo/es6-symbol/issues/13#issuecomment-164146149
-	defineProperty$2(HiddenSymbol.prototype, SymbolPolyfill.toPrimitive,
-		d$1('c', SymbolPolyfill.prototype[SymbolPolyfill.toPrimitive]));
-
-	var es6Symbol = isImplemented$2() ? Symbol : polyfill;
-
-	var objToString$2 = Object.prototype.toString
-	  , id$2 = objToString$2.call(
-		(function () {
-			return arguments;
-		})()
-	);
+		// Proper implementation of methods exposed on Symbol.prototype
+		// They won't be accessible on produced symbol instances as they derive from HiddenSymbol.prototype
+		defineProperties(SymbolPolyfill.prototype, {
+			toString: d(function () { return 'Symbol (' + validateSymbol(this).__description__ + ')'; }),
+			valueOf: d(function () { return validateSymbol(this); })
+		});
+		defineProperty(SymbolPolyfill.prototype, SymbolPolyfill.toPrimitive, d('', function () {
+			var symbol = validateSymbol(this);
+			if (typeof symbol === 'symbol') return symbol;
+			return symbol.toString();
+		}));
+		defineProperty(SymbolPolyfill.prototype, SymbolPolyfill.toStringTag, d('c', 'Symbol'));
 
-	var isArguments$1 = function (value) {
-		return objToString$2.call(value) === id$2;
-	};
+		// Proper implementaton of toPrimitive and toStringTag for returned symbol instances
+		defineProperty(HiddenSymbol.prototype, SymbolPolyfill.toStringTag,
+			d('c', SymbolPolyfill.prototype[SymbolPolyfill.toStringTag]));
 
-	var objToString$1 = Object.prototype.toString, id$1 = objToString$1.call(noop$4);
+		// Note: It's important to define `toPrimitive` as last one, as some implementations
+		// implement `toPrimitive` natively without implementing `toStringTag` (or other specified symbols)
+		// And that may invoke error in definition flow:
+		// See: https://github.com/medikoo/es6-symbol/issues/13#issuecomment-164146149
+		defineProperty(HiddenSymbol.prototype, SymbolPolyfill.toPrimitive,
+			d('c', SymbolPolyfill.prototype[SymbolPolyfill.toPrimitive]));
+		return polyfill;
+	}
 
-	var isFunction$1 = function (value) {
-		return typeof value === "function" && objToString$1.call(value) === id$1;
-	};
+	var es6Symbol;
+	var hasRequiredEs6Symbol;
+
+	function requireEs6Symbol () {
+		if (hasRequiredEs6Symbol) return es6Symbol;
+		hasRequiredEs6Symbol = 1;
+
+		es6Symbol = requireIsImplemented()() ? Symbol : requirePolyfill();
+		return es6Symbol;
+	}
+
+	var isArguments;
+	var hasRequiredIsArguments;
+
+	function requireIsArguments () {
+		if (hasRequiredIsArguments) return isArguments;
+		hasRequiredIsArguments = 1;
+
+		var objToString = Object.prototype.toString
+		  , id = objToString.call(
+			(function () {
+				return arguments;
+			})()
+		);
+
+		isArguments = function (value) {
+			return objToString.call(value) === id;
+		};
+		return isArguments;
+	}
+
+	var isFunction;
+	var hasRequiredIsFunction;
+
+	function requireIsFunction () {
+		if (hasRequiredIsFunction) return isFunction;
+		hasRequiredIsFunction = 1;
+
+		var objToString = Object.prototype.toString, id = objToString.call(noop$4);
+
+		isFunction = function (value) {
+			return typeof value === "function" && objToString.call(value) === id;
+		};
+		return isFunction;
+	}
 
 	var isImplemented$1 = function () {
 		var sign = Math.sign;
@@ -32514,15 +32687,24 @@
 		return (sign(10) === 1) && (sign(-20) === -1);
 	};
 
-	var shim$2 = function (value) {
-		value = Number(value);
-		if (isNaN(value) || (value === 0)) return value;
-		return value > 0 ? 1 : -1;
-	};
+	var shim$2;
+	var hasRequiredShim$2;
+
+	function requireShim$2 () {
+		if (hasRequiredShim$2) return shim$2;
+		hasRequiredShim$2 = 1;
+
+		shim$2 = function (value) {
+			value = Number(value);
+			if (isNaN(value) || (value === 0)) return value;
+			return value > 0 ? 1 : -1;
+		};
+		return shim$2;
+	}
 
 	var sign$1 = isImplemented$1()
 		? Math.sign
-		: shim$2;
+		: requireShim$2();
 
 	var sign = sign$1
 
@@ -32543,139 +32725,157 @@
 	 return max(0, toInteger(value));
 	};
 
-	var objToString = Object.prototype.toString, id = objToString.call("");
+	var isString;
+	var hasRequiredIsString;
 
-	var isString$1 = function (value) {
-		return (
-			typeof value === "string" ||
-			(value &&
-				typeof value === "object" &&
-				(value instanceof String || objToString.call(value) === id)) ||
-			false
-		);
-	};
+	function requireIsString () {
+		if (hasRequiredIsString) return isString;
+		hasRequiredIsString = 1;
 
-	var iteratorSymbol = es6Symbol.iterator
-	  , isArguments    = isArguments$1
-	  , isFunction     = isFunction$1
-	  , toPosInt$1       = toPosInteger
-	  , callable       = validCallable
-	  , validValue     = validValue$1
-	  , isValue$1        = isValue$5
-	  , isString       = isString$1
-	  , isArray        = Array.isArray
-	  , call           = Function.prototype.call
-	  , desc           = { configurable: true, enumerable: true, writable: true, value: null }
-	  , defineProperty$1 = Object.defineProperty;
-
-	// eslint-disable-next-line complexity
-	var shim$1 = function (arrayLike /*, mapFn, thisArg*/) {
-		var mapFn = arguments[1]
-		  , thisArg = arguments[2]
-		  , Context
-		  , i
-		  , j
-		  , arr
-		  , length
-		  , code
-		  , iterator
-		  , result
-		  , getIterator
-		  , value;
-
-		arrayLike = Object(validValue(arrayLike));
-
-		if (isValue$1(mapFn)) callable(mapFn);
-		if (!this || this === Array || !isFunction(this)) {
-			// Result: Plain array
-			if (!mapFn) {
-				if (isArguments(arrayLike)) {
-					// Source: Arguments
-					length = arrayLike.length;
-					if (length !== 1) return Array.apply(null, arrayLike);
-					arr = new Array(1);
-					arr[0] = arrayLike[0];
-					return arr;
-				}
-				if (isArray(arrayLike)) {
-					// Source: Array
-					arr = new Array(length = arrayLike.length);
-					for (i = 0; i < length; ++i) arr[i] = arrayLike[i];
-					return arr;
+		var objToString = Object.prototype.toString, id = objToString.call("");
+
+		isString = function (value) {
+			return (
+				typeof value === "string" ||
+				(value &&
+					typeof value === "object" &&
+					(value instanceof String || objToString.call(value) === id)) ||
+				false
+			);
+		};
+		return isString;
+	}
+
+	var shim$1;
+	var hasRequiredShim$1;
+
+	function requireShim$1 () {
+		if (hasRequiredShim$1) return shim$1;
+		hasRequiredShim$1 = 1;
+
+		var iteratorSymbol = requireEs6Symbol().iterator
+		  , isArguments    = requireIsArguments()
+		  , isFunction     = requireIsFunction()
+		  , toPosInt       = toPosInteger
+		  , callable       = validCallable
+		  , validValue$1     = validValue
+		  , isValue        = isValue$3
+		  , isString       = requireIsString()
+		  , isArray        = Array.isArray
+		  , call           = Function.prototype.call
+		  , desc           = { configurable: true, enumerable: true, writable: true, value: null }
+		  , defineProperty = Object.defineProperty;
+
+		// eslint-disable-next-line complexity
+		shim$1 = function (arrayLike /*, mapFn, thisArg*/) {
+			var mapFn = arguments[1]
+			  , thisArg = arguments[2]
+			  , Context
+			  , i
+			  , j
+			  , arr
+			  , length
+			  , code
+			  , iterator
+			  , result
+			  , getIterator
+			  , value;
+
+			arrayLike = Object(validValue$1(arrayLike));
+
+			if (isValue(mapFn)) callable(mapFn);
+			if (!this || this === Array || !isFunction(this)) {
+				// Result: Plain array
+				if (!mapFn) {
+					if (isArguments(arrayLike)) {
+						// Source: Arguments
+						length = arrayLike.length;
+						if (length !== 1) return Array.apply(null, arrayLike);
+						arr = new Array(1);
+						arr[0] = arrayLike[0];
+						return arr;
+					}
+					if (isArray(arrayLike)) {
+						// Source: Array
+						arr = new Array(length = arrayLike.length);
+						for (i = 0; i < length; ++i) arr[i] = arrayLike[i];
+						return arr;
+					}
 				}
+				arr = [];
+			} else {
+				// Result: Non plain array
+				Context = this;
 			}
-			arr = [];
-		} else {
-			// Result: Non plain array
-			Context = this;
-		}
-
-		if (!isArray(arrayLike)) {
-			if ((getIterator = arrayLike[iteratorSymbol]) !== undefined) {
-				// Source: Iterator
-				iterator = callable(getIterator).call(arrayLike);
-				if (Context) arr = new Context();
-				result = iterator.next();
-				i = 0;
-				while (!result.done) {
-					value = mapFn ? call.call(mapFn, thisArg, result.value, i) : result.value;
-					if (Context) {
-						desc.value = value;
-						defineProperty$1(arr, i, desc);
-					} else {
-						arr[i] = value;
-					}
+
+			if (!isArray(arrayLike)) {
+				if ((getIterator = arrayLike[iteratorSymbol]) !== undefined) {
+					// Source: Iterator
+					iterator = callable(getIterator).call(arrayLike);
+					if (Context) arr = new Context();
 					result = iterator.next();
-					++i;
-				}
-				length = i;
-			} else if (isString(arrayLike)) {
-				// Source: String
-				length = arrayLike.length;
-				if (Context) arr = new Context();
-				for (i = 0, j = 0; i < length; ++i) {
-					value = arrayLike[i];
-					if (i + 1 < length) {
-						code = value.charCodeAt(0);
-						// eslint-disable-next-line max-depth
-						if (code >= 0xd800 && code <= 0xdbff) value += arrayLike[++i];
+					i = 0;
+					while (!result.done) {
+						value = mapFn ? call.call(mapFn, thisArg, result.value, i) : result.value;
+						if (Context) {
+							desc.value = value;
+							defineProperty(arr, i, desc);
+						} else {
+							arr[i] = value;
+						}
+						result = iterator.next();
+						++i;
 					}
-					value = mapFn ? call.call(mapFn, thisArg, value, j) : value;
+					length = i;
+				} else if (isString(arrayLike)) {
+					// Source: String
+					length = arrayLike.length;
+					if (Context) arr = new Context();
+					for (i = 0, j = 0; i < length; ++i) {
+						value = arrayLike[i];
+						if (i + 1 < length) {
+							code = value.charCodeAt(0);
+							// eslint-disable-next-line max-depth
+							if (code >= 0xd800 && code <= 0xdbff) value += arrayLike[++i];
+						}
+						value = mapFn ? call.call(mapFn, thisArg, value, j) : value;
+						if (Context) {
+							desc.value = value;
+							defineProperty(arr, j, desc);
+						} else {
+							arr[j] = value;
+						}
+						++j;
+					}
+					length = j;
+				}
+			}
+			if (length === undefined) {
+				// Source: array or array-like
+				length = toPosInt(arrayLike.length);
+				if (Context) arr = new Context(length);
+				for (i = 0; i < length; ++i) {
+					value = mapFn ? call.call(mapFn, thisArg, arrayLike[i], i) : arrayLike[i];
 					if (Context) {
 						desc.value = value;
-						defineProperty$1(arr, j, desc);
+						defineProperty(arr, i, desc);
 					} else {
-						arr[j] = value;
+						arr[i] = value;
 					}
-					++j;
-				}
-				length = j;
-			}
-		}
-		if (length === undefined) {
-			// Source: array or array-like
-			length = toPosInt$1(arrayLike.length);
-			if (Context) arr = new Context(length);
-			for (i = 0; i < length; ++i) {
-				value = mapFn ? call.call(mapFn, thisArg, arrayLike[i], i) : arrayLike[i];
-				if (Context) {
-					desc.value = value;
-					defineProperty$1(arr, i, desc);
-				} else {
-					arr[i] = value;
 				}
 			}
-		}
-		if (Context) {
-			desc.value = null;
-			arr.length = length;
-		}
-		return arr;
-	};
+			if (Context) {
+				desc.value = null;
+				arr.length = length;
+			}
+			return arr;
+		};
+		return shim$1;
+	}
 
 	var from = isImplemented$3()
 		? Array.from
-		: shim$1;
+		: requireShim$1();
 
 	var isImplemented = function () {
 		var numberIsNaN = Number.isNaN;
@@ -32683,18 +32883,27 @@
 		return !numberIsNaN({}) && numberIsNaN(NaN) && !numberIsNaN(34);
 	};
 
-	var shim = function (value) {
-		// eslint-disable-next-line no-self-compare
-		return value !== value;
-	};
+	var shim;
+	var hasRequiredShim;
+
+	function requireShim () {
+		if (hasRequiredShim) return shim;
+		hasRequiredShim = 1;
+
+		shim = function (value) {
+			// eslint-disable-next-line no-self-compare
+			return value !== value;
+		};
+		return shim;
+	}
 
 	var isNan = isImplemented()
 		? Number.isNaN
-		: shim;
+		: requireShim();
 
 	var numberIsNaN       = isNan
 	  , toPosInt          = toPosInteger
-	  , value$1             = validValue$1
+	  , value$1             = validValue
 	  , indexOf$1           = Array.prototype.indexOf
 	  , objHasOwnProperty = Object.prototype.hasOwnProperty
 	  , abs               = Math.abs
@@ -32735,7 +32944,7 @@
 		);
 	};
 
-	var isValue = isValue$5;
+	var isValue = isValue$3;
 
 	var map = { function: true, object: true };
 
@@ -32753,8 +32962,8 @@
 	var aFrom          = from
 	  , remove         = remove$1
 	  , value          = validObject
-	  , d              = d$3.exports
-	  , emit           = eventEmitter.exports.methods.emit
+	  , d              = dExports
+	  , emit           = eventEmitterExports.methods.emit
 
 	  , defineProperty = Object.defineProperty
 	  , hasOwnProperty$1 = Object.prototype.hasOwnProperty
@@ -32791,6 +33000,8 @@
 		return pipe;
 	};
 
+	var pipe$1 = /*@__PURE__*/getDefaultExportFromCjs(pipe);
+
 	let registeredHandlers = [...pagedMediaHandlers, ...generatedContentHandlers, ...filters];
 
 	class Handlers {
@@ -32798,7 +33009,7 @@
 
 			registeredHandlers.forEach((Handler) => {
 				let handler = new Handler(chunker, polisher, caller);
-				pipe(handler, this);
+				pipe$1(handler, this);
 			});
 		}
 	}
@@ -32984,12 +33195,12 @@
 	var Paged = /*#__PURE__*/Object.freeze({
 		__proto__: null,
 		Chunker: Chunker,
+		Handler: Handler,
 		Polisher: Polisher,
 		Previewer: Previewer,
-		Handler: Handler,
-		registeredHandlers: registeredHandlers,
+		initializeHandlers: initializeHandlers,
 		registerHandlers: registerHandlers,
-		initializeHandlers: initializeHandlers
+		registeredHandlers: registeredHandlers
 	});
 
 	window.Paged = Paged;