@@ -44,6 +44,7 @@ return (function () {

             defineExtension : defineExtension,

             removeExtension : removeExtension,

             logAll : logAll,

+            logNone : logNone,

             logger : null,

             config : {

                 historyEnabled:true,

@@ -59,6 +60,7 @@ return (function () {

                 settlingClass:'htmx-settling',

                 swappingClass:'htmx-swapping',

                 allowEval:true,

+                allowScriptTags:true,

                 inlineScriptNonce:'',

                 attributesToSettle:["class", "style", "width", "height"],

                 withCredentials:false,

@@ -71,6 +73,11 @@ return (function () {

                 defaultFocusScroll: false,

                 getCacheBusterParam: false,

                 globalViewTransitions: false,

+                methodsThatUseUrlParams: ["get"],

+                selfRequestsOnly: false,

+                ignoreTitle: false,

+                scrollIntoViewOnBoost: true,

+                triggerSpecsCache: null,

             },

             parseInterval:parseInterval,

             _:internalEval,

@@ -82,7 +89,7 @@ return (function () {

                 sock.binaryType = htmx.config.wsBinaryType;

                 return sock;

             },

-            version: "1.9.2"

+            version: "1.9.10"

         };

         /** @type {import("./htmx").HtmxInternalApi} */

@@ -90,9 +97,11 @@ return (function () {

             addTriggerHandler: addTriggerHandler,

             bodyContains: bodyContains,

             canAccessLocalStorage: canAccessLocalStorage,

+            findThisElement: findThisElement,

             filterValues: filterValues,

             hasAttribute: hasAttribute,

             getAttributeValue: getAttributeValue,

+            getClosestAttributeValue: getClosestAttributeValue,

             getClosestMatch: getClosestMatch,

             getExpressionVars: getExpressionVars,

             getHeaders: getHeaders,

@@ -105,6 +114,7 @@ return (function () {

             mergeObjects: mergeObjects,

             makeSettleInfo: makeSettleInfo,

             oobSwap: oobSwap,

+            querySelectorExt: querySelectorExt,

             selectAndSwap: selectAndSwap,

             settleImmediately: settleImmediately,

             shouldCancel: shouldCancel,

@@ -118,24 +128,40 @@ return (function () {

             return "[hx-" + verb + "], [data-hx-" + verb + "]"

         }).join(", ");

+        var HEAD_TAG_REGEX = makeTagRegEx('head'),

+            TITLE_TAG_REGEX = makeTagRegEx('title'),

+            SVG_TAGS_REGEX = makeTagRegEx('svg', true);

+

         //====================================================================

         // Utilities

         //====================================================================

+        /**

+         * @param {string} tag

+         * @param {boolean} global

+         * @returns {RegExp}

+         */

+        function makeTagRegEx(tag, global = false) {

+            return new RegExp(`<${tag}(\\s[^>]*>|>)([\\s\\S]*?)<\\/${tag}>`,

+                global ? 'gim' : 'im');

+        }

+

         function parseInterval(str) {

             if (str == undefined)  {

-                return undefined

+                return undefined;

             }

+

+            let interval = NaN;

             if (str.slice(-2) == "ms") {

-                return parseFloat(str.slice(0,-2)) || undefined

-            }

-            if (str.slice(-1) == "s") {

-                return (parseFloat(str.slice(0,-1)) * 1000) || undefined

-            }

-            if (str.slice(-1) == "m") {

-                return (parseFloat(str.slice(0,-1)) * 1000 * 60) || undefined

+                interval = parseFloat(str.slice(0, -2));

+            } else if (str.slice(-1) == "s") {

+                interval = parseFloat(str.slice(0, -1)) * 1000;

+            } else if (str.slice(-1) == "m") {

+                interval = parseFloat(str.slice(0, -1)) * 1000 * 60;

+            } else {

+                interval = parseFloat(str);

             }

-            return parseFloat(str) || undefined

+            return isNaN(interval) ? undefined : interval;

         }

         /**

@@ -222,7 +248,7 @@ return (function () {

          * @returns {boolean}

          */

         function matches(elt, selector) {

-            // @ts-ignore: non-standard properties for browser compatability

+            // @ts-ignore: non-standard properties for browser compatibility

             // noinspection JSUnresolvedVariable

             var matchesFunction = elt.matches || elt.matchesSelector || elt.msMatchesSelector || elt.mozMatchesSelector || elt.webkitMatchesSelector || elt.oMatchesSelector;

             return matchesFunction && matchesFunction.call(elt, selector);

@@ -267,42 +293,46 @@ return (function () {

         }

         function aFullPageResponse(resp) {

-            return resp.match(/<body/);

+            return /<body/.test(resp)

         }

         /**

          *

-         * @param {string} resp

+         * @param {string} response

          * @returns {Element}

          */

-        function makeFragment(resp) {

-            var partialResponse = !aFullPageResponse(resp);

+        function makeFragment(response) {

+            var partialResponse = !aFullPageResponse(response);

+            var startTag = getStartTag(response);

+            var content = response;

+            if (startTag === 'head') {

+                content = content.replace(HEAD_TAG_REGEX, '');

+            }

             if (htmx.config.useTemplateFragments && partialResponse) {

-                var documentFragment = parseHTML("<body><template>" + resp + "</template></body>", 0);

+                var documentFragment = parseHTML("<body><template>" + content + "</template></body>", 0);

                 // @ts-ignore type mismatch between DocumentFragment and Element.

-                // TODO: Are these close enough for htmx to use interchangably?

+                // TODO: Are these close enough for htmx to use interchangeably?

                 return documentFragment.querySelector('template').content;

-            } else {

-                var startTag = getStartTag(resp);

-                switch (startTag) {

-                    case "thead":

-                    case "tbody":

-                    case "tfoot":

-                    case "colgroup":

-                    case "caption":

-                        return parseHTML("<table>" + resp + "</table>", 1);

-                    case "col":

-                        return parseHTML("<table><colgroup>" + resp + "</colgroup></table>", 2);

-                    case "tr":

-                        return parseHTML("<table><tbody>" + resp + "</tbody></table>", 2);

-                    case "td":

-                    case "th":

-                        return parseHTML("<table><tbody><tr>" + resp + "</tr></tbody></table>", 3);

-                    case "script":

-                        return parseHTML("<div>" + resp + "</div>", 1);

-                    default:

-                        return parseHTML(resp, 0);

-                }

+            }

+            switch (startTag) {

+                case "thead":

+                case "tbody":

+                case "tfoot":

+                case "colgroup":

+                case "caption":

+                    return parseHTML("<table>" + content + "</table>", 1);

+                case "col":

+                    return parseHTML("<table><colgroup>" + content + "</colgroup></table>", 2);

+                case "tr":

+                    return parseHTML("<table><tbody>" + content + "</tbody></table>", 2);

+                case "td":

+                case "th":

+                    return parseHTML("<table><tbody><tr>" + content + "</tr></tbody></table>", 3);

+                case "script":

+                case "style":

+                    return parseHTML("<div>" + content + "</div>", 1);

+                default:

+                    return parseHTML(content, 0);

             }

         }

@@ -386,7 +416,7 @@ return (function () {

         function bodyContains(elt) {

             // IE Fix

-            if (elt.getRootNode && elt.getRootNode() instanceof ShadowRoot) {

+            if (elt.getRootNode && elt.getRootNode() instanceof window.ShadowRoot) {

                 return getDocument().body.contains(elt.getRootNode().host);

             } else {

                 return getDocument().body.contains(elt);

@@ -440,7 +470,7 @@ return (function () {

                     path = url.pathname + url.search;

                 }

                 // remove trailing slash, unless index page

-                if (!path.match('^/$')) {

+                if (!(/^\/$/.test(path))) {

                     path = path.replace(/\/+$/, '');

                 }

                 return path;

@@ -475,6 +505,10 @@ return (function () {

             }

         }

+        function logNone() {

+            htmx.logger = null

+        }

+

         function find(eltOrSelector, selector) {

             if (selector) {

                 return eltOrSelector.querySelector(selector);

@@ -562,9 +596,17 @@ return (function () {

             }

         }

+        function startsWith(str, prefix) {

+            return str.substring(0, prefix.length) === prefix

+        }

+

+        function endsWith(str, suffix) {

+            return str.substring(str.length - suffix.length) === suffix

+        }

+

         function normalizeSelector(selector) {

             var trimmedSelector = selector.trim();

-            if (trimmedSelector.startsWith("<") && trimmedSelector.endsWith("/>")) {

+            if (startsWith(trimmedSelector, "<") && endsWith(trimmedSelector, "/>")) {

                 return trimmedSelector.substring(1, trimmedSelector.length - 2);

             } else {

                 return trimmedSelector;

@@ -576,14 +618,20 @@ return (function () {

                 return [closest(elt, normalizeSelector(selector.substr(8)))];

             } else if (selector.indexOf("find ") === 0) {

                 return [find(elt, normalizeSelector(selector.substr(5)))];

+            } else if (selector === "next") {

+                return [elt.nextElementSibling]

             } else if (selector.indexOf("next ") === 0) {

                 return [scanForwardQuery(elt, normalizeSelector(selector.substr(5)))];

+            } else if (selector === "previous") {

+                return [elt.previousElementSibling]

             } else if (selector.indexOf("previous ") === 0) {

                 return [scanBackwardsQuery(elt, normalizeSelector(selector.substr(9)))];

             } else if (selector === 'document') {

                 return [document];

             } else if (selector === 'window') {

                 return [window];

+            } else if (selector === 'body') {

+                return [document.body];

             } else {

                 return getDocument().querySelectorAll(normalizeSelector(selector));

             }

@@ -751,7 +799,7 @@ return (function () {

          * @returns

          */

         function oobSwap(oobValue, oobElement, settleInfo) {

-            var selector = "#" + oobElement.id;

+            var selector = "#" + getRawAttribute(oobElement, "id");

             var swapStyle = "outerHTML";

             if (oobValue === "true") {

                 // do nothing

@@ -799,7 +847,7 @@ return (function () {

             var oobSelects = getClosestAttributeValue(elt, "hx-select-oob");

             if (oobSelects) {

                 var oobSelectValues = oobSelects.split(",");

-                for (let i = 0; i < oobSelectValues.length; i++) {

+                for (var i = 0; i < oobSelectValues.length; i++) {

                     var oobSelectValue = oobSelectValues[i].split(":", 2);

                     var id = oobSelectValue[0].trim();

                     if (id.indexOf("#") === 0) {

@@ -832,8 +880,9 @@ return (function () {

         function handleAttributes(parentNode, fragment, settleInfo) {

             forEach(fragment.querySelectorAll("[id]"), function (newNode) {

-                if (newNode.id && newNode.id.length > 0) {

-                    var normalizedId = newNode.id.replace("'", "\\'");

+                var id = getRawAttribute(newNode, "id")

+                if (id && id.length > 0) {

+                    var normalizedId = id.replace("'", "\\'");

                     var normalizedTag = newNode.tagName.replace(':', '\\:');

                     var oldNode = parentNode.querySelector(normalizedTag + "[id='" + normalizedId + "']");

                     if (oldNode && oldNode !== parentNode) {

@@ -902,6 +951,17 @@ return (function () {

             return hash;

         }

+        function deInitOnHandlers(elt) {

+            var internalData = getInternalData(elt);

+            if (internalData.onHandlers) {

+                for (var i = 0; i < internalData.onHandlers.length; i++) {

+                    const handlerInfo = internalData.onHandlers[i];

+                    elt.removeEventListener(handlerInfo.event, handlerInfo.listener);

+                }

+                delete internalData.onHandlers

+            }

+        }

+

         function deInitNode(element) {

             var internalData = getInternalData(element);

             if (internalData.timeout) {

@@ -920,12 +980,8 @@ return (function () {

                     }

                 });

             }

-            if (internalData.onHandlers) {

-                for (let i = 0; i < internalData.onHandlers.length; i++) {

-                    const handlerInfo = internalData.onHandlers[i];

-                    element.removeEventListener(handlerInfo.name, handlerInfo.handler);

-                }

-            }

+            deInitOnHandlers(element);

+            forEach(Object.keys(internalData), function(key) { delete internalData[key] });

         }

         function cleanUpElement(element) {

@@ -949,8 +1005,7 @@ return (function () {

                 } else {

                     newElt = eltBeforeNewContent.nextSibling;

                 }

-                getInternalData(target).replacedWith = newElt; // tuck away so we can fire events on it later

-                settleInfo.elts = [] // clear existing elements

+                settleInfo.elts = settleInfo.elts.filter(function(e) { return e != target });

                 while(newElt && newElt !== target) {

                     if (newElt.nodeType === Node.ELEMENT_NODE) {

                         settleInfo.elts.push(newElt);

@@ -995,8 +1050,8 @@ return (function () {

             }

         }

-        function maybeSelectFromResponse(elt, fragment) {

-            var selector = getClosestAttributeValue(elt, "hx-select");

+        function maybeSelectFromResponse(elt, fragment, selectOverride) {

+            var selector = selectOverride || getClosestAttributeValue(elt, "hx-select");

             if (selector) {

                 var newFragment = getDocument().createDocumentFragment();

                 forEach(fragment.querySelectorAll(selector), function (node) {

@@ -1061,21 +1116,20 @@ return (function () {

         function findTitle(content) {

             if (content.indexOf('<title') > -1) {

-                var contentWithSvgsRemoved = content.replace(/<svg(\s[^>]*>|>)([\s\S]*?)<\/svg>/gim, '');

-                var result = contentWithSvgsRemoved.match(/<title(\s[^>]*>|>)([\s\S]*?)<\/title>/im);

-

+                var contentWithSvgsRemoved = content.replace(SVG_TAGS_REGEX, '');

+                var result = contentWithSvgsRemoved.match(TITLE_TAG_REGEX);

                 if (result) {

                     return result[2];

                 }

             }

         }

-        function selectAndSwap(swapStyle, target, elt, responseText, settleInfo) {

+        function selectAndSwap(swapStyle, target, elt, responseText, settleInfo, selectOverride) {

             settleInfo.title = findTitle(responseText);

             var fragment = makeFragment(responseText);

             if (fragment) {

                 handleOutOfBandSwaps(elt, fragment, settleInfo);

-                fragment = maybeSelectFromResponse(elt, fragment);

+                fragment = maybeSelectFromResponse(elt, fragment, selectOverride);

                 handlePreservedElements(fragment);

                 return swap(swapStyle, elt, target, fragment, settleInfo);

             }

@@ -1095,7 +1149,10 @@ return (function () {

                     }

                 }

             } else {

-                triggerEvent(elt, triggerBody, []);

+                var eventNames = triggerBody.split(",")

+                for (var i = 0; i < eventNames.length; i++) {

+                    triggerEvent(elt, eventNames[i].trim(), []);

+                }

             }

         }

@@ -1105,6 +1162,8 @@ return (function () {

         var SYMBOL_CONT = /[_$a-zA-Z0-9]/;

         var STRINGISH_START = ['"', "'", "/"];

         var NOT_WHITESPACE = /[^\s]/;

+        var COMBINED_SELECTOR_START = /[{(]/;

+        var COMBINED_SELECTOR_END = /[})]/;

         function tokenizeString(str) {

             var tokens = [];

             var position = 0;

@@ -1187,102 +1246,136 @@ return (function () {

         function consumeUntil(tokens, match) {

             var result = "";

-            while (tokens.length > 0 && !tokens[0].match(match)) {

+            while (tokens.length > 0 && !match.test(tokens[0])) {

                 result += tokens.shift();

             }

             return result;

         }

+        function consumeCSSSelector(tokens) {

+            var result;

+            if (tokens.length > 0 && COMBINED_SELECTOR_START.test(tokens[0])) {

+                tokens.shift();

+                result = consumeUntil(tokens, COMBINED_SELECTOR_END).trim();

+                tokens.shift();

+            } else {

+                result = consumeUntil(tokens, WHITESPACE_OR_COMMA);

+            }

+            return result;

+        }

+

         var INPUT_SELECTOR = 'input, textarea, select';

         /**

          * @param {HTMLElement} elt

+         * @param {string} explicitTrigger

+         * @param {cache} cache for trigger specs

          * @returns {import("./htmx").HtmxTriggerSpecification[]}

          */

-        function getTriggerSpecs(elt) {

-            var explicitTrigger = getAttributeValue(elt, 'hx-trigger');

+        function parseAndCacheTrigger(elt, explicitTrigger, cache) {

             var triggerSpecs = [];

-            if (explicitTrigger) {

-                var tokens = tokenizeString(explicitTrigger);

-                do {

-                    consumeUntil(tokens, NOT_WHITESPACE);

-                    var initialLength = tokens.length;

-                    var trigger = consumeUntil(tokens, /[,\[\s]/);

-                    if (trigger !== "") {

-                        if (trigger === "every") {

-                            var every = {trigger: 'every'};

-                            consumeUntil(tokens, NOT_WHITESPACE);

-                            every.pollInterval = parseInterval(consumeUntil(tokens, /[,\[\s]/));

-                            consumeUntil(tokens, NOT_WHITESPACE);

-                            var eventFilter = maybeGenerateConditional(elt, tokens, "event");

-                            if (eventFilter) {

-                                every.eventFilter = eventFilter;

-                            }

-                            triggerSpecs.push(every);

-                        } else if (trigger.indexOf("sse:") === 0) {

-                            triggerSpecs.push({trigger: 'sse', sseEvent: trigger.substr(4)});

-                        } else {

-                            var triggerSpec = {trigger: trigger};

-                            var eventFilter = maybeGenerateConditional(elt, tokens, "event");

-                            if (eventFilter) {

-                                triggerSpec.eventFilter = eventFilter;

-                            }

-                            while (tokens.length > 0 && tokens[0] !== ",") {

-                                consumeUntil(tokens, NOT_WHITESPACE)

-                                var token = tokens.shift();

-                                if (token === "changed") {

-                                    triggerSpec.changed = true;

-                                } else if (token === "once") {

-                                    triggerSpec.once = true;

-                                } else if (token === "consume") {

-                                    triggerSpec.consume = true;

-                                } else if (token === "delay" && tokens[0] === ":") {

-                                    tokens.shift();

-                                    triggerSpec.delay = parseInterval(consumeUntil(tokens, WHITESPACE_OR_COMMA));

-                                } else if (token === "from" && tokens[0] === ":") {

-                                    tokens.shift();

+            var tokens = tokenizeString(explicitTrigger);

+            do {

+                consumeUntil(tokens, NOT_WHITESPACE);

+                var initialLength = tokens.length;

+                var trigger = consumeUntil(tokens, /[,\[\s]/);

+                if (trigger !== "") {

+                    if (trigger === "every") {

+                        var every = {trigger: 'every'};

+                        consumeUntil(tokens, NOT_WHITESPACE);

+                        every.pollInterval = parseInterval(consumeUntil(tokens, /[,\[\s]/));

+                        consumeUntil(tokens, NOT_WHITESPACE);

+                        var eventFilter = maybeGenerateConditional(elt, tokens, "event");

+                        if (eventFilter) {

+                            every.eventFilter = eventFilter;

+                        }

+                        triggerSpecs.push(every);

+                    } else if (trigger.indexOf("sse:") === 0) {

+                        triggerSpecs.push({trigger: 'sse', sseEvent: trigger.substr(4)});

+                    } else {

+                        var triggerSpec = {trigger: trigger};

+                        var eventFilter = maybeGenerateConditional(elt, tokens, "event");

+                        if (eventFilter) {

+                            triggerSpec.eventFilter = eventFilter;

+                        }

+                        while (tokens.length > 0 && tokens[0] !== ",") {

+                            consumeUntil(tokens, NOT_WHITESPACE)

+                            var token = tokens.shift();

+                            if (token === "changed") {

+                                triggerSpec.changed = true;

+                            } else if (token === "once") {

+                                triggerSpec.once = true;

+                            } else if (token === "consume") {

+                                triggerSpec.consume = true;

+                            } else if (token === "delay" && tokens[0] === ":") {

+                                tokens.shift();

+                                triggerSpec.delay = parseInterval(consumeUntil(tokens, WHITESPACE_OR_COMMA));

+                            } else if (token === "from" && tokens[0] === ":") {

+                                tokens.shift();

+                                if (COMBINED_SELECTOR_START.test(tokens[0])) {

+                                    var from_arg = consumeCSSSelector(tokens);

+                                } else {

                                     var from_arg = consumeUntil(tokens, WHITESPACE_OR_COMMA);

                                     if (from_arg === "closest" || from_arg === "find" || from_arg === "next" || from_arg === "previous") {

                                         tokens.shift();

-                                        from_arg +=

-                                            " " +

-                                            consumeUntil(

-                                                tokens,

-                                                WHITESPACE_OR_COMMA

-                                            );

+                                        var selector = consumeCSSSelector(tokens);

+                                        // `next` and `previous` allow a selector-less syntax

+                                        if (selector.length > 0) {

+                                            from_arg += " " + selector;

+                                        }

                                     }

-                                    triggerSpec.from = from_arg;

-                                } else if (token === "target" && tokens[0] === ":") {

-                                    tokens.shift();

-                                    triggerSpec.target = consumeUntil(tokens, WHITESPACE_OR_COMMA);

-                                } else if (token === "throttle" && tokens[0] === ":") {

-                                    tokens.shift();

-                                    triggerSpec.throttle = parseInterval(consumeUntil(tokens, WHITESPACE_OR_COMMA));

-                                } else if (token === "queue" && tokens[0] === ":") {

-                                    tokens.shift();

-                                    triggerSpec.queue = consumeUntil(tokens, WHITESPACE_OR_COMMA);

-                                } else if ((token === "root" || token === "threshold") && tokens[0] === ":") {

-                                    tokens.shift();

-                                    triggerSpec[token] = consumeUntil(tokens, WHITESPACE_OR_COMMA);

-                                } else {

-                                    triggerErrorEvent(elt, "htmx:syntax:error", {token:tokens.shift()});

                                 }

+                                triggerSpec.from = from_arg;

+                            } else if (token === "target" && tokens[0] === ":") {

+                                tokens.shift();

+                                triggerSpec.target = consumeCSSSelector(tokens);

+                            } else if (token === "throttle" && tokens[0] === ":") {

+                                tokens.shift();

+                                triggerSpec.throttle = parseInterval(consumeUntil(tokens, WHITESPACE_OR_COMMA));

+                            } else if (token === "queue" && tokens[0] === ":") {

+                                tokens.shift();

+                                triggerSpec.queue = consumeUntil(tokens, WHITESPACE_OR_COMMA);

+                            } else if (token === "root" && tokens[0] === ":") {

+                                tokens.shift();

+                                triggerSpec[token] = consumeCSSSelector(tokens);

+                            } else if (token === "threshold" && tokens[0] === ":") {

+                                tokens.shift();

+                                triggerSpec[token] = consumeUntil(tokens, WHITESPACE_OR_COMMA);

+                            } else {

+                                triggerErrorEvent(elt, "htmx:syntax:error", {token:tokens.shift()});

                             }

-                            triggerSpecs.push(triggerSpec);

                         }

+                        triggerSpecs.push(triggerSpec);

                     }

-                    if (tokens.length === initialLength) {

-                        triggerErrorEvent(elt, "htmx:syntax:error", {token:tokens.shift()});

-                    }

-                    consumeUntil(tokens, NOT_WHITESPACE);

-                } while (tokens[0] === "," && tokens.shift())

+                }

+                if (tokens.length === initialLength) {

+                    triggerErrorEvent(elt, "htmx:syntax:error", {token:tokens.shift()});

+                }

+                consumeUntil(tokens, NOT_WHITESPACE);

+            } while (tokens[0] === "," && tokens.shift())

+            if (cache) {

+                cache[explicitTrigger] = triggerSpecs

+            }

+            return triggerSpecs

+        }

+

+        /**

+         * @param {HTMLElement} elt

+         * @returns {import("./htmx").HtmxTriggerSpecification[]}

+         */

+        function getTriggerSpecs(elt) {

+            var explicitTrigger = getAttributeValue(elt, 'hx-trigger');

+            var triggerSpecs = [];

+            if (explicitTrigger) {

+                var cache = htmx.config.triggerSpecsCache

+                triggerSpecs = (cache && cache[explicitTrigger]) || parseAndCacheTrigger(elt, explicitTrigger, cache)

             }

             if (triggerSpecs.length > 0) {

                 return triggerSpecs;

             } else if (matches(elt, 'form')) {

                 return [{trigger: 'submit'}];

-            } else if (matches(elt, 'input[type="button"]')){

+            } else if (matches(elt, 'input[type="button"], input[type="submit"]')){

                 return [{trigger: 'click'}];

             } else if (matches(elt, INPUT_SELECTOR)) {

                 return [{trigger: 'change'}];

@@ -1299,7 +1392,10 @@ return (function () {

             var nodeData = getInternalData(elt);

             nodeData.timeout = setTimeout(function () {

                 if (bodyContains(elt) && nodeData.cancelled !== true) {

-                    if (!maybeFilterEvent(spec, makeEvent('hx:poll:trigger', {triggerSpec:spec, target:elt}))) {

+                    if (!maybeFilterEvent(spec, elt, makeEvent('hx:poll:trigger', {

+                        triggerSpec: spec,

+                        target: elt

+                    }))) {

                         handler(elt);

                     }

                     processPolling(elt, handler, spec);

@@ -1319,7 +1415,7 @@ return (function () {

                 var verb, path;

                 if (elt.tagName === "A") {

                     verb = "get";

-                    path = elt.href; // DOM property gives the fully resolved href of a relative link

+                    path = getRawAttribute(elt, 'href')

                 } else {

                     var rawAttribute = getRawAttribute(elt, "method");

                     verb = rawAttribute ? rawAttribute.toLowerCase() : "get";

@@ -1329,6 +1425,10 @@ return (function () {

                 }

                 triggerSpecs.forEach(function(triggerSpec) {

                     addEventListener(elt, function(elt, evt) {

+                        if (closest(elt, htmx.config.disableSelector)) {

+                            cleanUpElement(elt)

+                            return

+                        }

                         issueAjaxRequest(verb, path, elt, evt)

                     }, nodeData, triggerSpec, true);

                 });

@@ -1361,11 +1461,11 @@ return (function () {

             return getInternalData(elt).boosted && elt.tagName === "A" && evt.type === "click" && (evt.ctrlKey || evt.metaKey);

         }

-        function maybeFilterEvent(triggerSpec, evt) {

+        function maybeFilterEvent(triggerSpec, elt, evt) {

             var eventFilter = triggerSpec.eventFilter;

             if(eventFilter){

                 try {

-                    return eventFilter(evt) !== true;

+                    return eventFilter.call(elt, evt) !== true;

                 } catch(e) {

                     triggerErrorEvent(getDocument().body, "htmx:eventFilter:error", {error: e, source:eventFilter.source});

                     return true;

@@ -1382,9 +1482,12 @@ return (function () {

             } else {

                 eltsToListenOn = [elt];

             }

-            // store the initial value of the element so we can tell if it changes

+            // store the initial values of the elements, so we can tell if they change

             if (triggerSpec.changed) {

-                elementData.lastValue = elt.value;

+                eltsToListenOn.forEach(function (eltToListenOn) {

+                    var eltToListenOnData = getInternalData(eltToListenOn);

+                    eltToListenOnData.lastValue = eltToListenOn.value;

+                })

             }

             forEach(eltsToListenOn, function (eltToListenOn) {

                 var eventListener = function (evt) {

@@ -1398,7 +1501,7 @@ return (function () {

                     if (explicitCancel || shouldCancel(evt, elt)) {

                         evt.preventDefault();

                     }

-                    if (maybeFilterEvent(triggerSpec, evt)) {

+                    if (maybeFilterEvent(triggerSpec, elt, evt)) {

                         return;

                     }

                     var eventData = getInternalData(evt);

@@ -1424,11 +1527,11 @@ return (function () {

                             }

                         }

                         if (triggerSpec.changed) {

-                            if (elementData.lastValue === elt.value) {

+                            var eltToListenOnData = getInternalData(eltToListenOn)

+                            if (eltToListenOnData.lastValue === eltToListenOn.value) {

                                 return;

-                            } else {

-                                elementData.lastValue = elt.value;

                             }

+                            eltToListenOnData.lastValue = eltToListenOn.value

                         }

                         if (elementData.delayed) {

                             clearTimeout(elementData.delayed);

@@ -1437,14 +1540,14 @@ return (function () {

                             return;

                         }

-                        if (triggerSpec.throttle) {

+                        if (triggerSpec.throttle > 0) {

                             if (!elementData.throttle) {

                                 handler(elt, evt);

                                 elementData.throttle = setTimeout(function () {

                                     elementData.throttle = null;

                                 }, triggerSpec.throttle);

                             }

-                        } else if (triggerSpec.delay) {

+                        } else if (triggerSpec.delay > 0) {

                             elementData.delayed = setTimeout(function() { handler(elt, evt) }, triggerSpec.delay);

                         } else {

                             triggerEvent(elt, 'htmx:trigger')

@@ -1650,6 +1753,9 @@ return (function () {

                 var sseEventSource = getInternalData(sseSourceElt).sseEventSource;

                 var sseListener = function (event) {

                     if (maybeCloseSSESource(sseSourceElt)) {

+                        return;

+                    }

+                    if (!bodyContains(elt)) {

                         sseEventSource.removeEventListener(sseEventName, sseListener);

                         return;

                     }

@@ -1666,7 +1772,7 @@ return (function () {

                     var target = getTarget(elt)

                     var settleInfo = makeSettleInfo(elt);

-                    selectAndSwap(swapSpec.swapStyle, elt, target, response, settleInfo)

+                    selectAndSwap(swapSpec.swapStyle, target, elt, response, settleInfo)

                     settleImmediately(settleInfo.tasks)

                     triggerEvent(elt, "htmx:sseMessage", event)

                 };

@@ -1718,7 +1824,7 @@ return (function () {

                     handler(elt);

                 }

             }

-            if (delay) {

+            if (delay > 0) {

                 setTimeout(load, delay);

             } else {

                 load();

@@ -1735,6 +1841,10 @@ return (function () {

                     nodeData.verb = verb;

                     triggerSpecs.forEach(function(triggerSpec) {

                         addTriggerHandler(elt, triggerSpec, nodeData, function (elt, evt) {

+                            if (closest(elt, htmx.config.disableSelector)) {

+                                cleanUpElement(elt)

+                                return

+                            }

                             issueAjaxRequest(verb, path, elt, evt)

                         })

                     });

@@ -1770,10 +1880,10 @@ return (function () {

                 observer.observe(elt);

                 addEventListener(elt, handler, nodeData, triggerSpec);

             } else if (triggerSpec.trigger === "load") {

-                if (!maybeFilterEvent(triggerSpec, makeEvent("load", {elt:elt}))) {

+                if (!maybeFilterEvent(triggerSpec, elt, makeEvent("load", {elt: elt}))) {

                                 loadImmediately(elt, handler, nodeData, triggerSpec.delay);

                             }

-            } else if (triggerSpec.pollInterval) {

+            } else if (triggerSpec.pollInterval > 0) {

                 nodeData.polling = true;

                 processPolling(elt, handler, triggerSpec);

             } else {

@@ -1782,7 +1892,7 @@ return (function () {

         }

         function evalScript(script) {

-            if (script.type === "text/javascript" || script.type === "module" || script.type === "") {

+            if (htmx.config.allowScriptTags && (script.type === "text/javascript" || script.type === "module" || script.type === "") ) {

                 var newScript = getDocument().createElement("script");

                 forEach(script.attributes, function (attr) {

                     newScript.setAttribute(attr.name, attr.value);

@@ -1816,14 +1926,46 @@ return (function () {

             });

         }

-        function hasChanceOfBeingBoosted() {

-            return document.querySelector("[hx-boost], [data-hx-boost]");

+        function shouldProcessHxOn(elt) {

+            var attributes = elt.attributes

+            for (var j = 0; j < attributes.length; j++) {

+                var attrName = attributes[j].name

+                if (startsWith(attrName, "hx-on:") || startsWith(attrName, "data-hx-on:") ||

+                    startsWith(attrName, "hx-on-") || startsWith(attrName, "data-hx-on-")) {

+                    return true

+                }

+            }

+            return false

+        }

+

+        function findHxOnWildcardElements(elt) {

+            var node = null

+            var elements = []

+

+            if (shouldProcessHxOn(elt)) {

+                elements.push(elt)

+            }

+

+            if (document.evaluate) {

+                var iter = document.evaluate('.//*[@*[ starts-with(name(), "hx-on:") or starts-with(name(), "data-hx-on:") or' +

+                                                                           ' starts-with(name(), "hx-on-") or starts-with(name(), "data-hx-on-") ]]', elt)

+                while (node = iter.iterateNext()) elements.push(node)

+            } else {

+                var allElements = elt.getElementsByTagName("*")

+                for (var i = 0; i < allElements.length; i++) {

+                    if (shouldProcessHxOn(allElements[i])) {

+                        elements.push(allElements[i])

+                    }

+                }

+            }

+

+            return elements

         }

         function findElementsToProcess(elt) {

             if (elt.querySelectorAll) {

-                var boostedElts = hasChanceOfBeingBoosted() ? ", a, form" : "";

-                var results = elt.querySelectorAll(VERB_SELECTOR + boostedElts + ", [hx-sse], [data-hx-sse], [hx-ws]," +

+                var boostedSelector = ", [hx-boost] a, [data-hx-boost] a, a[hx-boost], a[data-hx-boost]";

+                var results = elt.querySelectorAll(VERB_SELECTOR + boostedSelector + ", form, [type='submit'], [hx-sse], [data-hx-sse], [hx-ws]," +

                     " [data-hx-ws], [hx-ext], [data-hx-ext], [hx-trigger], [data-hx-trigger], [hx-on], [data-hx-on]");

                 return results;

             } else {

@@ -1831,31 +1973,45 @@ return (function () {

             }

         }

-        function initButtonTracking(form){

-            var maybeSetLastButtonClicked = function(evt){

-                var elt = closest(evt.target, "button, input[type='submit']");

-                if (elt !== null) {

-                    var internalData = getInternalData(form);

-                    internalData.lastButtonClicked = elt;

-                }

-            };

-

+        // Handle submit buttons/inputs that have the form attribute set

+        // see https://developer.mozilla.org/docs/Web/HTML/Element/button

+         function maybeSetLastButtonClicked(evt) {

+            var elt = closest(evt.target, "button, input[type='submit']");

+            var internalData = getRelatedFormData(evt)

+            if (internalData) {

+              internalData.lastButtonClicked = elt;

+            }

+        };

+        function maybeUnsetLastButtonClicked(evt){

+            var internalData = getRelatedFormData(evt)

+            if (internalData) {

+              internalData.lastButtonClicked = null;

+            }

+        }

+        function getRelatedFormData(evt) {

+           var elt = closest(evt.target, "button, input[type='submit']");

+           if (!elt) {

+             return;

+           }

+           var form = resolveTarget('#' + getRawAttribute(elt, 'form')) || closest(elt, 'form');

+           if (!form) {

+             return;

+           }

+           return getInternalData(form);

+        }

+        function initButtonTracking(elt) {

             // need to handle both click and focus in:

             //   focusin - in case someone tabs in to a button and hits the space bar

             //   click - on OSX buttons do not focus on click see https://bugs.webkit.org/show_bug.cgi?id=13724

-

-            form.addEventListener('click', maybeSetLastButtonClicked)

-            form.addEventListener('focusin', maybeSetLastButtonClicked)

-            form.addEventListener('focusout', function(evt){

-                var internalData = getInternalData(form);

-                internalData.lastButtonClicked = null;

-            })

+            elt.addEventListener('click', maybeSetLastButtonClicked)

+            elt.addEventListener('focusin', maybeSetLastButtonClicked)

+            elt.addEventListener('focusout', maybeUnsetLastButtonClicked)

         }

         function countCurlies(line) {

             var tokens = tokenizeString(line);

             var netCurlies = 0;

-            for (let i = 0; i < tokens.length; i++) {

+            for (var i = 0; i < tokens.length; i++) {

                 const token = tokens[i];

                 if (token === "{") {

                     netCurlies++;

@@ -1868,13 +2024,20 @@ return (function () {

         function addHxOnEventHandler(elt, eventName, code) {

             var nodeData = getInternalData(elt);

-            nodeData.onHandlers = [];

-            var func = new Function("event", code + "; return;");

-            var listener = elt.addEventListener(eventName, function (e) {

-                return func.call(elt, e);

-            });

+            if (!Array.isArray(nodeData.onHandlers)) {

+                nodeData.onHandlers = [];

+            }

+            var func;

+            var listener = function (e) {

+                return maybeEval(elt, function() {

+                    if (!func) {

+                        func = new Function("event", code);

+                    }

+                    func.call(elt, e);

+                });

+            };

+            elt.addEventListener(eventName, listener);

             nodeData.onHandlers.push({event:eventName, listener:listener});

-            return {nodeData, code, func, listener};

         }