Prvi commit

EveryThing/wwwroot/vendor/libs/htmx.org/CHANGELOG.md

@@ -0,0 +1,258 @@
+# Changelog
+
+## [1.6.1] - 2021-11-22
+
+* A new `HX-Retarget` header allows you to change the default target of returned content
+* The `htmx:beforeSwap` event now includes another configurable property: `detail.isError` which can
+  be used to indicate if a given response should be treated as an error or not
+* The `htmx:afterRequest` event has two new detail properties: `success` and `failed`, allowing you to write 
+  trigger filters in htmx or hyperscript:
+  ```applescript
+    on htmx:afterRequest[failed]
+      set #myCheckbox's checked to true
+  ```
+* Fixed the `from:` option in [`hx-trigger`](/attributes/hx-trigger) to support `closest <CSS selector>` 
+  and `find <CSS selector>` forms
+* Don't boost anchor tags with an explicit `target` set
+* Don't cancel all events on boosted elements, only the events that naturally trigger them (click for anchors, submit
+  for forms)
+* Persist revealed state in the DOM so that on history navigation, revealed elements are not re-requested
+* Process all [`hx-ext`](/attributes/hx-ext) attributes, even if no other htmx attribute is on the element
+* Snapshot the current URL on load so that history support works properly after a page refresh occurs
+* Many, many documentation updates (thank you to all the contributors!)
+
+
+## [1.6.0] - 2021-10-01
+
+* Completely reworked `<script>` tag support that now supports the `<script src="...'/>` form
+* You can now use the value `unset` to clear a property that would normally be inherited (e.g. hx-confirm)
+* The `htmx-added` class is added to new content before a swap and removed after the settle phase, which allows you
+  more flexibility in writing CSS transitions for added content (rather than relying on the target, as with `htmx-settling`)
+* The `htmx:beforeSwap` event has been updated to allow you to [configure swapping](https://htmx.org/docs/#modifying_swapping_behavior_with_events)
+  behavior
+* Improved `<title>` extraction support
+* You can listen to events on the `window` object using the `from:` modifier in `hx-trigger`
+* The `root` option of the `intersect` event was fixed
+* Boosted forms respect the `enctype` declaration
+* The `HX-Boosted` header will be sent on requests from boosted elements
+* Promises are not returned from the main ajax function unless it is an api call (i.e. `htmx.ajax`)
+
+## [1.5.0] - 2021-7-12
+
+* Support tracking of button clicked during a form submission
+* Conditional polling via the [hx-trigger](https://htmx.org/attributes/hx-trigger) attribute
+* `document` is now a valid pseudo-selector on the [hx-trigger](https://htmx.org/attributes/hx-trigger) `from:` argument, allowing you
+  to listen for events on the document.
+* Added the [hx-request](https://htmx.org/attributes/hx-request) attribute, allowing you to configure the following aspects of the request
+    * `timeout` - the timeout of the request
+    * `credentials` - if the request will send credentials
+    * `noHeaders` - strips all headers from the request
+* Along with the above attribute, you can configure the default values for each of these via the corresponding `htmx.config`
+  properties (e.g. `htmx.config.timeout`)
+* Both the `scroll` and `show` options on [hx-swap](https://htmx.org/attributes/hx-swap) now support extended syntax for selecting the
+  element to scroll or to show, including the pseudo-selectors `window:top` and `window:bottom`.
+
+## [1.4.1] - 2021-6-1
+
+* typo fix
+
+## [1.4.0] - 2021-5-25
+
+* Added the `queue` option to the [hx-trigger](https://htmx.org/attributes/hx-trigger) attribute, allowing you to specify how events
+  should be queued when they are received with a request in flight
+* The `htmx.config.useTemplateFragments` option was added, allowing you to use HTML template tags for parsing content
+  from the server.  This allows you to use Out of Band content when returning things like table rows, but it is not
+  IE11 compatible.
+* The `defaultSettleDelay` was dropped to 20ms from 100ms
+* Introduced a new synthetic event, [intersect](https://htmx.org/docs#pecial-events) that allows you to trigger when an item is scrolled into view
+  as specified by the `IntersectionObserver` API
+* Fixed timing issue that caused exceptions in the `reveal` logic when scrolling at incredible speeds - <https://github.com/bigskysoftware/htmx/issues/463>
+* Fixed bug causing SVG titles to be incorrectly used as page title - <https://github.com/bigskysoftware/htmx/issues/459>
+* Boosted forms that issue a GET will now push the URL by default - <https://github.com/bigskysoftware/htmx/issues/485>
+* Better dispatch of request events when an element is removed from the DOM
+* Fixed a bug causing `hx-prompt` to fail
+* The `htmx.config.withCredentials` option was added, to send credentials with ajax requests (default is `false`)
+* The `throttle` option on `hx-trigger` does not delay the initial request any longer
+* The `meta` key is ignored on boosted links
+* `<script>` tags are now evaluated in the global scope
+* `hx-swap` now supports the `none` option
+* Safari text selection bug - <https://github.com/bigskysoftware/htmx/issues/438>
+  
+## [1.3.3] - 2021-4-5
+
+* Added the [`hx-disabled`](https://htmx.org/docs#security) attribute to allow htmx to be turned off for parts of the DOM
+* SSE now uses a full-jitter exponential backoff algorithm on reconnection, using the `htmx.config.wsReconnectDelay`
+  setting
+
+## [1.3.2] - 2021-3-9
+
+* Bug fixes
+
+## [1.3.1] - 2021-3-9
+
+* IE11 fixes
+
+## [1.3.0] - 2021-3-6
+
+* Support a `target` modifier on `hx-trigger` to filter based on the element targeted by an event.  This allows
+  lazy binding to that target selector.
+* Events are no longer consumed by the first element that might handle them, unless the `consume` keyword is
+  added to the `hx-trigger` specification
+* Added the `htmx:beforeSend` event, fired just before an ajax request begins
+* SSE swaps are properly settled
+* Fixed bug that was improperly cancelling all clicks on anchors
+* `htmx.ajax()` now returns a promise
+
+## [1.2.1] - 2021-2-19
+
+* Fixed an issue with the history cache, where the cache was getting blown out after the first navigation backwards
+* Added the `htmx.config.refreshOnHistoryMiss` option, allowing users to trigger a full page refresh on history cache miss
+  rather than issuing an AJAX request
+
+## [1.2.0] - 2021-2-13
+
+### New Features
+
+* `hx-vars` has been deprecated in favor of `hx-vals`
+* `hx-vals` now supports a `javascript:` prefix to achieve the behavior that `hx-vars` provided
+* The new `hx-headers` attribute allows you to add headers to a request via an attribute.  Like `hx-vals` it supports
+  JSON or javascript via the `javascript:` prefix
+* `hx-include` will now include all inputs under an element, even if that element is not a form tag
+* The [preload extension](https://htmx.org/extensions/preload/) now offers a `preload-images="true"` attribute that will aggressively load images in preloaded content
+* On requests driven by a history cache miss, the new `HX-History-Restore-Request` header is included so that the server
+  can differentiate between history requests and normal requests 
+
+### Improvements & Bug fixes
+
+* Improved handling of precedence of input values to favor the enclosing form (see [here](https://github.com/bigskysoftware/htmx/commit/a10e43d619dc340aa324d37772c06a69a2f47ec9))
+* Moved event filtering logic *after* `preventDefault` so filtering still allows events to be properly handled
+* No longer trigger after swap events on elements that have been removed via an `outerHTML` swap
+* Properly remove event handlers added to other elements when an element is removed from the DOM
+* Handle the `scroll:` modifier in `hx-swap` properly when an `outerHTML` swap occurs
+* Lots of docs fixes
+
+## [1.1.0] - 2021-1-6
+
+* Newly added [preload extension](https://htmx.org/extensions/preload/) allows you to preload resources for lower
+  latency requests!
+* Support the `ignore:` modifier for extensions
+* Updated form variable order inclusion to include the enclosing form *last* so that, in the presence of multiple 
+  values, the most relevant value is the most likely to be selected by the server
+* Support for the [`htmx.ajax()`](https://dev.htmx.org/api/#ajax) javascript function, to issue an htmx-style ajax 
+  request from javascript
+* Removed the following htmx request headers for better cache behavior: `HX-Event-Target`, `HX-Active-Element`, 
+  `HX-Active-Element-Name`, `HX-Active-Element-Value`
+* Added the [`hx-preserve`](https://dev.htmx.org/attributes/hx-preserve) attribute, which allows 
+  you to preserve elements across requests (for example, to keep a video element playing properly)
+* The [path-deps](https://dev.htmx.org/extensions/path-deps/#refresh) now surfaces a small api
+  for refreshing path dependencies manually in javascript
+* Now support the `from:` clause on [`hx-trigger`](https://dev.htmx.org/attributes/hx-trigger) to
+  allow an element to respond to events on other elements.
+* Added the `htmx:beforeProcessNode` event, renamed the (previously undocumented) `htmx:processedNode` to `htmx:afterProcessNode`
+* Added `closest` syntax support for the [`hx-indicator`](https://dev.htmx.org/attributes/hx-indicator) attribute
+* Added `on load` support for the newest version of [hyperscript](https://hyperscript.org)
+* Added the `htmx.config.allowEval` configuration value, for CSP compatibility
+* Bug fixes & improvements 
+
+## [1.0.2] - 2020-12-12
+
+* Extend all API methods to take a string selector as well as an element
+* Out of band swap elements need not be top level now
+* [`hx-swap-oob`](https://htmx.org/attributes/hx-swap-oob) now can accept a CSS selector to retarget with
+
+## [1.0.1] - 2020-12-04
+
+* AJAX file upload now correctly fires events, allowing for [a proper progress bar](https://htmx.org/examples/file-upload)
+* htmx api functions that expect an element now can accept a string selector instead:
+   ```js
+    htmx.on('#form', 'htmx:xhr:progress', function(evt) {
+      htmx.find('#progress').setAttribute('value', evt.detail.loaded/evt.detail.total * 100)
+    });
+   ```
+* htmx now properly handles the `multiple` attribute on `<select>` elements
+
+## [1.0.0] - 2020-11-24
+
+* Bumped the release version :)
+
+## [0.4.1] - 2020-11-23
+
+* Fixed bug with title tag support when title tag contained HTML entities
+* Pass properties for the `loadstart`, `loadend`, `progress`, `abort` events through properly to the htmx equivalents
+
+## [0.4.0] - 2020-11-16
+
+* Now support the `HX-Redirect` and `HX-Refresh` response headers for redirecting client side and triggering a page refresh, respectively
+* `hx-vars` now overrides input values
+* `<title>` tags in responses will be used to update page titles
+* All uses of `eval()` have been removed in favor of `Function`
+* [`hx-vals`](https://htmx.org/attributes/hx-vals) is available as a safe alternative to `hx-vars`.  It uses `JSON.parse()` rather than evaluation, if you wish to safely pass user-provided values through to htmx.
+
+## [0.3.0] - 2020-10-27
+
+* `hx-trigger` parsing has been rewritten and now supports [trigger filters](https://htmx.org/docs/#trigger-filters) to filter
+  events based on arbitrary javascript expressions
+* htmx now supports two additional response headers `HX-Trigger-After-Swap` and `HX-Trigger-After-Settle` allowing
+  an event to be triggered after a given life cycle event (instead of before the swap)
+* The `requestConfig` is now passed out to events surrounding the AJAX life cycle
+* htmx now evaluates `<script>` tags as javascript when no language is defined on them
+* A new [`event-header`](https://htmx.org/extensions/event-header) extension, which will include a serialized JSON representation of the triggering event in requests
+  
+## [0.2.0] - 2020-9-30
+
+* AJAX file upload [support](https://htmx.org/docs#files)
+* The HTML validation API is [respected](https://htmx.org/docs#validation)
+
+## [0.1.0] - 2020-9-18
+
+* *BREAKING CHANGE*: The SSE attribute [`hx-sse`](https://htmx.org/attributes/hx-sse/) and the Web Sockets attribute [`hx-ws`](https://htmx.org/attributes/hx-ws) have changed syntax to now use colon separators: `hx-sse='connect:/chat swap:message'`
+* The SSE attribute [`hx-sse`](https://htmx.org/attributes/hx-sse/) allows for swapping content directly on an event, in addition to triggering an htmx element,
+with the new `swap:<event name>` syntax.
+* [`hx-target`](https://htmx.org/attributes/hx-target) now supports a `find` syntax to find elements below the element by a CSS selector
+* htmx plays better with deferred loading and many package managers
+* All htmx events are dispatched in both camelCase as well as kebab-case, for better compatibility with AlpineJS and other frameworks.  (e.g. `htmx:afterOnLoad` will also be triggered as
+`htmx:after-on-load`)
+* [hypeerscript](https://hyperscript.org) is now initialized independently of htmx
+
+## [0.0.8] - 2020-7-8
+
+* The `view` modifier on `hx-swap` has been renamed to `show`: `hx-swap='innerHTML show:top'`
+
+## [0.0.7] - 2020-6-30
+
+* The [`hx-swap`](https://htmx.org/attributes/hx-swap) attribute now supports two new modifiers:
+    * `scroll` - allows you to scroll the target to the `top` or `bottom`
+    * `view` - allows you to scroll the `top` or `bottom` of the target into view
+* The [`hx-push-url`](https://htmx.org/attributes/hx-push-url) attribute now can optionally take a URL to push, in addition to `true` and `false`
+* Added the [`hx-vars`](https://htmx.org/attributes/hx-vars) attribute that allows you to dynamically add to the parameters that will be submitted with a request
+
+## [0.0.6] - 2020-6-20
+
+* Custom request/response headers no longer start with the `X-` prefix, which is no longer recommended
+* empty verb attributes are now allowed and follow the anchor tag semantics (e.g. `<div hx-get></div>`)
+* nunjuks inline rendering is now supported in the `client-side-templates` extension
+* the new `ajax-header` extension includes the `X-Requested-With` header
+* bad JSON is now handled more gracefully
+* `hx-swap="none"` will cause no swap to take place <https://github.com/bigskysoftware/htmx/issues/89>
+* `hx-trigger` now supports a `throttle` modifier <https://github.com/bigskysoftware/htmx/issues/88>
+* the focused element is preserved if possible after a replacement
+* perf improvements for large DOM trees with sparse `hx-` annotations
+
+## [0.0.4] - 2020-5-24
+
+* Extension mechanism added
+* SSE support added
+* WebSocket support added
+
+## [0.0.3] - 2020-5-17
+
+* Renamed to htmx
+* A bug fix for the `hx-prompt` attribute
+* A bug fix for multiple `hx-swap-oob` attributes
+* Moved the default CSS indicator injection into its own sheet to avoid breaking
+* Added the `htmx.config.includeIndicatorStyles` configuration option so people can opt out of injecting the indicator CSS
+
+
+## [0.0.1] - 2020-5-15
+
+* Initial release (originally named kutty)

EveryThing/wwwroot/vendor/libs/htmx.org/LICENSE

@@ -0,0 +1,25 @@
+BSD 2-Clause License
+
+Copyright (c) 2020, Big Sky Software
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice, this
+   list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright notice,
+   this list of conditions and the following disclaimer in the documentation
+   and/or other materials provided with the distribution.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

EveryThing/wwwroot/vendor/libs/htmx.org/README.md

@@ -0,0 +1,106 @@
+[![</> htmx](https://raw.githubusercontent.com/bigskysoftware/htmx/master/www/img/htmx_logo.1.png "high power tools for HTML")](https://htmx.org)
+
+*high power tools for HTML*
+
+[![Discord](https://img.shields.io/discord/725789699527933952)](https://htmx.org/discord)
+[![Netlify](https://img.shields.io/netlify/dba3fc85-d9c9-476a-a35a-e52a632cef78)](https://app.netlify.com/sites/htmx/deploys)
+[![Bundlephobia](https://badgen.net/bundlephobia/dependency-count/htmx.org)](https://bundlephobia.com/result?p=htmx.org)
+[![Bundlephobia](https://badgen.net/bundlephobia/minzip/htmx.org)](https://bundlephobia.com/result?p=htmx.org)
+
+
+## introduction
+
+htmx allows you to access  [AJAX](https://htmx.org/docs#ajax), [CSS Transitions](https://htmx.org/docs#css_transitions),
+[WebSockets](https://htmx.org/docs#websockets) and [Server Sent Events](https://htmx.org/docs#sse) 
+directly in HTML, using [attributes](https://htmx.org/reference#attributes), so you can build 
+[modern user interfaces](https://htmx.org/examples) with the [simplicity](https://en.wikipedia.org/wiki/HATEOAS) and 
+[power](https://www.ics.uci.edu/~fielding/pubs/dissertation/rest_arch_style.htm) of hypertext
+
+htmx is small ([~10k min.gz'd](https://unpkg.com/htmx.org/dist/)), 
+[dependency-free](https://github.com/bigskysoftware/htmx/blob/master/package.json),
+[extendable](https://htmx.org/extensions) & 
+IE11 compatible
+
+## motivation
+
+* Why should only `<a>` and `<form>` be able to make HTTP requests?
+* Why should only `click` & `submit` events trigger them?
+* Why should only GET & POST be available?
+* Why should you only be able to replace the *entire* screen?
+
+By removing these arbitrary constraints htmx completes HTML as a 
+[hypertext](https://en.wikipedia.org/wiki/Hypertext)
+
+## quick start
+
+```html
+  <!-- Load from unpkg -->
+  <script src="https://unpkg.com/htmx.org@1.6.1" ></script>
+  <!-- have a button POST a click via AJAX -->
+  <button hx-post="/clicked" hx-swap="outerHTML">
+    Click Me
+  </button>
+```
+
+The [`hx-post`](https://htmx.org/attributes/hx-post) and [`hx-swap`](https://htmx.org/attributes/hx-swap) attributes tell htmx:
+
+> "When a user clicks on this button, issue an AJAX request to /clicked, and replace the entire button with the response"
+
+htmx is the successor to [intercooler.js](http://intercoolerjs.org)
+
+### installing as a node package
+
+To install using npm:
+
+```
+npm install htmx.org --save
+```
+
+Note there is an old broken package called `htmx`.  This is `htmx.org`.
+
+## website & docs
+
+* <https://htmx.org>
+* <https://htmx.org/docs>
+
+## contributing
+
+* please write code, including tests, in ES5 for [IE 11 compatibility](https://stackoverflow.com/questions/39902809/support-for-es6-in-internet-explorer-11)
+* please include test cases in [`/test`](https://github.com/bigskysoftware/htmx/tree/dev/test) and docs in [`/www`](https://github.com/bigskysoftware/htmx/tree/dev/www)
+* if you are adding a feature, consider doing it as an [extension](https://htmx.org/extensions) instead to
+keep the core htmx code tidy
+* development pull requests should be against the `dev` branch, docs fixes can be made directly against `master`
+* No time? Then [become a sponsor](https://github.com/sponsors/bigskysoftware#sponsors)
+
+### hacking guide
+
+to develop htmx locally, you will need to install the development dependencies:
+
+* `npm install`
+
+and then run a web server in the root (easiest with python):
+
+* `python3 -m http.server
+`
+
+you can then run the test suite by navigating to:
+
+<http://0.0.0.0:8000/test/>
+
+at this point you can modify `/src/htmx.js` to add features, and then add tests in the appropriate area under `/test`
+
+* `/test/index.html` - the root test page from which all other tests are included
+* `/test/attributres` - attribute specific tests
+* `/test/core` - core functionality tests
+* `/test/core/regressions.js` - regresssion tests
+* `/test/ext` - extension tests
+* `/test/manual` - manual tests that cannot be automated
+
+htmx uses the [mocha](https://mochajs.org/) testing framework, the [chai](https://www.chaijs.com/) assertion framework 
+and [sinon](https://sinonjs.org/releases/v11.1.1/fake-xhr-and-server/) to mock out AJAX requests.  They are all OK.
+
+## haiku
+
+*javascript fatigue:<br/>
+longing for a hypertext<br/>
+already in hand*

EveryThing/wwwroot/vendor/libs/htmx.org/dist/ext/ajax-header.js

@@ -0,0 +1,7 @@
+htmx.defineExtension('ajax-header', {
+    onEvent: function (name, evt) {
+        if (name === "htmx:configRequest") {
+            evt.detail.headers['X-Requested-With'] = 'XMLHttpRequest';
+        }
+    }
+});

EveryThing/wwwroot/vendor/libs/htmx.org/dist/ext/class-tools.js

@@ -0,0 +1,84 @@
+(function(){
+
+    function splitOnWhitespace(trigger) {
+        return trigger.split(/\s+/);
+    }
+
+    function parseClassOperation(trimmedValue) {
+        var split = splitOnWhitespace(trimmedValue);
+        if (split.length > 1) {
+            var operation = split[0];
+            var classDef = split[1].trim();
+            var cssClass;
+            var delay;
+            if (classDef.indexOf(":") > 0) {
+                var splitCssClass = classDef.split(':');
+                cssClass = splitCssClass[0];
+                delay = htmx.parseInterval(splitCssClass[1]);
+            } else {
+                cssClass = classDef;
+                delay = 100;
+            }
+            return {
+                operation:operation,
+                cssClass:cssClass,
+                delay:delay
+            }
+        } else {
+            return null;
+        }
+    }
+
+    function processClassList(elt, classList) {
+        var runs = classList.split("&");
+        for (var i = 0; i < runs.length; i++) {
+            var run = runs[i];
+            var currentRunTime = 0;
+            var classOperations = run.split(",");
+            for (var j = 0; j < classOperations.length; j++) {
+                var value = classOperations[j];
+                var trimmedValue = value.trim();
+                var classOperation = parseClassOperation(trimmedValue);
+                if (classOperation) {
+                    if (classOperation.operation === "toggle") {
+                        setTimeout(function () {
+                            setInterval(function () {
+                                elt.classList[classOperation.operation].call(elt.classList, classOperation.cssClass);
+                            }, classOperation.delay);
+                        }, currentRunTime);
+                        currentRunTime = currentRunTime + classOperation.delay;
+                    } else {
+                        currentRunTime = currentRunTime + classOperation.delay;
+                        setTimeout(function () {
+                            elt.classList[classOperation.operation].call(elt.classList, classOperation.cssClass);
+                        }, currentRunTime);
+                    }
+                }
+            }
+        }
+    }
+
+    function maybeProcessClasses(elt) {
+        if (elt.getAttribute) {
+            var classList = elt.getAttribute("classes") || elt.getAttribute("data-classes");
+            if (classList) {
+                processClassList(elt, classList);
+            }
+        }
+    }
+
+    htmx.defineExtension('class-tools', {
+        onEvent: function (name, evt) {
+            if (name === "htmx:afterProcessNode") {
+                var elt = evt.detail.elt;
+                maybeProcessClasses(elt);
+                if (elt.querySelectorAll) {
+                    var children = elt.querySelectorAll("[classes], [data-classes]");
+                    for (var i = 0; i < children.length; i++) {
+                        maybeProcessClasses(children[i]);
+                    }
+                }
+            }
+        }
+    });
+})();

EveryThing/wwwroot/vendor/libs/htmx.org/dist/ext/client-side-templates.js

@@ -0,0 +1,37 @@
+htmx.defineExtension('client-side-templates', {
+    transformResponse : function(text, xhr, elt) {
+
+        var mustacheTemplate = htmx.closest(elt, "[mustache-template]");
+        if (mustacheTemplate) {
+            var data = JSON.parse(text);
+            var templateId = mustacheTemplate.getAttribute('mustache-template');
+            var template = htmx.find("#" + templateId);
+            if (template) {
+                return Mustache.render(template.innerHTML, data);
+            } else {
+                throw "Unknown mustache template: " + templateId;
+            }
+        }
+
+        var handlebarsTemplate = htmx.closest(elt, "[handlebars-template]");
+        if (handlebarsTemplate) {
+            var data = JSON.parse(text);
+            var templateName = handlebarsTemplate.getAttribute('handlebars-template');
+            return Handlebars.partials[templateName](data);
+        }
+
+        var nunjucksTemplate = htmx.closest(elt, "[nunjucks-template]");
+        if (nunjucksTemplate) {
+            var data = JSON.parse(text);
+            var templateName = nunjucksTemplate.getAttribute('nunjucks-template');
+            var template = htmx.find('#' + templateName);
+            if (template) {
+                return nunjucks.renderString(template.innerHTML, data);
+            } else {
+                return nunjucks.render(templateName, data);
+            }
+          }
+
+        return text;
+    }
+});

EveryThing/wwwroot/vendor/libs/htmx.org/dist/ext/debug.js

@@ -0,0 +1,11 @@
+htmx.defineExtension('debug', {
+    onEvent: function (name, evt) {
+        if (console.debug) {
+            console.debug(name, evt);
+        } else if (console) {
+            console.log("DEBUG:", name, evt);
+        } else {
+            throw "NO CONSOLE SUPPORTED"
+        }
+    }
+});

EveryThing/wwwroot/vendor/libs/htmx.org/dist/ext/event-header.js

@@ -0,0 +1,37 @@
+(function(){
+    function stringifyEvent(event) {
+        var obj = {};
+        for (var key in event) {
+            obj[key] = event[key];
+        }
+        return JSON.stringify(obj, function(key, value){
+            if(value instanceof Node){
+                var nodeRep = value.tagName;
+                if (nodeRep) {
+                    nodeRep = nodeRep.toLowerCase();
+                    if(value.id){
+                        nodeRep += "#" + value.id;
+                    }
+                    if(value.classList && value.classList.length){
+                        nodeRep += "." + value.classList.toString().replace(" ", ".")
+                    }
+                    return nodeRep;
+                } else {
+                    return "Node"
+                }
+            }
+            if (value instanceof Window) return 'Window';
+            return value;
+        });
+    }
+
+    htmx.defineExtension('event-header', {
+        onEvent: function (name, evt) {
+            if (name === "htmx:configRequest") {
+                if (evt.detail.triggeringEvent) {
+                    evt.detail.headers['Triggering-Event'] = stringifyEvent(evt.detail.triggeringEvent);
+                }
+            }
+        }
+    });
+})();

EveryThing/wwwroot/vendor/libs/htmx.org/dist/ext/include-vals.js

@@ -0,0 +1,24 @@
+(function(){
+
+    function mergeObjects(obj1, obj2) {
+        for (var key in obj2) {
+            if (obj2.hasOwnProperty(key)) {
+                obj1[key] = obj2[key];
+            }
+        }
+        return obj1;
+    }
+
+    htmx.defineExtension('include-vals', {
+        onEvent: function (name, evt) {
+            if (name === "htmx:configRequest") {
+                var includeValsElt = htmx.closest(evt.detail.elt, "[include-vals],[data-include-vals]");
+                if (includeValsElt) {
+                    var includeVals = includeValsElt.getAttribute("include-vals") || includeValsElt.getAttribute("data-include-vals");
+                    var valuesToInclude = eval("({" + includeVals + "})");
+                    mergeObjects(evt.detail.parameters, valuesToInclude);
+                }
+            }
+        }
+    });
+})();

EveryThing/wwwroot/vendor/libs/htmx.org/dist/ext/json-enc.js

@@ -0,0 +1,12 @@
+htmx.defineExtension('json-enc', {
+    onEvent: function (name, evt) {
+        if (name === "htmx:configRequest") {
+            evt.detail.headers['Content-Type'] = "application/json";
+        }
+    },
+    
+    encodeParameters : function(xhr, parameters, elt) {
+        xhr.overrideMimeType('text/json');
+        return (JSON.stringify(parameters));
+    }
+});

EveryThing/wwwroot/vendor/libs/htmx.org/dist/ext/method-override.js

@@ -0,0 +1,11 @@
+htmx.defineExtension('method-override', {
+    onEvent: function (name, evt) {
+        if (name === "htmx:configRequest") {
+            var method = evt.detail.verb;
+            if (method !== "get" || method !== "post") {
+                evt.detail.headers['X-HTTP-Method-Override'] = method.toUpperCase();
+                evt.detail.verb = "post";
+            }
+        }
+    }
+});

EveryThing/wwwroot/vendor/libs/htmx.org/dist/ext/morphdom-swap.js

@@ -0,0 +1,16 @@
+htmx.defineExtension('morphdom-swap', {
+    isInlineSwap: function(swapStyle) {
+        return swapStyle === 'morphdom';
+    },
+    handleSwap: function (swapStyle, target, fragment) {
+        if (swapStyle === 'morphdom') {
+            if (fragment.nodeType === Node.DOCUMENT_FRAGMENT_NODE) {
+                morphdom(target, fragment.firstElementChild);
+                return [target];
+            } else {
+                morphdom(target, fragment.outerHTML);
+                return [target];
+            }
+        }
+    }
+});

EveryThing/wwwroot/vendor/libs/htmx.org/dist/ext/path-deps.js

@@ -0,0 +1,60 @@
+(function(undefined){
+    'use strict';
+
+    // Save a reference to the global object (window in the browser)
+    var _root = this;
+  
+    function dependsOn(pathSpec, url) {
+        if (pathSpec === "ignore") {
+            return false;
+        }
+        var dependencyPath = pathSpec.split("/");
+        var urlPath = url.split("/");
+        for (var i = 0; i < urlPath.length; i++) {
+            var dependencyElement = dependencyPath.shift();
+            var pathElement = urlPath[i];
+            if (dependencyElement !== pathElement && dependencyElement !== "*") {
+                return false;
+            }
+            if (dependencyPath.length === 0 || (dependencyPath.length === 1 && dependencyPath[0] === "")) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    function refreshPath(path) {
+        var eltsWithDeps = htmx.findAll("[path-deps]");
+        for (var i = 0; i < eltsWithDeps.length; i++) {
+            var elt = eltsWithDeps[i];
+            if (dependsOn(elt.getAttribute('path-deps'), path)) {
+                htmx.trigger(elt, "path-deps");
+            }
+        }      
+    }    
+
+    htmx.defineExtension('path-deps', {
+        onEvent: function (name, evt) {
+            if (name === "htmx:beforeOnLoad") {
+                var config = evt.detail.requestConfig;
+                // mutating call
+                if (config.verb !== "get" && evt.target.getAttribute('path-deps') !== 'ignore') {
+                    refreshPath(config.path);
+                }
+            } 
+        }
+    });
+
+    /**
+     *  ********************
+     *  Expose functionality
+     *  ********************
+     */    
+
+    _root.PathDeps = {
+        refresh: function(path) {
+            refreshPath(path);
+        }
+    };
+            
+}).call(this);

EveryThing/wwwroot/vendor/libs/htmx.org/dist/ext/preload.js

@@ -0,0 +1,137 @@
+// This adds the "preload" extension to htmx.  By default, this will 
+// preload the targets of any tags with `href` or `hx-get` attributes 
+// if they also have a `preload` attribute as well.  See documentation
+// for more details
+htmx.defineExtension("preload", {
+
+	onEvent: function(name, event) {
+
+		// Only take actions on "htmx:afterProcessNode"
+		if (name !== "htmx:afterProcessNode") {
+			return;
+		}
+
+		// SOME HELPER FUNCTIONS WE'LL NEED ALONG THE WAY
+
+		// attr gets the closest non-empty value from the attribute.
+		var attr = function(node, property) {
+			if (node == undefined) {return undefined;}
+			return node.getAttribute(property) || node.getAttribute("data-" + property) || attr(node.parentElement, property)
+		}
+		
+		// load handles the actual HTTP fetch, and uses htmx.ajax in cases where we're 
+		// preloading an htmx resource (this sends the same HTTP headers as a regular htmx request)
+		var load = function(node) {
+
+			// Called after a successful AJAX request, to mark the
+			// content as loaded (and prevent additional AJAX calls.)
+			var done = function(html) {
+				node.preloadState = "DONE"
+
+				if (attr(node, "preload-images") == "true") {
+					document.createElement("div").innerHTML = html // create and populate a node to load linked resources, too.
+				}
+			}
+
+			return function() {
+
+				// If this value has already been loaded, then do not try again.
+				if (node.preloadState !== "READY") {
+					return;
+				}
+
+				// Special handling for HX-GET - use built-in htmx.ajax function
+				// so that headers match other htmx requests, then set 
+				// node.preloadState = TRUE so that requests are not duplicated
+				// in the future
+				var hxGet = node.getAttribute("hx-get") || node.getAttribute("data-hx-get")
+				if (hxGet) {
+					htmx.ajax("GET", hxGet, {handler:function(elt, info) {
+						done(info.xhr.responseText);
+					}});
+					return;
+				}
+
+				// Otherwise, perform a standard xhr request, then set 
+				// node.preloadState = TRUE so that requests are not duplicated 
+				// in the future.
+				if (node.getAttribute("href")) {
+					var r = new XMLHttpRequest();
+					r.open("GET", node.getAttribute("href"));
+					r.onload = function() {done(r.responseText);};
+					r.send();
+					return;
+				}
+			}
+		}
+
+		// This function processes a specific node and sets up event handlers.
+		// We'll search for nodes and use it below.
+		var init = function(node) {
+
+			// If this node DOES NOT include a "GET" transaction, then there's nothing to do here.
+			if (node.getAttribute("href") + node.getAttribute("hx-get") + node.getAttribute("data-hx-get") == "") {
+				return;
+			}
+
+			// Guarantee that we only initialize each node once.
+			if (node.preloadState !== undefined) {
+				return;
+			}
+			
+			// Get event name from config.
+			var on = attr(node, "preload") || "mousedown"
+						
+			// FALL THROUGH to here means we need to add an EventListener
+	
+			// Apply the listener to the node
+			node.addEventListener(on, function(evt) {
+				if (node.preloadState === "PAUSE") { // Only add one event listener
+					node.preloadState = "READY"; // Requred for the `load` function to trigger
+
+					// Special handling for "mouseover" events.  Wait 100ms before triggering load.
+					if (on === "mouseover") {
+						window.setTimeout(load(node), 100);
+					} else {
+						load(node)() // all other events trigger immediately.
+					}
+				}
+			})
+
+			// Special handling for certain built-in event handlers
+			switch (on) {
+
+				case "mouseover":
+					// Mirror `touchstart` events (fires immediately)
+					node.addEventListener("touchstart", load(node));
+
+					// WHhen the mouse leaves, immediately disable the preload
+					node.addEventListener("mouseout", function(evt) {
+						if ((evt.target === node) && (node.preloadState === "READY")) {
+							node.preloadState = "PAUSE";
+						}
+					})
+					break;
+
+				case "mousedown":
+					 // Mirror `touchstart` events (fires immediately)
+					node.addEventListener("touchstart", load(node));
+					break;
+			}
+
+			// Mark the node as ready to run.
+			node.preloadState = "PAUSE";
+			htmx.trigger(node, "preload:init") // This event can be used to load content immediately.
+		}
+
+		// Search for all child nodes that have a "preload" attribute
+		event.target.querySelectorAll("[preload]").forEach(function(node) {
+
+			// Initialize the node with the "preload" attribute
+			init(node)
+
+			// Initialize all child elements that are anchors or have `hx-get` (use with care)
+			node.querySelectorAll("a,[hx-get],[data-hx-get]").forEach(init)
+		})
+	}
+})

EveryThing/wwwroot/vendor/libs/htmx.org/dist/ext/rails-method.js

@@ -0,0 +1,10 @@
+htmx.defineExtension('rails-method', {
+    onEvent: function (name, evt) {
+        if (name === "configRequest.htmx") {
+            var methodOverride = evt.detail.headers['X-HTTP-Method-Override'];
+            if (methodOverride) {
+                evt.detail.parameters['_method'] = methodOverride;
+            }
+        }
+    }
+});

EveryThing/wwwroot/vendor/libs/htmx.org/dist/ext/remove-me.js

@@ -0,0 +1,27 @@
+(function(){
+    function maybeRemoveMe(elt) {
+        var timing = elt.getAttribute("remove-me") || elt.getAttribute("data-remove-me");
+        if (timing) {
+            setTimeout(function () {
+                elt.parentElement.removeChild(elt);
+            }, htmx.parseInterval(timing));
+        }
+    }
+
+    htmx.defineExtension('remove-me', {
+        onEvent: function (name, evt) {
+            if (name === "htmx:afterProcessNode") {
+                var elt = evt.detail.elt;
+                if (elt.getAttribute) {
+                    maybeRemoveMe(elt);
+                    if (elt.querySelectorAll) {
+                        var children = elt.querySelectorAll("[remove-me], [data-remove-me]");
+                        for (var i = 0; i < children.length; i++) {
+                            maybeRemoveMe(children[i]);
+                        }
+                    }
+                }
+            }
+        }
+    });
+})();

EveryThing/wwwroot/vendor/libs/htmx.org/package.json

@@ -0,0 +1,73 @@
+{
+  "_from": "htmx.org@~1.6.1",
+  "_id": "htmx.org@1.6.1",
+  "_inBundle": false,
+  "_integrity": "sha512-i+1k5ee2eFWaZbomjckyrDjUpa3FMDZWufatUSBmmsjXVksn89nsXvr1KLGIdAajiz+ZSL7TE4U/QaZVd2U2sA==",
+  "_location": "/htmx.org",
+  "_phantomChildren": {},
+  "_requested": {
+    "type": "range",
+    "registry": true,
+    "raw": "htmx.org@~1.6.1",
+    "name": "htmx.org",
+    "escapedName": "htmx.org",
+    "rawSpec": "~1.6.1",
+    "saveSpec": null,
+    "fetchSpec": "~1.6.1"
+  },
+  "_requiredBy": [
+    "/"
+  ],
+  "_resolved": "https://registry.npmjs.org/htmx.org/-/htmx.org-1.6.1.tgz",
+  "_shasum": "6f0d59a93fa61cbaa15316c134a2f179045a5778",
+  "_spec": "htmx.org@~1.6.1",
+  "_where": "D:\\EveryThing\\EveryThing\\EveryThing",
+  "bugs": {
+    "url": "https://github.com/bigskysoftware/htmx/issues"
+  },
+  "bundleDependencies": false,
+  "deprecated": false,
+  "description": "high power tools for html",
+  "devDependencies": {
+    "@11ty/eleventy": "^0.10.0",
+    "@11ty/eleventy-plugin-rss": "^1.1.1",
+    "chai": "^4.3.4",
+    "eleventy-plugin-sass": "^1.2.0",
+    "fs-extra": "^9.1.0",
+    "mocha": "^7.2.0",
+    "mocha-chrome": "^2.2.0",
+    "sass": "^1.34.0",
+    "sinon": "^9.2.4",
+    "typescript": "^4.3.5",
+    "uglify-js": "^3.13.7"
+  },
+  "files": [
+    "LICENSE",
+    "README.md",
+    "dist/*.js",
+    "dist/ext/*.js",
+    "dist/*.js.gz"
+  ],
+  "homepage": "https://htmx.org/",
+  "keywords": [
+    "AJAX",
+    "HTML"
+  ],
+  "license": "BSD 2-Clause",
+  "main": "dist/htmx.min.js",
+  "name": "htmx.org",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/bigskysoftware/htmx.git"
+  },
+  "scripts": {
+    "dist": "cp -r src/* dist/ && npm run-script uglify && gzip -k -f dist/htmx.min.js > dist/htmx.min.js.gz && exit",
+    "test": "mocha-chrome test/index.html",
+    "test-types": "tsc --project ./jsconfig.json",
+    "uglify": "uglifyjs -m eval -o dist/htmx.min.js dist/htmx.js",
+    "www": "node scripts/www.js"
+  },
+  "types": "src/htmx.d.ts",
+  "unpkg": "dist/htmx.min.js",
+  "version": "1.6.1"
+}