UNPKG

hyperscript.org/dist/_hyperscript_w9y.js

Version:
194 kBJavaScriptView Raw
1///=========================================================================
2/// This module provides the core runtime and grammar for hyperscript
3///=========================================================================
4//AMD insanity
5
6/** @var {HyperscriptObject} _hyperscript */
7
8(function (root, factory) {
if (typeof module != 'undefined') {
module.exports = factory();
} else if (typeof this.define === "function" && this.define.amd) {
// AMD. Register as an anonymous module.
this.define([], factory);
} else {
// Browser globals
root._hyperscript = factory();
}
18})(typeof self !== "undefined" ? self : this, function () {
"use strict";
20
//====================================================================
// Utilities
//====================================================================
24
/**
* mergeObjects combines the keys from obj2 into obj2, then returns obj1
*
* @param {object} obj1
* @param {object} obj2
* @returns object
*/
function mergeObjects(obj1, obj2) {
for (var key in obj2) {
	if (obj2.hasOwnProperty(key)) {
		obj1[key] = obj2[key];
	}
}
return obj1;
}
40
function getOrInitObject(root, prop) {
var value = root[prop];
if (value) {
	return value;
} else {
	var newObj = {};
	root[prop] = newObj;
	return newObj;
}
}
51
/**
* parseJSON parses a JSON string into a corresponding value.  If the
* value passed in is not valid JSON, then it logs an error and returns `null`.
*
* @param {string} jString
* @returns any
*/
function parseJSON(jString) {
try {
	return JSON.parse(jString);
} catch (error) {
	logError(error);
	return null;
}
}
67
/**
* logError writes an error message to the Javascript console.  It can take any
* value, but msg should commonly be a simple string.
* @param {*} msg
*/
function logError(msg) {
if (console.error) {
	console.error(msg);
} else if (console.log) {
	console.log("ERROR: ", msg);
}
}
80
// TODO: JSDoc description of what's happening here
function varargConstructor(Cls, args) {
return new (Cls.bind.apply(Cls, [Cls].concat(args)))();
}
85
var globalScope = (1, eval)("this");
87
//====================================================================
// Standard library
//====================================================================
91
class ElementCollection {
constructor(css, relativeToElement) {
	this._css = css;
	this.relativeToElement = relativeToElement;
}
97
get css() {
	return _runtime.escapeSelector(this._css);
}
101
get className() {
	return this._css.substr(1);
}
105
get id() {
	return this.className();
}
109
[Symbol.iterator]() {
	return _runtime.getRootNode(this.relativeToElement)
		.querySelectorAll(this.css)
		[Symbol.iterator]();
}
}
116
//====================================================================
// Lexer
//====================================================================
120
/** @type LexerObject */
var _lexer = (function () {
var OP_TABLE = {
	"+": "PLUS",
	"-": "MINUS",
	"*": "MULTIPLY",
	"/": "DIVIDE",
	".": "PERIOD",
	"..": "ELLIPSIS",
	"\\": "BACKSLASH",
	":": "COLON",
	"%": "PERCENT",
	"|": "PIPE",
	"!": "EXCLAMATION",
	"?": "QUESTION",
	"#": "POUND",
	"&": "AMPERSAND",
	$: "DOLLAR",
	";": "SEMI",
	",": "COMMA",
	"(": "L_PAREN",
	")": "R_PAREN",
	"<": "L_ANG",
	">": "R_ANG",
	"<=": "LTE_ANG",
	">=": "GTE_ANG",
	"==": "EQ",
	"===": "EQQ",
	"!=": "NEQ",
	"!==": "NEQQ",
	"{": "L_BRACE",
	"}": "R_BRACE",
	"[": "L_BRACKET",
	"]": "R_BRACKET",
	"=": "EQUALS",
};
157
/**
 * isValidCSSClassChar returns `true` if the provided character is valid in a CSS class.
 * @param {string} c
 * @returns boolean
 */
function isValidCSSClassChar(c) {
	return isAlpha(c) || isNumeric(c) || c === "-" || c === "_" || c === ":";
}
166
/**
 * isValidCSSIDChar returns `true` if the provided character is valid in a CSS ID
 * @param {string} c
 * @returns boolean
 */
function isValidCSSIDChar(c) {
	return isAlpha(c) || isNumeric(c) || c === "-" || c === "_" || c === ":";
}
175
/**
 * isWhitespace returns `true` if the provided character is whitespace.
 * @param {string} c
 * @returns boolean
 */
function isWhitespace(c) {
	return c === " " || c === "\t" || isNewline(c);
}
184
/**
 * positionString returns a string representation of a Token's line and column details.
 * @param {Token} token
 * @returns string
 */
function positionString(token) {
	return "[Line: " + token.line + ", Column: " + token.column + "]";
}
193
/**
 * isNewline returns `true` if the provided character is a carrage return or newline
 * @param {string} c
 * @returns boolean
 */
function isNewline(c) {
	return c === "\r" || c === "\n";
}
202
/**
 * isNumeric returns `true` if the provided character is a number (0-9)
 * @param {string} c
 * @returns boolean
 */
function isNumeric(c) {
	return c >= "0" && c <= "9";
}
211
/**
 * isAlpha returns `true` if the provided character is a letter in the alphabet
 * @param {string} c
 * @returns boolean
 */
function isAlpha(c) {
	return (c >= "a" && c <= "z") || (c >= "A" && c <= "Z");
}
220
/**
 * @param {string} c
 * @param {boolean} [dollarIsOp]
 * @returns boolean
 */
function isIdentifierChar(c, dollarIsOp) {
	return c === "_" || c === "$";
}
229
/**
 * @param {string} c
 * @returns boolean
 */
function isReservedChar(c) {
	return c === "`" || c === "^";
}
237
/**
 * @param {Token[]} tokens
 * @param {Token[]} consumed
 * @param {string} source
 * @returns {TokensObject}
 */
function makeTokensObject(tokens, consumed, source) {
	consumeWhitespace(); // consume initial whitespace
246
	/** @type Token | null */
	var _lastConsumed = null;
249
	function consumeWhitespace() {
		while (token(0, true).type === "WHITESPACE") {
			consumed.push(tokens.shift());
		}
	}
255
	/**
	 * @param {TokensObject} tokens
	 * @param {*} error
	 */
	function raiseError(tokens, error) {
		_parser.raiseParseError(tokens, error);
	}
263
	/**
	 * @param {string} value
	 * @returns {Token}
	 */
	function requireOpToken(value) {
		var token = matchOpToken(value);
		if (token) {
			return token;
		} else {
			raiseError(this, "Expected '" + value + "' but found '" + currentToken().value + "'");
		}
	}
276
	/**
	 * @param {string} op1
	 * @param {string} [op2]
	 * @param {string} [op3]
	 * @returns {Token | void}
	 */
	function matchAnyOpToken(op1, op2, op3) {
		for (var i = 0; i < arguments.length; i++) {
			var opToken = arguments[i];
			var match = matchOpToken(opToken);
			if (match) {
				return match;
			}
		}
	}
292
	/**
	 * @param {string} op1
	 * @param {string} [op2]
	 * @param {string} [op3]
	 * @returns {Token | void}
	 */
	function matchAnyToken(op1, op2, op3) {
		for (var i = 0; i < arguments.length; i++) {
			var opToken = arguments[i];
			var match = matchToken(opToken);
			if (match) {
				return match;
			}
		}
	}
308
	/**
	 * @param {string} value
	 * @returns {Token | void}
	 */
	function matchOpToken(value) {
		if (currentToken() && currentToken().op && currentToken().value === value) {
			return consumeToken();
		}
	}
318
	/**
	 * @param {string} type1
	 * @param {string} [type2]
	 * @param {string} [type3]
	 * @param {string} [type4]
	 * @returns {Token}
	 */
	function requireTokenType(type1, type2, type3, type4) {
		var token = matchTokenType(type1, type2, type3, type4);
		if (token) {
			return token;
		} else {
			raiseError(this, "Expected one of " + JSON.stringify([type1, type2, type3]));
		}
	}
334
	/**
	 * @param {string} type1
	 * @param {string} [type2]
	 * @param {string} [type3]
	 * @param {string} [type4]
	 * @returns {Token | void}
	 */
	function matchTokenType(type1, type2, type3, type4) {
		if (
			currentToken() &&
			currentToken().type &&
			[type1, type2, type3, type4].indexOf(currentToken().type) >= 0
		) {
			return consumeToken();
		}
	}
351
	/**
	 * @param {string} value
	 * @param {string} [type]
	 * @returns {Token}
	 */
	function requireToken(value, type) {
		var token = matchToken(value, type);
		if (token) {
			return token;
		} else {
			raiseError(this, "Expected '" + value + "' but found '" + currentToken().value + "'");
		}
	}
365
	/**
	 * @param {string} value
	 * @param {string} [type]
	 * @returns {Token | void}
	 */
	function matchToken(value, type) {
		if (follows.indexOf(value) !== -1) {
			return; // disallowed token here
		}
		var type = type || "IDENTIFIER";
		if (currentToken() && currentToken().value === value && currentToken().type === type) {
			return consumeToken();
		}
	}
380
	/**
	 * @returns {Token}
	 */
	function consumeToken() {
		var match = tokens.shift();
		consumed.push(match);
		_lastConsumed = match;
		consumeWhitespace(); // consume any whitespace
		return match;
	}
391
	/**
	 * @param {string} value
	 * @param {string} [type]
	 * @returns {Token[]}
	 */
	function consumeUntil(value, type) {
		/** @type Token[] */
		var tokenList = [];
		var currentToken = token(0, true);
401
		while (
			(type == null || currentToken.type !== type) &&
			(value == null || currentToken.value !== value) &&
			currentToken.type !== "EOF"
		) {
			var match = tokens.shift();
			consumed.push(match);
			tokenList.push(currentToken);
			currentToken = token(0, true);
		}
		consumeWhitespace(); // consume any whitespace
		return tokenList;
	}
415
	/**
	 * @returns {string}
	 */
	function lastWhitespace() {
		if (consumed[consumed.length - 1] && consumed[consumed.length - 1].type === "WHITESPACE") {
			return consumed[consumed.length - 1].value;
		} else {
			return "";
		}
	}
426
	function consumeUntilWhitespace() {
		return consumeUntil(null, "WHITESPACE");
	}
430
	/**
	 * @returns {boolean}
	 */
	function hasMore() {
		return tokens.length > 0;
	}
437
	/**
	 * @param {number} n
	 * @param {boolean} [dontIgnoreWhitespace]
	 * @returns {Token}
	 */
	function token(n, dontIgnoreWhitespace) {
		var /**@type {Token}*/ token;
		var i = 0;
		do {
			if (!dontIgnoreWhitespace) {
				while (tokens[i] && tokens[i].type === "WHITESPACE") {
					i++;
				}
			}
			token = tokens[i];
			n--;
			i++;
		} while (n > -1);
		if (token) {
			return token;
		} else {
			return {
				type: "EOF",
				value: "<<<EOF>>>",
			};
		}
	}
465
	/**
	 * @returns {Token}
	 */
	function currentToken() {
		return token(0);
	}
472
	/**
	 * @returns {Token | null}
	 */
	function lastMatch() {
		return _lastConsumed;
	}
479
	/**
	 * @returns {string}
	 */
	function sourceFor() {
		return source.substring(this.startToken.start, this.endToken.end);
	}
486
	/**
	 * @returns {string}
	 */
	function lineFor() {
		return source.split("\n")[this.startToken.line - 1];
	}
493
	var follows = [];
495
	function pushFollow(str) {
		follows.push(str);
	}
499
	function popFollow() {
		follows.pop();
	}
503
	function clearFollows() {
		var tmp = follows;
		follows = [];
		return tmp;
	}
509
	function restoreFollows(f) {
		follows = f;
	}
513
	/** @type {TokensObject} */
	return {
		pushFollow: pushFollow,
		popFollow: popFollow,
		clearFollow: clearFollows,
		restoreFollow: restoreFollows,
		matchAnyToken: matchAnyToken,
		matchAnyOpToken: matchAnyOpToken,
		matchOpToken: matchOpToken,
		requireOpToken: requireOpToken,
		matchTokenType: matchTokenType,
		requireTokenType: requireTokenType,
		consumeToken: consumeToken,
		matchToken: matchToken,
		requireToken: requireToken,
		list: tokens,
		consumed: consumed,
		source: source,
		hasMore: hasMore,
		currentToken: currentToken,
		lastMatch: lastMatch,
		token: token,
		consumeUntil: consumeUntil,
		consumeUntilWhitespace: consumeUntilWhitespace,
		lastWhitespace: lastWhitespace,
		sourceFor: sourceFor,
		lineFor: lineFor,
	};
}
543
/**
 * @param {Token[]} tokens
 * @returns {boolean}
 */
function isValidSingleQuoteStringStart(tokens) {
	if (tokens.length > 0) {
		var previousToken = tokens[tokens.length - 1];
		if (
			previousToken.type === "IDENTIFIER" ||
			previousToken.type === "CLASS_REF" ||
			previousToken.type === "ID_REF"
		) {
			return false;
		}
		if (previousToken.op && (previousToken.value === ">" || previousToken.value === ")")) {
			return false;
		}
	}
	return true;
}
564
/**
 * @param {string} string
 * @param {boolean} [template]
 * @returns {TokensObject}
 */
function tokenize(string, template) {
	var tokens = /** @type {Token[]}*/ [];
	var source = string;
	var position = 0;
	var column = 0;
	var line = 1;
	var lastToken = "<START>";
	var templateBraceCount = 0;
578
	function inTemplate() {
		return template && templateBraceCount === 0;
	}
582
	while (position < source.length) {
		if (currentChar() === "-" && nextChar() === "-") {
			consumeComment();
		} else {
			if (isWhitespace(currentChar())) {
				tokens.push(consumeWhitespace());
			} else if (
				!possiblePrecedingSymbol() &&
				currentChar() === "." &&
				(isAlpha(nextChar()) || nextChar() === "{")
			) {
				tokens.push(consumeClassReference());
			} else if (
				!possiblePrecedingSymbol() &&
				currentChar() === "#" &&
				(isAlpha(nextChar()) || nextChar() === "{")
			) {
				tokens.push(consumeIdReference());
			} else if (currentChar() === "[" && nextChar() === "@") {
				tokens.push(consumeAttributeReference());
			} else if (currentChar() === "@") {
				tokens.push(consumeShortAttributeReference());
			} else if (isAlpha(currentChar()) || (!inTemplate() && isIdentifierChar(currentChar()))) {
				tokens.push(consumeIdentifier());
			} else if (isNumeric(currentChar())) {
				tokens.push(consumeNumber());
			} else if (!inTemplate() && (currentChar() === '"' || currentChar() === "`")) {
				tokens.push(consumeString());
			} else if (!inTemplate() && currentChar() === "'") {
				if (isValidSingleQuoteStringStart(tokens)) {
					tokens.push(consumeString());
				} else {
					tokens.push(consumeOp());
				}
			} else if (OP_TABLE[currentChar()]) {
				if (lastToken === "$" && currentChar() === "{") {
					templateBraceCount++;
				}
				if (currentChar() === "}") {
					templateBraceCount--;
				}
				tokens.push(consumeOp());
			} else if (inTemplate() || isReservedChar(currentChar())) {
				tokens.push(makeToken("RESERVED", consumeChar()));
			} else {
				if (position < source.length) {
					throw Error("Unknown token: " + currentChar() + " ");
				}
			}
		}
	}
634
	return makeTokensObject(tokens, [], source);
636
	/**
	 * @param {string} [type]
	 * @param {string} [value]
	 * @returns {Token}
	 */
	function makeOpToken(type, value) {
		var token = makeToken(type, value);
		token.op = true;
		return token;
	}
647
	/**
	 * @param {string} [type]
	 * @param {string} [value]
	 * @returns {Token}
	 */
	function makeToken(type, value) {
		return {
			type: type,
			value: value,
			start: position,
			end: position + 1,
			column: column,
			line: line,
		};
	}
663
	function consumeComment() {
		while (currentChar() && !isNewline(currentChar())) {
			consumeChar();
		}
		consumeChar();
	}
670
	/**
	 * @returns Token
	 */
	function consumeClassReference() {
		var classRef = makeToken("CLASS_REF");
		var value = consumeChar();
		if (currentChar() === "{") {
			classRef.template = true;
			value += consumeChar();
			while (currentChar() && currentChar() !== "}") {
				value += consumeChar();
			}
			if (currentChar() !== "}") {
				throw Error("Unterminated class reference");
			} else {
				value += consumeChar(); // consume final curly
			}
		} else {
			while (isValidCSSClassChar(currentChar())) {
				value += consumeChar();
			}
		}
		classRef.value = value;
		classRef.end = position;
		return classRef;
	}
697
	/**
	 * @returns Token
	 */
	function consumeAttributeReference() {
		var attributeRef = makeToken("ATTRIBUTE_REF");
		var value = consumeChar();
		while (position < source.length && currentChar() !== "]") {
			value += consumeChar();
		}
		if (currentChar() === "]") {
			value += consumeChar();
		}
		attributeRef.value = value;
		attributeRef.end = position;
		return attributeRef;
	}
714
	function consumeShortAttributeReference() {
		var attributeRef = makeToken("ATTRIBUTE_REF");
		var value = consumeChar();
		while (isValidCSSIDChar(currentChar())) {
			value += consumeChar();
		}
		attributeRef.value = value;
		attributeRef.end = position;
		return attributeRef;
	}
725
	/**
	 * @returns Token
	 */
	function consumeIdReference() {
		var idRef = makeToken("ID_REF");
		var value = consumeChar();
		if (currentChar() === "{") {
			idRef.template = true;
			value += consumeChar();
			while (currentChar() && currentChar() !== "}") {
				value += consumeChar();
			}
			if (currentChar() !== "}") {
				throw Error("Unterminated id reference");
			} else {
				consumeChar(); // consume final quote
			}
		} else {
			while (isValidCSSIDChar(currentChar())) {
				value += consumeChar();
			}
		}
		idRef.value = value;
		idRef.end = position;
		return idRef;
	}
752
	/**
	 * @returns Token
	 */
	function consumeIdentifier() {
		var identifier = makeToken("IDENTIFIER");
		var value = consumeChar();
		while (isAlpha(currentChar()) || isIdentifierChar(currentChar())) {
			value += consumeChar();
		}
		identifier.value = value;
		identifier.end = position;
		return identifier;
	}
766
	/**
	 * @returns Token
	 */
	function consumeNumber() {
		var number = makeToken("NUMBER");
		var value = consumeChar();
		while (isNumeric(currentChar())) {
			value += consumeChar();
		}
		if (currentChar() === "." && isNumeric(nextChar())) {
			value += consumeChar();
		}
		while (isNumeric(currentChar())) {
			value += consumeChar();
		}
		number.value = value;
		number.end = position;
		return number;
	}
786
	/**
	 * @returns Token
	 */
	function consumeOp() {
		var op = makeOpToken();
		var value = consumeChar(); // consume leading char
		while (currentChar() && OP_TABLE[value + currentChar()]) {
			value += consumeChar();
		}
		op.type = OP_TABLE[value];
		op.value = value;
		op.end = position;
		return op;
	}
801
	/**
	 * @returns Token
	 */
	function consumeString() {
		var string = makeToken("STRING");
		var startChar = consumeChar(); // consume leading quote
		var value = "";
		while (currentChar() && currentChar() !== startChar) {
			if (currentChar() === "\\") {
				consumeChar(); // consume escape char and move on
			}
			value += consumeChar();
		}
		if (currentChar() !== startChar) {
			throw Error("Unterminated string at " + positionString(string));
		} else {
			consumeChar(); // consume final quote
		}
		string.value = value;
		string.end = position;
		string.template = startChar === "`";
		return string;
	}
825
	/**
	 * @returns string
	 */
	function currentChar() {
		return source.charAt(position);
	}
832
	/**
	 * @returns string
	 */
	function nextChar() {
		return source.charAt(position + 1);
	}
839
	/**
	 * @returns string
	 */
	function consumeChar() {
		lastToken = currentChar();
		position++;
		column++;
		return lastToken;
	}
849
	/**
	 * @returns boolean
	 */
	function possiblePrecedingSymbol() {
		return (
			isAlpha(lastToken) ||
			isNumeric(lastToken) ||
			lastToken === ")" ||
			lastToken === "}" ||
			lastToken === "]"
		);
	}
862
	/**
	 * @returns Token
	 */
	function consumeWhitespace() {
		var whitespace = makeToken("WHITESPACE");
		var value = "";
		while (currentChar() && isWhitespace(currentChar())) {
			if (isNewline(currentChar())) {
				column = 0;
				line++;
			}
			value += consumeChar();
		}
		whitespace.value = value;
		whitespace.end = position;
		return whitespace;
	}
}
881
return {
	tokenize: tokenize,
	makeTokensObject: makeTokensObject,
};
})();
887
//====================================================================
// Parser
//====================================================================
891
/** @type ParserObject */
var _parser = (function () {
/** @type {Object<string,GrammarDefinition>} */
var GRAMMAR = {};
896
/** @type {Object<string,GrammarDefinition>} */
var COMMANDS = {};
899
/** @type {Object<string,GrammarDefinition>} */
var FEATURES = {};
902
var LEAF_EXPRESSIONS = [];
var INDIRECT_EXPRESSIONS = [];
905
/**
 * @param {*} parseElement
 * @param {*} start
 * @param {TokensObject} tokens
 */
function initElt(parseElement, start, tokens) {
	parseElement.startToken = start;
	parseElement.sourceFor = tokens.sourceFor;
	parseElement.lineFor = tokens.lineFor;
	parseElement.programSource = tokens.source;
}
917
/**
 * @param {string} type
 * @param {TokensObject} tokens
 * @param {GrammarElement?} root
 * @returns GrammarElement
 */
function parseElement(type, tokens, root = undefined) {
	var elementDefinition = GRAMMAR[type];
	if (elementDefinition) {
		var start = tokens.currentToken();
		var parseElement = elementDefinition(_parser, _runtime, tokens, root);
		if (parseElement) {
			initElt(parseElement, start, tokens);
			parseElement.endToken = parseElement.endToken || tokens.lastMatch();
			var root = parseElement.root;
			while (root != null) {
				initElt(root, start, tokens);
				root = root.root;
			}
		}
		return parseElement;
	}
}
941
/**
 * @param {string} type
 * @param {TokensObject} tokens
 * @param {string} [message]
 * @param {*} [root]
 * @returns {GrammarElement}
 */
function requireElement(type, tokens, message, root) {
	var result = parseElement(type, tokens, root);
	if (!result) raiseParseError(tokens, message || "Expected " + type);
	// @ts-ignore
	return result;
}
955
/**
 * @param {string[]} types
 * @param {TokensObject} tokens
 * @returns {GrammarElement}
 */
function parseAnyOf(types, tokens) {
	for (var i = 0; i < types.length; i++) {
		var type = types[i];
		var expression = parseElement(type, tokens);
		if (expression) {
			return expression;
		}
	}
}
970
/**
 * @param {string} name
 * @param {GrammarDefinition} definition
 */
function addGrammarElement(name, definition) {
	GRAMMAR[name] = definition;
}
978
/**
 * @param {string} keyword
 * @param {GrammarDefinition} definition
 */
function addCommand(keyword, definition) {
	var commandGrammarType = keyword + "Command";
	var commandDefinitionWrapper = function (parser, runtime, tokens) {
		const commandElement = definition(parser, runtime, tokens);
		if (commandElement) {
			commandElement.type = commandGrammarType;
			commandElement.execute = function (context) {
				context.meta.command = commandElement;
				return runtime.unifiedExec(this, context);
			};
			return commandElement;
		}
	};
	GRAMMAR[commandGrammarType] = commandDefinitionWrapper;
	COMMANDS[keyword] = commandDefinitionWrapper;
}
999
/**
 * @param {string} keyword
 * @param {GrammarDefinition} definition
 */
function addFeature(keyword, definition) {
	var featureGrammarType = keyword + "Feature";
1006
	/** @type {GrammarDefinition} */
	var featureDefinitionWrapper = function (parser, runtime, tokens) {
		var featureElement = definition(parser, runtime, tokens);
		if (featureElement) {
			featureElement.keyword = keyword;
			featureElement.type = featureGrammarType;
			return featureElement;
		}
	};
	GRAMMAR[featureGrammarType] = featureDefinitionWrapper;
	FEATURES[keyword] = featureDefinitionWrapper;
}
1019
/**
 * @param {string} name
 * @param {GrammarDefinition} definition
 */
function addLeafExpression(name, definition) {
	LEAF_EXPRESSIONS.push(name);
	addGrammarElement(name, definition);
}
1028
/**
 * @param {string} name
 * @param {GrammarDefinition} definition
 */
function addIndirectExpression(name, definition) {
	INDIRECT_EXPRESSIONS.push(name);
	addGrammarElement(name, definition);
}
1037
/* ============================================================================================ */
/* Core hyperscript Grammar Elements                                                            */
/* ============================================================================================ */
addGrammarElement("feature", function (parser, runtime, tokens) {
	if (tokens.matchOpToken("(")) {
		var featureElement = parser.requireElement("feature", tokens);
		tokens.requireOpToken(")");
		return featureElement;
	}
1047
	var featureDefinition = FEATURES[tokens.currentToken().value];
	if (featureDefinition) {
		return featureDefinition(parser, runtime, tokens);
	}
});
1053
addGrammarElement("command", function (parser, runtime, tokens) {
	if (tokens.matchOpToken("(")) {
		const commandElement = parser.requireElement("command", tokens);
		tokens.requireOpToken(")");
		return commandElement;
	}
1060
	var commandDefinition = COMMANDS[tokens.currentToken().value];
	let commandElement;
	if (commandDefinition) {
		commandElement = commandDefinition(parser, runtime, tokens);
	} else if (tokens.currentToken().type === "IDENTIFIER" && tokens.token(1).value === "(") {
		commandElement = parser.requireElement("pseudoCommand", tokens);
	}
	if (commandElement) {
		return parser.parseElement("indirectStatement", tokens, commandElement);
	}
1071
	return commandElement;
});
1074
addGrammarElement("commandList", function (parser, runtime, tokens) {
	var cmd = parser.parseElement("command", tokens);
	if (cmd) {
		tokens.matchToken("then");
		const next = parser.parseElement("commandList", tokens);
		if (next) cmd.next = next;
		return cmd;
	}
});
1084
addGrammarElement("leaf", function (parser, runtime, tokens) {
	var result = parseAnyOf(LEAF_EXPRESSIONS, tokens);
	// symbol is last so it doesn't consume any constants
	if (result == null) {
		return parseElement("symbol", tokens);
	}
1091
	return result;
});
1094
addGrammarElement("indirectExpression", function (parser, runtime, tokens, root) {
	for (var i = 0; i < INDIRECT_EXPRESSIONS.length; i++) {
		var indirect = INDIRECT_EXPRESSIONS[i];
		root.endToken = tokens.lastMatch();
		var result = parser.parseElement(indirect, tokens, root);
		if (result) {
			return result;
		}
	}
	return root;
});
1106
addGrammarElement("indirectStatement", function (parser, runtime, tokens, root) {
	if (tokens.matchToken("unless")) {
		root.endToken = tokens.lastMatch();
		var conditional = parser.requireElement("expression", tokens);
		var unless = {
			type: "unlessStatementModifier",
			args: [conditional],
			op: function (context, conditional) {
				if (conditional) {
					return this.next;
				} else {
					return root;
				}
			},
			execute: function (context) {
				return runtime.unifiedExec(this, context);
			},
		};
		root.parent = unless;
		return unless;
	}
	return root;
});
1130
addGrammarElement("primaryExpression", function (parser, runtime, tokens) {
	var leaf = parser.parseElement("leaf", tokens);
	if (leaf) {
		return parser.parseElement("indirectExpression", tokens, leaf);
	}
	parser.raiseParseError(tokens, "Unexpected value: " + tokens.currentToken().value);
});
1138
/* ============================================================================================ */
/* END Core hyperscript Grammar Elements                                                        */
1141
/* ============================================================================================ */
1143
/**
 *
 * @param {TokensObject} tokens
 * @returns string
 */
function createParserContext(tokens) {
	var currentToken = tokens.currentToken();
	var source = tokens.source;
	var lines = source.split("\n");
	var line = currentToken && currentToken.line ? currentToken.line - 1 : lines.length - 1;
	var contextLine = lines[line];
	var offset = currentToken && currentToken.line ? currentToken.column : contextLine.length - 1;
	return contextLine + "\n" + " ".repeat(offset) + "^^\n\n";
}
1158
/**
 * @param {TokensObject} tokens
 * @param {string} [message]
 */
function raiseParseError(tokens, message) {
	message =
		(message || "Unexpected Token : " + tokens.currentToken().value) + "\n\n" + createParserContext(tokens);
	var error = new Error(message);
	error["tokens"] = tokens;
	throw error;
}
1170
/**
 * @param {TokensObject} tokens
 * @returns {GrammarElement}
 */
function parseHyperScript(tokens) {
	var result = parseElement("hyperscript", tokens);
	if (tokens.hasMore()) raiseParseError(tokens);
	if (result) return result;
}
1180
/**
 * @param {GrammarElement} elt
 * @param {GrammarElement} parent
 */
function setParent(elt, parent) {
	if (elt) {
		elt.parent = parent;
		setParent(elt.next, parent);
	}
}
1191
/**
 * @param {Token} token
 * @returns {GrammarDefinition}
 */
function commandStart(token) {
	return COMMANDS[token.value];
}
1199
/**
 * @param {Token} token
 * @returns {GrammarDefinition}
 */
function featureStart(token) {
	return FEATURES[token.value];
}
1207
/**
 * @param {Token} token
 * @returns {boolean}
 */
function commandBoundary(token) {
	if (
		token.value == "end" ||
		token.value == "then" ||
		token.value == "else" ||
		token.value == ")" ||
		commandStart(token) ||
		featureStart(token) ||
		token.type == "EOF"
	) {
		return true;
	}
	return false;
}
1226
/**
 * @param {TokensObject} tokens
 * @returns {(string | GrammarElement)[]}
 */
function parseStringTemplate(tokens) {
	/** @type {(string | GrammarElement)[]} */
	var returnArr = [""];
	do {
		returnArr.push(tokens.lastWhitespace());
		if (tokens.currentToken().value === "$") {
			tokens.consumeToken();
			var startingBrace = tokens.matchOpToken("{");
			returnArr.push(requireElement("expression", tokens));
			if (startingBrace) {
				tokens.requireOpToken("}");
			}
			returnArr.push("");
		} else if (tokens.currentToken().value === "\\") {
			tokens.consumeToken(); // skip next
			tokens.consumeToken();
		} else {
			var token = tokens.consumeToken();
			returnArr[returnArr.length - 1] += token ? token.value : "";
		}
	} while (tokens.hasMore());
	returnArr.push(tokens.lastWhitespace());
	return returnArr;
}
1255
// parser API
return {
	setParent: setParent,
	requireElement: requireElement,
	parseElement: parseElement,
	featureStart: featureStart,
	commandStart: commandStart,
	commandBoundary: commandBoundary,
	parseAnyOf: parseAnyOf,
	parseHyperScript: parseHyperScript,
	raiseParseError: raiseParseError,
	addGrammarElement: addGrammarElement,
	addCommand: addCommand,
	addFeature: addFeature,
	addLeafExpression: addLeafExpression,
	addIndirectExpression: addIndirectExpression,
	parseStringTemplate: parseStringTemplate,
};
})();
1275
//====================================================================
// Runtime
//====================================================================
1279
var CONVERSIONS = {
dynamicResolvers: /** @type DynamicConversionFunction[] */ [],
String: function (val) {
	if (val.toString) {
		return val.toString();
	} else {
		return "" + val;
	}
},
Int: function (val) {
	return parseInt(val);
},
Float: function (val) {
	return parseFloat(val);
},
Number: function (val) {
	console.log(val);
	return Number(val);
},
Date: function (val) {
	return new Date(val);
},
Array: function (val) {
	return Array.from(val);
},
JSON: function (val) {
	return JSON.stringify(val);
},
Object: function (val) {
	if (val instanceof String) {
		val = val.toString();
	}
	if (typeof val === "string") {
		return JSON.parse(val);
	} else {
		return mergeObjects({}, val);
	}
},
};
1319
/********************************************
* RUNTIME OBJECT
********************************************/
1323
/** @type {RuntimeObject} */
var _runtime = (function () {
/**
 * @param {HTMLElement} elt
 * @param {string} selector
 * @returns boolean
 */
function matchesSelector(elt, selector) {
	// noinspection JSUnresolvedVariable
	var matchesFunction =
		// @ts-ignore
		elt.matches || elt.matchesSelector || elt.msMatchesSelector || elt.mozMatchesSelector || elt.webkitMatchesSelector || elt.oMatchesSelector;
	return matchesFunction && matchesFunction.call(elt, selector);
}
1338
/**
 * @param {string} eventName
 * @param {Object} [detail]
 * @returns {Event}
 */
function makeEvent(eventName, detail) {
	var evt;
	if (window.CustomEvent && typeof window.CustomEvent === "function") {
		evt = new CustomEvent(eventName, {
			bubbles: true,
			cancelable: true,
			detail: detail,
		});
	} else {
		evt = document.createEvent("CustomEvent");
		evt.initCustomEvent(eventName, true, true, detail);
	}
	return evt;
}
1358
/**
 * @param {Element} elt
 * @param {string} eventName
 * @param {Object} [detail]
 * @returns {boolean}
 */
function triggerEvent(elt, eventName, detail) {
	detail = detail || {};
	detail["sentBy"] = elt;
	var event = makeEvent(eventName, detail);
	var eventResult = elt.dispatchEvent(event);
	return eventResult;
}
1372
/**
 * isArrayLike returns `true` if the provided value is an array or
 * a NodeList (which is close enough to being an array for our purposes).
 *
 * @param {any} value
 * @returns {value is Array | NodeList}
 */
function isArrayLike(value) {
	return Array.isArray(value) || value instanceof NodeList;
}
1383
/**
 * isIterable returns `true` if the provided value supports the
 * iterator protocol.
 *
 * @param {any} value
 * @returns {value is Iterable}
 */
function isIterable(value) {
	return typeof value === 'object'
		&& Symbol.iterator in value
		&& typeof value[Symbol.iterator] === 'function';
}
1396
/**
 * shouldAutoIterate returns `true` if the provided value
 * should be implicitly iterated over when accessing properties,
 * and as the target of some commands.
 *
 * Currently, this is when the value is an {ElementCollection}
 * or {isArrayLike} returns true.
 *
 * @param {any} value
 * @returns {value is any[] | NodeList | ElementCollection}
 */
function shouldAutoIterate(value) {
	return value instanceof ElementCollection || isArrayLike(value);
}
1411
/**
 * forEach executes the provided `func` on every item in the `value` array.
 * if `value` is a single item (and not an array) then `func` is simply called
 * once.  If `value` is null, then no further actions are taken.
 *
 * @template T
 * @param {T | Iterable<T>} value
 * @param {(item: T) => void} func
 */
function forEach(value, func) {
	if (value == null) {
		// do nothing
	} else if (isIterable(value)) {
		for (const nth of value) {
			func(nth);
		}
	} else if (isArrayLike(value)) {
		for (var i = 0; i < value.length; i++) {
			func(value[i]);
		}
	} else {
		func(value);
	}
}
1436
/**
 * implicitLoop executes the provided `func` on:
 * - every item of {value}, if {value} should be auto-iterated
 *   (see {shouldAutoIterate})
 * - {value} otherwise
 *
 * @template T
 * @param {NodeList | T | T[]} value
 * @param {(item:Node | T) => void} func
 */
function implicitLoop(value, func) {
	if (shouldAutoIterate(value)) {
		for (const x of value) func(x);
	} else {
		func(value);
	}
}
1454
var ARRAY_SENTINEL = { array_sentinel: true };
1456
function linearize(args) {
	var arr = [];
	for (var i = 0; i < args.length; i++) {
		var arg = args[i];
		if (Array.isArray(arg)) {
			arr.push(ARRAY_SENTINEL);
			for (var j = 0; j < arg.length; j++) {
				arr.push(arg[j]);
			}
			arr.push(ARRAY_SENTINEL);
		} else {
			arr.push(arg);
		}
	}
	return arr;
}
1473
function delinearize(values) {
	var arr = [];
	for (var i = 0; i < values.length; i++) {
		var value = values[i];
		if (value === ARRAY_SENTINEL) {
			value = values[++i];
			var valueArray = [];
			arr.push(valueArray);
			while (value !== ARRAY_SENTINEL) {
				valueArray.push(value);
				value = values[++i];
			}
		} else {
			arr.push(value);
		}
	}
	return arr;
}
1492
function unwrapAsyncs(values) {
	for (var i = 0; i < values.length; i++) {
		var value = values[i];
		if (value.asyncWrapper) {
			values[i] = value.value;
		}
		if (Array.isArray(value)) {
			for (var j = 0; j < value.length; j++) {
				var valueElement = value[j];
				if (valueElement.asyncWrapper) {
					value[j] = valueElement.value;
				}
			}
		}
	}
}
1509
var HALT = {};
1511
/**
 * @param {GrammarElement} command
 * @param {Context} ctx
 */
function unifiedExec(command, ctx) {
	while (true) {
		try {
			var next = unifiedEval(command, ctx);
		} catch (e) {
			_runtime.registerHyperTrace(ctx, e);
			if (ctx.meta.errorHandler && !ctx.meta.handlingError) {
				ctx.meta.handlingError = true;
				ctx[ctx.meta.errorSymmbol] = e;
				command = ctx.meta.errorHandler;
				continue;
			} else if (ctx.meta.reject) {
				ctx.meta.reject(e);
				next = HALT;
			} else {
				throw e;
			}
		}
		if (next == null) {
			console.error(command, " did not return a next element to execute! context: ", ctx);
			return;
		} else if (next.then) {
			next.then(function (resolvedNext) {
				unifiedExec(resolvedNext, ctx);
			}).catch(function (reason) {
				_runtime.registerHyperTrace(ctx, reason);
				if (ctx.meta.errorHandler && !ctx.meta.handlingError) {
					ctx.meta.handlingError = true;
					ctx[ctx.meta.errorSymmbol] = reason;
					unifiedExec(ctx.meta.errorHandler, ctx);
				} else if (ctx.meta.reject) {
					ctx.meta.reject(reason);
				} else {
					throw reason;
				}
			});
			return;
		} else if (next === HALT) {
			// done
			return;
		} else {
			command = next; // move to the next command
		}
	}
}
1561
/**
 * @param {*} parseElement
 * @param {Context} ctx
 * @returns {*}
 */
function unifiedEval(parseElement, ctx) {
	/** @type any[] */
	var args = [ctx];
	var async = false;
	var wrappedAsyncs = false;
1572
	if (parseElement.args) {
		for (var i = 0; i < parseElement.args.length; i++) {
			var argument = parseElement.args[i];
			if (argument == null) {
				args.push(null);
			} else if (Array.isArray(argument)) {
				var arr = [];
				for (var j = 0; j < argument.length; j++) {
					var element = argument[j];
					var value = element ? element.evaluate(ctx) : null; // OK
					if (value) {
						if (value.then) {
							async = true;
						} else if (value.asyncWrapper) {
							wrappedAsyncs = true;
						}
					}
					arr.push(value);
				}
				args.push(arr);
			} else if (argument.evaluate) {
				var value = argument.evaluate(ctx); // OK
				if (value) {
					if (value.then) {
						async = true;
					} else if (value.asyncWrapper) {
						wrappedAsyncs = true;
					}
				}
				args.push(value);
			} else {
				args.push(argument);
			}
		}
	}
	if (async) {
		return new Promise(function (resolve, reject) {
			var linearized = linearize(args);
			Promise.all(linearized)
				.then(function (values) {
					values = delinearize(values);
					if (wrappedAsyncs) {
						unwrapAsyncs(values);
					}
					try {
						var apply = parseElement.op.apply(parseElement, values);
						resolve(apply);
					} catch (e) {
						reject(e);
					}
				})
				.catch(function (reason) {
					if (ctx.meta.errorHandler && !ctx.meta.handlingError) {
						ctx.meta.handlingError = true;
						ctx[ctx.meta.errorSymmbol] = reason;
						unifiedExec(ctx.meta.errorHandler, ctx);
					} else if (ctx.meta.reject) {
						ctx.meta.reject(reason);
					} else {
						// TODO: no meta context to reject with, trigger event?
					}
				});
		});
	} else {
		if (wrappedAsyncs) {
			unwrapAsyncs(args);
		}
		return parseElement.op.apply(parseElement, args);
	}
}
1643
var _scriptAttrs = null;
1645
/**
 * getAttributes returns the attribute name(s) to use when
 * locating hyperscript scripts in a DOM element.  If no value
 * has been configured, it defaults to _hyperscript.config.attributes
 * @returns string[]
 */
function getScriptAttributes() {
	if (_scriptAttrs == null) {
		_scriptAttrs = _hyperscript.config.attributes.replace(/ /g, "").split(",");
	}
	return _scriptAttrs;
}
1658
/**
 * @param {Element} elt
 * @returns {string | null}
 */
function getScript(elt) {
	for (var i = 0; i < getScriptAttributes().length; i++) {
		var scriptAttribute = getScriptAttributes()[i];
		if (elt.hasAttribute && elt.hasAttribute(scriptAttribute)) {
			return elt.getAttribute(scriptAttribute);
		}
	}
	if (elt instanceof HTMLScriptElement && elt.type === "text/hyperscript") {
		return elt.innerText;
	}
	return null;
}
1675
var hyperscriptFeaturesMap = new WeakMap
1677
/**
 * @param {Element} elt
 * @returns {Object}
 */
function getHyperscriptFeatures(elt) {
	var hyperscriptFeatures = hyperscriptFeaturesMap.get(elt);
	if (typeof hyperscriptFeatures === 'undefined') {
		hyperscriptFeaturesMap.set(elt, hyperscriptFeatures = {});
	}
	return hyperscriptFeatures;
}
1689
/**
 * @param {Object} owner
 * @param {Context} ctx
 */
function addFeatures(owner, ctx) {
	if (owner) {
		mergeObjects(ctx, getHyperscriptFeatures(owner));
		addFeatures(owner.parentElement, ctx);
	}
}
1700
/**
 * @param {*} owner
 * @param {*} feature
 * @param {*} hyperscriptTarget
 * @param {*} event
 * @returns {Context}
 */
function makeContext(owner, feature, hyperscriptTarget, event) {
	/** @type {Context} */
	var ctx = {
		meta: {
			parser: _parser,
			lexer: _lexer,
			runtime: _runtime,
			owner: owner,
			feature: feature,
			iterators: {},
		},
		me: hyperscriptTarget,
		event: event,
		target: event ? event.target : null,
		detail: event ? event.detail : null,
		body: "document" in globalScope ? document.body : null,
	};
	ctx.meta.ctx = ctx;
	addFeatures(owner, ctx);
	return ctx;
}
1729
/**
 * @returns string
 */
function getScriptSelector() {
	return getScriptAttributes()
		.map(function (attribute) {
			return "[" + attribute + "]";
		})
		.join(", ");
}
1740
/**
 * @param {any} value
 * @param {string} type
 * @returns {any}
 */
function convertValue(value, type) {
	var dynamicResolvers = CONVERSIONS.dynamicResolvers;
	for (var i = 0; i < dynamicResolvers.length; i++) {
		var dynamicResolver = dynamicResolvers[i];
		var converted = dynamicResolver(type, value);
		if (converted !== undefined) {
			return converted;
		}
	}
1755
	if (value == null) {
		return null;
	}
	var converter = CONVERSIONS[type];
	if (converter) {
		return converter(value);
	}
1763
	throw "Unknown conversion : " + type;
}
1766
// TODO: There do not seem to be any references to this function.
// Is it still in use, or can it be removed?
function isType(o, type) {
	return Object.prototype.toString.call(o) === "[object " + type + "]";
}
1772
/**
 * @param {string} src
 * @returns {GrammarElement}
 */
function parse(src) {
	var tokens = _lexer.tokenize(src);
	if (_parser.commandStart(tokens.currentToken())) {
		var commandList = _parser.requireElement("commandList", tokens);
		var last = commandList;
		while (last.next) {
			last = last.next;
		}
		last.next = {
			op: function () {
				return HALT;
			},
		};
		return commandList;
	} else if (_parser.featureStart(tokens.currentToken())) {
		var hyperscript = _parser.requireElement("hyperscript", tokens);
		return hyperscript;
	} else {
		var expression = _parser.requireElement("expression", tokens);
		return expression;
	}
}
1799
/**
 * @param {string} src
 * @param {Context} [ctx]
 * @returns {any}
 */
function evaluate(src, ctx) {
	var body = 'document' in globalScope ? globalScope.document.body : makeModule();
	ctx = mergeObjects(makeContext(body, null, body, null), ctx || {});
	var element = parse(src);
	if (element.execute) {
		return element.execute(ctx);
	} else if (element.apply) {
		element.apply(body, null);
		return getHyperscriptFeatures(body);
	} else {
		return element.evaluate(ctx);
	}
1817
	function makeModule() {
		return {}
	}
}
1822
/**
 * @param {HTMLElement} elt
 */
function processNode(elt) {
	var selector = _runtime.getScriptSelector();
	if (matchesSelector(elt, selector)) {
		initElement(elt, elt);
	}
	if (elt instanceof HTMLScriptElement && elt.type === "text/hyperscript") {
		initElement(elt, document.body);
	}
	if (elt.querySelectorAll) {
		forEach(elt.querySelectorAll(selector + ", [type='text/hyperscript']"), function (elt) {
			initElement(elt, elt instanceof HTMLScriptElement && elt.type === "text/hyperscript" ? document.body : elt);
		});
	}
}
1840
/**
 * @param {Element} elt
 * @param {Element} [target]
 */
function initElement(elt, target) {
	if (elt.closest && elt.closest(_hyperscript.config.disableSelector)) {
		return;
	}
	var internalData = getInternalData(elt);
	if (!internalData.initialized) {
		var src = getScript(elt);
		if (src) {
			try {
				internalData.initialized = true;
				internalData.script = src;
				var tokens = _lexer.tokenize(src);
				var hyperScript = _parser.parseHyperScript(tokens);
				if (!hyperScript) return;
				hyperScript.apply(target || elt, elt);
				setTimeout(function () {
					triggerEvent(target || elt, "load", {
						hyperscript: true,
					});
				}, 1);
			} catch (e) {
				_runtime.triggerEvent(elt, "exception", {
					error: e,
				});
				console.error(
					"hyperscript errors were found on the following element:",
					elt,
					"\n\n",
					e.message,
					e.stack
				);
			}
		}
	}
}
1880
var internalDataMap = new WeakMap
1882
/**
 * @param {Element} elt
 * @returns {Object}
 */
function getInternalData(elt) {
	var internalData = internalDataMap.get(elt);
	if (typeof internalData === 'undefined') {
		internalDataMap.set(elt, internalData = {});
	}
	return internalData;
}
1894
/**
 * @param {any} value
 * @param {string} typeString
 * @param {boolean} [nullOk]
 * @returns {boolean}
 */
function typeCheck(value, typeString, nullOk) {
	if (value == null && nullOk) {
		return true;
	}
	var typeName = Object.prototype.toString.call(value).slice(8, -1);
	return typeName === typeString;
}
1908
function getElementScope(context) {
	var elt = context.meta && context.meta.owner;
	if (elt) {
		var internalData = getInternalData(elt);
		var scopeName = "elementScope";
		if (context.meta.feature && context.meta.feature.behavior) {
			scopeName = context.meta.feature.behavior + "Scope";
		}
		var elementScope = getOrInitObject(internalData, scopeName);
		return elementScope;
	} else {
		return {}; // no element, return empty scope
	}
}
1923
/**
 * @param {string} str
 * @param {Context} context
 * @returns {any}
 */
function resolveSymbol(str, context, type) {
	if (str === "me" || str === "my" || str === "I") {
		return context["me"];
	}
	if (str === "it" || str === "its") {
		return context["result"];
	}
	if (str === "you" || str === "your" || str === "yourself") {
		return context["beingTold"];
	} else {
		if (type === "global") {
			return globalScope[str];
		} else if (type === "element") {
			var elementScope = getElementScope(context);
			return elementScope[str];
		} else if (type === "local") {
			return context[str];
		} else {
			// meta scope (used for event conditionals)
			if (context.meta && context.meta.context) {
				var fromMetaContext = context.meta.context[str];
				if (typeof fromMetaContext !== "undefined") {
					return fromMetaContext;
				}
			}
			// local scope
			var fromContext = context[str];
			if (typeof fromContext !== "undefined") {
				return fromContext;
			} else {
				// element scope
				var elementScope = getElementScope(context);
				fromContext = elementScope[str];
				if (typeof fromContext !== "undefined") {
					return fromContext;
				} else {
					// global scope
					return globalScope[str];
				}
			}
		}
	}
}
1972
function setSymbol(str, context, type, value) {
	if (type === "global") {
		globalScope[str] = value;
	} else if (type === "element") {
		var elementScope = getElementScope(context);
		elementScope[str] = value;
	} else if (type === "local") {
		context[str] = value;
	} else {
		// local scope
		var fromContext = context[str];
		if (typeof fromContext !== "undefined") {
			context[str] = value;
		} else {
			// element scope
			var elementScope = getElementScope(context);
			fromContext = elementScope[str];
			if (typeof fromContext !== "undefined") {
				elementScope[str] = value;
			} else {
				// global scope
				fromContext = globalScope[str];
				if (typeof fromContext !== "undefined") {
					globalScope[str] = value;
				} else {
					context[str] = value;
				}
			}
		}
	}
}
2004
/**
 * @param {GrammarElement} command
 * @param {Context} context
 * @returns {undefined | GrammarElement}
 */
function findNext(command, context) {
	if (command) {
		if (command.resolveNext) {
			return command.resolveNext(context);
		} else if (command.next) {
			return command.next;
		} else {
			return findNext(command.parent, context);
		}
	}
}
2021
/**
 * @param {Object<string,any>} root
 * @param {string} property
 * @param {boolean} attribute
 * @returns {any}
 */
function resolveProperty(root, property, attribute) {
	if (root != null) {
		var val = attribute && root.getAttribute ? root.getAttribute(property) : root[property];
		if (typeof val !== "undefined") {
			return val;
		}
2034
		if (shouldAutoIterate(root)) {
			// flat map
			var result = [];
			for (var component of root) {
				var componentValue = attribute ? component.getAttribute(property) : component[property];
				if (componentValue) {
					result.push(componentValue);
				}
			}
			return result;
		}
	}
}
2048
/**
 * @param {Element} elt
 * @param {string[]} nameSpace
 * @param {string} name
 * @param {any} value
 */
function assignToNamespace(elt, nameSpace, name, value) {
	if (typeof document === "undefined" || elt === document.body) {
		var root = globalScope;
	} else {
		var root = getHyperscriptFeatures(elt);
	}
	while (nameSpace.length > 0) {
		var propertyName = nameSpace.shift();
		var newRoot = root[propertyName];
		if (newRoot == null) {
			newRoot = {};
			root[propertyName] = newRoot;
		}
		root = newRoot;
	}
2070
	root[name] = value;
}
2073
function getHyperTrace(ctx, thrown) {
	var trace = [];
	var root = ctx;
	while (root.meta.caller) {
		root = root.meta.caller;
	}
	if (root.meta.traceMap) {
		return root.meta.traceMap.get(thrown, trace);
	}
}
2084
function registerHyperTrace(ctx, thrown) {
	var trace = [];
	var root = null;
	while (ctx != null) {
		trace.push(ctx);
		root = ctx;
		ctx = ctx.meta.caller;
	}
	if (root.meta.traceMap == null) {
		root.meta.traceMap = new Map(); // TODO - WeakMap?
	}
	if (!root.meta.traceMap.get(thrown)) {
		var traceEntry = {
			trace: trace,
			print: function (logger) {
				logger = logger || console.error;
				logger("hypertrace /// ");
				var maxLen = 0;
				for (var i = 0; i < trace.length; i++) {
					maxLen = Math.max(maxLen, trace[i].meta.feature.displayName.length);
				}
				for (var i = 0; i < trace.length; i++) {
					var traceElt = trace[i];
					logger(
						"  ->",
						traceElt.meta.feature.displayName.padEnd(maxLen + 2),
						"-",
						traceElt.meta.owner
					);
				}
			},
		};
		root.meta.traceMap.set(thrown, traceEntry);
	}
}
2120
/**
 * @param {string} str
 * @returns {string}
 */
function escapeSelector(str) {
	return str.replace(/:/g, function (str) {
		return "\\" + str;
	});
}
2130
/**
 * @param {any} value
 * @param {*} elt
 */
function nullCheck(value, elt) {
	if (value == null) {
		throw new Error(elt.sourceFor() + " is null");
	}
}
2140
/**
 * @param {any} value
 * @returns {boolean}
 */
function isEmpty(value) {
	return value == undefined || value.length === 0;
}
2148
/**
 * @param {Node} node
 * @returns {Document|ShadowRoot}
 */
function getRootNode(node) {
	var rv = node.getRootNode();
	if (rv instanceof Document || rv instanceof ShadowRoot) return rv;
	else return document;
}
2158
/** @type string | null */
// @ts-ignore
var hyperscriptUrl = "document" in globalScope ? document.currentScript.src : null;
2162
/** @type {RuntimeObject} */
return {
	typeCheck: typeCheck,
	forEach: forEach,
	implicitLoop: implicitLoop,
	triggerEvent: triggerEvent,
	matchesSelector: matchesSelector,
	getScript: getScript,
	processNode: processNode,
	evaluate: evaluate,
	parse: parse,
	getScriptSelector: getScriptSelector,
	resolveSymbol: resolveSymbol,
	setSymbol: setSymbol,
	makeContext: makeContext,
	findNext: findNext,
	unifiedEval: unifiedEval,
	convertValue: convertValue,
	unifiedExec: unifiedExec,
	resolveProperty: resolveProperty,
	assignToNamespace: assignToNamespace,
	registerHyperTrace: registerHyperTrace,
	getHyperTrace: getHyperTrace,
	getInternalData: getInternalData,
	escapeSelector: escapeSelector,
	nullCheck: nullCheck,
	isEmpty: isEmpty,
	getRootNode: getRootNode,
	hyperscriptUrl: hyperscriptUrl,
	HALT: HALT,
};
})();
2195
//====================================================================
// Grammar
//====================================================================
{
_parser.addLeafExpression("parenthesized", function (parser, _runtime, tokens) {
	if (tokens.matchOpToken("(")) {
		var follows = tokens.clearFollow();
		try {
			var expr = parser.requireElement("expression", tokens);
		} finally {
			tokens.restoreFollow(follows);
		}
		tokens.requireOpToken(")");
		return expr;
	}
});
2212
_parser.addLeafExpression("string", function (parser, runtime, tokens) {
	var stringToken = tokens.matchTokenType("STRING");
	if (!stringToken) return;
	var rawValue = stringToken.value;
	/** @type {any[]} */
	var args;
	if (stringToken.template) {
		var innerTokens = _lexer.tokenize(rawValue, true);
		args = parser.parseStringTemplate(innerTokens);
	} else {
		args = [];
	}
	return {
		type: "string",
		token: stringToken,
		args: args,
		op: function (context) {
			var returnStr = "";
			for (var i = 1; i < arguments.length; i++) {
				var val = arguments[i];
				if (val !== undefined) {
					returnStr += val;
				}
			}
			return returnStr;
		},
		evaluate: function (context) {
			if (args.length === 0) {
				return rawValue;
			} else {
				return runtime.unifiedEval(this, context);
			}
		},
	};
});
2248
_parser.addGrammarElement("nakedString", function (parser, runtime, tokens) {
	if (tokens.hasMore()) {
		var tokenArr = tokens.consumeUntilWhitespace();
		tokens.matchTokenType("WHITESPACE");
		return {
			type: "nakedString",
			tokens: tokenArr,
			evaluate: function (context) {
				return tokenArr
					.map(function (t) {
						return t.value;
					})
					.join("");
			},
		};
	}
});
2266
_parser.addLeafExpression("number", function (parser, runtime, tokens) {
	var number = tokens.matchTokenType("NUMBER");
	if (!number) return;
	var numberToken = number;
	var value = parseFloat(number.value);
	return {
		type: "number",
		value: value,
		numberToken: numberToken,
		evaluate: function () {
			return value;
		},
	};
});
2281
_parser.addLeafExpression("idRef", function (parser, runtime, tokens) {
	var elementId = tokens.matchTokenType("ID_REF");
	if (!elementId) return;
	// TODO - unify these two expression types
	if (elementId.template) {
		var templateValue = elementId.value.substr(2, elementId.value.length - 2);
		var innerTokens = _lexer.tokenize(templateValue);
		var innerExpression = parser.requireElement("expression", innerTokens);
		return {
			type: "idRefTemplate",
			args: [innerExpression],
			op: function (context, arg) {
				return runtime.getRootNode(context.me).getElementById(arg);
			},
			evaluate: function (context) {
				return runtime.unifiedEval(this, context);
			},
		};
	} else {
		const value = elementId.value.substr(1);
		return {
			type: "idRef",
			css: elementId.value,
			value: value,
			evaluate: function (context) {
				return (
					runtime.getRootNode(context.me).getElementById(value)
				);
			},
		};
	}
});
2314
_parser.addLeafExpression("classRef", function (parser, runtime, tokens) {
	var classRef = tokens.matchTokenType("CLASS_REF");
2317
	if (!classRef) return;
2319
	// TODO - unify these two expression types
	if (classRef.template) {
		var templateValue = classRef.value.substr(2, classRef.value.length - 2);
		var innerTokens = _lexer.tokenize(templateValue);
		var innerExpression = parser.requireElement("expression", innerTokens);
		return {
			type: "classRefTemplate",
			args: [innerExpression],
			op: function (context, arg) {
				return new ElementCollection("." + arg, context.me)
			},
			evaluate: function (context) {
				return runtime.unifiedEval(this, context);
			},
		};
	} else {
		const css = classRef.value;
		return {
			type: "classRef",
			css: css,
			evaluate: function (context) {
				return new ElementCollection(css, context.me)
			},
		};
	}
});
2346
class TemplatedQueryElementCollection extends ElementCollection {
	constructor(css, relativeToElement, templateParts) {
		super(css, relativeToElement);
		this.templateParts = templateParts;
		this.elements = templateParts.filter(elt => elt instanceof Element);
	}
2353
	get css() {
		let rv = "", i = 0
	    for (const val of this.templateParts) {
			if (val instanceof Element) {
				rv += "[data-hs-query-id='" + i++ + "']";
			} else rv += val;
		}
		return rv;
	}
2363
	[Symbol.iterator]() {
		this.elements.forEach((el, i) => el.dataset.hsQueryId = i);
		const rv = super[Symbol.iterator]();
		this.elements.forEach(el => el.removeAttribute('data-hs-query-id'));
		return rv;
	}
}
2371
_parser.addLeafExpression("queryRef", function (parser, runtime, tokens) {
	var queryStart = tokens.matchOpToken("<");
	if (!queryStart) return;
	var queryTokens = tokens.consumeUntil("/");
	tokens.requireOpToken("/");
	tokens.requireOpToken(">");
	var queryValue = queryTokens
		.map(function (t) {
			if (t.type === "STRING") {
				return '"' + t.value + '"';
			} else {
				return t.value;
			}
		})
		.join("");
2387
	if (queryValue.indexOf("$") >= 0) {
		var template = true;
		var innerTokens = _lexer.tokenize(queryValue, true);
		var args = parser.parseStringTemplate(innerTokens);
	}
2393
	return {
		type: "queryRef",
		css: queryValue,
		args: args,
		op: function (context, ...args) {
			if (template) {
				return new TemplatedQueryElementCollection(queryValue, context.me, args)
			} else {
				return new ElementCollection(queryValue, context.me)
			}
		},
		evaluate: function (context) {
			return runtime.unifiedEval(this, context);
		},
	};
});
2410
_parser.addLeafExpression("attributeRef", function (parser, runtime, tokens) {
	var attributeRef = tokens.matchTokenType("ATTRIBUTE_REF");
	if (!attributeRef) return;
	var outerVal = attributeRef.value;
	if (outerVal.indexOf("[") === 0) {
		var innerValue = outerVal.substring(2, outerVal.length - 1);
	} else {
		var innerValue = outerVal.substring(1);
	}
	var css = "[" + innerValue + "]";
	var split = innerValue.split("=");
	var name = split[0];
	var value = split[1];
	if (value) {
		// strip quotes
		if (value.indexOf('"') === 0) {
			value = value.substring(1, value.length - 1);
		}
	}
	return {
		type: "attributeRef",
		name: name,
		css: css,
		value: value,
		op: function (context) {
			var target = context.beingTold || context.me;
			if (target) {
				return target.getAttribute(name);
			}
		},
		evaluate: function (context) {
			return runtime.unifiedEval(this, context);
		},
	};
});
2446
_parser.addGrammarElement("objectKey", function (parser, runtime, tokens) {
	var token;
	if ((token = tokens.matchTokenType("STRING"))) {
		return {
			type: "objectKey",
			key: token.value,
			evaluate: function () {
				return token.value;
			},
		};
	} else if (tokens.matchOpToken("[")) {
		var expr = parser.parseElement("expression", tokens);
		tokens.requireOpToken("]");
		return {
			type: "objectKey",
			expr: expr,
			args: [expr],
			op: function (ctx, expr) {
				return expr;
			},
			evaluate: function (context) {
				return runtime.unifiedEval(this, context);
			},
		};
	} else {
		var key = "";
		do {
			token = tokens.matchTokenType("IDENTIFIER") || tokens.matchOpToken("-");
			if (token) key += token.value;
		} while (token);
		return {
			type: "objectKey",
			key: key,
			evaluate: function () {
				return key;
			},
		};
	}
});
2486
_parser.addLeafExpression("objectLiteral", function (parser, runtime, tokens) {
	if (!tokens.matchOpToken("{")) return;
	var keyExpressions = [];
	var valueExpressions = [];
	if (!tokens.matchOpToken("}")) {
		do {
			var name = parser.requireElement("objectKey", tokens);
			tokens.requireOpToken(":");
			var value = parser.requireElement("expression", tokens);
			valueExpressions.push(value);
			keyExpressions.push(name);
		} while (tokens.matchOpToken(","));
		tokens.requireOpToken("}");
	}
	return {
		type: "objectLiteral",
		args: [keyExpressions, valueExpressions],
		op: function (context, keys, values) {
			var returnVal = {};
			for (var i = 0; i < keys.length; i++) {
				returnVal[keys[i]] = values[i];
			}
			return returnVal;
		},
		evaluate: function (context) {
			return runtime.unifiedEval(this, context);
		},
	};
});
2516
_parser.addGrammarElement("namedArgumentList", function (parser, runtime, tokens) {
	if (!tokens.matchOpToken("(")) return;
	var fields = [];
	var valueExpressions = [];
	if (!tokens.matchOpToken(")")) {
		do {
			var name = tokens.requireTokenType("IDENTIFIER");
			tokens.requireOpToken(":");
			var value = parser.requireElement("expression", tokens);
			valueExpressions.push(value);
			fields.push({ name: name, value: value });
		} while (tokens.matchOpToken(","));
		tokens.requireOpToken(")");
	}
	return {
		type: "namedArgumentList",
		fields: fields,
		args: [valueExpressions],
		op: function (context, values) {
			var returnVal = { _namedArgList_: true };
			for (var i = 0; i < values.length; i++) {
				var field = fields[i];
				returnVal[field.name.value] = values[i];
			}
			return returnVal;
		},
		evaluate: function (context) {
			return runtime.unifiedEval(this, context);
		},
	};
});
2548
_parser.addGrammarElement("symbol", function (parser, runtime, tokens) {
	/** @type {SymbolScope} */
	var type = "default";
	if (tokens.matchToken("global")) {
		type = "global";
	} else if (tokens.matchToken("element") || tokens.matchToken("module")) {
		type = "element";
		// optional possessive
		if (tokens.matchOpToken("'")) {
			tokens.requireToken("s");
		}
	} else if (tokens.matchToken("local")) {
		type = "local";
	}
	var identifier = tokens.matchTokenType("IDENTIFIER");
	if (identifier) {
		const name = identifier.value;
		return {
			type: "symbol",
			symbolType: type,
			token: identifier,
			name: name,
			evaluate: function (context) {
				return runtime.resolveSymbol(name, context, type);
			},
		};
	}
});
2577
_parser.addGrammarElement("implicitMeTarget", function (parser, runtime, tokens) {
	return {
		type: "implicitMeTarget",
		evaluate: function (context) {
			return context.beingTold || context.me;
		},
	};
});
2586
_parser.addLeafExpression("boolean", function (parser, runtime, tokens) {
	var booleanLiteral = tokens.matchToken("true") || tokens.matchToken("false");
	if (!booleanLiteral) return;
	const value = booleanLiteral.value === "true";
	return {
		type: "boolean",
		evaluate: function (context) {
			return value;
		},
	};
});
2598
_parser.addLeafExpression("null", function (parser, runtime, tokens) {
	if (tokens.matchToken("null")) {
		return {
			type: "null",
			evaluate: function (context) {
				return null;
			},
		};
	}
});
2609
_parser.addLeafExpression("arrayLiteral", function (parser, runtime, tokens) {
	if (!tokens.matchOpToken("[")) return;
	var values = [];
	if (!tokens.matchOpToken("]")) {
		do {
			var expr = parser.requireElement("expression", tokens);
			values.push(expr);
		} while (tokens.matchOpToken(","));
		tokens.requireOpToken("]");
	}
	return {
		type: "arrayLiteral",
		values: values,
		args: [values],
		op: function (context, values) {
			return values;
		},
		evaluate: function (context) {
			return runtime.unifiedEval(this, context);
		},
	};
});
2632
_parser.addLeafExpression("blockLiteral", function (parser, runtime, tokens) {
	if (!tokens.matchOpToken("\\")) return;
	var args = [];
	var arg1 = tokens.matchTokenType("IDENTIFIER");
	if (arg1) {
		args.push(arg1);
		while (tokens.matchOpToken(",")) {
			args.push(tokens.requireTokenType("IDENTIFIER"));
		}
	}
	// TODO compound op token
	tokens.requireOpToken("-");
	tokens.requireOpToken(">");
	var expr = parser.requireElement("expression", tokens);
	return {
		type: "blockLiteral",
		args: args,
		expr: expr,
		evaluate: function (ctx) {
			var returnFunc = function () {
				//TODO - push scope
				for (var i = 0; i < args.length; i++) {
					ctx[args[i].value] = arguments[i];
				}
				return expr.evaluate(ctx); //OK
			};
			return returnFunc;
		},
	};
});
2663
_parser.addGrammarElement("timeExpression", function (parser, runtime, tokens) {
	var time = parser.requireElement("expression", tokens);
	var factor = 1;
	if (tokens.matchToken("s") || tokens.matchToken("seconds")) {
		factor = 1000;
	} else if (tokens.matchToken("ms") || tokens.matchToken("milliseconds")) {
		// do nothing
	}
	return {
		type: "timeExpression",
		time: time,
		factor: factor,
		args: [time],
		op: function (_context, val) {
			return val * factor;
		},
		evaluate: function (context) {
			return runtime.unifiedEval(this, context);
		},
	};
});
2685
_parser.addIndirectExpression("propertyAccess", function (parser, runtime, tokens, root) {
	if (!tokens.matchOpToken(".")) return;
	var prop = tokens.requireTokenType("IDENTIFIER");
	var propertyAccess = {
		type: "propertyAccess",
		root: root,
		prop: prop,
		args: [root],
		op: function (_context, rootVal) {
			var value = runtime.resolveProperty(rootVal, prop.value, false);
			return value;
		},
		evaluate: function (context) {
			return runtime.unifiedEval(this, context);
		},
	};
	return parser.parseElement("indirectExpression", tokens, propertyAccess);
});
2704
_parser.addIndirectExpression("of", function (parser, runtime, tokens, root) {
	if (!tokens.matchToken("of")) return;
	var newRoot = parser.requireElement("expression", tokens);
	// find the urroot
	var childOfUrRoot = null;
	var urRoot = root;
	while (urRoot.root) {
		childOfUrRoot = urRoot;
		urRoot = urRoot.root;
	}
	if (urRoot.type !== "symbol" && urRoot.type !== "attributeRef") {
		parser.raiseParseError(tokens, "Cannot take a property of a non-symbol: " + urRoot.type);
	}
	var attribute = urRoot.type === "attributeRef";
	var prop = urRoot.name;
	var propertyAccess = {
		type: "ofExpression",
		prop: urRoot.token,
		root: newRoot,
		attribute: attribute,
		expression: root,
		args: [newRoot],
		op: function (context, rootVal) {
			return runtime.resolveProperty(rootVal, prop, attribute);
		},
		evaluate: function (context) {
			return runtime.unifiedEval(this, context);
		},
	};
2734
	if (urRoot.type === "attributeRef") {
		propertyAccess.attribute = urRoot;
	}
	if (childOfUrRoot) {
		childOfUrRoot.root = propertyAccess;
		childOfUrRoot.args = [propertyAccess];
	} else {
		root = propertyAccess;
	}
2744
	return parser.parseElement("indirectExpression", tokens, root);
});
2747
_parser.addIndirectExpression("possessive", function (parser, runtime, tokens, root) {
	if (parser.possessivesDisabled) {
		return;
	}
	var apostrophe = tokens.matchOpToken("'");
	if (
		apostrophe ||
		(root.type === "symbol" &&
			(root.name === "my" || root.name === "its" || root.name === "your") &&
			tokens.currentToken().type === "IDENTIFIER")
	) {
		if (apostrophe) {
			tokens.requireToken("s");
		}
		var attribute = parser.parseElement("attributeRef", tokens);
		if (attribute == null) {
			var prop = tokens.requireTokenType("IDENTIFIER");
		}
		var propertyAccess = {
			type: "possessive",
			root: root,
			attribute: attribute,
			prop: prop,
			args: [root],
			op: function (context, rootVal) {
				if (attribute) {
					// @ts-ignore
					var value = runtime.resolveProperty(rootVal, attribute.name, true);
				} else {
					var value = runtime.resolveProperty(rootVal, prop.value, false);
				}
				return value;
			},
			evaluate: function (context) {
				return runtime.unifiedEval(this, context);
			},
		};
		return parser.parseElement("indirectExpression", tokens, propertyAccess);
	}
});
2788
_parser.addIndirectExpression("inExpression", function (parser, runtime, tokens, root) {
	if (!tokens.matchToken("in")) return;
	if ((root.type !== "idRef" && root.type === "queryRef") || root.type === "classRef") {
		var query = true;
	}
	var target = parser.requireElement("expression", tokens);
	var propertyAccess = {
		type: "inExpression",
		root: root,
		args: [query ? null : root, target],
		op: function (context, rootVal, target) {
			var returnArr = [];
			if (query) {
				runtime.forEach(target, function (targetElt) {
					var results = targetElt.querySelectorAll(root.css);
					for (var i = 0; i < results.length; i++) {
						returnArr.push(results[i]);
					}
				});
			} else {
				runtime.forEach(rootVal, function (rootElt) {
					runtime.forEach(target, function (targetElt) {
						if (rootElt === targetElt) {
							returnArr.push(rootElt);
						}
					});
				});
			}
			if (returnArr.length > 0) {
				return returnArr;
			} else {
				return null;
			}
		},
		evaluate: function (context) {
			return runtime.unifiedEval(this, context);
		},
	};
	return parser.parseElement("indirectExpression", tokens, propertyAccess);
});
2829
_parser.addIndirectExpression("asExpression", function (parser, runtime, tokens, root) {
	if (!tokens.matchToken("as")) return;
	tokens.matchToken("a") || tokens.matchToken("an");
	var conversion = parser.requireElement("dotOrColonPath", tokens).evaluate(); // OK No promise
	var propertyAccess = {
		type: "asExpression",
		root: root,
		args: [root],
		op: function (context, rootVal) {
			return runtime.convertValue(rootVal, conversion);
		},
		evaluate: function (context) {
			return runtime.unifiedEval(this, context);
		},
	};
	return parser.parseElement("indirectExpression", tokens, propertyAccess);
});
2847
_parser.addIndirectExpression("functionCall", function (parser, runtime, tokens, root) {
	if (!tokens.matchOpToken("(")) return;
	var args = [];
	if (!tokens.matchOpToken(")")) {
		do {
			args.push(parser.requireElement("expression", tokens));
		} while (tokens.matchOpToken(","));
		tokens.requireOpToken(")");
	}
2857
	if (root.root) {
		var functionCall = {
			type: "functionCall",
			root: root,
			argExressions: args,
			args: [root.root, args],
			op: function (context, rootRoot, args) {
				runtime.nullCheck(rootRoot, root.root);
				var func = rootRoot[root.prop.value];
				runtime.nullCheck(func, root);
				if (func.hyperfunc) {
					args.push(context);
				}
				return func.apply(rootRoot, args);
			},
			evaluate: function (context) {
				return runtime.unifiedEval(this, context);
			},
		};
	} else {
		var functionCall = {
			type: "functionCall",
			root: root,
			argExressions: args,
			args: [root, args],
			op: function (context, func, argVals) {
				runtime.nullCheck(func, root);
				if (func.hyperfunc) {
					argVals.push(context);
				}
				var apply = func.apply(null, argVals);
				return apply;
			},
			evaluate: function (context) {
				return runtime.unifiedEval(this, context);
			},
		};
	}
	return parser.parseElement("indirectExpression", tokens, functionCall);
});
2898
_parser.addIndirectExpression("attributeRefAccess", function (parser, runtime, tokens, root) {
	var attribute = parser.parseElement("attributeRef", tokens);
	if (!attribute) return;
	var attributeAccess = {
		type: "attributeRefAccess",
		root: root,
		attribute: attribute,
		args: [root],
		op: function (_ctx, rootVal) {
			// @ts-ignore
			var value = runtime.resolveProperty(rootVal, attribute.name, true);
			return value;
		},
		evaluate: function (context) {
			return _runtime.unifiedEval(this, context);
		},
	};
	return attributeAccess;
});
2918
_parser.addIndirectExpression("arrayIndex", function (parser, runtime, tokens, root) {
	if (!tokens.matchOpToken("[")) return;
	var andBefore = false;
	var andAfter = false;
	var firstIndex = null;
	var secondIndex = null;
2925
	if (tokens.matchOpToken("..")) {
		andBefore = true;
		firstIndex = parser.requireElement("expression", tokens);
	} else {
		firstIndex = parser.requireElement("expression", tokens);
2931
		if (tokens.matchOpToken("..")) {
			andAfter = true;
			var current = tokens.currentToken();
			if (current.type !== "R_BRACKET") {
				secondIndex = parser.parseElement("expression", tokens);
			}
		}
	}
	tokens.requireOpToken("]");
2941
	var arrayIndex = {
		type: "arrayIndex",
		root: root,
		firstIndex: firstIndex,
		secondIndex: secondIndex,
		args: [root, firstIndex, secondIndex],
		op: function (_ctx, root, firstIndex, secondIndex) {
			if (andBefore) {
				return root.slice(0, firstIndex + 1); // returns all items from beginning to firstIndex (inclusive)
			} else if (andAfter) {
				if (secondIndex != null) {
					return root.slice(firstIndex, secondIndex + 1); // returns all items from firstIndex to secondIndex (inclusive)
				} else {
					return root.slice(firstIndex); // returns from firstIndex to end of array
				}
			} else {
				return root[firstIndex];
			}
		},
		evaluate: function (context) {
			return _runtime.unifiedEval(this, context);
		},
	};
2965
	return _parser.parseElement("indirectExpression", tokens, arrayIndex);
});
2968
_parser.addGrammarElement("postfixExpression", function (parser, runtime, tokens) {
	var root = parser.parseElement("primaryExpression", tokens);
	if (tokens.matchOpToken(":")) {
		var typeName = tokens.requireTokenType("IDENTIFIER");
		var nullOk = !tokens.matchOpToken("!");
		return {
			type: "typeCheck",
			typeName: typeName,
			nullOk: nullOk,
			args: [root],
			op: function (context, val) {
				var passed = runtime.typeCheck(val, typeName.value, nullOk);
				if (passed) {
					return val;
				} else {
					throw new Error("Typecheck failed!  Expected: " + typeName.value);
				}
			},
			evaluate: function (context) {
				return runtime.unifiedEval(this, context);
			},
		};
	} else {
		return root;
	}
});
2995
_parser.addGrammarElement("logicalNot", function (parser, runtime, tokens) {
	if (!tokens.matchToken("not")) return;
	var root = parser.requireElement("unaryExpression", tokens);
	return {
		type: "logicalNot",
		root: root,
		args: [root],
		op: function (context, val) {
			return !val;
		},
		evaluate: function (context) {
			return runtime.unifiedEval(this, context);
		},
	};
});
3011
_parser.addGrammarElement("noExpression", function (parser, runtime, tokens) {
	if (!tokens.matchToken("no")) return;
	var root = parser.requireElement("unaryExpression", tokens);
	return {
		type: "noExpression",
		root: root,
		args: [root],
		op: function (_context, val) {
			return runtime.isEmpty(val);
		},
		evaluate: function (context) {
			return runtime.unifiedEval(this, context);
		},
	};
});
3027
_parser.addGrammarElement("negativeNumber", function (parser, runtime, tokens) {
	if (!tokens.matchOpToken("-")) return;
	var root = parser.requireElement("unaryExpression", tokens);
	return {
		type: "negativeNumber",
		root: root,
		args: [root],
		op: function (context, value) {
			return -1 * value;
		},
		evaluate: function (context) {
			return runtime.unifiedEval(this, context);
		},
	};
});
3043
_parser.addGrammarElement("unaryExpression", function (parser, runtime, tokens) {
	return parser.parseAnyOf(
		["logicalNot", "relativePositionalExpression", "positionalExpression", "noExpression", "negativeNumber", "postfixExpression"],
		tokens
	);
});
3050
var scanForwardQuery = function(start, root, match, wrap) {
	var results = root.querySelectorAll(match);
	for (var i = 0; i < results.length; i++) {
		var elt = results[i];
		if (elt.compareDocumentPosition(start) === Node.DOCUMENT_POSITION_PRECEDING) {
			return elt;
		}
	}
	if (wrap) {
		return results[0];
	}
}
3063
var scanBackwardsQuery = function(start, root, match, wrap) {
	var results = root.querySelectorAll(match);
	for (var i = results.length - 1; i >= 0; i--) {
		var elt = results[i];
		if (elt.compareDocumentPosition(start) === Node.DOCUMENT_POSITION_FOLLOWING) {
			return elt;
		}
	}
	if (wrap) {
		return results[results.length - 1];
	}
}
3076
var scanForwardArray = function(start, array, match, wrap) {
	var matches = [];
	_runtime.forEach(array, function(elt){
		if (elt.matches(match) || elt === start) {
			matches.push(elt);
		}
	})
	for (var i = 0; i < matches.length - 1; i++) {
		var elt = matches[i];
		if (elt === start) {
			return matches[i + 1];
		}
	}
	if (wrap) {
		var first = matches[0];
		if (first && first.matches(match)) {
			return first;
		}
	}
}
3097
var scanBackwardsArray = function(start, array, match, wrap) {
	return scanForwardArray(start, Array.from(array).reverse(), match, wrap);
}
3101
_parser.addGrammarElement("relativePositionalExpression", function (parser, runtime, tokens) {
	var op = tokens.matchAnyToken("next", "previous");
	if (!op) return;
	if (op.value === "next") {
		var forwardSearch = true;
	}
3108
	var thing = parser.parseElement("expression", tokens);
3110
	if (tokens.matchToken("from")) {
		tokens.pushFollow("in");
		try {
			var from = parser.requireElement("expression", tokens);
		} finally {
			tokens.popFollow();
		}
	} else {
		var from = parser.requireElement("implicitMeTarget", tokens);
	}
3121
	var inSearch = false;
	var withinElt;
	if (tokens.matchToken("in")) {
		inSearch = true;
		var inElt = parser.requireElement("expression", tokens);
	} else if (tokens.matchToken("within")) {
		withinElt = parser.requireElement("expression", tokens);
	} else {
		withinElt = document.body;
	}
3132
	var wrapping = false;
	if (tokens.matchToken("with")) {
		tokens.requireToken("wrapping")
		wrapping = true;
	}
3138
	return {
		type: "relativePositionalExpression",
		from: from,
		forwardSearch: forwardSearch,
		inSearch: inSearch,
		wrapping: wrapping,
		inElt: inElt,
		withinElt: withinElt,
		operator: op.value,
		args: [thing, from, inElt, withinElt],
		op: function (context, thing, from, inElt, withinElt) {
3150
			var css = thing.css;
			if (css == null) {
				throw "Expected a CSS value";
			}
3155
			if(inSearch) {
				if (inElt) {
					if (forwardSearch) {
						return scanForwardArray(from, inElt, css, wrapping);
					} else {
						return scanBackwardsArray(from, inElt, css, wrapping);
					}
				}
			} else {
				if (withinElt) {
					if (forwardSearch) {
						return scanForwardQuery(from, withinElt, css, wrapping);
					} else {
						return scanBackwardsQuery(from, withinElt, css, wrapping);
					}
				}
			}
		},
		evaluate: function (context) {
			return runtime.unifiedEval(this, context);
		},
	}
3178
});
3180
_parser.addGrammarElement("positionalExpression", function (parser, runtime, tokens) {
	var op = tokens.matchAnyToken("first", "last", "random");
	if (!op) return;
	tokens.matchAnyToken("in", "from", "of");
	var rhs = parser.requireElement("unaryExpression", tokens);
	const operator = op.value;
	return {
		type: "positionalExpression",
		rhs: rhs,
		operator: op.value,
		args: [rhs],
		op: function (context, rhsVal) {
			if (rhsVal && !Array.isArray(rhsVal)) {
				if (rhsVal.children) {
					rhsVal = rhsVal.children;
				} else {
					rhsVal = Array.from(rhsVal);
				}
			}
			if (rhsVal) {
				if (operator === "first") {
					return rhsVal[0];
				} else if (operator === "last") {
					return rhsVal[rhsVal.length - 1];
				} else if (operator === "random") {
					return rhsVal[Math.floor(Math.random() * rhsVal.length)];
				}
			}
		},
		evaluate: function (context) {
			return runtime.unifiedEval(this, context);
		},
	};
});
3215
_parser.addGrammarElement("mathOperator", function (parser, runtime, tokens) {
	var expr = parser.parseElement("unaryExpression", tokens);
	var mathOp,
		initialMathOp = null;
	mathOp = tokens.matchAnyOpToken("+", "-", "*", "/", "%");
	while (mathOp) {
		initialMathOp = initialMathOp || mathOp;
		var operator = mathOp.value;
		if (initialMathOp.value !== operator) {
			parser.raiseParseError(tokens, "You must parenthesize math operations with different operators");
		}
		var rhs = parser.parseElement("unaryExpression", tokens);
		expr = {
			type: "mathOperator",
			lhs: expr,
			rhs: rhs,
			operator: operator,
			args: [expr, rhs],
			op: function (context, lhsVal, rhsVal) {
				if (operator === "+") {
					return lhsVal + rhsVal;
				} else if (operator === "-") {
					return lhsVal - rhsVal;
				} else if (operator === "*") {
					return lhsVal * rhsVal;
				} else if (operator === "/") {
					return lhsVal / rhsVal;
				} else if (operator === "%") {
					return lhsVal % rhsVal;
				}
			},
			evaluate: function (context) {
				return runtime.unifiedEval(this, context);
			},
		};
		mathOp = tokens.matchAnyOpToken("+", "-", "*", "/", "%");
	}
	return expr;
});
3255
_parser.addGrammarElement("mathExpression", function (parser, runtime, tokens) {
	return parser.parseAnyOf(["mathOperator", "unaryExpression"], tokens);
});
3259
_parser.addGrammarElement("comparisonOperator", function (parser, runtime, tokens) {
	var expr = parser.parseElement("mathExpression", tokens);
	var comparisonToken = tokens.matchAnyOpToken("<", ">", "<=", ">=", "==", "===", "!=", "!==");
	var operator = comparisonToken ? comparisonToken.value : null;
	var hasRightValue = true; // By default, most comparisons require two values, but there are some exceptions.
	var typeCheck = false;
3266
	if (operator == null) {
		if (tokens.matchToken("is") || tokens.matchToken("am")) {
			if (tokens.matchToken("not")) {
				if (tokens.matchToken("in")) {
					operator = "not in";
				} else if (tokens.matchToken("a")) {
					operator = "not a";
					typeCheck = true;
				} else if (tokens.matchToken("empty")) {
					operator = "not empty";
					hasRightValue = false;
				} else {
					operator = "!=";
				}
			} else if (tokens.matchToken("in")) {
				operator = "in";
			} else if (tokens.matchToken("a")) {
				operator = "a";
				typeCheck = true;
			} else if (tokens.matchToken("empty")) {
				operator = "empty";
				hasRightValue = false;
			} else {
				operator = "==";
			}
		} else if (tokens.matchToken("matches") || tokens.matchToken("match")) {
			operator = "match";
		} else if (tokens.matchToken("contains") || tokens.matchToken("contain")) {
			operator = "contain";
		} else if (tokens.matchToken("do") || tokens.matchToken("does")) {
			tokens.requireToken("not");
			if (tokens.matchToken("matches") || tokens.matchToken("match")) {
				operator = "not match";
			} else if (tokens.matchToken("contains") || tokens.matchToken("contain")) {
				operator = "not contain";
			} else {
				parser.raiseParseError(tokens, "Expected matches or contains");
			}
		}
	}
3307
	if (operator) {
		// Do not allow chained comparisons, which is dumb
		if (typeCheck) {
			var typeName = tokens.requireTokenType("IDENTIFIER");
			var nullOk = !tokens.matchOpToken("!");
		} else if (hasRightValue) {
			var rhs = parser.requireElement("mathExpression", tokens);
			if (operator === "match" || operator === "not match") {
				rhs = rhs.css ? rhs.css : rhs;
			}
		}
		expr = {
			type: "comparisonOperator",
			operator: operator,
			typeName: typeName,
			nullOk: nullOk,
			lhs: expr,
			rhs: rhs,
			args: [expr, rhs],
			op: function (context, lhsVal, rhsVal) {
				if (operator === "==") {
					return lhsVal == rhsVal;
				} else if (operator === "!=") {
					return lhsVal != rhsVal;
				}
				if (operator === "in") {
					return rhsVal != null && Array.from(rhsVal).indexOf(lhsVal) >= 0;
				}
				if (operator === "not in") {
					return rhsVal == null || Array.from(rhsVal).indexOf(lhsVal) < 0;
				}
				if (operator === "match") {
					return lhsVal != null && lhsVal.matches(rhsVal);
				}
				if (operator === "not match") {
					return lhsVal == null || !lhsVal.matches(rhsVal);
				}
				if (operator === "contain") {
					return lhsVal != null && lhsVal.contains(rhsVal);
				}
				if (operator === "not contain") {
					return lhsVal == null || !lhsVal.contains(rhsVal);
				}
				if (operator === "===") {
					return lhsVal === rhsVal;
				} else if (operator === "!==") {
					return lhsVal !== rhsVal;
				} else if (operator === "<") {
					return lhsVal < rhsVal;
				} else if (operator === ">") {
					return lhsVal > rhsVal;
				} else if (operator === "<=") {
					return lhsVal <= rhsVal;
				} else if (operator === ">=") {
					return lhsVal >= rhsVal;
				} else if (operator === "empty") {
					return runtime.isEmpty(lhsVal);
				} else if (operator === "not empty") {
					return !runtime.isEmpty(lhsVal);
				} else if (operator === "a") {
					return runtime.typeCheck(lhsVal, typeName.value, nullOk);
				} else if (operator === "not a") {
					return !runtime.typeCheck(lhsVal, typeName.value, nullOk);
				} else {
					throw "Unknown comparison : " + operator;
				}
			},
			evaluate: function (context) {
				return runtime.unifiedEval(this, context);
			},
		};
	}
	return expr;
});
3382
_parser.addGrammarElement("comparisonExpression", function (parser, runtime, tokens) {
	return parser.parseAnyOf(["comparisonOperator", "mathExpression"], tokens);
});
3386
_parser.addGrammarElement("logicalOperator", function (parser, runtime, tokens) {
	var expr = parser.parseElement("comparisonExpression", tokens);
	var logicalOp,
		initialLogicalOp = null;
	logicalOp = tokens.matchToken("and") || tokens.matchToken("or");
	while (logicalOp) {
		initialLogicalOp = initialLogicalOp || logicalOp;
		if (initialLogicalOp.value !== logicalOp.value) {
			parser.raiseParseError(tokens, "You must parenthesize logical operations with different operators");
		}
		var rhs = parser.requireElement("comparisonExpression", tokens);
		const operator = logicalOp.value;
		expr = {
			type: "logicalOperator",
			operator: operator,
			lhs: expr,
			rhs: rhs,
			args: [expr, rhs],
			op: function (context, lhsVal, rhsVal) {
				if (operator === "and") {
					return lhsVal && rhsVal;
				} else {
					return lhsVal || rhsVal;
				}
			},
			evaluate: function (context) {
				return runtime.unifiedEval(this, context);
			},
		};
		logicalOp = tokens.matchToken("and") || tokens.matchToken("or");
	}
	return expr;
});
3420
_parser.addGrammarElement("logicalExpression", function (parser, runtime, tokens) {
	return parser.parseAnyOf(["logicalOperator", "mathExpression"], tokens);
});
3424
_parser.addGrammarElement("asyncExpression", function (parser, runtime, tokens) {
	if (tokens.matchToken("async")) {
		var value = parser.requireElement("logicalExpression", tokens);
		var expr = {
			type: "asyncExpression",
			value: value,
			evaluate: function (context) {
				return {
					asyncWrapper: true,
					value: this.value.evaluate(context), //OK
				};
			},
		};
		return expr;
	} else {
		return parser.parseElement("logicalExpression", tokens);
	}
});
3443
_parser.addGrammarElement("expression", function (parser, runtime, tokens) {
	tokens.matchToken("the"); // optional the
	return parser.parseElement("asyncExpression", tokens);
});
3448
_parser.addGrammarElement("assignableExpression", function (parser, runtime, tokens) {
	tokens.matchToken("the"); // optional the
3451
	// TODO obviously we need to generalize this as a left hand side / targetable concept
	var expr = parser.parseElement("primaryExpression", tokens);
	if (expr && (
		expr.type === "symbol" ||
		expr.type === "ofExpression" ||
		expr.type === "propertyAccess" ||
		expr.type === "attributeRefAccess" ||
		expr.type === "attributeRef" ||
		expr.type === "possessive")
	) {
		return expr;
	} else {
		_parser.raiseParseError(
			tokens,
			"A target expression must be writable.  The expression type '" + (expr && expr.type) + "' is not."
		);
	}
	return expr;
});
3471
_parser.addGrammarElement("hyperscript", function (parser, runtime, tokens) {
	var features = [];
3474
	if (tokens.hasMore()) {
		while (parser.featureStart(tokens.currentToken()) || tokens.currentToken().value === "(") {
			var feature = parser.requireElement("feature", tokens);
			features.push(feature);
			tokens.matchToken("end"); // optional end
		}
	}
	return {
		type: "hyperscript",
		features: features,
		apply: function (target, source, args) {
			// no op
			for (const feature of features) {
				feature.install(target, source, args);
			}
		},
	};
});
3493
var parseEventArgs = function (tokens) {
	var args = [];
	// handle argument list (look ahead 3)
	if (
		tokens.token(0).value === "(" &&
		(tokens.token(1).value === ")" || tokens.token(2).value === "," || tokens.token(2).value === ")")
	) {
		tokens.matchOpToken("(");
		do {
			args.push(tokens.requireTokenType("IDENTIFIER"));
		} while (tokens.matchOpToken(","));
		tokens.requireOpToken(")");
	}
	return args;
};
3509
_parser.addFeature("on", function (parser, runtime, tokens) {
	if (!tokens.matchToken("on")) return;
	var every = false;
	if (tokens.matchToken("every")) {
		every = true;
	}
	var events = [];
	var displayName = null;
	do {
		var on = parser.requireElement("eventName", tokens, "Expected event name");
3520
		var eventName = on.evaluate(); // OK No Promise
3522
		if (displayName) {
			displayName = displayName + " or " + eventName;
		} else {
			displayName = "on " + eventName;
		}
		var args = parseEventArgs(tokens);
3529
		var filter = null;
		if (tokens.matchOpToken("[")) {
			filter = parser.requireElement("expression", tokens);
			tokens.requireOpToken("]");
		}
3535
		if (tokens.currentToken().type === "NUMBER") {
			var startCountToken = tokens.consumeToken();
			var startCount = parseInt(startCountToken.value);
			if (tokens.matchToken("to")) {
				var endCountToken = tokens.consumeToken();
				var endCount = parseInt(endCountToken.value);
			} else if (tokens.matchToken("and")) {
				var unbounded = true;
				tokens.requireToken("on");
			}
		}
3547
		if (eventName === "intersection") {
			var intersectionSpec = {};
			if (tokens.matchToken("with")) {
				intersectionSpec["with"] = parser.requireElement("expression", tokens).evaluate();
			}
			if (tokens.matchToken("having")) {
				do {
					if (tokens.matchToken("margin")) {
						intersectionSpec["rootMargin"] = parser.requireElement("stringLike", tokens).evaluate();
					} else if (tokens.matchToken("threshold")) {
						intersectionSpec["threshold"] = parser.requireElement("expression", tokens).evaluate();
					} else {
						parser.raiseParseError(tokens, "Unknown intersection config specification");
					}
				} while (tokens.matchToken("and"));
			}
		} else if (eventName === "mutation") {
			var mutationSpec = {};
			if (tokens.matchToken("of")) {
				do {
					if (tokens.matchToken("anything")) {
						mutationSpec["attributes"] = true;
						mutationSpec["subtree"] = true;
						mutationSpec["characterData"] = true;
						mutationSpec["childList"] = true;
					} else if (tokens.matchToken("childList")) {
						mutationSpec["childList"] = true;
					} else if (tokens.matchToken("attributes")) {
						mutationSpec["attributes"] = true;
						mutationSpec["attributeOldValue"] = true;
					} else if (tokens.matchToken("subtree")) {
						mutationSpec["subtree"] = true;
					} else if (tokens.matchToken("characterData")) {
						mutationSpec["characterData"] = true;
						mutationSpec["characterDataOldValue"] = true;
					} else if (tokens.currentToken().type === "ATTRIBUTE_REF") {
						var attribute = tokens.consumeToken();
						if (mutationSpec["attributeFilter"] == null) {
							mutationSpec["attributeFilter"] = [];
						}
						if (attribute.value.indexOf("@") == 0) {
							mutationSpec["attributeFilter"].push(attribute.value.substring(1));
						} else {
							parser.raiseParseError(
								tokens,
								"Only shorthand attribute references are allowed here"
							);
						}
					} else {
						parser.raiseParseError(tokens, "Unknown mutation config specification");
					}
				} while (tokens.matchToken("or"));
			} else {
				mutationSpec["attributes"] = true;
				mutationSpec["characterData"] = true;
				mutationSpec["childList"] = true;
			}
		}
3606
		var from = null;
		var elsewhere = false;
		if (tokens.matchToken("from")) {
			if (tokens.matchToken("elsewhere")) {
				elsewhere = true;
			} else {
				from = parser.parseElement("expression", tokens);
				if (!from) {
					parser.raiseParseError(tokens, 'Expected either target value or "elsewhere".');
				}
			}
		}
		// support both "elsewhere" and "from elsewhere"
		if (from === null && elsewhere === false && tokens.matchToken("elsewhere")) {
			elsewhere = true;
		}
3623
		if (tokens.matchToken("in")) {
			var inExpr = parser.parseAnyOf(["idRef", "queryRef", "classRef"], tokens);
		}
3627
		if (tokens.matchToken("debounced")) {
			tokens.requireToken("at");
			var timeExpr = parser.requireElement("timeExpression", tokens);
			// @ts-ignore
			var debounceTime = timeExpr.evaluate({}); // OK No promise TODO make a literal time expr
		} else if (tokens.matchToken("throttled")) {
			tokens.requireToken("at");
			var timeExpr = parser.requireElement("timeExpression", tokens);
			// @ts-ignore
			var throttleTime = timeExpr.evaluate({}); // OK No promise TODO make a literal time expr
		}
3639
		events.push({
			execCount: 0,
			every: every,
			on: eventName,
			args: args,
			filter: filter,
			from: from,
			inExpr: inExpr,
			elsewhere: elsewhere,
			startCount: startCount,
			endCount: endCount,
			unbounded: unbounded,
			debounceTime: debounceTime,
			throttleTime: throttleTime,
			mutationSpec: mutationSpec,
			intersectionSpec: intersectionSpec,
		});
	} while (tokens.matchToken("or"));
3658
	var queue = [];
	var queueLast = true;
	if (!every) {
		if (tokens.matchToken("queue")) {
			if (tokens.matchToken("all")) {
				var queueAll = true;
				var queueLast = false;
			} else if (tokens.matchToken("first")) {
				var queueFirst = true;
			} else if (tokens.matchToken("none")) {
				var queueNone = true;
			} else {
				tokens.requireToken("last");
			}
		}
	}
3675
	var commandList = parser.parseElement("commandList", tokens);
3677
	var implicitReturn = {
		type: "implicitReturn",
		op: function (context) {
			// automatically resolve at the end of an event handler if nothing else does
			context.meta.resolve();
			return runtime.HALT;
		},
		execute: function (ctx) {
			// do nothing
		},
	};
3689
	if (commandList) {
		/** @type {GrammarElement} */
		var start = commandList;
3693
		var end = start;
		while (end.next) {
			end = end.next;
		}
		end.next = implicitReturn;
	} else {
		start = implicitReturn;
	}
3702
	var onFeature = {
		displayName: displayName,
		events: events,
		start: start,
		every: every,
		executing: false,
		execCount: 0,
		queue: queue,
		execute: function (/** @type {Context} */ ctx) {
			if (this.executing && every === false) {
				if (queueNone || (queueFirst && queue.length > 0)) {
					return;
				}
				if (queueLast) {
					onFeature.queue.length = 0;
				}
				onFeature.queue.push(ctx);
				return;
			}
			onFeature.execCount++;
			this.executing = true;
			ctx.meta.resolve = function () {
				onFeature.executing = false;
				var queued = onFeature.queue.shift();
				if (queued) {
					setTimeout(function () {
						onFeature.execute(queued);
					}, 1);
				}
			};
			ctx.meta.reject = function (err) {
				console.error(err.message ? err.message : err);
				var hypertrace = runtime.getHyperTrace(ctx, err);
				if (hypertrace) {
					hypertrace.print();
				}
				runtime.triggerEvent(ctx.me, "exception", {
					error: err,
				});
				onFeature.executing = false;
				var queued = onFeature.queue.shift();
				if (queued) {
					setTimeout(function () {
						onFeature.execute(queued);
					}, 1);
				}
			};
			start.execute(ctx);
		},
		install: function (elt, source) {
			for (const eventSpec of onFeature.events) {
				var targets;
				if (eventSpec.elsewhere) {
					targets = [document];
				} else if (eventSpec.from) {
					targets = eventSpec.from.evaluate(runtime.makeContext(elt, onFeature, elt, null));
				} else {
					targets = [elt];
				}
				runtime.forEach(targets, function (target) {
					// OK NO PROMISE
3764
					var eventName = eventSpec.on;
					if (eventSpec.mutationSpec) {
						eventName = "hyperscript:mutation";
						const observer = new MutationObserver(function (mutationList, observer) {
							console.log(target, mutationList);
							if (!onFeature.executing) {
								_runtime.triggerEvent(target, eventName, {
									mutationList: mutationList,
									observer: observer,
								});
							}
						});
						observer.observe(target, eventSpec.mutationSpec);
					}
3779
					if (eventSpec.intersectionSpec) {
						eventName = "hyperscript:insersection";
						const observer = new IntersectionObserver(function (entries) {
							for (const entry of entries) {
								var detail = {
									observer: observer,
								};
								detail = mergeObjects(detail, entry);
								detail["intersecting"] = entry.isIntersecting;
								_runtime.triggerEvent(target, eventName, detail);
							}
						}, eventSpec.intersectionSpec);
						observer.observe(target);
					}
3794
					target.addEventListener(eventName, function listener(evt) {
						// OK NO PROMISE
						if (elt instanceof Node && target !== elt && !elt.isConnected) {
							target.removeEventListener(eventName, listener);
							return;
						}
3801
						var ctx = runtime.makeContext(elt, onFeature, elt, evt);
						if (eventSpec.elsewhere && elt.contains(evt.target)) {
							return;
						}
						if (eventSpec.from) {
							ctx.result = target;
						}
3809
						// establish context
						for (const arg of eventSpec.args) {
							ctx[arg.value] =
								ctx.event[arg.value] || ('detail' in ctx.event ? ctx.event['detail'][arg.value] : null);
						}
3815
						// apply filter
						if (eventSpec.filter) {
							var initialCtx = ctx.meta.context;
							ctx.meta.context = ctx.event;
							try {
								var value = eventSpec.filter.evaluate(ctx); //OK NO PROMISE
								if (value) {
									// match the javascript semantics for if statements
								} else {
									return;
								}
							} finally {
								ctx.meta.context = initialCtx;
							}
						}
3831
						if (eventSpec.inExpr) {
							var inElement = evt.target;
							while (true) {
								if (inElement.matches && inElement.matches(eventSpec.inExpr.css)) {
									ctx.result = inElement;
									break;
								} else {
									inElement = inElement.parentElement;
									if (inElement == null) {
										return; // no match found
									}
								}
							}
						}
3846
						// verify counts
						eventSpec.execCount++;
						if (eventSpec.startCount) {
							if (eventSpec.endCount) {
								if (
									eventSpec.execCount < eventSpec.startCount ||
									eventSpec.execCount > eventSpec.endCount
								) {
									return;
								}
							} else if (eventSpec.unbounded) {
								if (eventSpec.execCount < eventSpec.startCount) {
									return;
								}
							} else if (eventSpec.execCount !== eventSpec.startCount) {
								return;
							}
						}
3865
						//debounce
						if (eventSpec.debounceTime) {
							if (eventSpec.debounced) {
								clearTimeout(eventSpec.debounced);
							}
							eventSpec.debounced = setTimeout(function () {
								onFeature.execute(ctx);
							}, eventSpec.debounceTime);
							return;
						}
3876
						// throttle
						if (eventSpec.throttleTime) {
							if (
								eventSpec.lastExec &&
								Date.now() < eventSpec.lastExec + eventSpec.throttleTime
							) {
								return;
							} else {
								eventSpec.lastExec = Date.now();
							}
						}
3888
						// apply execute
						onFeature.execute(ctx);
					});
				});
			}
		},
	};
	parser.setParent(start, onFeature);
	return onFeature;
});
3899
_parser.addFeature("def", function (parser, runtime, tokens) {
	if (!tokens.matchToken("def")) return;
	var functionName = parser.requireElement("dotOrColonPath", tokens);
	var nameVal = functionName.evaluate(); // OK
	var nameSpace = nameVal.split(".");
	var funcName = nameSpace.pop();
3906
	var args = [];
	if (tokens.matchOpToken("(")) {
		if (tokens.matchOpToken(")")) {
			// emtpy args list
		} else {
			do {
				args.push(tokens.requireTokenType("IDENTIFIER"));
			} while (tokens.matchOpToken(","));
			tokens.requireOpToken(")");
		}
	}
3918
	var start = parser.requireElement("commandList", tokens);
	if (tokens.matchToken("catch")) {
		var errorSymbol = tokens.requireTokenType("IDENTIFIER").value;
		var errorHandler = parser.parseElement("commandList", tokens);
	}
	var functionFeature = {
		displayName:
			funcName +
			"(" +
			args
				.map(function (arg) {
					return arg.value;
				})
				.join(", ") +
			")",
		name: funcName,
		args: args,
		start: start,
		errorHandler: errorHandler,
		errorSymbol: errorSymbol,
		install: function (target, source) {
			var func = function () {
				// null, worker
				var ctx = runtime.makeContext(source, functionFeature, target, null);
3943
				// install error handler if any
				ctx.meta.errorHandler = errorHandler;
				ctx.meta.errorSymmbol = errorSymbol;
3947
				for (var i = 0; i < args.length; i++) {
					var name = args[i];
					var argumentVal = arguments[i];
					if (name) {
						ctx[name.value] = argumentVal;
					}
				}
				ctx.meta.caller = arguments[args.length];
				if (ctx.meta.caller) {
					ctx.meta.callingCommand = ctx.meta.caller.meta.command;
				}
				var resolve,
					reject = null;
				var promise = new Promise(function (theResolve, theReject) {
					resolve = theResolve;
					reject = theReject;
				});
				start.execute(ctx);
				if (ctx.meta.returned) {
					return ctx.meta.returnValue;
				} else {
					ctx.meta.resolve = resolve;
					ctx.meta.reject = reject;
					return promise;
				}
			};
			func.hyperfunc = true;
			func.hypername = nameVal;
			runtime.assignToNamespace(target, nameSpace, funcName, func);
		},
	};
3979
	var implicitReturn = {
		type: "implicitReturn",
		op: function (context) {
			// automatically return at the end of the function if nothing else does
			context.meta.returned = true;
			if (context.meta.resolve) {
				context.meta.resolve();
			}
			return runtime.HALT;
		},
		execute: function (context) {
			// do nothing
		},
	};
	// terminate body
	if (start) {
		var end = start;
		while (end.next) {
			end = end.next;
		}
		end.next = implicitReturn;
	} else {
		functionFeature.start = implicitReturn;
	}
4004
	// terminate error handler
	if (errorHandler) {
		var end = errorHandler;
		while (end.next) {
			end = end.next;
		}
		end.next = implicitReturn;
	}
4013
	parser.setParent(start, functionFeature);
	return functionFeature;
});
4017
_parser.addFeature("init", function (parser, runtime, tokens) {
	if (!tokens.matchToken("init")) return;
4020
	var start = parser.parseElement("commandList", tokens);
	var initFeature = {
		start: start,
		install: function (target, source) {
			setTimeout(function () {
				start && start.execute(runtime.makeContext(target, initFeature, target, null));
			}, 0);
		},
	};
4030
	var implicitReturn = {
		type: "implicitReturn",
		op: function (context) {
			return runtime.HALT;
		},
		execute: function (context) {
			// do nothing
		},
	};
	// terminate body
	if (start) {
		var end = start;
		while (end.next) {
			end = end.next;
		}
		end.next = implicitReturn;
	} else {
		initFeature.start = implicitReturn;
	}
	parser.setParent(start, initFeature);
	return initFeature;
});
4053
_parser.addFeature("worker", function (parser, runtime, tokens) {
	if (tokens.matchToken("worker")) {
		parser.raiseParseError(
			tokens,
			"In order to use the 'worker' feature, include " +
				"the _hyperscript worker plugin. See " +
				"https://hyperscript.org/features/worker/ for " +
				"more info."
		);
	}
});
4065
_parser.addFeature("behavior", function (parser, runtime, tokens) {
	if (!tokens.matchToken("behavior")) return;
	var path = parser.requireElement("dotOrColonPath", tokens).evaluate();
	var nameSpace = path.split(".");
	var name = nameSpace.pop();
4071
	var formalParams = [];
	if (tokens.matchOpToken("(") && !tokens.matchOpToken(")")) {
		do {
			formalParams.push(tokens.requireTokenType("IDENTIFIER").value);
		} while (tokens.matchOpToken(","));
		tokens.requireOpToken(")");
	}
	var hs = parser.requireElement("hyperscript", tokens);
	for (var i = 0; i < hs.features.length; i++) {
		var feature = hs.features[i];
		feature.behavior = path;
	}
4084
	return {
		install: function (target, source) {
			runtime.assignToNamespace(
				globalScope.document && globalScope.document.body,
				nameSpace,
				name,
				function (target, source, innerArgs) {
					var internalData = runtime.getInternalData(target);
					var elementScope = getOrInitObject(internalData, path + "Scope");
					for (var i = 0; i < formalParams.length; i++) {
						elementScope[formalParams[i]] = innerArgs[formalParams[i]];
					}
					hs.apply(target, source);
				}
			);
		},
	};
});
4103
_parser.addFeature("install", function (parser, runtime, tokens) {
	if (!tokens.matchToken("install")) return;
	var behaviorPath = parser.requireElement("dotOrColonPath", tokens).evaluate();
	var behaviorNamespace = behaviorPath.split(".");
	var args = parser.parseElement("namedArgumentList", tokens);
4109
	var installFeature;
	return (installFeature = {
		install: function (target, source) {
			runtime.unifiedEval(
				{
					args: [args],
					op: function (ctx, args) {
						var behavior = globalScope;
						for (var i = 0; i < behaviorNamespace.length; i++) {
							behavior = behavior[behaviorNamespace[i]];
							if (typeof behavior !== "object" && typeof behavior !== "function")
								throw new Error("No such behavior defined as " + behaviorPath);
						}
4123
						if (!(behavior instanceof Function))
							throw new Error(behaviorPath + " is not a behavior");
4126
						behavior(target, source, args);
					},
				},
				runtime.makeContext(target, installFeature, target)
			);
		},
	});
});
4135
_parser.addGrammarElement("jsBody", function (parser, runtime, tokens) {
	var jsSourceStart = tokens.currentToken().start;
	var jsLastToken = tokens.currentToken();
4139
	var funcNames = [];
	var funcName = "";
	var expectFunctionDeclaration = false;
	while (tokens.hasMore()) {
		jsLastToken = tokens.consumeToken();
		var peek = tokens.token(0, true);
		if (peek.type === "IDENTIFIER" && peek.value === "end") {
			break;
		}
		if (expectFunctionDeclaration) {
			if (jsLastToken.type === "IDENTIFIER" || jsLastToken.type === "NUMBER") {
				funcName += jsLastToken.value;
			} else {
				if (funcName !== "") funcNames.push(funcName);
				funcName = "";
				expectFunctionDeclaration = false;
			}
		} else if (jsLastToken.type === "IDENTIFIER" && jsLastToken.value === "function") {
			expectFunctionDeclaration = true;
		}
	}
	var jsSourceEnd = jsLastToken.end + 1;
4162
	return {
		type: "jsBody",
		exposedFunctionNames: funcNames,
		jsSource: tokens.source.substring(jsSourceStart, jsSourceEnd),
	};
});
4169
_parser.addFeature("js", function (parser, runtime, tokens) {
	if (!tokens.matchToken("js")) return;
	var jsBody = parser.requireElement("jsBody", tokens);
4173
	var jsSource =
		jsBody.jsSource +
		"\nreturn { " +
		jsBody.exposedFunctionNames
			.map(function (name) {
				return name + ":" + name;
			})
			.join(",") +
		" } ";
	var func = new Function(jsSource);
4184
	return {
		jsSource: jsSource,
		function: func,
		exposedFunctionNames: jsBody.exposedFunctionNames,
		install: function () {
			mergeObjects(globalScope, func());
		},
	};
});
4194
_parser.addCommand("js", function (parser, runtime, tokens) {
	if (!tokens.matchToken("js")) return;
	// Parse inputs
	var inputs = [];
	if (tokens.matchOpToken("(")) {
		if (tokens.matchOpToken(")")) {
			// empty input list
		} else {
			do {
				var inp = tokens.requireTokenType("IDENTIFIER");
				inputs.push(inp.value);
			} while (tokens.matchOpToken(","));
			tokens.requireOpToken(")");
		}
	}
4210
	var jsBody = parser.requireElement("jsBody", tokens);
	tokens.matchToken("end");
4213
	var func = varargConstructor(Function, inputs.concat([jsBody.jsSource]));
4215
	var command = {
		jsSource: jsBody.jsSource,
		function: func,
		inputs: inputs,
		op: function (context) {
			var args = [];
			inputs.forEach(function (input) {
				args.push(runtime.resolveSymbol(input, context, 'default'));
			});
			var result = func.apply(globalScope, args);
			if (result && typeof result.then === "function") {
				return new Promise(function (resolve) {
					result.then(function (actualResult) {
						context.result = actualResult;
						resolve(runtime.findNext(this, context));
					});
				});
			} else {
				context.result = result;
				return runtime.findNext(this, context);
			}
		},
	};
	return command;
});
4241
_parser.addCommand("async", function (parser, runtime, tokens) {
	if (!tokens.matchToken("async")) return;
	if (tokens.matchToken("do")) {
		var body = parser.requireElement("commandList", tokens);
4246
		// Append halt
		var end = body;
		while (end.next) end = end.next;
		end.next = runtime.HALT;
4251
		tokens.requireToken("end");
	} else {
		var body = parser.requireElement("command", tokens);
	}
	var command = {
		body: body,
		op: function (context) {
			setTimeout(function () {
				body.execute(context);
			});
			return runtime.findNext(this, context);
		},
	};
	return command;
});
4267
_parser.addCommand("tell", function (parser, runtime, tokens) {
	var startToken = tokens.currentToken();
	if (!tokens.matchToken("tell")) return;
	var value = parser.requireElement("expression", tokens);
	var body = parser.requireElement("commandList", tokens);
	if (tokens.hasMore()) {
		tokens.requireToken("end");
	}
	var slot = "tell_" + startToken.start;
	var tellCmd = {
		value: value,
		body: body,
		args: [value],
		resolveNext: function (context) {
			var iterator = context.meta.iterators[slot];
			if (iterator.index < iterator.value.length) {
				context.beingTold = iterator.value[iterator.index++];
				return body;
			} else {
				// restore original me
				context.beingTold = iterator.originalBeingTold;
				if (this.next) {
					return this.next;
				} else {
					return runtime.findNext(this.parent, context);
				}
			}
		},
		op: function (context, value) {
			if (value == null) {
				value = [];
			} else if (!(Array.isArray(value) || value instanceof NodeList)) {
				value = [value];
			}
			context.meta.iterators[slot] = {
				originalBeingTold: context.beingTold,
				index: 0,
				value: value,
			};
			return this.resolveNext(context);
		},
	};
	parser.setParent(body, tellCmd);
	return tellCmd;
});
4313
_parser.addCommand("wait", function (parser, runtime, tokens) {
	if (!tokens.matchToken("wait")) return;
	var command;
4317
	// wait on event
	if (tokens.matchToken("for")) {
		tokens.matchToken("a"); // optional "a"
		var events = [];
		do {
			var lookahead = tokens.token(0);
			if (lookahead.type === 'NUMBER' || lookahead.type === 'L_PAREN') {
				events.push({
					time: parser.requireElement('timeExpression', tokens).evaluate() // TODO: do we want to allow async here?
				})
			} else {
				events.push({
					name: _parser.requireElement("dotOrColonPath", tokens, "Expected event name").evaluate(),
					args: parseEventArgs(tokens),
				});
			}
		} while (tokens.matchToken("or"));
4335
		if (tokens.matchToken("from")) {
			var on = parser.requireElement("expression", tokens);
		}
4339
		// wait on event
		command = {
			event: events,
			on: on,
			args: [on],
			op: function (context, on) {
				var target = on ? on : context.me;
				if (!(target instanceof EventTarget))
					throw new Error("Not a valid event target: " + this.on.sourceFor());
				return new Promise((resolve) => {
					var resolved = false;
					for (const eventInfo of events) {
						var listener = (event) => {
							context.result = event;
							for (const arg of eventInfo.args) {
								context[arg.value] =
									event[arg.value] || (event.detail ? event.detail[arg.value] : null);
							}
							if (!resolved) {
								resolved = true;
								resolve(runtime.findNext(this, context));
							}
						};
						if (eventInfo.name) target.addEventListener(eventInfo.name, listener, { once: true });
						else if (eventInfo.time) setTimeout(listener, eventInfo.time, eventInfo.time)
					}
				});
			},
		};
		return command;
	} else {
		var time;
		if (tokens.matchToken("a")) {
			tokens.requireToken("tick");
			time = 0;
		} else {
			time = _parser.requireElement("timeExpression", tokens);
		}
4378
		command = {
			type: "waitCmd",
			time: time,
			args: [time],
			op: function (context, timeValue) {
				return new Promise((resolve) => {
					setTimeout(() => {
						resolve(runtime.findNext(this, context));
					}, timeValue);
				});
			},
			execute: function (context) {
				return runtime.unifiedExec(this, context);
			},
		};
		return command;
	}
});
4397
// TODO  - colon path needs to eventually become part of ruby-style symbols
_parser.addGrammarElement("dotOrColonPath", function (parser, runtime, tokens) {
	var root = tokens.matchTokenType("IDENTIFIER");
	if (root) {
		var path = [root.value];
4403
		var separator = tokens.matchOpToken(".") || tokens.matchOpToken(":");
		if (separator) {
			do {
				path.push(tokens.requireTokenType("IDENTIFIER").value);
			} while (tokens.matchOpToken(separator.value));
		}
4410
		return {
			type: "dotOrColonPath",
			path: path,
			evaluate: function () {
				return path.join(separator ? separator.value : "");
			},
		};
	}
});
4420
_parser.addGrammarElement("eventName", function (parser, runtime, tokens) {
	var token;
	if ((token = tokens.matchTokenType("STRING"))) {
		return {
			evaluate: function() {
				return token.value;
			},
		};
	}
4430
	return parser.parseElement("dotOrColonPath", tokens);
});
4433
_parser.addCommand("send", function (parser, runtime, tokens) {
	if (!tokens.matchToken("send")) return;
	var eventName = parser.requireElement("eventName", tokens);
4437
	var details = parser.parseElement("namedArgumentList", tokens);
	if (tokens.matchToken("to")) {
		var to = parser.requireElement("expression", tokens);
	} else {
		var to = parser.requireElement("implicitMeTarget", tokens);
	}
4444
	var sendCmd = {
		eventName: eventName,
		details: details,
		to: to,
		args: [to, eventName, details],
		op: function (context, to, eventName, details) {
			runtime.forEach(to, function (target) {
				runtime.triggerEvent(target, eventName, details ? details : {});
			});
			return runtime.findNext(sendCmd, context);
		},
	};
	return sendCmd;
});
4459
var parseReturnFunction = function (parser, runtime, tokens, returnAValue) {
	if (returnAValue) {
		var value = parser.requireElement("expression", tokens);
	}
4464
	var returnCmd = {
		value: value,
		args: [value],
		op: function (context, value) {
			var resolve = context.meta.resolve;
			context.meta.returned = true;
			if (resolve) {
				if (value) {
					resolve(value);
				} else {
					resolve();
				}
			} else {
				context.meta.returned = true;
				context.meta.returnValue = value;
			}
			return runtime.HALT;
		},
	};
	return returnCmd;
};
4486
_parser.addCommand("return", function (parser, runtime, tokens) {
	if (tokens.matchToken("return")) {
		return parseReturnFunction(parser, runtime, tokens, true);
	}
});
4492
_parser.addCommand("exit", function (parser, runtime, tokens) {
	if (tokens.matchToken("exit")) {
		return parseReturnFunction(parser, runtime, tokens, false);
	}
});
4498
_parser.addCommand("halt", function (parser, runtime, tokens) {
	if (tokens.matchToken("halt")) {
		if (tokens.matchToken("the")) {
			tokens.requireToken("event");
			// optional possessive
			if (tokens.matchOpToken("'")) {
				tokens.requireToken("s");
			}
			var keepExecuting = true;
		}
		if (tokens.matchToken("bubbling")) {
			var bubbling = true;
		} else if (tokens.matchToken("default")) {
			var haltDefault = true;
		}
		var exit = parseReturnFunction(parser, runtime, tokens, false);
4515
		var haltCmd = {
			keepExecuting: true,
			bubbling: bubbling,
			haltDefault: haltDefault,
			exit: exit,
			op: function (ctx) {
				if (ctx.event) {
					if (bubbling) {
						ctx.event.stopPropagation();
					} else if (haltDefault) {
						ctx.event.preventDefault();
					} else {
						ctx.event.stopPropagation();
						ctx.event.preventDefault();
					}
					if (keepExecuting) {
						return runtime.findNext(this, ctx);
					} else {
						return exit;
					}
				}
			},
		};
		return haltCmd;
	}
});
4542
_parser.addCommand("log", function (parser, runtime, tokens) {
	if (!tokens.matchToken("log")) return;
	var exprs = [parser.parseElement("expression", tokens)];
	while (tokens.matchOpToken(",")) {
		exprs.push(parser.requireElement("expression", tokens));
	}
	if (tokens.matchToken("with")) {
		var withExpr = parser.requireElement("expression", tokens);
	}
	var logCmd = {
		exprs: exprs,
		withExpr: withExpr,
		args: [withExpr, exprs],
		op: function (ctx, withExpr, values) {
			if (withExpr) {
				withExpr.apply(null, values);
			} else {
				console.log.apply(null, values);
			}
			return runtime.findNext(this, ctx);
		},
	};
	return logCmd;
});
4567
_parser.addCommand("throw", function (parser, runtime, tokens) {
	if (!tokens.matchToken("throw")) return;
	var expr = parser.requireElement("expression", tokens);
	var throwCmd = {
		expr: expr,
		args: [expr],
		op: function (ctx, expr) {
			runtime.registerHyperTrace(ctx, expr);
			var reject = ctx.meta && ctx.meta.reject;
			if (reject) {
				reject(expr);
				return runtime.HALT;
			} else {
				throw expr;
			}
		},
	};
	return throwCmd;
});
4587
var parseCallOrGet = function (parser, runtime, tokens) {
	var expr = parser.requireElement("expression", tokens);
	var callCmd = {
		expr: expr,
		args: [expr],
		op: function (context, result) {
			context.result = result;
			return runtime.findNext(callCmd, context);
		},
	};
	return callCmd;
};
_parser.addCommand("call", function (parser, runtime, tokens) {
	if (!tokens.matchToken("call")) return;
	var call = parseCallOrGet(parser, runtime, tokens);
	if (call.expr && call.expr.type !== "functionCall") {
		parser.raiseParseError(tokens, "Must be a function invocation");
	}
	return call;
});
_parser.addCommand("get", function (parser, runtime, tokens) {
	if (tokens.matchToken("get")) {
		return parseCallOrGet(parser, runtime, tokens);
	}
});
4613
_parser.addCommand("make", function (parser, runtime, tokens) {
	if (!tokens.matchToken("make")) return;
	tokens.matchToken("a") || tokens.matchToken("an");
4617
	var expr = parser.requireElement("expression", tokens);
4619
	var args = [];
	if (expr.type !== "queryRef" && tokens.matchToken("from")) {
		do {
			args.push(parser.requireElement("expression", tokens));
		} while (tokens.matchOpToken(","));
	}
4626
	if (tokens.matchToken("called")) {
		var name = tokens.requireTokenType("IDENTIFIER").value;
	}
4630
	var command;
	if (expr.type === "queryRef") {
		command = {
			op: function (ctx) {
				var match,
					tagname = "div",
					id,
					classes = [];
				var re = /(?:(^|#|\.)([^#\. ]+))/g;
				while ((match = re.exec(expr.css))) {
					if (match[1] === "") tagname = match[2].trim();
					else if (match[1] === "#") id = match[2].trim();
					else classes.push(match[2].trim());
				}
4645
				var result = document.createElement(tagname);
				if (id !== undefined) result.id = id;
				for (var i = 0; i < classes.length; i++) {
					var cls = classes[i];
					result.classList.add(cls)
				}
4652
				ctx.result = result;
				if (name) ctx[name] = result;
4655
				return runtime.findNext(this, ctx);
			},
		};
		return command;
	} else {
		command = {
			args: [expr, args],
			op: function (ctx, expr, args) {
				ctx.result = varargConstructor(expr, args);
				if (name) ctx[name] = ctx.result;
4666
				return runtime.findNext(this, ctx);
			},
		};
		return command;
	}
});
4673
_parser.addGrammarElement("pseudoCommand", function (parser, runtime, tokens) {
4675
	try {
		var expr = parser.requireElement("primaryExpression", tokens);
	} finally {
		tokens.popFollow();
	}
	if (expr.type !== "functionCall" && expr.root.type !== "symbol" && expr.root.root != null) {
		parser.raiseParseError(tokens, "Implicit function calls must start with a simple function");
	}
4684
	var functionName = expr.root.name;
4686
	if (tokens.matchAnyToken("the", "to", "on", "with", "into", "from", "at")) {
		var target = parser.requireElement("expression", tokens);
	} else if (tokens.matchToken("me")) {
		var target = parser.requireElement("implicitMeTarget", tokens);
	}
	var functionArgs = expr.argExressions;
4693
	/** @type {GrammarElement} */
	var pseudoCommand = {
		type: "pseudoCommand",
		expr: expr,
		args: [target, functionArgs],
		op: function (context, target, args) {
			if (target) {
				var func = target[functionName];
			} else {
				var func = runtime.resolveSymbol(functionName, context);
			}
			if (func.hyperfunc) {
				args.push(context);
			}
			var result = func.apply(target, args);
			context.result = result;
			return runtime.findNext(pseudoCommand, context);
		},
		execute: function (context) {
			return runtime.unifiedExec(this, context);
		},
	};
4716
	return pseudoCommand;
});
4719
/**
 * @param {ParserObject} parser
 * @param {RuntimeObject} runtime
 * @param {TokensObject} tokens
 * @param {*} target
 * @param {*} value
 * @returns
 */
var makeSetter = function (parser, runtime, tokens, target, value) {
	var symbolWrite = target.type === "symbol";
	var attributeWrite = target.type === "attributeRef";
	if (!attributeWrite && !symbolWrite && target.root == null) {
		parser.raiseParseError(tokens, "Can only put directly into symbols, not references");
	}
4734
	var root = null;
	var prop = null;
	if (symbolWrite) {
		// root is null
	} else if (attributeWrite) {
		root = parser.requireElement("implicitMeTarget", tokens);
		var attribute = target;
	} else {
		prop = target.prop ? target.prop.value : null;
		var attribute = target.attribute;
		root = target.root;
	}
4747
	/** @type {GrammarElement} */
	var setCmd = {
		target: target,
		symbolWrite: symbolWrite,
		value: value,
		args: [root, value],
		op: function (context, root, valueToSet) {
			if (symbolWrite) {
				runtime.setSymbol(target.name, context, target.symbolType, valueToSet);
			} else {
				runtime.implicitLoop(root, function (elt) {
					if (attribute) {
						if (valueToSet == null) {
							elt.removeAttribute(attribute.name);
						} else {
							elt.setAttribute(attribute.name, valueToSet);
						}
					} else {
						elt[prop] = valueToSet;
					}
				});
			}
			return runtime.findNext(this, context);
		},
	};
	return setCmd;
};
4775
_parser.addCommand("default", function (parser, runtime, tokens) {
	if (!tokens.matchToken("default")) return;
	var target = parser.requireElement("assignableExpression", tokens);
	tokens.requireToken("to");
4780
	var value = parser.requireElement("expression", tokens);
4782
	/** @type {GrammarElement} */
	var setter = makeSetter(parser, runtime, tokens, target, value);
	var defaultCmd = {
		target: target,
		value: value,
		setter: setter,
		args: [target],
		op: function (context, target) {
			if (target) {
				return runtime.findNext(this, context);
			} else {
				return setter;
			}
		},
	};
	setter.parent = defaultCmd;
	return defaultCmd;
});
4801
_parser.addCommand("set", function (parser, runtime, tokens) {
	if (!tokens.matchToken("set")) return;
	if (tokens.currentToken().type === "L_BRACE") {
		var obj = parser.requireElement("objectLiteral", tokens);
		tokens.requireToken("on");
		var target = parser.requireElement("expression", tokens);
4808
		var command = {
			objectLiteral: obj,
			target: target,
			args: [obj, target],
			op: function (ctx, obj, target) {
				mergeObjects(target, obj);
				return runtime.findNext(this, ctx);
			},
		};
		return command;
	}
4820
	try {
		tokens.pushFollow("to");
		var target = parser.requireElement("assignableExpression", tokens);
	} finally {
		tokens.popFollow();
	}
	tokens.requireToken("to");
	var value = parser.requireElement("expression", tokens);
	return makeSetter(parser, runtime, tokens, target, value);
});
4831
_parser.addCommand("if", function (parser, runtime, tokens) {
	if (!tokens.matchToken("if")) return;
	var expr = parser.requireElement("expression", tokens);
	tokens.matchToken("then"); // optional 'then'
	var trueBranch = parser.parseElement("commandList", tokens);
	if (tokens.matchToken("else")) {
		var falseBranch = parser.parseElement("commandList", tokens);
	}
	if (tokens.hasMore()) {
		tokens.requireToken("end");
	}
4843
	/** @type {GrammarElement} */
	var ifCmd = {
		expr: expr,
		trueBranch: trueBranch,
		falseBranch: falseBranch,
		args: [expr],
		op: function (context, exprValue) {
			if (exprValue) {
				return trueBranch;
			} else if (falseBranch) {
				return falseBranch;
			} else {
				return runtime.findNext(this, context);
			}
		},
	};
	parser.setParent(trueBranch, ifCmd);
	parser.setParent(falseBranch, ifCmd);
	return ifCmd;
});
4864
var parseRepeatExpression = function (parser, tokens, runtime, startedWithForToken) {
	var innerStartToken = tokens.currentToken();
	var identifier;
	if (tokens.matchToken("for") || startedWithForToken) {
		var identifierToken = tokens.requireTokenType("IDENTIFIER");
		identifier = identifierToken.value;
		tokens.requireToken("in");
		var expression = parser.requireElement("expression", tokens);
	} else if (tokens.matchToken("in")) {
		identifier = "it";
		var expression = parser.requireElement("expression", tokens);
	} else if (tokens.matchToken("while")) {
		var whileExpr = parser.requireElement("expression", tokens);
	} else if (tokens.matchToken("until")) {
		var isUntil = true;
		if (tokens.matchToken("event")) {
			var evt = _parser.requireElement("dotOrColonPath", tokens, "Expected event name");
			if (tokens.matchToken("from")) {
				var on = parser.requireElement("expression", tokens);
			}
		} else {
			var whileExpr = parser.requireElement("expression", tokens);
		}
	} else if (tokens.matchTokenType("NUMBER")) {
		var times = parseFloat(innerStartToken.value);
		tokens.requireToken("times");
	} else {
		tokens.matchToken("forever"); // consume optional forever
		var forever = true;
	}
4895
	if (tokens.matchToken("index")) {
		var identifierToken = tokens.requireTokenType("IDENTIFIER");
		var indexIdentifier = identifierToken.value;
	}
4900
	var loop = parser.parseElement("commandList", tokens);
	if (loop && evt) {
		// if this is an event based loop, wait a tick at the end of the loop so that
		// events have a chance to trigger in the loop condition o_O)))
		var last = loop;
		while (last.next) {
			last = last.next;
		}
		var waitATick = {
			type: "waitATick",
			op: function () {
				return new Promise(function (resolve) {
					setTimeout(function () {
						resolve(runtime.findNext(waitATick));
					}, 0);
				});
			},
		};
		last.next = waitATick;
	}
	if (tokens.hasMore()) {
		tokens.requireToken("end");
	}
4924
	if (identifier == null) {
		identifier = "_implicit_repeat_" + innerStartToken.start;
		var slot = identifier;
	} else {
		var slot = identifier + "_" + innerStartToken.start;
	}
4931
	var repeatCmd = {
		identifier: identifier,
		indexIdentifier: indexIdentifier,
		slot: slot,
		expression: expression,
		forever: forever,
		times: times,
		until: isUntil,
		event: evt,
		on: on,
		whileExpr: whileExpr,
		resolveNext: function () {
			return this;
		},
		loop: loop,
		args: [whileExpr],
		op: function (context, whileValue) {
			var iteratorInfo = context.meta.iterators[slot];
			var keepLooping = false;
			var loopVal = null;
			if (this.forever) {
				keepLooping = true;
			} else if (this.until) {
				if (evt) {
					keepLooping = context.meta.iterators[slot].eventFired === false;
				} else {
					keepLooping = whileValue !== true;
				}
			} else if (whileExpr) {
				keepLooping = whileValue;
			} else if (times) {
				keepLooping = iteratorInfo.index < this.times;
			} else {
				var nextValFromIterator = iteratorInfo.iterator.next();
				keepLooping = !nextValFromIterator.done;
				loopVal = nextValFromIterator.value;
			}
4969
			if (keepLooping) {
				if (iteratorInfo.value) {
					context.result = context[identifier] = loopVal;
				} else {
					context.result = iteratorInfo.index;
				}
				if (indexIdentifier) {
					context[indexIdentifier] = iteratorInfo.index;
				}
				iteratorInfo.index++;
				return loop;
			} else {
				context.meta.iterators[slot] = null;
				return runtime.findNext(this.parent, context);
			}
		},
	};
	parser.setParent(loop, repeatCmd);
	var repeatInit = {
		name: "repeatInit",
		args: [expression, evt, on],
		op: function (context, value, event, on) {
			var iteratorInfo = {
				index: 0,
				value: value,
				eventFired: false,
			};
			context.meta.iterators[slot] = iteratorInfo;
			if (value && value[Symbol.iterator]) {
				iteratorInfo.iterator = value[Symbol.iterator]();
			}
			if (evt) {
				var target = on || context.me;
				target.addEventListener(
					event,
					function (e) {
						context.meta.iterators[slot].eventFired = true;
					},
					{ once: true }
				);
			}
			return repeatCmd; // continue to loop
		},
		execute: function (context) {
			return runtime.unifiedExec(this, context);
		},
	};
	parser.setParent(repeatCmd, repeatInit);
	return repeatInit;
};
5020
_parser.addCommand("repeat", function (parser, runtime, tokens) {
	if (tokens.matchToken("repeat")) {
		return parseRepeatExpression(parser, tokens, runtime, false);
	}
});
5026
_parser.addCommand("for", function (parser, runtime, tokens) {
	if (tokens.matchToken("for")) {
		return parseRepeatExpression(parser, tokens, runtime, true);
	}
});
5032
_parser.addGrammarElement("stringLike", function (parser, runtime, tokens) {
	return _parser.parseAnyOf(["string", "nakedString"], tokens);
});
5036
_parser.addCommand("append", function (parser, runtime, tokens) {
	if (!tokens.matchToken("append")) return;
	var target = null;
	var prop = null;
5041
	var value = parser.requireElement("expression", tokens);
5043
	if (tokens.matchToken("to")) {
		target = parser.requireElement("expression", tokens);
	}
5047
	if (target == null) {
		prop = "result";
	} else if (target.type === "symbol") {
		prop = target.name;
	} else if (target.type === "propertyAccess") {
		prop = target.prop.value;
	} else {
		throw "Unable to append to " + target.type;
	}
5057
	var command = {
		value: value,
		target: target,
		args: [value],
		op: function (context, value) {
			if (Array.isArray(context[prop])) {
				context[prop].push(value);
			} else if (context[prop] instanceof Element) {
				if (typeof value == "string") {
					context[prop].innerHTML += value;
				} else {
					throw "Don't know how to append non-strings to an HTML Element yet.";
				}
			} else {
				context[prop] += value;
			}
5074
			return runtime.findNext(this, context);
		},
		execute: function (context) {
			return runtime.unifiedExec(this, context/*, value, target*/);
		},
	};
	return command;
});
5083
_parser.addCommand("increment", function (parser, runtime, tokens) {
	if (!tokens.matchToken("increment")) return;
	var amount;
5087
	// This is optional.  Defaults to "result"
	var target = parser.parseElement("assignableExpression", tokens);
5090
	// This is optional. Defaults to 1.
	if (tokens.matchToken("by")) {
		amount = parser.requireElement("expression", tokens);
	}
5095
	var command = {
		target: target,
		args: [target, amount],
		op: function (context, targetValue, amount) {
			targetValue = targetValue ? parseFloat(targetValue) : 0;
			amount = amount ? parseFloat(amount) : 1;
			var newValue = targetValue + amount;
			var setter = makeSetter(parser, runtime, tokens, target, newValue);
			context.result = newValue;
			setter.parent = this;
			return setter;
		},
		execute: function (context) {
			return runtime.unifiedExec(this, context/* , target, amount */);
		},
	};
	return command;
});
5114
_parser.addCommand("decrement", function (parser, runtime, tokens) {
	if (!tokens.matchToken("decrement")) return;
	var amount;
5118
	// This is optional.  Defaults to "result"
	var target = parser.parseElement("assignableExpression", tokens);
5121
	// This is optional. Defaults to 1.
	if (tokens.matchToken("by")) {
		amount = parser.requireElement("expression", tokens);
	}
5126
	var command = {
		target: target,
		args: [target, amount],
		op: function (context, targetValue, amount) {
			targetValue = targetValue ? parseFloat(targetValue) : 0;
			amount = amount ? parseFloat(amount) : 1;
			var newValue = targetValue - amount;
			var setter = makeSetter(parser, runtime, tokens, target, newValue);
			context.result = newValue;
			setter.parent = this;
			return setter;
		},
		execute: function (context) {
			return runtime.unifiedExec(this, context/*, target, amount*/);
		},
	};
	return command;
});
5145
_parser.addCommand("fetch", function (parser, runtime, tokens) {
	if (!tokens.matchToken("fetch")) return;
	var url = parser.requireElement("stringLike", tokens);
	var args = parser.parseElement("objectLiteral", tokens);
5150
	var type = "text";
	var conversion;
	if (tokens.matchToken("as")) {
		tokens.matchToken("a") || tokens.matchToken("an");
		if (tokens.matchToken("json") || tokens.matchToken("Object")) {
			type = "json";
		} else if (tokens.matchToken("response")) {
			type = "response";
		} else if (tokens.matchToken("html")) {
			type = "html";
		} else if (tokens.matchToken("text")) {
			// default, ignore
		} else {
			conversion = parser.requireElement("dotOrColonPath", tokens).evaluate();
		}
	}
5167
	/** @type {GrammarElement} */
	var fetchCmd = {
		url: url,
		argExpressions: args,
		args: [url, args],
		op: function (context, url, args) {
			var detail = args || {};
			detail["sentBy"] = context.me;
			runtime.triggerEvent(context.me, "hyperscript:beforeFetch", detail);
			args = detail;
			return fetch(url, args)
				.then(function (resp) {
					if (type === "response") {
						context.result = resp;
						return runtime.findNext(fetchCmd, context);
					}
					if (type === "json") {
						return resp.json().then(function (result) {
							context.result = result;
							return runtime.findNext(fetchCmd, context);
						});
					}
					return resp.text().then(function (result) {
						if (conversion) result = runtime.convertValue(result, conversion);
5192
						if (type === "html") result = runtime.convertValue(result, "Fragment");
5194
						context.result = result;
						return runtime.findNext(fetchCmd, context);
					});
				})
				.catch(function (reason) {
					runtime.triggerEvent(context.me, "fetch:error", {
						reason: reason,
					});
					throw reason;
				});
		},
	};
	return fetchCmd;
});
}
5210
//====================================================================
// Initialization
//====================================================================
function ready(fn) {
if (document.readyState !== "loading") {
	setTimeout(fn);
} else {
	document.addEventListener("DOMContentLoaded", fn);
}
}
5221
function getMetaConfig() {
/** @type {HTMLMetaElement} */
var element = document.querySelector('meta[name="htmx-config"]');
if (element) {
	return parseJSON(element.content);
} else {
	return null;
}
}
5231
function mergeMetaConfig() {
var metaConfig = getMetaConfig();
if (metaConfig) {
	_hyperscript.config = mergeObjects(_hyperscript.config, metaConfig);
}
}
5238
if ("document" in globalScope) {
/** @type {HTMLScriptElement[]} */
var scripts = Array.from(document.querySelectorAll("script[type='text/hyperscript'][src]"))
Promise.all(
	scripts.map(function (script) {
		return fetch(script.src)
			.then(function (res) {
				return res.text();
			})
			.then(function (code) {
				return _runtime.evaluate(code);
			});
	})
).then(function () {
	ready(function () {
		mergeMetaConfig();
		_runtime.processNode(document.documentElement);
		document.addEventListener("htmx:load", function (/** @type {CustomEvent} */ evt) {
			_runtime.processNode(evt.detail.elt);
		});
	});
});
}
5262
//====================================================================
// API
//====================================================================
return mergeObjects(
function (str, ctx) {
	return _runtime.evaluate(str, ctx); //OK
},
{
	internals: {
		lexer: _lexer,
		parser: _parser,
		runtime: _runtime,
	},
	ElementCollection: ElementCollection,
	addFeature: function (keyword, definition) {
		_parser.addFeature(keyword, definition);
	},
	addCommand: function (keyword, definition) {
		_parser.addCommand(keyword, definition);
	},
	addLeafExpression: function (name, definition) {
		_parser.addLeafExpression(name, definition);
	},
	addIndirectExpression: function (name, definition) {
		_parser.addIndirectExpression(name, definition);
	},
	evaluate: function (str, ctx) {
		//OK
		return _runtime.evaluate(str, ctx); //OK
	},
	parse: function (str) {
		//OK
		return _runtime.parse(str); //OK
	},
	processNode: function (elt) {
		_runtime.processNode(elt);
	},
	config: {
		attributes: "_, script, data-script",
		defaultTransition: "all 500ms ease-in",
		disableSelector: "[disable-scripting], [data-disable-scripting]",
		conversions: CONVERSIONS,
	},
}
);
5308});
5309
5310///=========================================================================
5311/// This module provides the core web functionality for hyperscript
5312///=========================================================================
5313(function () {
function mergeObjects(obj1, obj2) {
for (var key in obj2) {
	if (obj2.hasOwnProperty(key)) {
		obj1[key] = obj2[key];
	}
}
return obj1;
}
5322
var _hyperscript = this._hyperscript
5324
_hyperscript.addCommand("settle", function (parser, runtime, tokens) {
if (tokens.matchToken("settle")) {
	if (!parser.commandBoundary(tokens.currentToken())) {
		var on = parser.requireElement("expression", tokens);
	} else {
		var on = parser.requireElement("implicitMeTarget", tokens);
	}
5332
	var settleCommand = {
		type: "settleCmd",
		args: [on],
		op: function (context, on) {
			var resolve = null;
			var resolved = false;
			var transitionStarted = false;
5340
			var promise = new Promise(function (r) {
				resolve = r;
			});
5344
			// listen for a transition begin
			on.addEventListener(
				"transitionstart",
				function () {
					transitionStarted = true;
				},
				{ once: true }
			);
5353
			// if no transition begins in 500ms, cancel
			setTimeout(function () {
				if (!transitionStarted && !resolved) {
					resolve(runtime.findNext(settleCommand, context));
				}
			}, 500);
5360
			// continue on a transition emd
			on.addEventListener(
				"transitionend",
				function () {
					if (!resolved) {
						resolve(runtime.findNext(settleCommand, context));
					}
				},
				{ once: true }
			);
			return promise;
		},
		execute: function (context) {
			return runtime.unifiedExec(this, context);
		},
	};
	return settleCommand;
}
});
5380
_hyperscript.addCommand("add", function (parser, runtime, tokens) {
if (tokens.matchToken("add")) {
	var classRef = parser.parseElement("classRef", tokens);
	var attributeRef = null;
	var cssDeclaration = null;
	if (classRef == null) {
		attributeRef = parser.parseElement("attributeRef", tokens);
		if (attributeRef == null) {
			cssDeclaration = parser.parseElement("styleLiteral", tokens);
			if (cssDeclaration == null) {
				parser.raiseParseError(tokens, "Expected either a class reference or attribute expression");
			}
		}
	} else {
		var classRefs = [classRef];
		while ((classRef = parser.parseElement("classRef", tokens))) {
			classRefs.push(classRef);
		}
	}
5400
	if (tokens.matchToken("to")) {
		var to = parser.requireElement("expression", tokens);
	} else {
		var to = parser.parseElement("implicitMeTarget", tokens);
	}
5406
	if (classRefs) {
		return {
			classRefs: classRefs,
			to: to,
			args: [to, classRefs],
			op: function (context, to, classRefs) {
				runtime.forEach(classRefs, function (classRef) {
					runtime.forEach(to, function (target) {
						if (target instanceof Element) target.classList.add(classRef.className);
					});
				});
				return runtime.findNext(this, context);
			},
		};
	} else if (attributeRef) {
		return {
			type: "addCmd",
			attributeRef: attributeRef,
			to: to,
			args: [to],
			op: function (context, to, attrRef) {
				runtime.forEach(to, function (target) {
					target.setAttribute(attributeRef.name, attributeRef.value);
				});
				return runtime.findNext(this, context);
			},
			execute: function (ctx) {
				return runtime.unifiedExec(this, ctx);
			},
		};
	} else {
		return {
			type: "addCmd",
			cssDeclaration: cssDeclaration,
			to: to,
			args: [to, cssDeclaration],
			op: function (context, to, css) {
				runtime.forEach(to, function (target) {
					target.style.cssText += css;
				});
				return runtime.findNext(this, context);
			},
			execute: function (ctx) {
				return runtime.unifiedExec(this, ctx);
			},
		};
	}
}
});
5456
_hyperscript.internals.parser.addGrammarElement("styleLiteral", function (parser, runtime, tokens) {
if (!tokens.matchOpToken("{")) return;
5459
var stringParts = [""]
var exprs = []
5462
while (tokens.hasMore()) {
	if (tokens.matchOpToken("\\")) {
		tokens.consumeToken();
	} else if (tokens.matchOpToken("}")) {
		break;
	} else if (tokens.matchToken("$")) {
		var opencurly = tokens.matchOpToken("{");
		var expr = parser.parseElement("expression", tokens);
		if (opencurly) tokens.requireOpToken("}");
5472
		exprs.push(expr)
		stringParts.push("")
	} else {
		var tok = tokens.consumeToken();
		stringParts[stringParts.length-1] += tokens.source.substring(tok.start, tok.end);
	}
5479
	stringParts[stringParts.length-1] += tokens.lastWhitespace();
}
5482
return {
	type: "styleLiteral",
	args: [exprs],
	op: function (ctx, exprs) {
		var rv = "";
5488
		stringParts.forEach(function (part, idx) {
			rv += part;
			if (idx in exprs) rv += exprs[idx];
		});
5493
		return rv;
	},
	evaluate: function(ctx) {
		return runtime.unifiedEval(this, ctx);
	}
}
})
5501
_hyperscript.addCommand("remove", function (parser, runtime, tokens) {
if (tokens.matchToken("remove")) {
	var classRef = parser.parseElement("classRef", tokens);
	var attributeRef = null;
	var elementExpr = null;
	if (classRef == null) {
		attributeRef = parser.parseElement("attributeRef", tokens);
		if (attributeRef == null) {
			elementExpr = parser.parseElement("expression", tokens);
			if (elementExpr == null) {
				parser.raiseParseError(
					tokens,
					"Expected either a class reference, attribute expression or value expression"
				);
			}
		}
	} else {
		var classRefs = [classRef];
		while ((classRef = parser.parseElement("classRef", tokens))) {
			classRefs.push(classRef);
		}
	}
5524
	if (tokens.matchToken("from")) {
		var from = parser.requireElement("expression", tokens);
	} else {
		var from = parser.requireElement("implicitMeTarget", tokens);
	}
5530
	if (elementExpr) {
		return {
			elementExpr: elementExpr,
			from: from,
			args: [elementExpr],
			op: function (context, element) {
				runtime.forEach(element, function (target) {
					if (target.parentElement) {
						target.parentElement.removeChild(target);
					}
				});
				return runtime.findNext(this, context);
			},
		};
	} else {
		return {
			classRefs: classRefs,
			attributeRef: attributeRef,
			elementExpr: elementExpr,
			from: from,
			args: [classRefs, from],
			op: function (context, classRefs, from) {
				if (classRefs) {
					runtime.forEach(classRefs, function (classRef) {
						runtime.implicitLoop(from, function (target) {
							target.classList.remove(classRef.className);
						});
					});
				} else {
					runtime.forEach(from, function (target) {
						target.removeAttribute(attributeRef.name);
					});
				}
				return runtime.findNext(this, context);
			},
		};
	}
}
});
5570
_hyperscript.addCommand("toggle", function (parser, runtime, tokens) {
if (tokens.matchToken("toggle")) {
	if (tokens.matchToken("between")) {
		var between = true;
		var classRef = parser.parseElement("classRef", tokens);
		tokens.requireToken("and");
		var classRef2 = parser.requireElement("classRef", tokens);
	} else {
		var classRef = parser.parseElement("classRef", tokens);
		var attributeRef = null;
		if (classRef == null) {
			attributeRef = parser.parseElement("attributeRef", tokens);
			if (attributeRef == null) {
				parser.raiseParseError(tokens, "Expected either a class reference or attribute expression");
			}
		} else {
			var classRefs = [classRef];
			while ((classRef = parser.parseElement("classRef", tokens))) {
				classRefs.push(classRef);
			}
		}
	}
5593
	if (tokens.matchToken("on")) {
		var on = parser.requireElement("expression", tokens);
	} else {
		var on = parser.requireElement("implicitMeTarget", tokens);
	}
5599
	if (tokens.matchToken("for")) {
		var time = parser.requireElement("timeExpression", tokens);
	} else if (tokens.matchToken("until")) {
		var evt = parser.requireElement("dotOrColonPath", tokens, "Expected event name");
		if (tokens.matchToken("from")) {
			var from = parser.requireElement("expression", tokens);
		}
	}
5608
	var toggleCmd = {
		classRef: classRef,
		classRef2: classRef2,
		classRefs: classRefs,
		attributeRef: attributeRef,
		on: on,
		time: time,
		evt: evt,
		from: from,
		toggle: function (on, classRef, classRef2, classRefs) {
			if (between) {
				runtime.forEach(on, function (target) {
					if (target.classList.contains(classRef.className)) {
						target.classList.remove(classRef.className);
						target.classList.add(classRef2.className);
					} else {
						target.classList.add(classRef.className);
						target.classList.remove(classRef2.className);
					}
				});
			} else if (classRefs) {
				runtime.forEach(classRefs, function (classRef) {
					runtime.forEach(on, function (target) {
						target.classList.toggle(classRef.className);
					});
				});
			} else {
				runtime.forEach(on, function (target) {
					if (target.hasAttribute(attributeRef.name)) {
						target.removeAttribute(attributeRef.name);
					} else {
						target.setAttribute(attributeRef.name, attributeRef.value);
					}
				});
			}
		},
		args: [on, time, evt, from, classRef, classRef2, classRefs],
		op: function (context, on, time, evt, from, classRef, classRef2, classRefs) {
			if (time) {
				return new Promise(function (resolve) {
					toggleCmd.toggle(on, classRef, classRef2, classRefs);
					setTimeout(function () {
						toggleCmd.toggle(on, classRef, classRef2, classRefs);
						resolve(runtime.findNext(toggleCmd, context));
					}, time);
				});
			} else if (evt) {
				return new Promise(function (resolve) {
					var target = from || context.me;
					target.addEventListener(
						evt,
						function () {
							toggleCmd.toggle(on, classRef, classRef2, classRefs);
							resolve(runtime.findNext(toggleCmd, context));
						},
						{ once: true }
					);
					toggleCmd.toggle(on, classRef, classRef2, classRefs);
				});
			} else {
				this.toggle(on, classRef, classRef2, classRefs);
				return runtime.findNext(toggleCmd, context);
			}
		},
	};
	return toggleCmd;
}
});
5677
var HIDE_SHOW_STRATEGIES = {
display: function (op, element, arg) {
	if (arg) {
		element.style.display = arg;
	} else if (op === "hide") {
		element.style.display = "none";
	} else {
		element.style.display = "block";
	}
},
visibility: function (op, element, arg) {
	if (arg) {
		element.style.visibility = arg;
	} else if (op === "hide") {
		element.style.visibility = "hidden";
	} else {
		element.style.visibility = "visible";
	}
},
opacity: function (op, element, arg) {
	if (arg) {
		element.style.opacity = arg;
	} else if (op === "hide") {
		element.style.opacity = "0";
	} else {
		element.style.opacity = "1";
	}
},
};
5707
var parseShowHideTarget = function (parser, runtime, tokens) {
var target;
var currentTokenValue = tokens.currentToken();
if (currentTokenValue.value === "with" || parser.commandBoundary(currentTokenValue)) {
	target = parser.parseElement("implicitMeTarget", tokens);
} else {
	target = parser.parseElement("expression", tokens);
}
return target;
};
5718
var resolveStrategy = function (parser, tokens, name) {
var configDefault = _hyperscript.config.defaultHideShowStrategy;
var strategies = HIDE_SHOW_STRATEGIES;
if (_hyperscript.config.hideShowStrategies) {
	strategies = mergeObjects(strategies, _hyperscript.config.hideShowStrategies); // merge in user provided strategies
}
name = name || configDefault || "display";
var value = strategies[name];
if (value == null) {
	parser.raiseParseError(tokens, "Unknown show/hide strategy : " + name);
}
return value;
};
5732
_hyperscript.addCommand("hide", function (parser, runtime, tokens) {
if (tokens.matchToken("hide")) {
	var target = parseShowHideTarget(parser, runtime, tokens);
5736
	var name = null;
	if (tokens.matchToken("with")) {
		name = tokens.requireTokenType("IDENTIFIER").value;
	}
	var hideShowStrategy = resolveStrategy(parser, tokens, name);
5742
	return {
		target: target,
		args: [target],
		op: function (ctx, target) {
			runtime.forEach(target, function (elt) {
				hideShowStrategy("hide", elt);
			});
			return runtime.findNext(this, ctx);
		},
	};
}
});
5755
_hyperscript.addCommand("show", function (parser, runtime, tokens) {
if (tokens.matchToken("show")) {
	var target = parseShowHideTarget(parser, runtime, tokens);
5759
	var name = null;
	if (tokens.matchToken("with")) {
		name = tokens.requireTokenType("IDENTIFIER").value;
	}
	var arg = null;
	if (tokens.matchOpToken(":")) {
		var tokenArr = tokens.consumeUntilWhitespace();
		tokens.matchTokenType("WHITESPACE");
		arg = tokenArr
			.map(function (t) {
				return t.value;
			})
			.join("");
	}
	var hideShowStrategy = resolveStrategy(parser, tokens, name);
5775
	return {
		target: target,
		args: [target],
		op: function (ctx, target) {
			runtime.forEach(target, function (elt) {
				hideShowStrategy("show", elt, arg);
			});
			return runtime.findNext(this, ctx);
		},
	};
}
});
5788
_hyperscript.addCommand("trigger", function (parser, runtime, tokens) {
if (tokens.matchToken("trigger")) {
	var eventName = parser.requireElement("eventName", tokens);
	var details = parser.parseElement("namedArgumentList", tokens);
5793
	var triggerCmd = {
		eventName: eventName,
		details: details,
		args: [eventName, details],
		op: function (context, eventNameStr, details) {
			runtime.triggerEvent(context.me, eventNameStr, details ? details : {});
			return runtime.findNext(triggerCmd, context);
		},
	};
	return triggerCmd;
}
});
5806
_hyperscript.addCommand("take", function (parser, runtime, tokens) {
if (tokens.matchToken("take")) {
	var classRef = parser.parseElement("classRef", tokens);
5810
	if (tokens.matchToken("from")) {
		var from = parser.requireElement("expression", tokens);
	} else {
		var from = classRef;
	}
5816
	if (tokens.matchToken("for")) {
		var forElt = parser.requireElement("expression", tokens);
	} else {
		var forElt = parser.requireElement("implicitMeTarget", tokens);
	}
5822
	var takeCmd = {
		classRef: classRef,
		from: from,
		forElt: forElt,
		args: [classRef, from, forElt],
		op: function (context, eltColl, from, forElt) {
			var clazz = eltColl.className;
			runtime.forEach(from, function (target) {
				target.classList.remove(clazz);
			});
			runtime.forEach(forElt, function (target) {
				target.classList.add(clazz);
			});
			return runtime.findNext(this, context);
		},
	};
	return takeCmd;
}
});
5842
function putInto(runtime, context, prop, valueToPut) {
if (prop) {
	var value = runtime.resolveSymbol(prop, context);
} else {
	var value = context;
}
if (value instanceof Element || value instanceof HTMLDocument) {
	while (value.firstChild) value.removeChild(value.firstChild);
	value.append(_hyperscript.internals.runtime.convertValue(valueToPut, "Fragment"));
} else {
	if (prop) {
		runtime.setSymbol(prop, context, null, valueToPut);
	} else {
		throw "Don't know how to put a value into " + typeof context;
	}
}
}
5860
_hyperscript.addCommand("put", function (parser, runtime, tokens) {
if (tokens.matchToken("put")) {
	var value = parser.requireElement("expression", tokens);
5864
	var operationToken = tokens.matchAnyToken("into", "before", "after");
5866
	if (operationToken == null && tokens.matchToken("at")) {
		tokens.matchToken("the"); // optional "the"
		operationToken = tokens.matchAnyToken("start", "end");
		tokens.requireToken("of");
	}
5872
	if (operationToken == null) {
		parser.raiseParseError(tokens, "Expected one of 'into', 'before', 'at start of', 'at end of', 'after'");
	}
	var target = parser.requireElement("expression", tokens);
5877
	var operation = operationToken.value;
5879
	var symbolWrite = false;
	var root = null;
	var prop = null;
	if (target.prop && target.root && operation === "into") {
		prop = target.prop.value;
		root = target.root;
	} else if (target.type === "symbol" && operation === "into") {
		symbolWrite = true;
		prop = target.name;
	} else if (target.type === "attributeRef" && operation === "into") {
		var attributeWrite = true;
		prop = target.name;
		root = parser.requireElement("implicitMeTarget", tokens);
	} else if (target.type === "attributeRefAccess" && operation === "into") {
		var attributeWrite = true;
		prop = target.attribute.name;
		root = target.root;
	} else {
		root = target;
	}
5900
	var putCmd = {
		target: target,
		operation: operation,
		symbolWrite: symbolWrite,
		value: value,
		args: [root, value],
		op: function (context, root, valueToPut) {
			if (symbolWrite) {
				putInto(runtime, context, prop, valueToPut);
			} else {
				if (operation === "into") {
					if (attributeWrite) {
						runtime.implicitLoop(root, function (elt) {
							elt.setAttribute(prop, valueToPut);
						});
					} else {
						runtime.implicitLoop(root, function (elt) {
							putInto(runtime, elt, prop, valueToPut);
						});
					}
				} else {
					var op =
						operation === "before"
							? Element.prototype.before
							: operation === "after"
							? Element.prototype.after
							: operation === "start"
							? Element.prototype.prepend
							: operation === "end"
							? Element.prototype.append
							: Element.prototype.append; // unreachable
5932
					runtime.implicitLoop(root, function (elt) {
						op.call(
							elt,
							valueToPut instanceof Node
								? valueToPut
								: runtime.convertValue(valueToPut, "Fragment")
						);
					});
				}
			}
			return runtime.findNext(this, context);
		},
	};
	return putCmd;
}
});
5949
function parsePseudopossessiveTarget(parser, runtime, tokens) {
var targets;
if (
	tokens.matchToken("the") ||
	tokens.matchToken("element") ||
	tokens.matchToken("elements") ||
	tokens.currentToken().type === "CLASS_REF" ||
	tokens.currentToken().type === "ID_REF" ||
	(tokens.currentToken().op && tokens.currentToken().value === "<")
) {
	parser.possessivesDisabled = true;
	try {
		targets = parser.parseElement("expression", tokens);
	} finally {
		delete parser.possessivesDisabled;
	}
	// optional possessive
	if (tokens.matchOpToken("'")) {
		tokens.requireToken("s");
	}
} else if (tokens.currentToken().type === "IDENTIFIER" && tokens.currentToken().value === "its") {
	var identifier = tokens.matchToken("its");
	targets = {
		type: "pseudopossessiveIts",
		token: identifier,
		name: identifier.value,
		evaluate: function (context) {
			return runtime.resolveSymbol("it", context);
		},
	};
} else {
	tokens.matchToken("my") || tokens.matchToken("me"); // consume optional 'my'
	targets = parser.parseElement("implicitMeTarget", tokens);
}
return targets;
}
5986
_hyperscript.addCommand("transition", function (parser, runtime, tokens) {
if (tokens.matchToken("transition")) {
	var targets = parsePseudopossessiveTarget(parser, runtime, tokens);
5990
	var properties = [];
	var from = [];
	var to = [];
	var currentToken = tokens.currentToken();
	while (
		!parser.commandBoundary(currentToken) &&
		currentToken.value !== "over" &&
		currentToken.value !== "using"
	) {
		properties.push(parser.requireElement("stringLike", tokens));
6001
		if (tokens.matchToken("from")) {
			from.push(parser.requireElement("stringLike", tokens));
		} else {
			from.push(null);
		}
		tokens.requireToken("to");
		to.push(parser.requireElement("stringLike", tokens));
		currentToken = tokens.currentToken();
	}
	if (tokens.matchToken("over")) {
		var over = parser.requireElement("timeExpression", tokens);
	} else if (tokens.matchToken("using")) {
		var using = parser.requireElement("expression", tokens);
	}
6016
	var transition = {
		to: to,
		args: [targets, properties, from, to, using, over],
		op: function (context, targets, properties, from, to, using, over) {
			var promises = [];
			runtime.forEach(targets, function (target) {
				var promise = new Promise(function (resolve, reject) {
					var initialTransition = target.style.transition;
					if (over) {
						target.style.transition = "all " + over + "ms ease-in";
					} else if (using) {
						target.style.transition = using;
					} else {
						target.style.transition = _hyperscript.config.defaultTransition;
					}
					var internalData = runtime.getInternalData(target);
					var computedStyles = getComputedStyle(target);
6034
					var initialStyles = {};
					for (var i = 0; i < computedStyles.length; i++) {
						var name = computedStyles[i];
						var initialValue = computedStyles[name];
						initialStyles[name] = initialValue;
					}
6041
					// store intitial values
					if (!internalData.initalStyles) {
						internalData.initalStyles = initialStyles;
					}
6046
					for (var i = 0; i < properties.length; i++) {
						var property = properties[i];
						var fromVal = from[i];
						if (fromVal == "computed" || fromVal == null) {
							target.style[property] = initialStyles[property];
						} else {
							target.style[property] = fromVal;
						}
					}
					// console.log("transition started", transition);
					setTimeout(function () {
						var autoProps = [];
						for (var i = 0; i < properties.length; i++) {
							var property = properties[i];
							var toVal = to[i];
							if (toVal == "initial") {
								var propertyValue = internalData.initalStyles[property];
								target.style[property] = propertyValue;
							} else {
								target.style[property] = toVal;
							}
							// console.log("set", property, "to", target.style[property], "on", target, "value passed in : ", toVal);
						}
						target.addEventListener(
							"transitionend",
							function () {
								// console.log("transition ended", transition);
								target.style.transition = initialTransition;
								resolve();
							},
							{ once: true }
						);
					}, 5);
				});
				promises.push(promise);
			});
			return Promise.all(promises).then(function () {
				return runtime.findNext(transition, context);
			});
		},
	};
	return transition;
}
});
6091
_hyperscript.addCommand("measure", function (parser, runtime, tokens) {
if (!tokens.matchToken("measure")) return;
6094
var target = parsePseudopossessiveTarget(parser, runtime, tokens);
6096
var propsToMeasure = [];
if (!parser.commandBoundary(tokens.currentToken()))
	do {
		propsToMeasure.push(tokens.matchTokenType("IDENTIFIER").value);
	} while (tokens.matchOpToken(","));
6102
return {
	properties: propsToMeasure,
	args: [target],
	op: function (ctx, target) {
		if (0 in target) target = target[0]; // not measuring multiple elts
		var rect = target.getBoundingClientRect();
		var scroll = {
			top: target.scrollTop,
			left: target.scrollLeft,
			topMax: target.scrollTopMax,
			leftMax: target.scrollLeftMax,
			height: target.scrollHeight,
			width: target.scrollWidth,
		};
6117
		ctx.result = {
			x: rect.x,
			y: rect.y,
			left: rect.left,
			top: rect.top,
			right: rect.right,
			bottom: rect.bottom,
			width: rect.width,
			height: rect.height,
			bounds: rect,
6128
			scrollLeft: scroll.left,
			scrollTop: scroll.top,
			scrollLeftMax: scroll.leftMax,
			scrollTopMax: scroll.topMax,
			scrollWidth: scroll.width,
			scrollHeight: scroll.height,
			scroll: scroll,
		};
6137
		runtime.forEach(propsToMeasure, function (prop) {
			if (prop in ctx.result) ctx[prop] = ctx.result[prop];
			else throw "No such measurement as " + prop;
		});
6142
		return runtime.findNext(this, ctx);
	},
};
});
6147
_hyperscript.addLeafExpression("closestExpr", function (parser, runtime, tokens) {
if (tokens.matchToken("closest")) {
	if (tokens.matchToken("parent")) {
		var parentSearch = true;
	}
6153
	var css = null;
	if (tokens.currentToken().type === "ATTRIBUTE_REF") {
		var attributeRef = parser.parseElement("attributeRefAccess", tokens, null);
		css = "[" + attributeRef.attribute.name + "]";
	}
6159
	if (css == null) {
		var expr = parser.parseElement("expression", tokens);
		if (expr.css == null) {
			parser.raiseParseError(tokens, "Expected a CSS expression");
		} else {
			css = expr.css;
		}
	}
6168
	if (tokens.matchToken("to")) {
		var to = parser.parseElement("expression", tokens);
	} else {
		var to = parser.parseElement("implicitMeTarget", tokens);
	}
6174
	var closestExpr = {
		type: "closestExpr",
		parentSearch: parentSearch,
		expr: expr,
		css: css,
		to: to,
		args: [to],
		op: function (ctx, to) {
			if (to == null || !(to instanceof Element)) {
				return null;
			} else {
				if (parentSearch) {
					var node = to.parentElement ? to.parentElement.closest(css) : null;
				} else {
					var node = to.closest(css);
				}
				return node;
			}
		},
		evaluate: function (context) {
			return runtime.unifiedEval(this, context);
		},
	};
6198
	if (attributeRef) {
		attributeRef.root = closestExpr;
		attributeRef.args = [closestExpr];
		return attributeRef;
	} else {
		return closestExpr;
	}
}
});
6208
_hyperscript.addCommand("go", function (parser, runtime, tokens) {
if (tokens.matchToken("go")) {
	if (tokens.matchToken("back")) {
		var back = true;
	} else {
		tokens.matchToken("to");
		if (tokens.matchToken("url")) {
			var target = parser.requireElement("stringLike", tokens);
			var url = true;
			if (tokens.matchToken("in")) {
				tokens.requireToken("new");
				tokens.requireToken("window");
				var newWindow = true;
			}
		} else {
			tokens.matchToken("the"); // optional the
			var verticalPosition = tokens.matchAnyToken("top", "bottom", "middle");
			var horizontalPosition = tokens.matchAnyToken("left", "center", "right");
			if (verticalPosition || horizontalPosition) {
				tokens.requireToken("of");
			}
			var target = parser.requireElement("expression", tokens);
			var smoothness = tokens.matchAnyToken("smoothly", "instantly");
6232
			var scrollOptions = {};
			if (verticalPosition) {
				if (verticalPosition.value === "top") {
					scrollOptions.block = "start";
				} else if (verticalPosition.value === "bottom") {
					scrollOptions.block = "end";
				} else if (verticalPosition.value === "middle") {
					scrollOptions.block = "center";
				}
			}
6243
			if (horizontalPosition) {
				if (horizontalPosition.value === "left") {
					scrollOptions.inline = "start";
				} else if (horizontalPosition.value === "center") {
					scrollOptions.inline = "center";
				} else if (horizontalPosition.value === "right") {
					scrollOptions.inline = "end";
				}
			}
6253
			if (smoothness) {
				if (smoothness.value === "smoothly") {
					scrollOptions.behavior = "smooth";
				} else if (smoothness.value === "instantly") {
					scrollOptions.behavior = "instant";
				}
			}
		}
	}
6263
	var goCmd = {
		target: target,
		args: [target],
		op: function (ctx, to) {
			if (back) {
				window.history.back();
			} else if (url) {
				if (to) {
					if (to.indexOf("#") === 0 && !newWindow) {
						window.location.href = to;
					} else {
						window.open(to, newWindow ? "_blank" : null);
					}
				}
			} else {
				runtime.forEach(to, function (target) {
					target.scrollIntoView(scrollOptions);
				});
			}
			return runtime.findNext(goCmd);
		},
	};
	return goCmd;
}
});
6289
_hyperscript.config.conversions["Values"] = function (/** @type {Node | NodeList} */ node) {
/** @type Object<string,string | string[]> */
var result = {};
6293
var implicitLoop = _hyperscript.internals.runtime.implicitLoop;
6295
implicitLoop(node, function (/** @type HTMLInputElement */ node) {
	// Try to get a value directly from this node
	var input = getInputInfo(node);
6299
	if (input !== undefined) {
		result[input.name] = input.value;
		return;
	}
6304
	// Otherwise, try to query all child elements of this node that *should* contain values.
	if (node.querySelectorAll != undefined) {
		var children = node.querySelectorAll("input,select,textarea");
		children.forEach(appendValue);
	}
});
6311
return result;
6313
/**
 * @param {HTMLInputElement} node
 */
function appendValue(node) {
	var info = getInputInfo(node);
6319
	if (info == undefined) {
		return;
	}
6323
	// If there is no value already stored in this space.
	if (result[info.name] == undefined) {
		result[info.name] = info.value;
		return;
	}
6329
	if (Array.isArray(result[info.name]) && Array.isArray(info.value)) {
		result[info.name] = [].concat(result[info.name], info.value);
		return;
	}
}
6335
/**
 * @param {HTMLInputElement} node
 * @returns {{name:string, value:string | string[]} | undefined}
 */
function getInputInfo(node) {
	try {
		/** @type {{name: string, value: string | string[]}}*/
		var result = {
			name: node.name,
			value: node.value,
		};
6347
		if (result.name == undefined || result.value == undefined) {
			return undefined;
		}
6351
		if (node.type == "radio" && node.checked == false) {
			return undefined;
		}
6355
		if (node.type == "checkbox") {
			if (node.checked == false) {
				result.value = undefined;
			} else if (typeof result.value === "string") {
				result.value = [result.value];
			}
		}
6363
		if (node.type == "select-multiple") {
			/** @type {NodeListOf<HTMLSelectElement>} */
			var selected = node.querySelectorAll("option[selected]");
6367
			result.value = [];
			for (var index = 0; index < selected.length; index++) {
				result.value.push(selected[index].value);
			}
		}
		return result;
	} catch (e) {
		return undefined;
	}
}
};
6379
_hyperscript.config.conversions["HTML"] = function (value) {
var toHTML = /** @returns {string}*/ function (/** @type any*/ value) {
	if (value instanceof Array) {
		return value
			.map(function (item) {
				return toHTML(item);
			})
			.join("");
	}
6389
	if (value instanceof HTMLElement) {
		return value.outerHTML;
	}
6393
	if (value instanceof NodeList) {
		var result = "";
		for (var i = 0; i < value.length; i++) {
			var node = value[i];
			if (node instanceof HTMLElement) {
				result += node.outerHTML;
			}
		}
		return result;
	}
6404
	if (value.toString) {
		return value.toString();
	}
6408
	return "";
};
6411
return toHTML(value);
};
6414
_hyperscript.config.conversions["Fragment"] = function (val) {
var frag = document.createDocumentFragment();
_hyperscript.internals.runtime.implicitLoop(val, function (val) {
	if (val instanceof Node) frag.append(val);
	else {
		var temp = document.createElement("template");
		temp.innerHTML = val;
		frag.append(temp.content);
	}
});
return frag;
};
6427})();
6428
6429///=========================================================================
6430/// This module provides the worker feature for hyperscript
6431///=========================================================================
6432(function () {
var _hyperscript = typeof module !== 'undefined' ? module.exports : this._hyperscript
6434
var invocationIdCounter = 0;
6436
var workerFunc = function () {
self.onmessage = function (e) {
	switch (e.data.type) {
		case "init":
			importScripts(e.data._hyperscript);
			importScripts.apply(self, e.data.extraScripts);
			var tokens = _hyperscript.internals.lexer.makeTokensObject(e.data.tokens, [], e.data.source);
			var hyperscript = _hyperscript.internals.parser.parseElement("hyperscript", tokens);
			hyperscript.apply(self);
			postMessage({ type: "didInit" });
			break;
		case "call":
			try {
				var result = self[e.data.function].apply(self, e.data.args);
				Promise.resolve(result)
					.then(function (value) {
						postMessage({
							type: "resolve",
							id: e.data.id,
							value: value,
						});
					})
					.catch(function (error) {
						postMessage({
							type: "reject",
							id: e.data.id,
							error: error.toString(),
						});
					});
			} catch (error) {
				postMessage({
					type: "reject",
					id: e.data.id,
					error: error.toString(),
				});
			}
			break;
	}
};
};
6477
// extract the body of the function, which was only defined so
// that we can get syntax highlighting
var workerCode = "(" + workerFunc.toString() + ")()";
var blob = new Blob([workerCode], { type: "text/javascript" });
var workerUri = URL.createObjectURL(blob);
6483
_hyperscript.addFeature("worker", function (parser, runtime, tokens) {
if (tokens.matchToken("worker")) {
	var name = parser.requireElement("dotOrColonPath", tokens);
	var qualifiedName = name.evaluate();
	var nameSpace = qualifiedName.split(".");
	var workerName = nameSpace.pop();
6490
	// Parse extra scripts
	var extraScripts = [];
	if (tokens.matchOpToken("(")) {
		if (tokens.matchOpToken(")")) {
			// no external scripts
		} else {
			do {
				var extraScript = tokens.requireTokenType("STRING").value;
				var absoluteUrl = new URL(extraScript, location.href).href;
				extraScripts.push(absoluteUrl);
			} while (tokens.matchOpToken(","));
			tokens.requireOpToken(")");
		}
	}
6505
	// Consume worker methods
6507
	var funcNames = [];
	var bodyStartIndex = tokens.consumed.length;
	var bodyEndIndex = tokens.consumed.length;
	do {
		var feature = parser.parseAnyOf(["defFeature", "jsFeature"], tokens);
		if (feature) {
			if (feature.type === "defFeature") {
				funcNames.push(feature.name);
				bodyEndIndex = tokens.consumed.length;
			} else {
				if (tokens.hasMore()) continue;
			}
		} else break;
	} while (tokens.matchToken("end") && tokens.hasMore()); // worker end
6522
	var bodyTokens = tokens.consumed.slice(bodyStartIndex, bodyEndIndex + 1);
6524
	// Create worker
6526
	var worker = new Worker(workerUri);
6528
	// Send init message to worker
6530
	worker.postMessage({
		type: "init",
		_hyperscript: runtime.hyperscriptUrl,
		extraScripts: extraScripts,
		tokens: bodyTokens,
		source: tokens.source,
	});
6538
	var workerPromise = new Promise(function (resolve, reject) {
		worker.addEventListener(
			"message",
			function (e) {
				if (e.data.type === "didInit") resolve();
			},
			{ once: true }
		);
	});
6548
	// Create function stubs
	var stubs = {};
	funcNames.forEach(function (funcName) {
		stubs[funcName] = function () {
			var args = arguments;
			return new Promise(function (resolve, reject) {
				var id = invocationIdCounter++;
				worker.addEventListener("message", function returnListener(e) {
					if (e.data.id !== id) return;
					worker.removeEventListener("message", returnListener);
					if (e.data.type === "resolve") resolve(e.data.value);
					else reject(e.data.error);
				});
				workerPromise.then(function () {
					// Worker has been initialized, send invocation.
					worker.postMessage({
						type: "call",
						function: funcName,
						args: Array.from(args),
						id: id,
					});
				});
			});
		};
	});
6574
	return {
		name: workerName,
		worker: worker,
		install: function (target) {
			runtime.assignToNamespace(target, nameSpace, workerName, stubs);
		},
	};
}
});
6584})();
6585
6586("use strict");
6587
6588(function (_hyperscript) {
function compileTemplate(template) {
return template.replace(/(?:^|\n)([^@]*)@?/gm, function (match, p1) {
	var templateStr = (" " + p1).replace(/([^\\])\$\{/g, "$1$${escape html ").substring(1);
	return "\ncall __ht_template_result.push(`" + templateStr + "`)\n";
});
}
6595
function renderTemplate(template, ctx) {
var buf = [];
_hyperscript(template, Object.assign({ __ht_template_result: buf }, ctx));
return buf.join("");
}
6601
var _hyperscript = typeof module !== 'undefined' ? module.exports : this._hyperscript
6603
_hyperscript.addCommand("render", function (parser, runtime, tokens) {
if (!tokens.matchToken("render")) return;
var template_ = parser.requireElement("expression", tokens);
var templateArgs = {};
if (tokens.matchToken("with")) {
	templateArgs = parser.parseElement("namedArgumentList", tokens);
}
return {
	args: [template_, templateArgs],
	op: function (ctx, template, templateArgs) {
		if (!(template instanceof Element)) throw new Error(template_.sourceFor() + " is not an element");
		console.log(compileTemplate(template.innerHTML));
		ctx.result = renderTemplate(compileTemplate(template.innerHTML), templateArgs);
		return runtime.findNext(this, ctx);
	},
};
});
6621
function escapeHTML(html) {
return String(html)
	.replace(/&/g, "&amp;")
	.replace(/</g, "&lt;")
	.replace(/>/g, "&gt;")
	.replace(/\x22/g, "&quot;")
	.replace(/\x27/g, "&#039;");
}
6630
_hyperscript.addLeafExpression("escape", function (parser, runtime, tokens) {
if (!tokens.matchToken("escape")) return;
var escapeType = tokens.matchTokenType("IDENTIFIER").value;
6634
// hidden! for use in templates
var unescaped = tokens.matchToken("unescaped");
6637
var arg = parser.requireElement("expression", tokens);
6639
return {
	args: [arg],
	op: function (ctx, arg) {
		if (unescaped) return arg;
		if (arg === undefined) return "";
		switch (escapeType) {
			case "html":
				return escapeHTML(arg);
			default:
				throw new Error("Unknown escape: " + escapeType);
		}
	},
	evaluate: function (ctx) {
		return runtime.unifiedEval(this, ctx);
	},
};
});
6657})(_hyperscript);
6658
6659///=========================================================================
6660/// This module provides the worker feature for hyperscript
6661///=========================================================================
6662(function () {
function mergeObjects(obj1, obj2) {
for (var key in obj2) {
	if (obj2.hasOwnProperty(key)) {
		obj1[key] = obj2[key];
	}
}
return obj1;
}
6671
function genUUID() {
return "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, function (c) {
	var r = (Math.random() * 16) | 0,
		v = c == "x" ? r : (r & 0x3) | 0x8;
	return v.toString(16);
});
}
6679
function createSocket(url) {
return new WebSocket(url.evaluate());
}
6683
var PROXY_BLACKLIST = ["then", "catch", "length", "asyncWrapper", "toJSON"];
6685
var _hyperscript = typeof module !== 'undefined' ? module.exports : this._hyperscript
6687
_hyperscript.addFeature("socket", function (parser, runtime, tokens) {
function getProxy(timeout) {
	return new Proxy(
		{},
		{
			get: function (obj, property) {
				if (PROXY_BLACKLIST.indexOf(property) >= 0) {
					return null;
				} else if (property === "noTimeout") {
					return getProxy(-1);
				} else if (property === "timeout") {
					return function (i) {
						return getProxy(parseInt(i));
					};
				} else {
					return function () {
						var uuid = genUUID();
						var args = [];
						for (var i = 0; i < arguments.length; i++) {
							args.push(arguments[i]);
						}
						var rpcInfo = {
							iid: uuid,
							function: property,
							args: args,
						};
						socket = socket ? socket : createSocket(url); //recreate socket if needed
						socket.send(JSON.stringify(rpcInfo));
6716
						var promise = new Promise(function (resolve, reject) {
							promises[uuid] = {
								resolve: resolve,
								reject: reject,
							};
						});
6723
						if (timeout >= 0) {
							setTimeout(function () {
								if (promises[uuid]) {
									promises[uuid].reject("Timed out");
								}
								delete promises[uuid];
							}, timeout); // TODO configurable?
						}
						return promise;
					};
				}
			},
		}
	);
}
6739
if (tokens.matchToken("socket")) {
	var name = parser.requireElement("dotOrColonPath", tokens);
	var qualifiedName = name.evaluate();
	var nameSpace = qualifiedName.split(".");
	var socketName = nameSpace.pop();
6745
	var promises = {};
	var url = parser.requireElement("stringLike", tokens);
6748
	var defaultTimeout = 10000;
	if (tokens.matchToken("with")) {
		tokens.requireToken("timeout");
		defaultTimeout = parser.requireElement("timeExpression", tokens).evaluate();
	}
6754
	if (tokens.matchToken("on")) {
		tokens.requireToken("message");
		if (tokens.matchToken("as")) {
			tokens.requireToken("json");
			var jsonMessages = true;
		}
		var messageHandler = parser.requireElement("commandList", tokens);
		var implicitReturn = {
			type: "implicitReturn",
			op: function (context) {
				return runtime.HALT;
			},
			execute: function (context) {
				// do nothing
			},
		};
		var end = messageHandler;
		while (end.next) {
			end = end.next;
		}
		end.next = implicitReturn;
		// TODO set parent?
		// parser.setParent(implicitReturn, initFeature);
	}
6779
	var socket = createSocket(url);
	var rpcProxy = getProxy(defaultTimeout);
6782
	var socketObject = {
		raw: socket,
		dispatchEvent: function (evt) {
			var details = evt.detail;
			// remove hyperscript internals
			delete details.sentBy;
			delete details._namedArgList_;
			socket.send(JSON.stringify(mergeObjects({ type: evt.type }, details)));
		},
		rpc: rpcProxy,
	};
6794
	var socketFeature = {
		name: socketName,
		socket: socketObject,
		install: function (target) {
			runtime.assignToNamespace(target, nameSpace, socketName, socketObject);
		},
	};
6802
	socket.onmessage = function (evt) {
		var data = evt.data;
		try {
			var dataAsJson = JSON.parse(data);
		} catch (e) {
			// not JSON
		}
6810
		// RPC reply
		if (dataAsJson && dataAsJson.iid) {
			if (dataAsJson.throw) {
				promises[dataAsJson.iid].reject(dataAsJson.throw);
			} else {
				promises[dataAsJson.iid].resolve(dataAsJson.return);
			}
			delete promises[dataAsJson.iid];
		}
6820
		if (messageHandler) {
			var context = runtime.makeContext(socketObject, socketFeature, socketObject);
			if (jsonMessages) {
				if (dataAsJson) {
					context.message = dataAsJson;
					context.result = dataAsJson;
				} else {
					throw "Received non-JSON message from socket: " + data;
				}
			} else {
				context.message = data;
				context.result = data;
			}
			messageHandler.execute(context);
		}
	};
6837
	// clear socket on close to be recreated
	socket.addEventListener("close", function (e) {
		socket = null;
	});
6842
	return socketFeature;
}
});
6846})();
6847
6848///=========================================================================
6849/// This module provides the EventSource (SSE) feature for hyperscript
6850///=========================================================================
6851
6852(function () {
var _hyperscript = typeof module !== 'undefined' ? module.exports : this._hyperscript
_hyperscript.addFeature("eventsource", function (parser, runtime, tokens) {
if (tokens.matchToken("eventsource")) {
	var urlElement;
	var withCredentials = false;
6858
	// Get the name we'll assign to this EventSource in the hyperscript context
	/** @type {string} */
	var name = parser.requireElement("dotOrColonPath", tokens).evaluate();
	var nameSpace = name.split(".");
	var eventSourceName = nameSpace.pop();
6864
	// Get the URL of the EventSource
	if (tokens.matchToken("from")) {
		urlElement = parser.requireElement("stringLike", tokens);
	}
6869
	// Get option to connect with/without credentials
	if (tokens.matchToken("with")) {
		if (tokens.matchToken("credentials")) {
			withCredentials = true;
		}
	}
6876
	/** @type {EventSourceStub} */
	var stub = {
		eventSource: null,
		listeners: [],
		retryCount: 0,
		open: function (url) {
			// calculate default values for URL argument.
			if (url == undefined) {
				if (stub.eventSource != null && stub.eventSource.url != undefined) {
					url = stub.eventSource.url;
				} else {
					throw "no url defined for EventSource.";
				}
			}
6891
			// Guard multiple opens on the same EventSource
			if (stub.eventSource != null) {
				// If we're opening a new URL, then close the old one first.
				if (url != stub.eventSource.url) {
					stub.eventSource.close();
				} else if (stub.eventSource.readyState != EventSource.CLOSED) {
					// Otherwise, we already have the right connection open, so there's nothing left to do.
					return;
				}
			}
6902
			// Open the EventSource and get ready to populate event handlers
			stub.eventSource = new EventSource(url, {
				withCredentials: withCredentials,
			});
6907
			// On successful connection.  Reset retry count.
			stub.eventSource.addEventListener("open", function (event) {
				stub.retryCount = 0;
			});
6912
			// On connection error, use exponential backoff to retry (random values from 1 second to 2^7 (128) seconds
			stub.eventSource.addEventListener("error", function (event) {
				// If the EventSource is closed, then try to reopen
				if (stub.eventSource.readyState == EventSource.CLOSED) {
					stub.retryCount = Math.min(7, stub.retryCount + 1);
					var timeout = Math.random() * (2 ^ stub.retryCount) * 500;
					window.setTimeout(stub.open, timeout);
				}
			});
6922
			// Add event listeners
			for (var index = 0; index < stub.listeners.length; index++) {
				var item = stub.listeners[index];
				stub.eventSource.addEventListener(item.type, item.handler, item.options);
			}
		},
		close: function () {
			if (stub.eventSource != undefined) {
				stub.eventSource.close();
			}
			stub.retryCount = 0;
		},
		addEventListener: function (type, handler, options) {
			stub.listeners.push({
				type: type,
				handler: handler,
				options: options,
			});
6941
			if (stub.eventSource != null) {
				stub.eventSource.addEventListener(type, handler, options);
			}
		},
	};
6947
	// Create the "feature" that will be returned by this function.
6949
	/** @type {EventSourceFeature} */
	var feature = {
		name: eventSourceName,
		object: stub,
		install: function (target) {
			runtime.assignToNamespace(target, nameSpace, eventSourceName, stub);
		},
	};
6958
	// Parse each event listener and add it into the list
	while (tokens.matchToken("on")) {
		// get event name
		var eventName = parser.requireElement("stringLike", tokens, "Expected event name").evaluate(); // OK to evaluate this in real-time?
6963
		// default encoding is "" (autodetect)
		var encoding = "";
6966
		// look for alternate encoding
		if (tokens.matchToken("as")) {
			encoding = parser.requireElement("stringLike", tokens, "Expected encoding type").evaluate(); // Ok to evaluate this in real time?
		}
6971
		// get command list for this event handler
		var commandList = parser.requireElement("commandList", tokens);
		addImplicitReturnToCommandList(commandList);
		tokens.requireToken("end");
6976
		// Save the event listener into the feature.  This lets us
		// connect listeners to new EventSources if we have to reconnect.
		stub.listeners.push({
			type: eventName,
			handler: makeHandler(encoding, commandList),
		});
	}
6984
	tokens.requireToken("end");
6986
	// If we have a URL element, then connect to the remote server now.
	// Otherwise, we can connect later with a call to .open()
	if (urlElement != undefined) {
		stub.open(urlElement.evaluate());
	}
6992
	// Success!
	return feature;
6995
	////////////////////////////////////////////
	// ADDITIONAL HELPER FUNCTIONS HERE...
	////////////////////////////////////////////
6999
	/**
	 * Makes an eventHandler function that can execute the correct hyperscript commands
	 * This is outside of the main loop so that closures don't cause us to run the wrong commands.
	 *
	 * @param {string} encoding
	 * @param {*} commandList
	 * @returns {EventHandlerNonNull}
	 */
	function makeHandler(encoding, commandList) {
		return function (evt) {
			var data = decode(evt["data"], encoding);
			var context = runtime.makeContext(stub, feature, stub);
			context.event = evt;
			context.result = data;
			commandList.execute(context);
		};
	}
7017
	/**
	 * Decodes/Unmarshals a string based on the selected encoding.  If the
	 * encoding is not recognized, attempts to auto-detect based on its content
	 *
	 * @param {string} data - The original data to be decoded
	 * @param {string} encoding - The method that the data is currently encoded ("string", "json", or unknown)
	 * @returns {string} - The decoded data
	 */
	function decode(data, encoding) {
		// Force JSON encoding
		if (encoding == "json") {
			return JSON.parse(data);
		}
7031
		// Otherwise, return the data without modification
		return data;
	}
7035
	/**
	 * Adds a "HALT" command to the commandList.
	 * TODO: This seems like something that could be optimized:
	 * maybe the parser could do automatically,
	 * or could be a public function in the parser available to everyone,
	 * or the command-executer-thingy could just handle nulls implicitly.
	 *
	 * @param {*} commandList
	 * @returns void
	 */
	function addImplicitReturnToCommandList(commandList) {
		if (commandList.next) {
			return addImplicitReturnToCommandList(commandList.next);
		}
7050
		commandList.next = {
			type: "implicitReturn",
			op: function (/** @type {Context} */ _context) {
				return runtime.HALT;
			},
			execute: function (/** @type {Context} */ _context) {
				// do nothing
			},
		};
	}
}
});
7063})();
1	`///=========================================================================`
2	`/// This module provides the core runtime and grammar for hyperscript`
3	`///=========================================================================`
4	`//AMD insanity`
5
6	`/** @var {HyperscriptObject} _hyperscript */`
7
8	`(function (root, factory) {`
9	`if (typeof module != 'undefined') {`
10	`module.exports = factory();`
11	`} else if (typeof this.define === "function" && this.define.amd) {`
12	`// AMD. Register as an anonymous module.`
13	`this.define([], factory);`
14	`} else {`
15	`// Browser globals`
16	`root._hyperscript = factory();`
17	`}`
18	`})(typeof self !== "undefined" ? self : this, function () {`
19	`"use strict";`
20
21	`//====================================================================`
22	`// Utilities`
23	`//====================================================================`
24
25	`/**`
26	`* mergeObjects combines the keys from obj2 into obj2, then returns obj1`
27	`*`
28	`* @param {object} obj1`
29	`* @param {object} obj2`
30	`* @returns object`
31	`*/`
32	`function mergeObjects(obj1, obj2) {`
33	`for (var key in obj2) {`
34	`if (obj2.hasOwnProperty(key)) {`
35	`obj1[key] = obj2[key];`
36	`}`
37	`}`
38	`return obj1;`
39	`}`
40