@max-ts/svelte 1.8.5 → 1.9.1

package/dist/node_modules/.pnpm/media-query-parser@2.0.2/node_modules/media-query-parser/dist/media-query-parser.esm.js

@@ -0,0 +1,939 @@
+//#region node_modules/.pnpm/media-query-parser@2.0.2/node_modules/media-query-parser/dist/media-query-parser.esm.js
+/*! @license MediaQueryParser - MIT License - Tom Golden (github@tbjgolden.com) */
+/*! *****************************************************************************
+Copyright (c) Microsoft Corporation.
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+PERFORMANCE OF THIS SOFTWARE.
+***************************************************************************** */
+var __assign = function() {
+	__assign = Object.assign || function __assign(t) {
+		for (var s, i = 1, n = arguments.length; i < n; i++) {
+			s = arguments[i];
+			for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];
+		}
+		return t;
+	};
+	return __assign.apply(this, arguments);
+};
+function __rest(s, e) {
+	var t = {};
+	for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0) t[p] = s[p];
+	if (s != null && typeof Object.getOwnPropertySymbols === "function") {
+		for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i])) t[p[i]] = s[p[i]];
+	}
+	return t;
+}
+function __values(o) {
+	var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
+	if (m) return m.call(o);
+	if (o && typeof o.length === "number") return { next: function() {
+		if (o && i >= o.length) o = void 0;
+		return {
+			value: o && o[i++],
+			done: !o
+		};
+	} };
+	throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
+}
+function __read(o, n) {
+	var m = typeof Symbol === "function" && o[Symbol.iterator];
+	if (!m) return o;
+	var i = m.call(o), r, ar = [], e;
+	try {
+		while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+	} catch (error) {
+		e = { error };
+	} finally {
+		try {
+			if (r && !r.done && (m = i["return"])) m.call(i);
+		} finally {
+			if (e) throw e.error;
+		}
+	}
+	return ar;
+}
+var weirdNewlines = /(\u000D|\u000C|\u000D\u000A)/g;
+var nullOrSurrogates = /[\u0000\uD800-\uDFFF]/g;
+var commentRegex = /(\/\*)[\s\S]*?(\*\/)/g;
+var lexicalAnalysis = function lexicalAnalysis(str, index) {
+	if (index === void 0) index = 0;
+	str = str.replace(weirdNewlines, "\n").replace(nullOrSurrogates, "�");
+	str = str.replace(commentRegex, "");
+	var tokens = [];
+	for (; index < str.length; index += 1) {
+		var code = str.charCodeAt(index);
+		if (code === 9 || code === 32 || code === 10) {
+			var code_1 = str.charCodeAt(++index);
+			while (code_1 === 9 || code_1 === 32 || code_1 === 10) code_1 = str.charCodeAt(++index);
+			index -= 1;
+			tokens.push({ type: "<whitespace-token>" });
+		} else if (code === 34) {
+			var result = consumeString(str, index);
+			if (result === null) return null;
+			var _a = __read(result, 2), lastIndex = _a[0], value = _a[1];
+			tokens.push({
+				type: "<string-token>",
+				value
+			});
+			index = lastIndex;
+		} else if (code === 35) {
+			if (index + 1 < str.length) {
+				var nextCode = str.charCodeAt(index + 1);
+				if (nextCode === 95 || nextCode >= 65 && nextCode <= 90 || nextCode >= 97 && nextCode <= 122 || nextCode >= 128 || nextCode >= 48 && nextCode <= 57 || nextCode === 92 && index + 2 < str.length && str.charCodeAt(index + 2) !== 10) {
+					var flag = wouldStartIdentifier(str, index + 1) ? "id" : "unrestricted";
+					var result = consumeIdentUnsafe(str, index + 1);
+					if (result !== null) {
+						var _b = __read(result, 2), lastIndex = _b[0], value = _b[1];
+						tokens.push({
+							type: "<hash-token>",
+							value: value.toLowerCase(),
+							flag
+						});
+						index = lastIndex;
+						continue;
+					}
+				}
+			}
+			tokens.push({
+				type: "<delim-token>",
+				value: code
+			});
+		} else if (code === 39) {
+			var result = consumeString(str, index);
+			if (result === null) return null;
+			var _c = __read(result, 2), lastIndex = _c[0], value = _c[1];
+			tokens.push({
+				type: "<string-token>",
+				value
+			});
+			index = lastIndex;
+		} else if (code === 40) tokens.push({ type: "<(-token>" });
+		else if (code === 41) tokens.push({ type: "<)-token>" });
+		else if (code === 43) {
+			var plusNumeric = consumeNumeric(str, index);
+			if (plusNumeric === null) tokens.push({
+				type: "<delim-token>",
+				value: code
+			});
+			else {
+				var _d = __read(plusNumeric, 2), lastIndex = _d[0], tokenTuple = _d[1];
+				if (tokenTuple[0] === "<dimension-token>") tokens.push({
+					type: "<dimension-token>",
+					value: tokenTuple[1],
+					unit: tokenTuple[2].toLowerCase(),
+					flag: "number"
+				});
+				else if (tokenTuple[0] === "<number-token>") tokens.push({
+					type: tokenTuple[0],
+					value: tokenTuple[1],
+					flag: tokenTuple[2]
+				});
+				else tokens.push({
+					type: tokenTuple[0],
+					value: tokenTuple[1],
+					flag: "number"
+				});
+				index = lastIndex;
+			}
+		} else if (code === 44) tokens.push({ type: "<comma-token>" });
+		else if (code === 45) {
+			var minusNumeric = consumeNumeric(str, index);
+			if (minusNumeric !== null) {
+				var _e = __read(minusNumeric, 2), lastIndex = _e[0], tokenTuple = _e[1];
+				if (tokenTuple[0] === "<dimension-token>") tokens.push({
+					type: "<dimension-token>",
+					value: tokenTuple[1],
+					unit: tokenTuple[2].toLowerCase(),
+					flag: "number"
+				});
+				else if (tokenTuple[0] === "<number-token>") tokens.push({
+					type: tokenTuple[0],
+					value: tokenTuple[1],
+					flag: tokenTuple[2]
+				});
+				else tokens.push({
+					type: tokenTuple[0],
+					value: tokenTuple[1],
+					flag: "number"
+				});
+				index = lastIndex;
+				continue;
+			}
+			if (index + 2 < str.length) {
+				var nextCode = str.charCodeAt(index + 1);
+				var nextNextCode = str.charCodeAt(index + 2);
+				if (nextCode === 45 && nextNextCode === 62) {
+					tokens.push({ type: "<CDC-token>" });
+					index += 2;
+					continue;
+				}
+			}
+			var result = consumeIdentLike(str, index);
+			if (result !== null) {
+				var _f = __read(result, 3), lastIndex = _f[0], value = _f[1], type = _f[2];
+				tokens.push({
+					type,
+					value
+				});
+				index = lastIndex;
+				continue;
+			}
+			tokens.push({
+				type: "<delim-token>",
+				value: code
+			});
+		} else if (code === 46) {
+			var minusNumeric = consumeNumeric(str, index);
+			if (minusNumeric === null) tokens.push({
+				type: "<delim-token>",
+				value: code
+			});
+			else {
+				var _g = __read(minusNumeric, 2), lastIndex = _g[0], tokenTuple = _g[1];
+				if (tokenTuple[0] === "<dimension-token>") tokens.push({
+					type: "<dimension-token>",
+					value: tokenTuple[1],
+					unit: tokenTuple[2].toLowerCase(),
+					flag: "number"
+				});
+				else if (tokenTuple[0] === "<number-token>") tokens.push({
+					type: tokenTuple[0],
+					value: tokenTuple[1],
+					flag: tokenTuple[2]
+				});
+				else tokens.push({
+					type: tokenTuple[0],
+					value: tokenTuple[1],
+					flag: "number"
+				});
+				index = lastIndex;
+				continue;
+			}
+		} else if (code === 58) tokens.push({ type: "<colon-token>" });
+		else if (code === 59) tokens.push({ type: "<semicolon-token>" });
+		else if (code === 60) {
+			if (index + 3 < str.length) {
+				var nextCode = str.charCodeAt(index + 1);
+				var nextNextCode = str.charCodeAt(index + 2);
+				var nextNextNextCode = str.charCodeAt(index + 3);
+				if (nextCode === 33 && nextNextCode === 45 && nextNextNextCode === 45) {
+					tokens.push({ type: "<CDO-token>" });
+					index += 3;
+					continue;
+				}
+			}
+			tokens.push({
+				type: "<delim-token>",
+				value: code
+			});
+		} else if (code === 64) {
+			var result = consumeIdent(str, index + 1);
+			if (result !== null) {
+				var _h = __read(result, 2), lastIndex = _h[0], value = _h[1];
+				tokens.push({
+					type: "<at-keyword-token>",
+					value: value.toLowerCase()
+				});
+				index = lastIndex;
+				continue;
+			}
+			tokens.push({
+				type: "<delim-token>",
+				value: code
+			});
+		} else if (code === 91) tokens.push({ type: "<[-token>" });
+		else if (code === 92) {
+			var result = consumeEscape(str, index);
+			if (result === null) return null;
+			var _j = __read(result, 2), lastIndex = _j[0], value = _j[1];
+			str = str.slice(0, index) + value + str.slice(lastIndex + 1);
+			index -= 1;
+		} else if (code === 93) tokens.push({ type: "<]-token>" });
+		else if (code === 123) tokens.push({ type: "<{-token>" });
+		else if (code === 125) tokens.push({ type: "<}-token>" });
+		else if (code >= 48 && code <= 57) {
+			var result = consumeNumeric(str, index);
+			var _k = __read(result, 2), lastIndex = _k[0], tokenTuple = _k[1];
+			if (tokenTuple[0] === "<dimension-token>") tokens.push({
+				type: "<dimension-token>",
+				value: tokenTuple[1],
+				unit: tokenTuple[2].toLowerCase(),
+				flag: "number"
+			});
+			else if (tokenTuple[0] === "<number-token>") tokens.push({
+				type: tokenTuple[0],
+				value: tokenTuple[1],
+				flag: tokenTuple[2]
+			});
+			else tokens.push({
+				type: tokenTuple[0],
+				value: tokenTuple[1],
+				flag: "number"
+			});
+			index = lastIndex;
+		} else if (code === 95 || code >= 65 && code <= 90 || code >= 97 && code <= 122 || code >= 128) {
+			var result = consumeIdentLike(str, index);
+			if (result === null) return null;
+			var _l = __read(result, 3), lastIndex = _l[0], value = _l[1], type = _l[2];
+			tokens.push({
+				type,
+				value
+			});
+			index = lastIndex;
+		} else tokens.push({
+			type: "<delim-token>",
+			value: code
+		});
+	}
+	tokens.push({ type: "<EOF-token>" });
+	return tokens;
+};
+var consumeString = function consumeString(str, index) {
+	if (str.length <= index + 1) return null;
+	var firstCode = str.charCodeAt(index);
+	var charCodes = [];
+	for (var i = index + 1; i < str.length; i += 1) {
+		var code = str.charCodeAt(i);
+		if (code === firstCode) return [i, String.fromCharCode.apply(null, charCodes)];
+		else if (code === 92) {
+			var result = consumeEscape(str, i);
+			if (result === null) return null;
+			var _a = __read(result, 2), lastIndex = _a[0], charCode = _a[1];
+			charCodes.push(charCode);
+			i = lastIndex;
+		} else if (code === 10) return null;
+		else charCodes.push(code);
+	}
+	return null;
+};
+var wouldStartIdentifier = function wouldStartIdentifier(str, index) {
+	if (str.length <= index) return false;
+	var code = str.charCodeAt(index);
+	if (code === 45) {
+		if (str.length <= index + 1) return false;
+		var nextCode = str.charCodeAt(index + 1);
+		if (nextCode === 45 || nextCode === 95 || nextCode >= 65 && nextCode <= 90 || nextCode >= 97 && nextCode <= 122 || nextCode >= 128) return true;
+		else if (nextCode === 92) {
+			if (str.length <= index + 2) return false;
+			return str.charCodeAt(index + 2) !== 10;
+		} else return false;
+	} else if (code === 95 || code >= 65 && code <= 90 || code >= 97 && code <= 122 || code >= 128) return true;
+	else if (code === 92) {
+		if (str.length <= index + 1) return false;
+		var nextCode = str.charCodeAt(index + 1);
+		return nextCode !== 10;
+	} else return false;
+};
+var consumeEscape = function consumeEscape(str, index) {
+	if (str.length <= index + 1) return null;
+	if (str.charCodeAt(index) !== 92) return null;
+	var code = str.charCodeAt(index + 1);
+	if (code === 10) return null;
+	else if (code >= 48 && code <= 57 || code >= 65 && code <= 70 || code >= 97 && code <= 102) {
+		var hexCharCodes = [code];
+		var min = Math.min(index + 7, str.length);
+		var i = index + 2;
+		for (; i < min; i += 1) {
+			var code_2 = str.charCodeAt(i);
+			if (code_2 >= 48 && code_2 <= 57 || code_2 >= 65 && code_2 <= 70 || code_2 >= 97 && code_2 <= 102) hexCharCodes.push(code_2);
+			else break;
+		}
+		if (i < str.length) {
+			var code_3 = str.charCodeAt(i);
+			if (code_3 === 9 || code_3 === 32 || code_3 === 10) i += 1;
+		}
+		return [i - 1, parseInt(String.fromCharCode.apply(null, hexCharCodes), 16)];
+	} else return [index + 1, code];
+};
+var consumeNumeric = function consumeNumeric(str, index) {
+	var numberResult = consumeNumber(str, index);
+	if (numberResult === null) return null;
+	var _a = __read(numberResult, 3), numberEndIndex = _a[0], numberValue = _a[1], numberFlag = _a[2];
+	var identResult = consumeIdent(str, numberEndIndex + 1);
+	if (identResult !== null) {
+		var _b = __read(identResult, 2);
+		return [_b[0], [
+			"<dimension-token>",
+			numberValue,
+			_b[1]
+		]];
+	}
+	if (numberEndIndex + 1 < str.length && str.charCodeAt(numberEndIndex + 1) === 37) return [numberEndIndex + 1, ["<percentage-token>", numberValue]];
+	return [numberEndIndex, [
+		"<number-token>",
+		numberValue,
+		numberFlag
+	]];
+};
+var consumeNumber = function consumeNumber(str, index) {
+	if (str.length <= index) return null;
+	var flag = "integer";
+	var numberChars = [];
+	var firstCode = str.charCodeAt(index);
+	if (firstCode === 43 || firstCode === 45) {
+		index += 1;
+		if (firstCode === 45) numberChars.push(45);
+	}
+	while (index < str.length) {
+		var code = str.charCodeAt(index);
+		if (code >= 48 && code <= 57) {
+			numberChars.push(code);
+			index += 1;
+		} else break;
+	}
+	if (index + 1 < str.length) {
+		var nextCode = str.charCodeAt(index);
+		var nextNextCode = str.charCodeAt(index + 1);
+		if (nextCode === 46 && nextNextCode >= 48 && nextNextCode <= 57) {
+			numberChars.push(nextCode, nextNextCode);
+			flag = "number";
+			index += 2;
+			while (index < str.length) {
+				var code = str.charCodeAt(index);
+				if (code >= 48 && code <= 57) {
+					numberChars.push(code);
+					index += 1;
+				} else break;
+			}
+		}
+	}
+	if (index + 1 < str.length) {
+		var nextCode = str.charCodeAt(index);
+		var nextNextCode = str.charCodeAt(index + 1);
+		var nextNextNextCode = str.charCodeAt(index + 2);
+		if (nextCode === 69 || nextCode === 101) {
+			var nextNextIsDigit = nextNextCode >= 48 && nextNextCode <= 57;
+			if (nextNextIsDigit || (nextNextCode === 43 || nextNextCode === 45) && nextNextNextCode >= 48 && nextNextNextCode <= 57) {
+				flag = "number";
+				if (nextNextIsDigit) {
+					numberChars.push(69, nextNextCode);
+					index += 2;
+				} else if (nextNextCode === 45) {
+					numberChars.push(69, 45, nextNextNextCode);
+					index += 3;
+				} else {
+					numberChars.push(69, nextNextNextCode);
+					index += 3;
+				}
+				while (index < str.length) {
+					var code = str.charCodeAt(index);
+					if (code >= 48 && code <= 57) {
+						numberChars.push(code);
+						index += 1;
+					} else break;
+				}
+			}
+		}
+	}
+	var numberString = String.fromCharCode.apply(null, numberChars);
+	var value = flag === "number" ? parseFloat(numberString) : parseInt(numberString);
+	if (value === -0) value = 0;
+	return Number.isNaN(value) ? null : [
+		index - 1,
+		value,
+		flag
+	];
+};
+var consumeIdentUnsafe = function consumeIdentUnsafe(str, index) {
+	if (str.length <= index) return null;
+	var identChars = [];
+	for (var code = str.charCodeAt(index); index < str.length; code = str.charCodeAt(++index)) {
+		if (code === 45 || code === 95 || code >= 65 && code <= 90 || code >= 97 && code <= 122 || code >= 128 || code >= 48 && code <= 57) {
+			identChars.push(code);
+			continue;
+		} else {
+			var result = consumeEscape(str, index);
+			if (result !== null) {
+				var _a = __read(result, 2), lastIndex = _a[0], code_4 = _a[1];
+				identChars.push(code_4);
+				index = lastIndex;
+				continue;
+			}
+		}
+		break;
+	}
+	return index === 0 ? null : [index - 1, String.fromCharCode.apply(null, identChars)];
+};
+var consumeIdent = function consumeIdent(str, index) {
+	if (str.length <= index || !wouldStartIdentifier(str, index)) return null;
+	var identChars = [];
+	for (var code = str.charCodeAt(index); index < str.length; code = str.charCodeAt(++index)) {
+		if (code === 45 || code === 95 || code >= 65 && code <= 90 || code >= 97 && code <= 122 || code >= 128 || code >= 48 && code <= 57) {
+			identChars.push(code);
+			continue;
+		} else {
+			var result = consumeEscape(str, index);
+			if (result !== null) {
+				var _a = __read(result, 2), lastIndex = _a[0], code_5 = _a[1];
+				identChars.push(code_5);
+				index = lastIndex;
+				continue;
+			}
+		}
+		break;
+	}
+	return [index - 1, String.fromCharCode.apply(null, identChars)];
+};
+var consumeUrl = function consumeUrl(str, index) {
+	var code = str.charCodeAt(index);
+	while (code === 9 || code === 32 || code === 10) code = str.charCodeAt(++index);
+	var urlChars = [];
+	var hasFinishedWord = false;
+	while (index < str.length) {
+		if (code === 41) return [index, String.fromCharCode.apply(null, urlChars)];
+		else if (code === 34 || code === 39 || code === 40) return null;
+		else if (code === 9 || code === 32 || code === 10) {
+			if (!hasFinishedWord && urlChars.length !== 0) hasFinishedWord = true;
+		} else if (code === 92) {
+			var result = consumeEscape(str, index);
+			if (result === null || hasFinishedWord) return null;
+			var _a = __read(result, 2), lastIndex = _a[0], value = _a[1];
+			urlChars.push(value);
+			index = lastIndex;
+		} else {
+			if (hasFinishedWord) return null;
+			urlChars.push(code);
+		}
+		code = str.charCodeAt(++index);
+	}
+	return null;
+};
+var consumeIdentLike = function consumeIdentLike(str, index) {
+	var result = consumeIdent(str, index);
+	if (result === null) return null;
+	var _a = __read(result, 2), lastIndex = _a[0], value = _a[1];
+	if (value.toLowerCase() === "url") {
+		if (str.length > lastIndex + 1) {
+			var nextCode = str.charCodeAt(lastIndex + 1);
+			if (nextCode === 40) {
+				for (var offset = 2; lastIndex + offset < str.length; offset += 1) {
+					var nextNextCode = str.charCodeAt(lastIndex + offset);
+					if (nextNextCode === 34 || nextNextCode === 39) return [
+						lastIndex + 1,
+						value.toLowerCase(),
+						"<function-token>"
+					];
+					else if (nextNextCode !== 9 && nextNextCode !== 32 && nextNextCode !== 10) {
+						var result_1 = consumeUrl(str, lastIndex + offset);
+						if (result_1 === null) return null;
+						var _b = __read(result_1, 2);
+						return [
+							_b[0],
+							_b[1],
+							"<url-token>"
+						];
+					}
+				}
+				return [
+					lastIndex + 1,
+					value.toLowerCase(),
+					"<function-token>"
+				];
+			}
+		}
+	} else if (str.length > lastIndex + 1) {
+		var nextCode = str.charCodeAt(lastIndex + 1);
+		if (nextCode === 40) return [
+			lastIndex + 1,
+			value.toLowerCase(),
+			"<function-token>"
+		];
+	}
+	return [
+		lastIndex,
+		value.toLowerCase(),
+		"<ident-token>"
+	];
+};
+var simplifyAST = function simplifyAST(ast) {
+	for (var i = ast.length - 1; i >= 0; i--) ast[i] = simplifyMediaQuery(ast[i]);
+	return ast;
+};
+var simplifyMediaQuery = function simplifyMediaQuery(mediaQuery) {
+	if (mediaQuery.mediaCondition === null) return mediaQuery;
+	var mediaCondition = simplifyMediaCondition(mediaQuery.mediaCondition);
+	if (mediaCondition.operator === null && mediaCondition.children.length === 1 && "children" in mediaCondition.children[0]) mediaCondition = mediaCondition.children[0];
+	return {
+		mediaPrefix: mediaQuery.mediaPrefix,
+		mediaType: mediaQuery.mediaType,
+		mediaCondition
+	};
+};
+var simplifyMediaCondition = function simplifyMediaCondition(mediaCondition) {
+	for (var i = mediaCondition.children.length - 1; i >= 0; i--) {
+		var unsimplifiedChild = mediaCondition.children[i];
+		if (!("context" in unsimplifiedChild)) {
+			var child = simplifyMediaCondition(unsimplifiedChild);
+			if (child.operator === null && child.children.length === 1) mediaCondition.children[i] = child.children[0];
+			else if (child.operator === mediaCondition.operator && (child.operator === "and" || child.operator === "or")) {
+				var spliceArgs = [i, 1];
+				for (var i_1 = 0; i_1 < child.children.length; i_1++) spliceArgs.push(child.children[i_1]);
+				mediaCondition.children.splice.apply(mediaCondition.children, spliceArgs);
+			}
+		}
+	}
+	return mediaCondition;
+};
+var createError = function createError(message, err) {
+	if (err instanceof Error) return new Error("".concat(err.message.trim(), "\n").concat(message.trim()));
+	else return new Error(message.trim());
+};
+var toAST = function toAST(str) {
+	return simplifyAST(toUnflattenedAST(str));
+};
+var toUnflattenedAST = function toUnflattenedAST(str) {
+	var tokenList = lexicalAnalysis(str.trim());
+	if (tokenList === null) throw createError("Failed tokenizing");
+	var startIndex = 0;
+	var endIndex = tokenList.length - 1;
+	if (tokenList[0].type === "<at-keyword-token>" && tokenList[0].value === "media") {
+		if (tokenList[1].type !== "<whitespace-token>") throw createError("Expected whitespace after media");
+		startIndex = 2;
+		for (var i = 2; i < tokenList.length - 1; i++) {
+			var token = tokenList[i];
+			if (token.type === "<{-token>") {
+				endIndex = i;
+				break;
+			} else if (token.type === "<semicolon-token>") throw createError("Expected '{' in media query but found ';'");
+		}
+	}
+	tokenList = tokenList.slice(startIndex, endIndex);
+	return syntacticAnalysis(tokenList);
+};
+var removeWhitespace = function removeWhitespace(tokenList) {
+	var newTokenList = [];
+	var before = false;
+	for (var i = 0; i < tokenList.length; i++) if (tokenList[i].type === "<whitespace-token>") {
+		before = true;
+		if (newTokenList.length > 0) newTokenList[newTokenList.length - 1].wsAfter = true;
+	} else {
+		newTokenList.push(__assign(__assign({}, tokenList[i]), {
+			wsBefore: before,
+			wsAfter: false
+		}));
+		before = false;
+	}
+	return newTokenList;
+};
+var syntacticAnalysis = function syntacticAnalysis(tokenList) {
+	var e_1, _a;
+	var mediaQueryList = [[]];
+	for (var i = 0; i < tokenList.length; i++) {
+		var token = tokenList[i];
+		if (token.type === "<comma-token>") mediaQueryList.push([]);
+		else mediaQueryList[mediaQueryList.length - 1].push(token);
+	}
+	var mediaQueries = mediaQueryList.map(removeWhitespace);
+	if (mediaQueries.length === 1 && mediaQueries[0].length === 0) return [{
+		mediaCondition: null,
+		mediaPrefix: null,
+		mediaType: "all"
+	}];
+	else {
+		var mediaQueryTokens = mediaQueries.map(function(mediaQueryTokens) {
+			if (mediaQueryTokens.length === 0) return null;
+			else return tokenizeMediaQuery(mediaQueryTokens);
+		});
+		var nonNullMediaQueryTokens = [];
+		try {
+			for (var mediaQueryTokens_1 = __values(mediaQueryTokens), mediaQueryTokens_1_1 = mediaQueryTokens_1.next(); !mediaQueryTokens_1_1.done; mediaQueryTokens_1_1 = mediaQueryTokens_1.next()) {
+				var mediaQueryToken = mediaQueryTokens_1_1.value;
+				if (mediaQueryToken !== null) nonNullMediaQueryTokens.push(mediaQueryToken);
+			}
+		} catch (e_1_1) {
+			e_1 = { error: e_1_1 };
+		} finally {
+			try {
+				if (mediaQueryTokens_1_1 && !mediaQueryTokens_1_1.done && (_a = mediaQueryTokens_1["return"])) _a.call(mediaQueryTokens_1);
+			} finally {
+				if (e_1) throw e_1.error;
+			}
+		}
+		if (nonNullMediaQueryTokens.length === 0) throw createError("No valid media queries");
+		return nonNullMediaQueryTokens;
+	}
+};
+var tokenizeMediaQuery = function tokenizeMediaQuery(tokens) {
+	var firstToken = tokens[0];
+	if (firstToken.type === "<(-token>") try {
+		return {
+			mediaPrefix: null,
+			mediaType: "all",
+			mediaCondition: tokenizeMediaCondition(tokens, true)
+		};
+	} catch (err) {
+		throw createError("Expected media condition after '('", err);
+	}
+	else if (firstToken.type === "<ident-token>") {
+		var mediaPrefix = null;
+		var mediaType = void 0;
+		var value = firstToken.value;
+		if (value === "only" || value === "not") mediaPrefix = value;
+		var firstIndex = mediaPrefix === null ? 0 : 1;
+		if (tokens.length <= firstIndex) throw createError("Expected extra token in media query");
+		var firstNonUnaryToken = tokens[firstIndex];
+		if (firstNonUnaryToken.type === "<ident-token>") {
+			var value_1 = firstNonUnaryToken.value;
+			if (value_1 === "all") mediaType = "all";
+			else if (value_1 === "print" || value_1 === "screen") mediaType = value_1;
+			else if (value_1 === "tty" || value_1 === "tv" || value_1 === "projection" || value_1 === "handheld" || value_1 === "braille" || value_1 === "embossed" || value_1 === "aural" || value_1 === "speech") {
+				mediaPrefix = mediaPrefix === "not" ? null : "not";
+				mediaType = "all";
+			} else throw createError("Unknown ident '".concat(value_1, "' in media query"));
+		} else if (mediaPrefix === "not" && firstNonUnaryToken.type === "<(-token>") {
+			var tokensWithParens = [{
+				type: "<(-token>",
+				wsBefore: false,
+				wsAfter: false
+			}];
+			tokensWithParens.push.apply(tokensWithParens, tokens);
+			tokensWithParens.push({
+				type: "<)-token>",
+				wsBefore: false,
+				wsAfter: false
+			});
+			try {
+				return {
+					mediaPrefix: null,
+					mediaType: "all",
+					mediaCondition: tokenizeMediaCondition(tokensWithParens, true)
+				};
+			} catch (err) {
+				throw createError("Expected media condition after '('", err);
+			}
+		} else throw createError("Invalid media query");
+		if (firstIndex + 1 === tokens.length) return {
+			mediaPrefix,
+			mediaType,
+			mediaCondition: null
+		};
+		else if (firstIndex + 4 < tokens.length) {
+			var secondNonUnaryToken = tokens[firstIndex + 1];
+			if (secondNonUnaryToken.type === "<ident-token>" && secondNonUnaryToken.value === "and") try {
+				return {
+					mediaPrefix,
+					mediaType,
+					mediaCondition: tokenizeMediaCondition(tokens.slice(firstIndex + 2), false)
+				};
+			} catch (err) {
+				throw createError("Expected media condition after 'and'", err);
+			}
+			else throw createError("Expected 'and' after media prefix");
+		} else throw createError("Expected media condition after media prefix");
+	} else throw createError("Expected media condition or media prefix");
+};
+var tokenizeMediaCondition = function tokenizeMediaCondition(tokens, mayContainOr, previousOperator) {
+	if (previousOperator === void 0) previousOperator = null;
+	if (tokens.length < 3 || tokens[0].type !== "<(-token>" || tokens[tokens.length - 1].type !== "<)-token>") throw new Error("Invalid media condition");
+	var endIndexOfFirstFeature = tokens.length - 1;
+	var maxDepth = 0;
+	var count = 0;
+	for (var i = 0; i < tokens.length; i++) {
+		var token = tokens[i];
+		if (token.type === "<(-token>") {
+			count += 1;
+			maxDepth = Math.max(maxDepth, count);
+		} else if (token.type === "<)-token>") count -= 1;
+		if (count === 0) {
+			endIndexOfFirstFeature = i;
+			break;
+		}
+	}
+	if (count !== 0) throw new Error("Mismatched parens\nInvalid media condition");
+	var child;
+	var featureTokens = tokens.slice(0, endIndexOfFirstFeature + 1);
+	if (maxDepth === 1) child = tokenizeMediaFeature(featureTokens);
+	else if (featureTokens[1].type === "<ident-token>" && featureTokens[1].value === "not") child = tokenizeMediaCondition(featureTokens.slice(2, -1), true, "not");
+	else child = tokenizeMediaCondition(featureTokens.slice(1, -1), true);
+	if (endIndexOfFirstFeature === tokens.length - 1) return {
+		operator: previousOperator,
+		children: [child]
+	};
+	else {
+		var nextToken = tokens[endIndexOfFirstFeature + 1];
+		if (nextToken.type !== "<ident-token>") throw new Error("Invalid operator\nInvalid media condition");
+		else if (previousOperator !== null && previousOperator !== nextToken.value) throw new Error("'".concat(nextToken.value, "' and '").concat(previousOperator, "' must not be at same level\nInvalid media condition"));
+		else if (nextToken.value === "or" && !mayContainOr) throw new Error("Cannot use 'or' at top level of a media query\nInvalid media condition");
+		else if (nextToken.value !== "and" && nextToken.value !== "or") throw new Error("Invalid operator: '".concat(nextToken.value, "'\nInvalid media condition"));
+		var siblings = tokenizeMediaCondition(tokens.slice(endIndexOfFirstFeature + 2), mayContainOr, nextToken.value);
+		return {
+			operator: nextToken.value,
+			children: [child].concat(siblings.children)
+		};
+	}
+};
+var tokenizeMediaFeature = function tokenizeMediaFeature(rawTokens) {
+	if (rawTokens.length < 3 || rawTokens[0].type !== "<(-token>" || rawTokens[rawTokens.length - 1].type !== "<)-token>") throw new Error("Invalid media feature");
+	var tokens = [rawTokens[0]];
+	for (var i = 1; i < rawTokens.length; i++) {
+		if (i < rawTokens.length - 2) {
+			var a = rawTokens[i];
+			var b = rawTokens[i + 1];
+			var c = rawTokens[i + 2];
+			if (a.type === "<number-token>" && a.value > 0 && b.type === "<delim-token>" && b.value === 47 && c.type === "<number-token>" && c.value > 0) {
+				tokens.push({
+					type: "<ratio-token>",
+					numerator: a.value,
+					denominator: c.value,
+					wsBefore: a.wsBefore,
+					wsAfter: c.wsAfter
+				});
+				i += 2;
+				continue;
+			}
+		}
+		tokens.push(rawTokens[i]);
+	}
+	var nextToken = tokens[1];
+	if (nextToken.type === "<ident-token>" && tokens.length === 3) return {
+		context: "boolean",
+		feature: nextToken.value
+	};
+	else if (tokens.length === 5 && tokens[1].type === "<ident-token>" && tokens[2].type === "<colon-token>") {
+		var valueToken = tokens[3];
+		if (valueToken.type === "<number-token>" || valueToken.type === "<dimension-token>" || valueToken.type === "<ratio-token>" || valueToken.type === "<ident-token>") {
+			var feature = tokens[1].value;
+			var prefix = null;
+			var slice = feature.slice(0, 4);
+			if (slice === "min-") {
+				prefix = "min";
+				feature = feature.slice(4);
+			} else if (slice === "max-") {
+				prefix = "max";
+				feature = feature.slice(4);
+			}
+			valueToken.wsBefore;
+			valueToken.wsAfter;
+			var value = __rest(valueToken, ["wsBefore", "wsAfter"]);
+			return {
+				context: "value",
+				prefix,
+				feature,
+				value
+			};
+		}
+	} else if (tokens.length >= 5) try {
+		var range = tokenizeRange(tokens);
+		return {
+			context: "range",
+			feature: range.featureName,
+			range
+		};
+	} catch (err) {
+		throw createError("Invalid media feature", err);
+	}
+	throw new Error("Invalid media feature");
+};
+var tokenizeRange = function tokenizeRange(tokens) {
+	var _a, _b, _c, _d;
+	if (tokens.length < 5 || tokens[0].type !== "<(-token>" || tokens[tokens.length - 1].type !== "<)-token>") throw new Error("Invalid range");
+	var range = {
+		leftToken: null,
+		leftOp: null,
+		featureName: "",
+		rightOp: null,
+		rightToken: null
+	};
+	var hasLeft = tokens[1].type === "<number-token>" || tokens[1].type === "<dimension-token>" || tokens[1].type === "<ratio-token>" || tokens[1].type === "<ident-token>" && tokens[1].value === "infinite";
+	if (tokens[2].type === "<delim-token>") {
+		if (tokens[2].value === 60) if (tokens[3].type === "<delim-token>" && tokens[3].value === 61 && !tokens[3].wsBefore) range[hasLeft ? "leftOp" : "rightOp"] = "<=";
+		else range[hasLeft ? "leftOp" : "rightOp"] = "<";
+		else if (tokens[2].value === 62) if (tokens[3].type === "<delim-token>" && tokens[3].value === 61 && !tokens[3].wsBefore) range[hasLeft ? "leftOp" : "rightOp"] = ">=";
+		else range[hasLeft ? "leftOp" : "rightOp"] = ">";
+		else if (tokens[2].value === 61) range[hasLeft ? "leftOp" : "rightOp"] = "=";
+		else throw new Error("Invalid range");
+		if (hasLeft) range.leftToken = tokens[1];
+		else if (tokens[1].type === "<ident-token>") range.featureName = tokens[1].value;
+		else throw new Error("Invalid range");
+		var tokenIndexAfterFirstOp = 2 + ((_b = (_a = range[hasLeft ? "leftOp" : "rightOp"]) === null || _a === void 0 ? void 0 : _a.length) !== null && _b !== void 0 ? _b : 0);
+		var tokenAfterFirstOp = tokens[tokenIndexAfterFirstOp];
+		if (hasLeft) if (tokenAfterFirstOp.type === "<ident-token>") {
+			range.featureName = tokenAfterFirstOp.value;
+			if (tokens.length >= 7) {
+				var secondOpToken = tokens[tokenIndexAfterFirstOp + 1];
+				var followingToken = tokens[tokenIndexAfterFirstOp + 2];
+				if (secondOpToken.type === "<delim-token>") {
+					var charCode = secondOpToken.value;
+					if (charCode === 60) if (followingToken.type === "<delim-token>" && followingToken.value === 61 && !followingToken.wsBefore) range.rightOp = "<=";
+					else range.rightOp = "<";
+					else if (charCode === 62) if (followingToken.type === "<delim-token>" && followingToken.value === 61 && !followingToken.wsBefore) range.rightOp = ">=";
+					else range.rightOp = ">";
+					else throw new Error("Invalid range");
+					range.rightToken = tokens[tokenIndexAfterFirstOp + 1 + ((_d = (_c = range.rightOp) === null || _c === void 0 ? void 0 : _c.length) !== null && _d !== void 0 ? _d : 0)];
+				} else throw new Error("Invalid range");
+			} else if (tokenIndexAfterFirstOp + 2 !== tokens.length) throw new Error("Invalid range");
+		} else throw new Error("Invalid range");
+		else range.rightToken = tokenAfterFirstOp;
+		var validRange = null;
+		var lt = range.leftToken, leftOp = range.leftOp, featureName = range.featureName, rightOp = range.rightOp, rt = range.rightToken;
+		var leftToken = null;
+		if (lt !== null) {
+			if (lt.type === "<ident-token>") {
+				var type = lt.type, value = lt.value;
+				if (value === "infinite") leftToken = {
+					type,
+					value
+				};
+			} else if (lt.type === "<number-token>" || lt.type === "<dimension-token>" || lt.type === "<ratio-token>") {
+				lt.wsBefore;
+				lt.wsAfter;
+				leftToken = __rest(lt, ["wsBefore", "wsAfter"]);
+			}
+		}
+		var rightToken = null;
+		if (rt !== null) {
+			if (rt.type === "<ident-token>") {
+				var type = rt.type, value = rt.value;
+				if (value === "infinite") rightToken = {
+					type,
+					value
+				};
+			} else if (rt.type === "<number-token>" || rt.type === "<dimension-token>" || rt.type === "<ratio-token>") {
+				rt.wsBefore;
+				rt.wsAfter;
+				rightToken = __rest(rt, ["wsBefore", "wsAfter"]);
+			}
+		}
+		if (leftToken !== null && rightToken !== null) if ((leftOp === "<" || leftOp === "<=") && (rightOp === "<" || rightOp === "<=")) validRange = {
+			leftToken,
+			leftOp,
+			featureName,
+			rightOp,
+			rightToken
+		};
+		else if ((leftOp === ">" || leftOp === ">=") && (rightOp === ">" || rightOp === ">=")) validRange = {
+			leftToken,
+			leftOp,
+			featureName,
+			rightOp,
+			rightToken
+		};
+		else throw new Error("Invalid range");
+		else if (leftToken === null && leftOp === null && rightOp !== null && rightToken !== null) validRange = {
+			leftToken,
+			leftOp,
+			featureName,
+			rightOp,
+			rightToken
+		};
+		else if (leftToken !== null && leftOp !== null && rightOp === null && rightToken === null) validRange = {
+			leftToken,
+			leftOp,
+			featureName,
+			rightOp,
+			rightToken
+		};
+		return validRange;
+	} else throw new Error("Invalid range");
+};
+//#endregion
+export { toAST };