package tags
import (
	"net/http"
	"webster/MemoryLane/data"
	"webster/MemoryLane/graphStore"
	"webster/MemoryLane/web/components"
	"webster/MemoryLane/web/exceptions"
	g "github.com/christophersw/gomponents-htmx"
	"github.com/rs/zerolog/log"
)
func UpdateTags(w http.ResponseWriter, r *http.Request) {
	ctx := r.Context()
	item := ctx.Value("item").(data.GraphNode)
	updateMessage := ctx.Value("message").(string)
	tags, err := data.GetItemTags(item, graphStore.GetGraphManager(), graphStore.GetGpart())
	if err != nil {
		log.Error().Err(err).Msg("Error getting tags")
		exceptions.ErrorPage(w, "Error getting tags")
		return
	}
	comps := []g.Node{}
	comps = append(comps, components.Tags(item, tags, true, r))
	comps = append(comps, components.UpdateText(updateMessage))
	comps = append(comps, components.TagList(true))
	for _, comp := range comps {
		err := comp.Render(w)
		if err != nil {
			log.Error().Err(err).Msg("Error rendering remove tag response")
		}
	}
}

package tags
import (
	"context"
	"net/http"
	"webster/MemoryLane/data"
	"webster/MemoryLane/graphStore"
	"webster/MemoryLane/web/exceptions"
	"github.com/rs/zerolog/log"
)
func RemoveTagCtx(next http.Handler) http.Handler {
	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		var ctx context.Context
		gm := graphStore.GetGraphManager()
		gpart := graphStore.GetGpart()
		err := r.ParseForm()
		if err != nil {
			log.Error().Err(err).Msg("Error parsing form")
			exceptions.ErrorPage(w, "Error parsing form")
			return
		}
		key := r.PostForm.Get("item-key")
		kind := r.PostForm.Get("item-kind")
		tagKey := r.PostForm.Get("tag-key")
		tag, err := data.GetTagByKey(tagKey, gm, gpart)
		if err != nil {
			log.Error().Err(err).Msg("Error getting tag")
			exceptions.ErrorPage(w, "Error getting tag")
			return
		}
		node := data.GraphNode{
			Key:  key,
			Kind: kind,
		}
		err = tag.RemoveTag(node, gm, gpart)
		if err != nil {
			log.Error().Err(err).Msg("Error removing tag")
			exceptions.ErrorPage(w, "Error removing tag")
			return
		}
		ctx = context.WithValue(r.Context(), "item", node)
		ctx = context.WithValue(ctx, "message", "🏷️ Removed tag.")
		next.ServeHTTP(w, r.WithContext(ctx))
	})
}

package tags
import (
	"context"
	"net/http"
	"strings"
	"webster/MemoryLane/data"
	"webster/MemoryLane/graphStore"
	"webster/MemoryLane/web/exceptions"
	"github.com/rs/zerolog/log"
)
func BulkTagCtx(next http.Handler) http.Handler {
	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		var ctx context.Context
		gm := graphStore.GetGraphManager()
		gpart := graphStore.GetGpart()
		err := r.ParseForm()
		if err != nil {
			log.Error().Err(err).Msg("Error parsing form")
			exceptions.ErrorPage(w, "Error parsing form")
			return
		}
		resultsDisplay := r.PostForm.Get("results-display")
		var items []data.GraphNode
		var formTags []string
		for i, formValue := range r.PostForm {
			if formValue[0] == "on" {
				items = append(items, data.GraphNode{
					Key:  strings.Split(i, "-")[1],
					Kind: strings.Split(i, "-")[0],
				})
				continue
			}
			if i == "bulk-tag-string" {
				formTags = strings.Split(formValue[0], ",")
			}
		}
		for i := 0; i < len(formTags); i++ {
			formTag := strings.TrimSpace(formTags[i])
			tag, err := data.GetTagByName(formTag, gm, gpart)
			if err != nil {
				log.Error().Err(err).Msg("Error getting tag")
				exceptions.ErrorPage(w, "Error getting tag")
				return
			}
			// If this tag doesn't exist, create it
			if tag.GraphNode.Key == "" {
				tag = data.Tag{
					Name: formTags[i],
					GraphNode: data.GraphNode{
						Key:  "",
						Kind: "Tag",
					},
				}
				err := tag.Upsert(gm, gpart)
				if err != nil {
					log.Error().Err(err).Msg("Error upserting tag")
					exceptions.ErrorPage(w, "Error upserting tag")
					return
				}
			}
			for _, item := range items {
				err := tag.SetTag(item, gm, gpart)
				if err != nil {
					log.Error().Err(err).Msg("Error setting tag")
					exceptions.ErrorPage(w, "Error setting tag")
					return
				}
			}
		}
		ctx = context.WithValue(r.Context(), "items", items)
		ctx = context.WithValue(ctx, "results-display", resultsDisplay)
		next.ServeHTTP(w, r.WithContext(ctx))
	})
}

package tags
import (
	"fmt"
	"net/http"
	"webster/MemoryLane/data"
	"webster/MemoryLane/graphStore"
	"webster/MemoryLane/web/components"
	g "github.com/christophersw/gomponents-htmx"
	"github.com/rs/zerolog/log"
)
func BulkTag(w http.ResponseWriter, r *http.Request) {
	ctx := r.Context()
	items := ctx.Value("items").([]data.GraphNode)
	resultsDisplay := ctx.Value("results-display").(string)
	comps := make([]g.Node, 0)
	var photos []data.Photo
	for _, result := range items {
		photo, err := data.GetPhotoByKey(result.Key, true, true, true, graphStore.GetGraphManager(), graphStore.GetGpart())
		if err != nil {
			log.Error().Err(err).Msg("Error in search")
			return
		}
		if photo.ProcessedPreviews == "true" {
			photos = append(photos, photo)
		}
	}
	for _, photo := range photos {
		comps = append(comps, components.ImageTile(photo, resultsDisplay, true, r),
			components.Tags(photo.GraphNode, photo.Tags, true, r),
		)
	}
	comps = append(comps, components.TagList(true))
	comps = append(comps, components.UpdateText(fmt.Sprintf("🏷️ %d items tagged!", len(items))))
	for _, comp := range comps {
		err := comp.Render(w)
		if err != nil {
			log.Error().Err(err).Msg("Error rendering bulk tag add response")
		}
	}
}

package tags
import (
	"context"
	"net/http"
	"strings"
	"webster/MemoryLane/data"
	"webster/MemoryLane/graphStore"
	"webster/MemoryLane/web/exceptions"
	"github.com/rs/zerolog/log"
)
func AddTagCtx(next http.Handler) http.Handler {
	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		var ctx context.Context
		gm := graphStore.GetGraphManager()
		gpart := graphStore.GetGpart()
		err := r.ParseForm()
		if err != nil {
			log.Error().Err(err).Msg("Error parsing form")
			exceptions.ErrorPage(w, "Error parsing form")
			return
		}
		key := r.PostForm.Get("item-key")
		kind := r.PostForm.Get("item-kind")
		item := data.GraphNode{
			Key:  key,
			Kind: kind,
		}
		var formTags []string
		for i, formValue := range r.PostForm {
			if i == "tag-string" {
				formTags = strings.Split(formValue[0], ",")
			}
		}
		for i := 0; i < len(formTags); i++ {
			formTag := strings.TrimSpace(formTags[i])
			formTag = strings.ToLower(formTag)
			tag, err := data.GetTagByName(formTag, gm, gpart)
			if err != nil {
				log.Error().Err(err).Msg("Error getting tag")
				exceptions.ErrorPage(w, "Error getting tag")
				return
			}
			// If this tag doesn't exist, create it
			if tag.GraphNode.Key == "" {
				tag = data.Tag{
					Name: formTag,
					GraphNode: data.GraphNode{
						Key:  "",
						Kind: "Tag",
					},
				}
				err := tag.Upsert(gm, gpart)
				if err != nil {
					log.Error().Err(err).Msg("Error upserting tag")
					exceptions.ErrorPage(w, "Error upserting tag")
					return
				}
			}
			err = tag.SetTag(item, gm, gpart)
			if err != nil {
				log.Error().Err(err).Msg("Error setting tag")
				exceptions.ErrorPage(w, "Error setting tag")
				return
			}
		}
		ctx = context.WithValue(r.Context(), "item", item)
		ctx = context.WithValue(ctx, "message", "🏷️ Added tag.")
		next.ServeHTTP(w, r.WithContext(ctx))
	})
}

package sideView
import (
	"context"
	"net/http"
	"webster/MemoryLane/data"
	"webster/MemoryLane/graphStore"
	"github.com/go-chi/chi/v5"
)
func PhotoCtx(next http.Handler) http.Handler {
	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		gm := graphStore.GetGraphManager()
		gpart := graphStore.GetGpart()
		photoKey := chi.URLParam(r, "photoKey")
		p, err := data.GetPhotoByKey(photoKey, true, true, true, gm, gpart)
		if err != nil || p.GraphNode.Key == "" {
			http.Error(w, http.StatusText(http.StatusNotFound), http.StatusNotFound)
			return
		}
		ctx := context.WithValue(r.Context(), "photo", p)
		next.ServeHTTP(w, r.WithContext(ctx))
	})
}

package sideView
import (
	"net/http"
	"webster/MemoryLane/data"
	"webster/MemoryLane/web/components"
	g "github.com/christophersw/gomponents-htmx"
	. "github.com/christophersw/gomponents-htmx/html"
	"github.com/rs/zerolog/log"
)
func Photo(w http.ResponseWriter, r *http.Request) {
	ctx := r.Context()
	photo := ctx.Value("photo").(data.Photo)
	comp := Div(
		components.SideViewPhoto(photo, false, r),
		Div(ID("side-tagger"), Class(""),
			FormEl(
				Class("relative"),
				Action("/tags/add"),
				Span(Class("z-10 absolute left-0  text-lg p-2"),
					g.Text("🏷️ "),
					Img(ID("tag-spinner"), Class("htmx-indicator search-spinner-image absolute left-0"), Src("/css/spinner.svg")),
				),
				Input(Class("hidden"), Type("hidden"), Name("item-key"), Value(photo.GraphNode.Key)),
				Input(Class("hidden"), Type("hidden"), Name("item-kind"), Value(photo.GraphNode.Kind)),
				Input(Class("px-3 py-3 placeholder-gray-400 text-gray-600 relative bg-white bg-white rounded text-sm border border-opal-dark outline-none focus:outline-none focus:ring w-full pl-10"),
					g.Attr("list", "tag-list"),
					Type("text"),
					Placeholder("Add tag"),
					Name("tag-string"),
				),
				components.CsrfInputToken(r),
				HxSwap("none"),
				HxPost("/tags/add"),
				HxIndicator("#tag-spinner"),
			),
		),
	)
	err := comp.Render(w)
	if err != nil {
		log.Error().Err(err).Msg("Error rendering photo page")
		return
	}
}

package web
import (
	"context"
	"fmt"
	"os"
	"os/exec"
	"path/filepath"
	"strings"
	"time"
	"net/http"
	"webster/MemoryLane/global"
	"webster/MemoryLane/web/captions"
	"webster/MemoryLane/web/favorites"
	"webster/MemoryLane/web/login"
	"webster/MemoryLane/web/photos"
	"webster/MemoryLane/web/search"
	"webster/MemoryLane/web/security"
	"webster/MemoryLane/web/sideView"
	"webster/MemoryLane/web/tags"
	"github.com/go-chi/chi/v5"
	"github.com/go-chi/chi/v5/middleware"
	"github.com/rs/zerolog/log"
)
func Server() {
	fmt.Println("\033[2J")
	fmt.Println("*********************")
	fmt.Println("* Running Server    *")
	fmt.Println("*********************")
	fmt.Println("Building CSS")
	cmd := exec.Command("npx", "tailwindcss", "-o", "css/tailwind.css")
	stdout, err := cmd.Output()
	fmt.Println(string(stdout))
	if err != nil {
		fmt.Println(err.Error())
		return
	}
	r := chi.NewRouter()
	r.Use(middleware.Logger)
	// A good base middleware stack
	r.Use(middleware.RequestID)
	r.Use(middleware.RealIP)
	r.Use(middleware.Logger)
	r.Use(middleware.Recoverer)
	r.Use(middleware.Compress(5))
	// Set a timeout value on the request context (ctx), that will signal
	// through ctx.Done() that the request has timed out and further
	// processing should be stopped.
	r.Use(middleware.Timeout(90 * time.Second))
	/**************
	* S E A R C H *
	***************/
	r.Route("/", func(r chi.Router) {
		r.Use(security.SecurityCtx)
		r.Use(security.CSRFMiddleware())
		r.Use(search.SearchCtx)
		r.Get("/", search.SearchPage)
		r.Post("/results", search.Results)
	})
	/*******************
	* S I D E V I E W  *
	********************/
	r.Route("/side-view", func(r chi.Router) {
		r.Use(security.SecurityCtx)
		r.Use(security.CSRFMiddleware())
		r.Route("/photo/{photoKey}", func(r chi.Router) {
			r.Use(sideView.PhotoCtx)
			r.Get("/", sideView.Photo)
		})
	})
	/***********
	* T A G S  *
	************/
	r.Route("/tags", func(r chi.Router) {
		r.Use(security.SecurityCtx)
		r.Use(security.CSRFMiddleware())
		//r.Get("/", search.SearchPage)
		r.Route("/bulk-add", func(r chi.Router) {
			r.Use(tags.BulkTagCtx)
			r.Post("/", tags.BulkTag)
		})
		r.Route("/remove", func(r chi.Router) {
			r.Use(tags.RemoveTagCtx)
			r.Post("/", tags.UpdateTags)
		})
		r.Route("/add", func(r chi.Router) {
			r.Use(tags.AddTagCtx)
			r.Post("/", tags.UpdateTags)
		})
	})
	/******************
	* C A P T I O N S *
	*******************/
	r.Route("/caption", func(r chi.Router) {
		r.Use(security.SecurityCtx)
		r.Use(security.CSRFMiddleware())
		r.Route("/form", func(r chi.Router) {
			r.Use(captions.EditCaptionFormCtx)
			r.Post("/", captions.EditCaptionForm)
		})
		r.Route("/update", func(r chi.Router) {
			r.Use(captions.UpdateCaptionsCtx)
			r.Post("/", captions.UpdateCaption)
		})
	})
	/********************
	* F A V O R I T E S *
	*********************/
	r.Route("/favorites", func(r chi.Router) {
		r.Use(security.SecurityCtx)
		r.Use(security.CSRFMiddleware())
		r.Use(favorites.FavoritesCtx)
		r.Post("/", favorites.Favorite)
	})
	/**************
	* P H O T O S *
	***************/
	r.Route("/photos", func(r chi.Router) {
		r.Use(security.SecurityCtx)
		// Subrouters:
		r.Route("/{photoKey}", func(r chi.Router) {
			r.Use(photos.PhotoCtx)
			r.Get("/", photos.GetPhoto) // GET /photos/123
		})
	})
	/*************
	* L O G I N  *
	**************/
	r.Route("/login", func(r chi.Router) {
		r.Use(security.CSRFMiddleware())
		r.Get("/", login.LoginPage)  // GET /login
		r.Post("/", login.PostLogin) // POST /login
		r.Get("/logout", login.Logout)
	})
	/***************
	* S T A T I C  *
	****************/
	workDir, _ := os.Getwd()
	previews := http.Dir(filepath.Join(workDir, "previews"))
	css := http.Dir(filepath.Join(workDir, "css"))
	js := http.Dir(filepath.Join(workDir, "js"))
	r.Route("/files", func(r chi.Router) {
		r.Use(security.SecurityCtx)
		FileServer(r, "/previews", previews)
	})
	FileServer(r, "/css", css)
	FileServer(r, "/js", js)
	// TODO - Port should be set from config
	fmt.Printf("Starting server at port 8080\n")
	s := http.Server{Addr: ":8080", Handler: r}
	go s.ListenAndServe()
	global.RegisterShutdownAction(func() {
		log.Info().Msg("Server shutting down.")
		fmt.Println("Server shutting down.")
		s.Shutdown(context.Background())
	})
	// Keep this process running until an interrupt signal is received.
	<-global.GetGlobalContext().Done()
}
// FileServer conveniently sets up a http.FileServer handler to serve
// static files from a http.FileSystem.
func FileServer(r chi.Router, path string, root http.FileSystem) {
	if strings.ContainsAny(path, "{}*") {
		panic("FileServer does not permit any URL parameters.")
	}
	if path != "/" && path[len(path)-1] != '/' {
		r.Get(path, http.RedirectHandler(path+"/", 301).ServeHTTP)
		path += "/"
	}
	path += "*"
	r.Get(path, func(w http.ResponseWriter, r *http.Request) {
		rctx := chi.RouteContext(r.Context())
		pathPrefix := strings.TrimSuffix(rctx.RoutePattern(), "/*")
		fs := http.StripPrefix(pathPrefix, http.FileServer(root))
		fs.ServeHTTP(w, r)
	})
}

package security
import (
	"context"
	"fmt"
	"net/http"
	"webster/MemoryLane/data"
	"webster/MemoryLane/graphStore"
)
func SecurityCtx(next http.Handler) http.Handler {
	var ctx context.Context
	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		s := NewSecureCookie()
		if cookie, err := r.Cookie("auth"); err == nil {
			value := make(map[string]string)
			if err = s.Decode("auth", cookie.Value, &value); err == nil {
				user, err := data.GetUserByKey(value["key"], true, graphStore.GetGraphManager(), graphStore.GetGpart())
				if err != nil {
					w.WriteHeader(http.StatusInternalServerError)
					fmt.Fprint(w, "Internal Server Error")
					return
				}
				ctx = context.WithValue(r.Context(), "user", user)
				next.ServeHTTP(w, r.WithContext(ctx))
				return
			}
		}
		http.Redirect(w, r, fmt.Sprintf("/login?redirect=%s", r.URL.Path), http.StatusFound)
	})
}

package security
import "github.com/gorilla/securecookie"
var _initializedCookies = false
var _hashKey []byte
var _blockKey []byte
func NewSecureCookie() *securecookie.SecureCookie {
	if !_initializedCookies {
		initializeCookies()
	}
	return securecookie.New(_hashKey, _blockKey)
}
// TODO - This should be called on a timed basis to reset the keys
func ResetCookieKeys() {
	_hashKey = securecookie.GenerateRandomKey(32)
	if _hashKey == nil {
		panic("Error generating hash key")
	}
	_blockKey = securecookie.GenerateRandomKey(32)
	if _blockKey == nil {
		panic("error generating block key")
	}
}
func initializeCookies() {
	ResetCookieKeys()
	_initializedCookies = true
	return
}

package security
import (
	"net/http"
	"github.com/gorilla/csrf"
	"github.com/spf13/viper"
)
var _initialized = false
var _csrfKey []byte
func CSRFMiddleware() func(http.Handler) http.Handler {
	if !_initialized {
		initializeCSRF()
	}
	runLevel := viper.GetString("RunLevel")
	switch runLevel {
	case "development":
		return csrf.Protect([]byte(_csrfKey), csrf.Secure(false))
	case "production":
		return csrf.Protect([]byte(_csrfKey), csrf.Secure(true))
	default:
		return csrf.Protect([]byte(_csrfKey), csrf.Secure(true))
	}
}
func initializeCSRF() {
	_csrfKey = []byte(viper.GetString("CSRFKey"))
	_initialized = true
}

package search
import (
	"fmt"
	"net/http"
	"webster/MemoryLane/data"
	"webster/MemoryLane/web/components"
	"webster/MemoryLane/web/layouts"
	g "github.com/christophersw/gomponents-htmx"
	. "github.com/christophersw/gomponents-htmx/html"
)
func SearchPage(w http.ResponseWriter, r *http.Request) {
	ctx := r.Context()
	user := ctx.Value("user").(data.User)
	radioPanelButtons := []components.RadioPanelButton{
		{Name: "small", Label: "small", Value: "small", Checked: true},
		{Name: "medium", Label: "medium", Value: "medium", Checked: false},
		{Name: "polaroid", Label: "polaroid", Value: "polaroid", Checked: false},
	}
	b := Div(Class("w-full space-y-4"),
		Div(Class("flew w-full"),
			Div(Class("flex p-5 w-full"),
				FormEl(
					Class("flex-grow w-full bulk-form relative"),
					Action("/results"),
					Span(Class("z-10 absolute left-0  text-lg p-2"),
						g.Text("🔍"),
						Img(ID("search-spinner"), Class("htmx-indicator search-spinner-image absolute left-0"), Src("/css/spinner.svg")),
					),
					Input(Class("px-3 py-3 pl-10 placeholder-gray-light text-dark relative bg-white bg-white rounded text-sm border border-opal-dark outline-none focus:outline-none focus:ring w-full"),
						Type("text"),
						Placeholder(fmt.Sprintf("Hello %s, search here to wander Memory Lane", user.UserName)),
						Name("search-string"),
					),
					components.CsrfInputToken(r),
					Div(Class("float-right p-4"),
						components.RadioPanel("results-display", radioPanelButtons, "/results", "#search-results", "#search-spinner"),
						//components.Toggle("size-medium", "small", "large", "/results", "#search-results", "#search-spinner"),
					),
					Div(ID("bulk-tagger")),
					HxPost("/results"),
					HxTarget("#search-results"),
					HxIndicator("#search-spinner"),
				),
			),
		),
		Div(Class(""),
			Div(Class("flex p-5 z-10 bulk-form"),
				ID("search-results"),
			),
		),
	)
	_ = layouts.SidebarView("Search", r.URL.Path, b, nil, true).Render(w)
}

package search
import (
	"context"
	"time"
	"net/http"
	"webster/MemoryLane/data"
	"webster/MemoryLane/web/exceptions"
	"github.com/rs/zerolog/log"
)
func SearchCtx(next http.Handler) http.Handler {
	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		var ctx context.Context
		var results = []data.GraphNode{}
		var err error
		t1 := time.Now()
		err = r.ParseForm()
		if err != nil {
			log.Error().Err(err).Msg("Error parsing form")
			exceptions.ErrorPage(w, "Error parsing form")
			return
		}
		searchString := r.PostForm.Get("search-string")
		resultsDisplay := r.PostForm.Get("results-display")
		user := r.Context().Value("user").(data.User)
		results, err = data.Search(searchString, nil, user, nil)
		if err != nil {
			http.Error(w, err.Error(), http.StatusInternalServerError)
			return
		}
		ctx = context.WithValue(r.Context(), "results", results)
		ctx = context.WithValue(ctx, "results-display", resultsDisplay)
		ctx = context.WithValue(ctx, "t1", t1)
		next.ServeHTTP(w, r.WithContext(ctx))
	})
}

package search
import (
	"fmt"
	"net/http"
	"sort"
	"time"
	"webster/MemoryLane/data"
	"webster/MemoryLane/graphStore"
	"webster/MemoryLane/web/components"
	g "github.com/christophersw/gomponents-htmx"
	. "github.com/christophersw/gomponents-htmx/html"
	"github.com/rs/zerolog/log"
)
func Results(w http.ResponseWriter, r *http.Request) {
	ctx := r.Context()
	results := ctx.Value("results").([]data.GraphNode)
	resultsDisplay := ctx.Value("results-display").(string)
	t1 := ctx.Value("t1").(time.Time)
	tiles := make([]g.Node, 0)
	gm := graphStore.GetGraphManager()
	gpart := graphStore.GetGpart()
	//TODO Eventually this will need to track items that aren't just photos.
	var photos []data.Photo
	for _, result := range results {
		photo, err := data.GetPhotoByKey(result.Key, true, true, true, gm, gpart)
		if err != nil {
			log.Error().Err(err).Msg("Error in search")
			return
		}
		if photo.ProcessedPreviews == "true" {
			photos = append(photos, photo)
		}
	}
	sort.SliceStable(photos, func(i, j int) bool {
		return photos[i].DateTaken.After((photos[j].DateTaken))
	})
	for _, photo := range photos {
		tiles = append(tiles, components.ImageTile(photo, resultsDisplay, false, r))
	}
	comps := []g.Node{}
	comps = append(comps, g.Group(tiles),
		components.TagList(true),
		components.UpdateText(fmt.Sprintf("🔍  %d results found in %s.", len(photos), time.Since(t1).String())),
	)
	if len(photos) > 0 {
		comps = append(comps, BulkTagger(true, r))
	}
	b := Div(Class("flex-grow"),
		g.Group(comps),
	)
	w.Header().Set("Content-Type", "text/html")
	err := b.Render(w)
	if err != nil {
		log.Error().Err(err).Msg("Error in search")
		return
	}
}

package search
import (
	"net/http"
	"webster/MemoryLane/web/components"
	g "github.com/christophersw/gomponents-htmx"
	. "github.com/christophersw/gomponents-htmx/html"
)
func BulkTagger(oobSwap bool, r *http.Request) (comp g.Node) {
	oob := ""
	if oobSwap {
		oob = "outerHTML:#bulk-tagger"
	}
	comp = Div(ID("bulk-tagger"), Class("flex-grow p-2  w-1/2 float-left"),
		HxSwapOob(oob),
		FormEl(
			Class("flex-grow w-full bulk-form relative"),
			Action("/tags/bulk-add"),
			Span(Class("z-10 absolute left-0  text-lg p-2"),
				g.Text("🏷️ "),
				Img(ID("tag-spinner"), Class("htmx-indicator search-spinner-image absolute left-0"), Src("/css/spinner.svg")),
			),
			Input(Class("px-3 py-3 placeholder-gray-light text-gray-dark relative bg-white bg-white rounded text-sm border border-opal-dark outline-none focus:outline-none focus:ring w-full pl-10"),
				g.Attr("list", "tag-list"),
				Type("text"),
				Placeholder("Add tag to selected images"),
				Name("bulk-tag-string"),
			),
			components.CsrfInputToken(r),
			HxSwap("none"),
			HxInclude(".bulk-form"),
			HxPost("/tags/bulk-add"),
			HxIndicator("#tag-spinner"),
		),
	)
	return
}

package photos
import (
	"net/http"
	"webster/MemoryLane/data"
	"webster/MemoryLane/web/components"
	"webster/MemoryLane/web/layouts"
	g "github.com/maragudk/gomponents"
	. "github.com/maragudk/gomponents/html"
	"github.com/rs/zerolog/log"
)
func GetPhoto(w http.ResponseWriter, r *http.Request) {
	log.Debug().Msg("Building Photo Page")
	ctx := r.Context()
	photo := ctx.Value("photo").(data.Photo)
	b := Div(Class("container mx-auto"),
		H1(g.Textf("Photo Page for %s", photo.GraphNode.Name)),
		components.CardWithImage(photo),
	)
	_ = layouts.SidebarView("Photo", r.URL.Path, b, nil, true).Render(w)
}

package photos
import (
	"context"
	"net/http"
	"webster/MemoryLane/data"
	"webster/MemoryLane/graphStore"
	"github.com/go-chi/chi/v5"
)
func PhotoCtx(next http.Handler) http.Handler {
	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		gm := graphStore.GetGraphManager()
		gpart := graphStore.GetGpart()
		photoKey := chi.URLParam(r, "photoKey")
		p, err := data.GetPhotoByKey(photoKey, true, true, true, gm, gpart)
		if err != nil || p.GraphNode.Key == "" {
			http.Error(w, http.StatusText(http.StatusNotFound), http.StatusNotFound)
			return
		}
		ctx := context.WithValue(r.Context(), "photo", p)
		next.ServeHTTP(w, r.WithContext(ctx))
	})
}

package login
import (
	"net/http"
	"time"
	"webster/MemoryLane/data"
	"webster/MemoryLane/graphStore"
	"webster/MemoryLane/web/components"
	"webster/MemoryLane/web/exceptions"
	"webster/MemoryLane/web/layouts"
	"webster/MemoryLane/web/security"
	g "github.com/christophersw/gomponents-htmx"
	"github.com/rs/zerolog/log"
	"github.com/spf13/viper"
	. "github.com/christophersw/gomponents-htmx/html"
)
func LoginPage(w http.ResponseWriter, r *http.Request) {
	b := Div(Class("flex flex-col items-center justify-center min-h-screen bg-gray"),
		FormEl(Class("bg-gray-paper w-full sm:w-3/4 max-w-lg p-12 pb-6 shadow-2xl rounded"),
			Action(r.RequestURI),
			Method("post"),
			Div(Class("text-gray-dark pb-4 text-3xl font-semibold"), g.Text("Memory Lane")),
			Input(Class("block text-gray p-1 m-4 ml-0 w-full rounded text-lg font-normal placeholder-gray-lighter active:border-opal required:border-gold invalid:border-red valid:border-opal-dark"),
				Name("username"),
				ID("username"),
				Type("text"),
				Placeholder("your username"),
				Required(),
			),
			Input(Class("block text-gray p-1 m-4 ml-0 w-full rounded text-lg font-normal placeholder-gray-lighter required:border-gold invalid:border-red valid:border-opal-dark"),
				Name("password"),
				ID("password"),
				Type("password"),
				Placeholder("your password"),
				Required(),
			),
			components.CsrfInputToken(r),
			Button(Class("inline-block mt-2 bg-opal-dark hover:bg-opal focus:bg-opal px-6 py-2 rounded text-gray-dark shadow-lg"),
				g.Text("Login"),
				Type("submit"),
			),
		),
	)
	_ = layouts.EmptyPage("Login", r.URL.Path, b).Render(w)
}
func LoginPageWithMessage(w http.ResponseWriter, r *http.Request, message string) {
	b := Div(Class("flex flex-col items-center justify-center min-h-screen bg-gray"),
		FormEl(Class("bg-gray-paper w-full sm:w-3/4 max-w-lg p-12 pb-6 shadow-2xl rounded"),
			Action(r.URL.Path),
			Method("post"),
			components.WarningAlert(message),
			Div(Class("text-gray-dark pb-4 text-3xl font-semibold"), g.Text("Memory Lane")),
			Input(Class("block text-gray-black p-1 m-4 ml-0 w-full rounded text-lg font-normal placeholder-gray-300"),
				Name("username"),
				ID("username"),
				Type("text"),
				Placeholder("your username"),
			),
			Input(Class("block text-gray-black p-1 m-4 ml-0 w-full rounded text-lg font-normal placeholder-gray-300"),
				Name("password"),
				ID("password"),
				Type("password"),
				Placeholder("your password"),
			),
			components.CsrfInputToken(r),
			Button(Class("inline-block mt-2 bg-opal-dark hover:bg-opal focus:bg-opal px-6 py-2 rounded text-gray-dark shadow-lg"),
				g.Text("Login"),
				Type("submit"),
			),
		),
	)
	_ = layouts.EmptyPage("Login", r.URL.Path, b).Render(w)
}
func PostLogin(w http.ResponseWriter, r *http.Request) {
	query := r.URL.Query()
	redirect := query.Get("redirect")
	if redirect == "" {
		redirect = "/"
	}
	err := r.ParseForm()
	if err != nil {
		http.Error(w, err.Error(), http.StatusInternalServerError)
		exceptions.ErrorPage(w, "Error reading body")
		return
	}
	username := r.PostForm.Get("username")
	password := r.PostForm.Get("password")
	if username == "" {
		LoginPageWithMessage(w, r, "Missing username")
		return
	}
	if password == "" {
		LoginPageWithMessage(w, r, "Missing password")
		return
	}
	u, err := data.GetUserByUsername(username, graphStore.GetGraphManager(), graphStore.GetGpart())
	if err != nil {
		http.Error(w, err.Error(), http.StatusInternalServerError)
		exceptions.ErrorPage(w, "Error reading body")
		return
	}
	if u.GraphNode.Key == "" {
		log.Warn().Msgf("Failed Login Attempt, user %s does not exist", username)
		LoginPageWithMessage(w, r, "Invalid username or password")
		return
	}
	match, err := u.CheckPassword(password, graphStore.GetGraphManager(), graphStore.GetGpart())
	if err != nil {
		log.Warn().Msgf("Failed Login Attempt, wrong password for user %s ", username)
		LoginPageWithMessage(w, r, "Invalid username or password")
		return
	}
	if match {
		s := security.NewSecureCookie()
		value := map[string]string{
			"username": u.UserName,
			"key":      u.GraphNode.Key,
		}
		if encoded, err := s.Encode("auth", value); err == nil {
			runLevel := viper.GetString("RunLevel")
			secure := true
			switch runLevel {
			case "development":
				secure = false
			case "production":
				secure = true
			}
			cookie := &http.Cookie{
				Name:     "auth",
				Value:    encoded,
				Path:     "/",
				Secure:   secure,
				HttpOnly: true,
			}
			http.SetCookie(w, cookie)
		}
		http.Redirect(w, r, redirect, http.StatusFound)
		return
	}
}
func Logout(w http.ResponseWriter, r *http.Request) {
	c := &http.Cookie{
		Name:    "auth",
		Value:   "",
		Path:    "/",
		Expires: time.Unix(0, 0),
		HttpOnly: true,
		Secure:   true,
	}
	http.SetCookie(w, c)
	http.Redirect(w, r, "/", http.StatusFound)
}

package layouts
import (
	"webster/MemoryLane/web/components"
	g "github.com/christophersw/gomponents-htmx"
	c "github.com/christophersw/gomponents-htmx/components"
	. "github.com/christophersw/gomponents-htmx/html"
)
func SidebarView(title, path string, body g.Node, sideView g.Node, usesTags bool) g.Node {
	lists := []g.Node{}
	if usesTags {
		lists = append(lists, components.TagList(false))
	}
	// HTML5 boilerplate document
	return c.HTML5(c.HTML5Props{
		Title:    title,
		Language: "en",
		Head:     head(),
		Body: []g.Node{
			// See https://play.tailwindcss.com/uOnWQzR9tl
			Main(Class("flex flex-col h-screen"),
				Div(Class("flex flex-1 overflow-hidden"),
					Div(Class("flex-col w-1/3 p-4 bg-gray-lightest drop-shadow-xl resize-x overflow-y-auto"),
						// Sidebar
						Div(Class(""),
							Div(Class("h-1/6"), H1(Class("text-gold-dark"), g.Text("Memory Lane"))),
						),
						Div(ID("side-view"), Class("flex w-full"),
							sideView,
						),
					),
					Div(Class("flex flex-1 flex-col"),
						Div(Class("flex h-16 p-4 bg-opal-light "),
							// Header
							components.Top(),
						),
						Div(Class("flex flex-1 bg-gray-paper overflow-y-auto paragraph px-4"),
							// Body
							body,
						),
						Div(Class("flex w-full bg-opal-light"),
							// Bottom
							components.Bottom(),
						),
					),
				),
				g.Group(lists),
			),
		},
	})
}
func EmptyPage(title, path string, body g.Node) g.Node {
	// HTML5 boilerplate document
	return c.HTML5(c.HTML5Props{
		Title:    title,
		Language: "en",
		Head:     head(),
		Body: []g.Node{
			body,
		},
	})
}
func head() []g.Node {
	return []g.Node{
		Script(Src("/js/htmx.min.js")),
		//Script(Src("https://unpkg.com/htmx.org@1.6.1")),
		//Script(Type("module"), Src("https://unpkg.com/blurhash-img?module")),
		Script(Src("https://unpkg.com/hyperscript.org@0.9.1")),
		Link(Href("/css/tailwind.css"), Rel("stylesheet")),
		Link(Href("/css/custom.css"), Rel("stylesheet")),
		//Link(Href("https://cdn.jsdelivr.net/npm/@tailwindcss/custom-forms@0.2.1/dist/custom-forms.css"), Rel("stylesheet")),
	}
}

package favorites
import (
	"context"
	"net/http"
	"webster/MemoryLane/data"
	"webster/MemoryLane/graphStore"
	"webster/MemoryLane/web/exceptions"
	"github.com/rs/zerolog/log"
)
func FavoritesCtx(next http.Handler) http.Handler {
	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		ctx := r.Context()
		gm := graphStore.GetGraphManager()
		gpart := graphStore.GetGpart()
		err := r.ParseForm()
		if err != nil {
			log.Error().Err(err).Msg("Error parsing form")
			exceptions.ErrorPage(w, "Error parsing form")
			return
		}
		user := ctx.Value("user").(data.User)
		key := r.PostForm.Get("item-key")
		kind := r.PostForm.Get("item-kind")
		node := data.GraphNode{
			Key:  key,
			Kind: kind,
		}
		ctx = context.WithValue(ctx, "item", node)
		isFav := false
		userFavs, err := user.GetFavorites(node.Kind, gm, gpart)
		if err != nil {
			log.Error().Err(err).Msg("Error getting favorites")
			exceptions.ErrorPage(w, "Error getting favorites")
			return
		}
		for _, fav := range userFavs {
			if fav.Key == node.Key {
				isFav = true
				break
			}
		}
		if isFav {
			err = user.RemoveFavorite(node, gm, gpart)
			if err != nil {
				log.Error().Err(err).Msg("Error removing favorite")
				exceptions.ErrorPage(w, "Error removing favorite")
				return
			}
			ctx = context.WithValue(ctx, "message", "❤️ Unfavorited.")
		} else {
			err = user.SetFavorite(node, gm, gpart)
			if err != nil {
				log.Error().Err(err).Msg("Error adding favorite")
				exceptions.ErrorPage(w, "Error adding favorite")
				return
			}
			ctx = context.WithValue(ctx, "message", "❤️ Favorited.")
		}
		next.ServeHTTP(w, r.WithContext(ctx))
	})
}

package favorites
import (
	"net/http"
	"webster/MemoryLane/data"
	"webster/MemoryLane/web/components"
	g "github.com/christophersw/gomponents-htmx"
	"github.com/rs/zerolog/log"
)
func Favorite(w http.ResponseWriter, r *http.Request) {
	item := r.Context().Value("item").(data.GraphNode)
	message := r.Context().Value("message").(string)
	comps := []g.Node{
		components.FavoriteButton(item, true, r),
		components.UpdateText(message),
	}
	for _, comp := range comps {
		err := comp.Render(w)
		if err != nil {
			log.Error().Err(err).Msg("Error rendering favorite response")
		}
	}
}

package exceptions
import (
	"net/http"
)
func ErrorPage(w http.ResponseWriter, message string) {
	w.WriteHeader(http.StatusInternalServerError)
	w.Write([]byte("<html><body><h1>" + message + "</h1></body></html>"))
}

package components
import (
	g "github.com/christophersw/gomponents-htmx"
	. "github.com/christophersw/gomponents-htmx/html"
)
func Top() (comp g.Node) {
	comp =
		Div(Class("flex flex-row-reverse w-full"),
			Div(
				A(Class("bg-gold text-xs hover:bg-gold-light text-gray-dark object-right font-bold py-2 px-4 rounded"),
					g.Text("logout"),
					Href("/login/logout"),
				),
			),
		)
	return
}

package components
import (
	g "github.com/christophersw/gomponents-htmx"
	. "github.com/christophersw/gomponents-htmx/html"
)
func Toggle(id string, leftLabel string, rightLabel string, url string, target string, indicator string) (comp g.Node) {
	comp = Div(Class("flex items-center justify-right w-full"),
		Div(Class("ml-3 text-gray-700 font-medium"),
			g.Text(leftLabel),
		),
		Label(For(id), Class("flex items-center cursor-pointer"),
			// Toggle
			Div(Class("relative"),
				// Input
				Input(ID(id), Name(id), Type("checkbox"), Class("sr-only"),
					g.Attr("hx-post", url),
					g.Attr("hx-target", target),
					g.Attr("hx-trigger", "change"),
					g.Attr("hx-indicator", indicator),
				),
				// Line
				Div(Class("w-10 h-4 bg-gray-400 rounded-full shadow-inner")),
				// Dot
				Div(Class("dot absolute w-6 h-6 bg-white rounded-full shadow -left-1 -top-1 transition")),
			),
		),
		// Label
		Div(Class("ml-3 text-gray-700 font-medium"),
			g.Text(rightLabel),
		),
	)
	return
}

package components
import (
	"fmt"
	"net/http"
	"sort"
	"strings"
	"webster/MemoryLane/data"
	"webster/MemoryLane/graphStore"
	g "github.com/christophersw/gomponents-htmx"
	. "github.com/christophersw/gomponents-htmx/html"
)
func Tags(item data.GraphNode, tags []data.Tag, oobSwap bool, r *http.Request) (comp g.Node) {
	tagNodes := []g.Node{}
	sort.SliceStable(tags, func(i, j int) bool {
		nameI := strings.ToLower(tags[i].Name)
		nameJ := strings.ToLower(tags[j].Name)
		return nameI < nameJ
	})
	for _, tag := range tags {
		tagNodes = append(tagNodes, Tag(item, tag, r))
	}
	className := fmt.Sprintf("tags-%s", item.Key)
	oob := ""
	if oobSwap {
		oob = "outerHTML:." + className
	}
	comp = Div(Class(className+" text-xs font-mono text-gray h-20 overflow-scroll"),
		HxSwapOob(oob),
		P(Class("ml-2"), g.Textf("%d tags", len(tags))),
		g.Group(tagNodes),
	)
	return comp
}
func Tag(item data.GraphNode, tag data.Tag, r *http.Request) (comp g.Node) {
	comp = Div(Class("tag rounded inline-block bg-opal-dark text-white p-1 m-2 relative"),
		A(Class("tag-link"), Href("#"), g.Text(tag.Name)),
		FormEl(
			Input(Class("hidden"), Type("hidden"), Name("item-key"), Value(item.Key)),
			Input(Class("hidden"), Type("hidden"), Name("item-kind"), Value(item.Kind)),
			Input(Class("hidden"), Type("hidden"), Name("tag-name"), Value(tag.GraphNode.Name)),
			Input(Class("hidden"), Type("hidden"), Name("tag-key"), Value(tag.GraphNode.Key)),
			Button(Class("tag-remove"), g.Text("x"),
				Span(Class("rounded-full bg-white absolute top-0 right-0 htmx-indicator"), ID(fmt.Sprintf("%s-%s-spinner", item.Key, tag.GraphNode.Key)),
					Img(Src("/css/spinner.svg")),
				),
				HxIndicator(fmt.Sprintf("#%s-%s-spinner", item.Key, tag.GraphNode.Key)),
				HxPost("/tags/remove"),
				CsrfInputToken(r),
			),
		),
	)
	return
}
func TagList(oobSwap bool) (comp g.Node) {
	tags, err := data.GetAllTags(graphStore.GetGraphManager(), graphStore.GetGpart())
	if err != nil {
		panic(err)
	}
	oob := ""
	if oobSwap {
		oob = "#tag-list"
	}
	tagOptions := []g.Node{}
	for _, tag := range tags {
		tagOptions = append(tagOptions, Option(Label(g.Text(tag.Name)), Value(tag.Name)))
	}
	comp = DataList(ID("tag-list"), HxSwapOob(oob), g.Group(tagOptions))
	return
}

package components
import (
	g "github.com/christophersw/gomponents-htmx"
	. "github.com/christophersw/gomponents-htmx/html"
)
type RadioPanelButton struct {
	Name    string
	Value   string
	Label   string
	Checked bool
}
func RadioPanel(name string, buttons []RadioPanelButton, url string, target string, indicator string) (comp g.Node) {
	radioButtons := []g.Node{}
	for _, button := range buttons {
		checked := ""
		if button.Checked {
			checked = "checked"
		}
		radioButton := Label(Class("radio-panel-button"),
			Span(Class("radio-panel-label"), g.Text(button.Label)),
			Input(ID(button.Name), Name(name), Value(button.Value), Type("radio"), g.Attr(checked),
				g.Attr("hx-post", url),
				g.Attr("hx-target", target),
				g.Attr("hx-trigger", "change"),
				g.Attr("hx-indicator", indicator)),
			Span(Class("radio-panel-checkmark")),
		)
		radioButtons = append(radioButtons, radioButton)
	}
	comp = Div(ID("radio-panel-"+name), Class("radio-panel"),
		Div(Class("radio-panel-track")),
		g.Group(radioButtons))
	return
}

package components
import (
	"fmt"
	"net/http"
	"webster/MemoryLane/data"
	g "github.com/christophersw/gomponents-htmx"
	. "github.com/christophersw/gomponents-htmx/html"
	"github.com/rs/zerolog/log"
)
func CardWithImage(photo data.Photo) (comp g.Node) {
	log.Debug().Msg("Building Photo Page")
	comp = Div(Class("bg-white shadow-md border border-gray-200 rounded-lg max-w-sm dark:bg-gray-800 dark:border-gray-700"),
		Img(Class("rounded-t-lg"),
			Src(fmt.Sprintf("/files/previews/medium/%s.webp", photo.GraphNode.Key)),
			g.Raw(fmt.Sprintf("-blurhash=\"%s\"", photo.BlurHash)),
		),
		Div(Class("p-5"),
			H5(Class("text-gray-900 font-bold text-2xl tracking-tight mb-2 dark:text-white"),
				g.Textf("Photo %s", photo.GraphNode.Key),
			),
			P(Class("font-normal text-gray-700 mb-3 dark:text-gray-400"),
				Ul(
					Li(g.Textf("Date Taken: %s", photo.DateTaken)),
					Li(g.Textf("Lens: %s", photo.LensInfo)),
					Li(g.Textf("Make: %s", photo.Make)),
					Li(g.Textf("Model: %s", photo.Model)),
					Li(g.Textf("GPS: %g, %g", photo.Longitude, photo.Latitude)),
				),
			),
		),
	)
	return
}
func ImageTile(photo data.Photo, displayType string, oobSwap bool, r *http.Request) (comp g.Node) {
	switch displayType {
	case "small":
		return SmallTile(photo, oobSwap, r)
	case "medium":
		return MediumTile(photo, oobSwap, r)
	case "polaroid":
		return PolaroidTile(photo, oobSwap, r)
	default:
		return SmallTile(photo, oobSwap, r)
	}
}
func SmallTile(photo data.Photo, oobSwap bool, r *http.Request) (comp g.Node) {
	const compType = "small-tile"
	src := fmt.Sprintf("/files/previews/square-small/%s.webp", photo.GraphNode.Key)
	oob := ""
	if oobSwap {
		oob = "true"
	}
	comp = Div(ID(getId(compType, photo)), Class("inline-block relative p-2"), HxSwapOob(oob),
		Span(Class("absolute top-2.5 right-3 z-50 w-4"),
			FavoriteButton(photo.GraphNode, false, r),
		),
		Input(Class("absolute top-1 left-1 m-2 z-50"), Type("checkbox"), Name(fmt.Sprintf("photo-%s", photo.GraphNode.Key))),
		A(Href("#"),
			//g.Raw(fmt.Sprintf("<blurhash-img hash=\"%s\" id=\"blur-%s\" class=\"rounded max-w-full h-auto align-middle border-none\" style=\"width:100px; --aspect-ratio: 4/4\"></blurhash-img>", photo.BlurHash, photo.GraphNode.Key)),
			Img(Class("rounded max-w-full h-auto align-middle border-none"),
				Src(src),
				Loading("lazy"),
				//HxTrigger("load"),
				//g.Attr("_", fmt.Sprintf("on load hide #blur-%s then show me", photo.GraphNode.Key)),
			),
			P(Class("text-xs"), g.Text(photo.DateTaken.Format("Jan 2, 2006"))),
			HxTrigger("click"),
			HxGet(fmt.Sprintf("/side-view/photo/%s", photo.GraphNode.Key)),
			HxTarget("#side-view"),
			HxIndicator("#side-preview-spinner"),
		),
	)
	return
}
func MediumTile(photo data.Photo, oobSwap bool, r *http.Request) (comp g.Node) {
	const compType = "medium-tile"
	src := fmt.Sprintf("/files/previews/square-medium/%s.webp", photo.GraphNode.Key)
	oob := ""
	if oobSwap {
		oob = "true"
	}
	comp = Div(ID(getId(compType, photo)), Class("inline-block relative p-2"), HxSwapOob(oob),
		Span(Class("absolute top-2.5 right-3 z-50 w-4"),
			FavoriteButton(photo.GraphNode, false, r),
		),
		Input(Class("absolute top-1 left-1 m-2 z-50"), Type("checkbox"), Name(fmt.Sprintf("photo-%s", photo.GraphNode.Key))),
		A(Href("#"),
			//g.Raw(fmt.Sprintf("<blurhash-img hash=\"%s\" id=\"blur-%s\" class=\"rounded max-w-full h-auto align-middle border-none\" style=\"width:100px; --aspect-ratio: 4/4\"></blurhash-img>", photo.BlurHash, photo.GraphNode.Key)),
			Img(Class("rounded max-w-full h-auto align-middle border-none"),
				Src(src),
				Loading("lazy"),
				//HxTrigger("load"),
				//g.Attr("_", fmt.Sprintf("on load hide #blur-%s then show me", photo.GraphNode.Key)),
			),
			P(Class("text-xs"), g.Text(photo.DateTaken.Format("Jan 2, 2006"))),
			HxTrigger("click"),
			HxGet(fmt.Sprintf("/side-view/photo/%s", photo.GraphNode.Key)),
			HxTarget("#side-view"),
			HxIndicator("#side-preview-spinner"),
		),
	)
	return
}
func PolaroidTile(photo data.Photo, oobSwap bool, r *http.Request) (comp g.Node) {
	const compType = "polaroid-tile"
	src := fmt.Sprintf("/files/previews/square-medium/%s.webp", photo.GraphNode.Key)
	oob := ""
	if oobSwap {
		oob = "true"
	}
	comp = Div(ID(getId(compType, photo)), Class("inline-block bg-white w-80 rounded overflow-hidden shadow-2xl relative p-2 m-4"), HxSwapOob(oob),
		Span(Class("absolute top-2.5 right-3 z-50 w-4"),
			FavoriteButton(photo.GraphNode, false, r),
		),
		Input(Class("absolute top-1 left-1 m-2 z-50"), Type("checkbox"), Name(fmt.Sprintf("photo-%s", photo.GraphNode.Key))),
		A(Href("#"), Class("z-10 relative"),
			//g.Raw(fmt.Sprintf("<blurhash-img hash=\"%s\" id=\"blur-%s\" class=\"rounded max-w-full h-auto align-middle border-none\" style=\"width:100px; --aspect-ratio: 4/4\"></blurhash-img>", photo.BlurHash, photo.GraphNode.Key)),
			Img(Class("rounded w-full h-auto align-middle border-none"),
				Src(src),
				Loading("lazy"),
				//HxTrigger("load"),
				//g.Attr("_", fmt.Sprintf("on load hide #blur-%s then show me", photo.GraphNode.Key)),
			),
			HxTrigger("click"),
			HxGet(fmt.Sprintf("/side-view/photo/%s", photo.GraphNode.Key)),
			HxTarget("#side-view"),
			HxIndicator("#side-preview-spinner"),
		),
		P(Class("text-xs font-mono float-right text-gray"), g.Textf("%s", photo.DateTaken.Format("Jan 2, 2006"))),
		Div(Class("w-full h-20 z-50 overflow-y-scroll"),
			DisplayCaption(photo.GraphNode, photo.Caption, false, r),
		),
		Div(Class("text-xs font-mono text-gray w-full h-20 p-1 overflow-scroll"),
			Tags(photo.GraphNode, photo.Tags, false, r),
		), //TODO Fix this when tags searching is added, should be a link
	)
	return
}
func SideViewPhoto(photo data.Photo, oobSwap bool, r *http.Request) (comp g.Node) {
	const compType = "sideview-photo"
	src := fmt.Sprintf("/files/previews/full/%s.webp", photo.GraphNode.Key)
	oob := ""
	if oobSwap {
		oob = "true"
	}
	comp = Div(ID(getId(compType, photo)), Class("bg-white w-full rounded relative overflow-hidden drop-shadow p-2"), HxSwapOob(oob),
		Img(Class("rounded w-full h-auto align-middle border-none"),
			Src(src),
			Loading("lazy"),
		),
		Span(Class("absolute top-3.5 right-4 z-50 w-6"),
			FavoriteButton(photo.GraphNode, false, r),
		),
		Div(Class("px-6 py-4 h-30 overflow-scroll"),
			P(Class("text-xs font-mono float-right text-gray"), g.Textf("%s", photo.DateTaken.Format("Jan 2, 2006"))),
			Div(Class("flex w-full"),
				DisplayCaption(photo.GraphNode, photo.Caption, false, r),
			),
		),
		Div(Class("text-xs font-mono text-gray h-20 overflow-scroll"),
			Tags(photo.GraphNode, photo.Tags, false, r),
		), //TODO Fix this when tags searching is added, should be a link
	)
	return
}
func getId(componentType string, photo data.Photo) string {
	return fmt.Sprintf("%s-%s", componentType, photo.GraphNode.Key)
}

package components
import (
	"fmt"
	"net/http"
	"webster/MemoryLane/data"
	g "github.com/christophersw/gomponents-htmx"
	. "github.com/christophersw/gomponents-htmx/html"
	"github.com/teris-io/shortid"
)
func EditCaption(item data.GraphNode, caption data.Caption, r *http.Request) (comp g.Node) {
	className := fmt.Sprintf("caption-box-%s", item.Key)
	id := fmt.Sprintf("caption-%s-%s", item.Key, shortid.MustGenerate())
	comp = FormEl(ID(id), Class(className+" w-full h-full"),
		Input(Class("hidden"), Type("hidden"), Name("item-key"), Value(item.Key)),
		Input(Class("hidden"), Type("hidden"), Name("item-kind"), Value(item.Kind)),
		Textarea(Name("caption-text"), Class("w-full h-full"), MaxLength("100"),
			AutoFocus(),
			HxPost("/caption/update"),
			HxTrigger("keyup changed delay:3s"),
			g.Text(caption.Text),
		),
		CsrfInputToken(r),
	)
	return
}
func DisplayCaption(item data.GraphNode, caption data.Caption, oobSwap bool, r *http.Request) (comp g.Node) {
	className := fmt.Sprintf("caption-box-%s", item.Key)
	helpText := P()
	if caption.Text == "" {
		helpText = P(Class("text-gray-light font-xs"), g.Text("click to caption"))
	}
	id := fmt.Sprintf("caption-%s-%s", item.Key, shortid.MustGenerate())
	oob := ""
	if oobSwap {
		oob = "outerHTML:." + className
	}
	comp = FormEl(Class(className+" w-full h-full"), ID(id),
		P(Class("w-full h-full"), g.Text(caption.Text)),
		helpText,
		HxTrigger("click"),
		HxPost("/caption/form"),
		Input(Class("hidden"), Type("hidden"), Name("replace"), Value(id)),
		Input(Class("hidden"), Type("hidden"), Name("item-key"), Value(item.Key)),
		Input(Class("hidden"), Type("hidden"), Name("item-kind"), Value(item.Kind)),
		CsrfInputToken(r),
		HxTarget("#"+id),
		HxSwap("outerHTML"),
		HxSwapOob(oob),
	)
	return
}

package components
import (
	"fmt"
	"net/http"
	"webster/MemoryLane/data"
	"webster/MemoryLane/graphStore"
	g "github.com/christophersw/gomponents-htmx"
	. "github.com/christophersw/gomponents-htmx/html"
	"github.com/rs/zerolog/log"
)
func FavoriteButton(item data.GraphNode, oobSwap bool, r *http.Request) (comp g.Node) {
	user := r.Context().Value("user").(data.User)
	isFav := false
	favorites, err := user.GetFavorites(item.Kind, graphStore.GetGraphManager(), graphStore.GetGpart())
	if err != nil {
		log.Error().Err(err).Msg("Error adding favorite")
		panic(err)
	}
	for _, fav := range favorites {
		if fav.Key == item.Key {
			isFav = true
			break
		}
	}
	className := fmt.Sprintf("%s-favorite-form", item.Key)
	oob := ""
	if oobSwap {
		oob = "outerHTML:." + className
	}
	if isFav {
		comp = FormEl(Class(className),
			CsrfInputToken(r),
			Input(Type("hidden"), Name("item-key"), Value(item.Key)),
			Input(Type("hidden"), Name("item-kind"), Value(item.Kind)),
			Button(
				g.Raw(`<svg viewBox="0 0 128 128" width="100%" xml:space="preserve" xmlns="http://www.w3.org/2000/svg" enable-background="new 0 0 128 128"><path d="M39.9 96.4c-1.1-1.3-2.7-2.8-3.9-4l-7.9-7.9c-4.1-4-8.3-8.2-12.5-12.2C5.9 66.1 0 55.4 0 43.8c0-18.8 15.2-34 34-34 12.9 0 24.2 7.2 30 18 5.7-10.7 17.1-18 30-18 18.8 0 34 15.2 34 34 0 11.6-5.9 22.3-15.6 28.6-4.2 3.9-8.4 8.1-12.5 12.2-2.7 2.6-5.3 5.2-7.9 7.9-1.2 1.2-2.8 2.7-3.9 4-.2.3-.4.6-.7.9l-20.6 21c-.8.8-1.7 1.2-2.9 1.2-1.1 0-2.1-.4-2.9-1.2l-20.6-21c-.1-.4-.3-.7-.5-1zM64 115.5l20.6-21c-.8 0 25.3-25.3 25.4-25.3 8.4-5.3 14-14.7 14-25.4 0-16.6-13.4-30-30-30-16.2 0-29.4 12.8-30 28.8-.6-16-13.8-28.8-30-28.8-16.6 0-30 13.4-30 30 0 10.7 5.6 20.1 14 25.4.1 0 26.2 25.3 25.4 25.3l20.6 21z" fill-rule="evenodd" clip-rule="evenodd" fill="#ED5C5A" class="fill-000000"></path><path d="m64 115.5-20.6-21c.8 0-25.3-25.3-25.4-25.3C9.6 63.9 4 54.5 4 43.8c0-16.6 13.4-30 30-30 16.2 0 29.4 12.8 30 28.8.6-16 13.8-28.8 30-28.8 16.6 0 30 13.4 30 30 0 10.7-5.6 20.1-14 25.4-.1 0-26.2 25.3-25.4 25.3l-20.6 21z" fill-rule="evenodd" clip-rule="evenodd" fill="#ED5C5A" class="fill-7aced7"></path></svg>`),
				Span(Class("rounded-full bg-white absolute top-0 right-0 htmx-indicator"), ID(fmt.Sprintf("%s-favorite-spinner", item.Key)),
					Img(Src("/css/spinner.svg")),
				),
			),
			HxPost("/favorites"),
			HxIndicator(fmt.Sprintf("#%s-favorite-spinner", item.Key)),
			HxSwapOob(oob),
		)
	} else {
		comp = FormEl(Class(className),
			CsrfInputToken(r),
			Input(Type("hidden"), Name("item-key"), Value(item.Key)),
			Input(Type("hidden"), Name("item-kind"), Value(item.Kind)),
			Button(
				g.Raw(`<svg viewBox="0 0 128 128" width="100%" xml:space="preserve" xmlns="http://www.w3.org/2000/svg" enable-background="new 0 0 128 128"><path d="M39.9 96.4c-1.1-1.3-2.7-2.8-3.9-4l-7.9-7.9c-4.1-4-8.3-8.2-12.5-12.2C5.9 66.1 0 55.4 0 43.8c0-18.8 15.2-34 34-34 12.9 0 24.2 7.2 30 18 5.7-10.7 17.1-18 30-18 18.8 0 34 15.2 34 34 0 11.6-5.9 22.3-15.6 28.6-4.2 3.9-8.4 8.1-12.5 12.2-2.7 2.6-5.3 5.2-7.9 7.9-1.2 1.2-2.8 2.7-3.9 4-.2.3-.4.6-.7.9l-20.6 21c-.8.8-1.7 1.2-2.9 1.2-1.1 0-2.1-.4-2.9-1.2l-20.6-21c-.1-.4-.3-.7-.5-1zM64 115.5l20.6-21c-.8 0 25.3-25.3 25.4-25.3 8.4-5.3 14-14.7 14-25.4 0-16.6-13.4-30-30-30-16.2 0-29.4 12.8-30 28.8-.6-16-13.8-28.8-30-28.8-16.6 0-30 13.4-30 30 0 10.7 5.6 20.1 14 25.4.1 0 26.2 25.3 25.4 25.3l20.6 21z" fill-rule="evenodd" clip-rule="evenodd" fill="#34425B" class="fill-000000"></path><path d="m64 115.5-20.6-21c.8 0-25.3-25.3-25.4-25.3C9.6 63.9 4 54.5 4 43.8c0-16.6 13.4-30 30-30 16.2 0 29.4 12.8 30 28.8.6-16 13.8-28.8 30-28.8 16.6 0 30 13.4 30 30 0 10.7-5.6 20.1-14 25.4-.1 0-26.2 25.3-25.4 25.3l-20.6 21z" fill-rule="evenodd" clip-rule="evenodd" fill="#ffffff" class="fill-7aced7"></path></svg>`),
				Span(Class("rounded-full bg-white absolute top-0 right-0 htmx-indicator"), ID(fmt.Sprintf("%s-favorite-spinner", item.Key)),
					Img(Src("/css/spinner.svg")),
				),
			),
			HxPost("/favorites"),
			HxIndicator(fmt.Sprintf("#%s-favorite-spinner", item.Key)),
			HxSwapOob(oob),
		)
	}
	return
}

package components
import (
	"net/http"
	g "github.com/christophersw/gomponents-htmx"
	. "github.com/christophersw/gomponents-htmx/html"
	"github.com/gorilla/csrf"
)
func CsrfInputToken(r *http.Request) g.Node {
	return Input(Name("gorilla.csrf.Token"), Type("hidden"), Value(csrf.Token(r)))
}

package components
import (
	g "github.com/christophersw/gomponents-htmx"
	. "github.com/christophersw/gomponents-htmx/html"
)
func Bottom() (comp g.Node) {
	comp = Div(Class("flex w-full p-2"),
		Img(ID("side-preview-spinner"), Class("htmx-indicator w-9 p-2 object-right"), Src("/css/spinner.svg")),
		UpdateText("👋 Hello."),
	)
	return
}
func UpdateText(message string) (comp g.Node) {
	comp = Div(ID("update-text"), Class("w-full text-xs font-mono text-gray"),
		P(Class("float-right"), g.Text(message)),
		HxSwapOob("true"),
	)
	return
}

package components
import (
	g "github.com/christophersw/gomponents-htmx"
	. "github.com/christophersw/gomponents-htmx/html"
)
// see https://tailwind-elements.com/docs/standard/components/alerts/
func WarningAlert(msg string) (comp g.Node) {
	comp = Div(Class("my-3 block text-sm text-left text-gray-black bg-gold h-12 flex items-center p-4 rounded-md shadow-lg"),
		Role("alert"),
		g.Text(msg),
	)
	return
}

package captions
import (
	"context"
	"fmt"
	"net/http"
	"webster/MemoryLane/data"
	"webster/MemoryLane/graphStore"
	"webster/MemoryLane/web/exceptions"
	"github.com/rs/zerolog/log"
)
func UpdateCaptionsCtx(next http.Handler) http.Handler {
	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		var ctx context.Context
		gm := graphStore.GetGraphManager()
		gpart := graphStore.GetGpart()
		err := r.ParseForm()
		if err != nil {
			log.Error().Err(err).Msg("Error parsing form")
			exceptions.ErrorPage(w, "Error parsing form")
			return
		}
		key := r.PostForm.Get("item-key")
		kind := r.PostForm.Get("item-kind")
		text := r.PostForm.Get("caption-text")
		item := data.GraphNode{
			Key:  key,
			Kind: kind,
		}
		caption := data.Caption{
			Text:          text,
			CaptionedItem: item,
		}
		err = caption.Upsert(gm, gpart)
		if err != nil {
			log.Error().Err(err).Msg("Error adding caption")
			exceptions.ErrorPage(w, "Error adding caption")
			return
		}
		ctx = context.WithValue(r.Context(), "item", item)
		ctx = context.WithValue(ctx, "message", fmt.Sprintf("📝 Caption updated for %s.", item.Key))
		next.ServeHTTP(w, r.WithContext(ctx))
	})
}
func EditCaptionFormCtx(next http.Handler) http.Handler {
	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		var ctx context.Context
		err := r.ParseForm()
		if err != nil {
			log.Error().Err(err).Msg("Error parsing form")
			exceptions.ErrorPage(w, "Error parsing form")
			return
		}
		key := r.PostForm.Get("item-key")
		kind := r.PostForm.Get("item-kind")
		replace := r.PostForm.Get("replace")
		item := data.GraphNode{
			Key:  key,
			Kind: kind,
		}
		ctx = context.WithValue(r.Context(), "item", item)
		ctx = context.WithValue(ctx, "replace", replace)
		next.ServeHTTP(w, r.WithContext(ctx))
	})
}

package captions
import (
	"net/http"
	"webster/MemoryLane/data"
	"webster/MemoryLane/graphStore"
	"webster/MemoryLane/web/components"
	"webster/MemoryLane/web/exceptions"
	g "github.com/christophersw/gomponents-htmx"
	"github.com/rs/zerolog/log"
)
func UpdateCaption(w http.ResponseWriter, r *http.Request) {
	ctx := r.Context()
	item := ctx.Value("item").(data.GraphNode)
	updateMessage := ctx.Value("message").(string)
	caption, err := data.GetItemCaption(item, graphStore.GetGraphManager(), graphStore.GetGpart())
	if err != nil {
		log.Error().Err(err).Msg("Error getting caption")
		exceptions.ErrorPage(w, "Error getting caption")
		return
	}
	comps := []g.Node{}
	comps = append(comps, components.DisplayCaption(item, caption, true, r))
	comps = append(comps, components.UpdateText(updateMessage))
	for _, comp := range comps {
		err := comp.Render(w)
		if err != nil {
			log.Error().Err(err).Msg("Error rendering caption response")
		}
	}
}
func EditCaptionForm(w http.ResponseWriter, r *http.Request) {
	ctx := r.Context()
	item := ctx.Value("item").(data.GraphNode)
	caption, err := data.GetItemCaption(item, graphStore.GetGraphManager(), graphStore.GetGpart())
	if err != nil {
		log.Error().Err(err).Msg("Error getting caption")
		exceptions.ErrorPage(w, "Error getting caption")
		return
	}
	err = components.EditCaption(item, caption, r).Render(w)
	if err != nil {
		log.Error().Err(err).Msg("Error rendering caption response")
	}
}

module.exports = {
  purge: {
    enabled: true,
    content: [
      './web/**/*.go'
    ]
  },
  darkMode: false, // or 'media' or 'class'
  theme: {
    colors: {
      // Configure your color palette here
      // See https://coolors.co/ed5c5a-d78f09-252f41-96c0b7-e7ea1f
      red: {
        light: '#F5A5A3',
        DEFAULT: '#ED5C5A',
        dark: '#DC1C18',
      },
      gold: {
        light: '#FAD389',
        DEFAULT: '#F6AE2D',
        dark: '#D78F09',
      },
      gray: {
        paper: '#F2F4F8',
        lightest: "#E5E9F0",
        lighter: "#B1BDD2",
        light: '#7D92B5',
        DEFAULT: '#34425B',
        dark: '#2E3A4D',
        black: '#161C27'
      },
      opal: {
        light: '#CCE0DC',
        DEFAULT: '#96C0B7',
        dark: '#66A396'
      },
      yellow: {
        light: '#F7F8B4',
        DEFAULT: '#EFF16A',
        dark: '#E7EA1F'
      },
      white: {
        DEFAULT: '#FFFFFF',
      }
    },
    extend: { 
      dropShadow: { 
        '2xl': '0 35px 35px rgba(52, 66, 91, 0.25)', 
      } 
    }
  },
  variants: {
    extend: {},
  },
  plugins: [],
}

---
#########
# TEMP  #
#########
"TempLocation" : "temp"
###########
# LOGGING #
###########
"LogLevel": "debug" # debug, info, warn, error, fatal
"LogOutput": "stdout" # stdout, or file path
#################
# ASSET STORAGE #
#################
"AssetStorageType": "s3" # s3, or local
## LOCAL ##
"AssetLocalPath": "fs://../../../Nextcloud/Photos"
## S3 ##
"AssetS3AccessKeyId": "***"
"AssetS3SecretAccessKey": "***"
"AssetS3Region": "us-east-1"
"AssetS3Bucket": "***"
"AssetS3Endpoint": "https://us-east-1.linodeobjects.com"
#################
# GRAPH STORAGE #
#################
"GraphEndpoint": "https://***.us-east-1.aws.cloud.dgraph.io"
"GraphAPIKey": "***"
#################
#  SCAFFOLDING  #
#################
## Users ##
DefaultUser:
  "username": "admin"
  "password": "***"
  "email": ""
##############
#  SECURITY  #
##############
"CSRFKey": "***"
...

module.exports = {
  plugins: {
    tailwindcss: {},
    autoprefixer: {},
  },
}

/*
Copyright © 2021 NAME HERE <EMAIL ADDRESS>
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
    http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/
package main
import (
	"context"
	"fmt"
	"os"
	"os/signal"
	"webster/MemoryLane/cmd"
	"webster/MemoryLane/global"
	"github.com/rs/zerolog/log"
)
func main() {
	ctx := global.GetGlobalContext()
	// trap Ctrl+C and call cancel on the context
	ctx, cancel := context.WithCancel(ctx)
	global.SetGlobalContext(ctx)
	c := make(chan os.Signal, 1)
	signal.Notify(c, os.Interrupt)
	defer func() {
		signal.Stop(c)
		cancel()
	}()
	go func() {
		select {
		case <-c:
			fmt.Println("\033[2J")
			fmt.Println("***********************")
			fmt.Println("* Shut Down Requested *")
			fmt.Println("***********************")
			log.Info().Msg("***  Shut Down Requested  ***")
			cancel()
			global.Shutdown()
		case <-ctx.Done():
		}
	}()
	cmd.Execute()
}

{"level":"info","time":"2021-12-21T15:13:21-05:00","message":"VIPS:g_getenv( \"PATH\" ) == \"/opt/homebrew/bin:/opt/homebrew/sbin:/usr/local/bin:/usr/bin:/bin:/usr/sbin:/sbin:/usr/local/MacGPG2/bin\""}
{"level":"info","time":"2021-12-21T15:13:21-05:00","message":"VIPS:looking in \"/opt/homebrew/bin\" for \"govips\""}
{"level":"info","time":"2021-12-21T15:13:21-05:00","message":"VIPS:looking in \"/opt/homebrew/sbin\" for \"govips\""}
{"level":"info","time":"2021-12-21T15:13:21-05:00","message":"VIPS:looking in \"/usr/local/bin\" for \"govips\""}
{"level":"info","time":"2021-12-21T15:13:21-05:00","message":"VIPS:looking in \"/usr/bin\" for \"govips\""}
{"level":"info","time":"2021-12-21T15:13:21-05:00","message":"VIPS:looking in \"/bin\" for \"govips\""}
{"level":"info","time":"2021-12-21T15:13:21-05:00","message":"VIPS:looking in \"/usr/sbin\" for \"govips\""}
{"level":"info","time":"2021-12-21T15:13:21-05:00","message":"VIPS:looking in \"/sbin\" for \"govips\""}
{"level":"info","time":"2021-12-21T15:13:21-05:00","message":"VIPS:looking in \"/usr/local/MacGPG2/bin\" for \"govips\""}
{"level":"info","time":"2021-12-21T15:13:21-05:00","message":"VIPS:trying for dir = \"/Users/christopherwebster/Projects/MemoryLane/govips\", name = \"govips\""}
{"level":"info","time":"2021-12-21T15:13:21-05:00","message":"VIPS:canonicalised path = \"/Users/christopherwebster/Projects/MemoryLane\""}
{"level":"info","time":"2021-12-21T15:13:21-05:00","message":"VIPS:VIPS_PREFIX = /opt/homebrew/Cellar/vips/8.12.1"}
{"level":"info","time":"2021-12-21T15:13:21-05:00","message":"VIPS:VIPS_LIBDIR = /opt/homebrew/Cellar/vips/8.12.1/lib"}
{"level":"info","time":"2021-12-21T15:13:21-05:00","message":"VIPS:prefix = /opt/homebrew/Cellar/vips/8.12.1"}
{"level":"info","time":"2021-12-21T15:13:21-05:00","message":"VIPS:libdir = /opt/homebrew/Cellar/vips/8.12.1/lib"}
{"level":"info","time":"2021-12-21T15:13:21-05:00","message":"VIPS:searching \"/opt/homebrew/Cellar/vips/8.12.1/lib/vips-plugins-8.12\""}
{"level":"info","time":"2021-12-21T15:13:21-05:00","message":"VIPS:vips 8.12.1 started with concurrency=1 cache_max_files=0 cache_max_mem=52428800 cache_max=100"}
{"level":"info","time":"2021-12-21T15:13:21-05:00","message":"VIPS:registered image type loader type=magick"}
{"level":"info","time":"2021-12-21T15:13:21-05:00","message":"VIPS:registered image type loader type=pdf"}
{"level":"info","time":"2021-12-21T15:13:21-05:00","message":"VIPS:registered image type loader type=webp"}
{"level":"info","time":"2021-12-21T15:13:21-05:00","message":"VIPS:registered image type loader type=tiff"}
{"level":"info","time":"2021-12-21T15:13:21-05:00","message":"VIPS:registered image type loader type=heif"}
{"level":"info","time":"2021-12-21T15:13:21-05:00","message":"VIPS:registered image type loader type=heif"}
{"level":"info","time":"2021-12-21T15:13:21-05:00","message":"VIPS:registered image type loader type=gif"}
{"level":"info","time":"2021-12-21T15:13:21-05:00","message":"VIPS:registered image type loader type=jpeg"}
{"level":"info","time":"2021-12-21T15:13:21-05:00","message":"VIPS:registered image type loader type=png"}
{"level":"info","time":"2021-12-21T15:13:21-05:00","message":"VIPS:registered image type loader type=svg"}
{"level":"debug","caller":"/Users/christopherwebster/Projects/MemoryLane/graphStore/connect.go:41","time":"2021-12-21T15:13:21-05:00","message":"Initializing Connection to EliasDB ."}
{"level":"fatal","error":"GraphError: Failed to open graph storage (mkdir : no such file or directory)","time":"2021-12-21T15:13:21-05:00","message":"Could not create graph storage"}

//AMD insanity
(function (root, factory) {
    //@ts-ignore
    if (typeof define === 'function' && define.amd) {
        // AMD. Register as an anonymous module.
        //@ts-ignore
        define([], factory);
    } else {
        // Browser globals
        root.htmx = factory();
    }
}(typeof self !== 'undefined' ? self : this, function () {
return (function () {
        'use strict';
        // Public API
        //** @type {import("./htmx").HtmxApi} */
        // TODO: list all methods in public API
        var htmx = {
            onLoad: onLoadHelper,
            process: processNode,
            on: addEventListenerImpl,
            off: removeEventListenerImpl,
            trigger : triggerEvent,
            ajax : ajaxHelper,
            find : find,
            findAll : findAll,
            closest : closest,
            values : function(elt, type){
                var inputValues = getInputValues(elt, type || "post");
                return inputValues.values;
            },
            remove : removeElement,
            addClass : addClassToElement,
            removeClass : removeClassFromElement,
            toggleClass : toggleClassOnElement,
            takeClass : takeClassForElement,
            defineExtension : defineExtension,
            removeExtension : removeExtension,
            logAll : logAll,
            logger : null,
            config : {
                historyEnabled:true,
                historyCacheSize:10,
                refreshOnHistoryMiss:false,
                defaultSwapStyle:'innerHTML',
                defaultSwapDelay:0,
                defaultSettleDelay:20,
                includeIndicatorStyles:true,
                indicatorClass:'htmx-indicator',
                requestClass:'htmx-request',
                addedClass:'htmx-added',
                settlingClass:'htmx-settling',
                swappingClass:'htmx-swapping',
                allowEval:true,
                attributesToSettle:["class", "style", "width", "height"],
                withCredentials:false,
                timeout:0,
                disableSelector: "[hx-disable], [data-hx-disable]",
                useTemplateFragments: false,
                scrollBehavior: 'smooth',
            },
            parseInterval:parseInterval,
            _:internalEval,
            version: "1.7.0"
        };
        /** @type {import("./htmx").HtmxInternalApi} */
        var internalAPI = {
            bodyContains: bodyContains,
            filterValues: filterValues,
            hasAttribute: hasAttribute,
            getAttributeValue: getAttributeValue,
            getClosestMatch: getClosestMatch,
            getExpressionVars: getExpressionVars,
            getHeaders: getHeaders,
            getInputValues: getInputValues,
            getInternalData: getInternalData,
            getSwapSpecification: getSwapSpecification,
            getTriggerSpecs: getTriggerSpecs,
            getTarget: getTarget,
            makeFragment: makeFragment,
            mergeObjects: mergeObjects,
            makeSettleInfo: makeSettleInfo,
            oobSwap: oobSwap,
            selectAndSwap: selectAndSwap,
            settleImmediately: settleImmediately,
            shouldCancel: shouldCancel,
            triggerEvent: triggerEvent,
            triggerErrorEvent: triggerErrorEvent,
            withExtensions: withExtensions,
        }
        var VERBS = ['get', 'post', 'put', 'delete', 'patch'];
        var VERB_SELECTOR = VERBS.map(function(verb){
            return "[hx-" + verb + "], [data-hx-" + verb + "]"
        }).join(", ");
        //====================================================================
        // Utilities
        //====================================================================
		function parseInterval(str) {
			if (str == undefined)  {
				return undefined
			}
			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
			}
			return parseFloat(str) || undefined
        }
        /**
         * @param {HTMLElement} elt
         * @param {string} name
         * @returns {(string | null)}
         */
        function getRawAttribute(elt, name) {
            return elt.getAttribute && elt.getAttribute(name);
        }
        // resolve with both hx and data-hx prefixes
        function hasAttribute(elt, qualifiedName) {
            return elt.hasAttribute && (elt.hasAttribute(qualifiedName) ||
                elt.hasAttribute("data-" + qualifiedName));
        }
        /**
         *
         * @param {HTMLElement} elt
         * @param {string} qualifiedName
         * @returns {(string | null)}
         */
        function getAttributeValue(elt, qualifiedName) {
            return getRawAttribute(elt, qualifiedName) || getRawAttribute(elt, "data-" + qualifiedName);
        }
        /**
         * @param {HTMLElement} elt
         * @returns {HTMLElement | null}
         */
        function parentElt(elt) {
            return elt.parentElement;
        }
        /**
         * @returns {Document}
         */
        function getDocument() {
            return document;
        }
        /**
         * @param {HTMLElement} elt
         * @param {(e:HTMLElement) => boolean} condition
         * @returns {HTMLElement | null}
         */
        function getClosestMatch(elt, condition) {
            if (condition(elt)) {
                return elt;
            } else if (parentElt(elt)) {
                return getClosestMatch(parentElt(elt), condition);
            } else {
                return null;
            }
        }
        /**
         * @param {HTMLElement} elt
         * @param {string} attributeName
         * @returns {string | null}
         */
        function getClosestAttributeValue(elt, attributeName) {
            var closestAttr = null;
            getClosestMatch(elt, function (e) {
                return closestAttr = getAttributeValue(e, attributeName);
            });
            if (closestAttr !== "unset") {
                return closestAttr;
            }
        }
        /**
         * @param {HTMLElement} elt
         * @param {string} selector
         * @returns {boolean}
         */
        function matches(elt, selector) {
            // @ts-ignore: non-standard properties for browser compatability
            // noinspection JSUnresolvedVariable
            var matchesFunction = elt.matches || elt.matchesSelector || elt.msMatchesSelector || elt.mozMatchesSelector || elt.webkitMatchesSelector || elt.oMatchesSelector;
            return matchesFunction && matchesFunction.call(elt, selector);
        }
        /**
         * @param {string} str
         * @returns {string}
         */
        function getStartTag(str) {
            var tagMatcher = /<([a-z][^\/\0>\x20\t\r\n\f]*)/i
            var match = tagMatcher.exec( str );
            if (match) {
                return match[1].toLowerCase();
            } else {
                return "";
            }
        }
        /**
         *
         * @param {string} resp
         * @param {number} depth
         * @returns {Element}
         */
        function parseHTML(resp, depth) {
            var parser = new DOMParser();
            var responseDoc = parser.parseFromString(resp, "text/html");
            /** @type {Element} */
            var responseNode = responseDoc.body;
            while (depth > 0) {
                depth--;
                // @ts-ignore
                responseNode = responseNode.firstChild;
            }
            if (responseNode == null) {
                // @ts-ignore
                responseNode = getDocument().createDocumentFragment();
            }
            return responseNode;
        }
        /**
         *
         * @param {string} resp
         * @returns {Element}
         */
        function makeFragment(resp) {
            if (htmx.config.useTemplateFragments) {
                var documentFragment = parseHTML("<body><template>" + resp + "</template></body>", 0);
                // @ts-ignore type mismatch between DocumentFragment and Element.
                // TODO: Are these close enough for htmx to use interchangably?
                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);
                }
            }
        }
        /**
         * @param {Function} func
         */
        function maybeCall(func){
            if(func) {
                func();
            }
        }
        /**
         * @param {any} o
         * @param {string} type
         * @returns
         */
        function isType(o, type) {
            return Object.prototype.toString.call(o) === "[object " + type + "]";
        }
        /**
         * @param {*} o
         * @returns {o is Function}
         */
        function isFunction(o) {
            return isType(o, "Function");
        }
        /**
         * @param {*} o
         * @returns {o is Object}
         */
        function isRawObject(o) {
            return isType(o, "Object");
        }
        /**
         * getInternalData retrieves "private" data stored by htmx within an element
         * @param {HTMLElement} elt
         * @returns {*}
         */
        function getInternalData(elt) {
            var dataProp = 'htmx-internal-data';
            var data = elt[dataProp];
            if (!data) {
                data = elt[dataProp] = {};
            }
            return data;
        }
        /**
         * toArray converts an ArrayLike object into a real array.
         * @param {ArrayLike} arr
         * @returns {any[]}
         */
        function toArray(arr) {
            var returnArr = [];
            if (arr) {
                for (var i = 0; i < arr.length; i++) {
                    returnArr.push(arr[i]);
                }
            }
            return returnArr
        }
        function forEach(arr, func) {
            if (arr) {
                for (var i = 0; i < arr.length; i++) {
                    func(arr[i]);
                }
            }
        }
        function isScrolledIntoView(el) {
            var rect = el.getBoundingClientRect();
            var elemTop = rect.top;
            var elemBottom = rect.bottom;
            return elemTop < window.innerHeight && elemBottom >= 0;
        }
        function bodyContains(elt) {
            return getDocument().body.contains(elt);
        }
        function splitOnWhitespace(trigger) {
            return trigger.trim().split(/\s+/);
        }
        /**
         * mergeObjects takes all of the keys from
         * obj2 and duplicates them into 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;
        }
        function parseJSON(jString) {
            try {
                return JSON.parse(jString);
            } catch(error) {
                logError(error);
                return null;
            }
        }
        //==========================================================================================
        // public API
        //==========================================================================================
        function internalEval(str){
            return maybeEval(getDocument().body, function () {
                return eval(str);
            });
        }
        function onLoadHelper(callback) {
            var value = htmx.on("htmx:load", function(evt) {
                callback(evt.detail.elt);
            });
            return value;
        }
        function logAll(){
            htmx.logger = function(elt, event, data) {
                if(console) {
                    console.log(event, elt, data);
                }
            }
        }
        function find(eltOrSelector, selector) {
            if (selector) {
                return eltOrSelector.querySelector(selector);
            } else {
                return find(getDocument(), eltOrSelector);
            }
        }
        function findAll(eltOrSelector, selector) {
            if (selector) {
                return eltOrSelector.querySelectorAll(selector);
            } else {
                return findAll(getDocument(), eltOrSelector);
            }
        }
        function removeElement(elt, delay) {
            elt = resolveTarget(elt);
            if (delay) {
                setTimeout(function(){removeElement(elt);}, delay)
            } else {
                elt.parentElement.removeChild(elt);
            }
        }
        function addClassToElement(elt, clazz, delay) {
            elt = resolveTarget(elt);
            if (delay) {
                setTimeout(function(){addClassToElement(elt, clazz);}, delay)
            } else {
                elt.classList && elt.classList.add(clazz);
            }
        }
        function removeClassFromElement(elt, clazz, delay) {
            elt = resolveTarget(elt);
            if (delay) {
                setTimeout(function(){removeClassFromElement(elt, clazz);}, delay)
            } else {
                if (elt.classList) {
                    elt.classList.remove(clazz);
                    // if there are no classes left, remove the class attribute
                    if (elt.classList.length === 0) {
                        elt.removeAttribute("class");
                    }
                }
            }
        }
        function toggleClassOnElement(elt, clazz) {
            elt = resolveTarget(elt);
            elt.classList.toggle(clazz);
        }
        function takeClassForElement(elt, clazz) {
            elt = resolveTarget(elt);
            forEach(elt.parentElement.children, function(child){
                removeClassFromElement(child, clazz);
            })
            addClassToElement(elt, clazz);
        }
        function closest(elt, selector) {
            elt = resolveTarget(elt);
            if (elt.closest) {
                return elt.closest(selector);
            } else {
                do{
                    if (elt == null || matches(elt, selector)){
                        return elt;
                    }
                }
                while (elt = elt && parentElt(elt));
            }
        }
        function querySelectorAllExt(elt, selector) {
		    if (selector.indexOf("closest ") === 0) {
                return [closest(elt, selector.substr(8))];
            } else if (selector.indexOf("find ") === 0) {
                return [find(elt, selector.substr(5))];
            } else if (selector === 'document') {
                return [document];
            } else if (selector === 'window') {
                return [window];
            } else {
                return getDocument().querySelectorAll(selector);
            }
        }
        function querySelectorExt(eltOrSelector, selector) {
            if (selector) {
                return querySelectorAllExt(eltOrSelector, selector)[0];
            } else {
                return querySelectorAllExt(getDocument().body, eltOrSelector)[0];
            }
        }
        function resolveTarget(arg2) {
            if (isType(arg2, 'String')) {
                return find(arg2);
            } else {
                return arg2;
            }
        }
        function processEventArgs(arg1, arg2, arg3) {
            if (isFunction(arg2)) {
                return {
                    target: getDocument().body,
                    event: arg1,
                    listener: arg2
                }
            } else {
                return {
                    target: resolveTarget(arg1),
                    event: arg2,
                    listener: arg3
                }
            }
        }
        function addEventListenerImpl(arg1, arg2, arg3) {
            ready(function(){
                var eventArgs = processEventArgs(arg1, arg2, arg3);
                eventArgs.target.addEventListener(eventArgs.event, eventArgs.listener);
            })
            var b = isFunction(arg2);
            return b ? arg2 : arg3;
        }
        function removeEventListenerImpl(arg1, arg2, arg3) {
            ready(function(){
                var eventArgs = processEventArgs(arg1, arg2, arg3);
                eventArgs.target.removeEventListener(eventArgs.event, eventArgs.listener);
            })
            return isFunction(arg2) ? arg2 : arg3;
        }
        //====================================================================
        // Node processing
        //====================================================================
        function getTarget(elt) {
            var explicitTarget = getClosestMatch(elt, function(e){return getAttributeValue(e,"hx-target") !== null});
            if (explicitTarget) {
                var targetStr = getAttributeValue(explicitTarget, "hx-target");
                if (targetStr === "this") {
                    return explicitTarget;
                } else {
                    return querySelectorExt(elt, targetStr)
                }
            } else {
                var data = getInternalData(elt);
                if (data.boosted) {
                    return getDocument().body;
                } else {
                    return elt;
                }
            }
        }
        function shouldSettleAttribute(name) {
            var attributesToSettle = htmx.config.attributesToSettle;
            for (var i = 0; i < attributesToSettle.length; i++) {
                if (name === attributesToSettle[i]) {
                    return true;
                }
            }
            return false;
        }
        function cloneAttributes(mergeTo, mergeFrom) {
            forEach(mergeTo.attributes, function (attr) {
                if (!mergeFrom.hasAttribute(attr.name) && shouldSettleAttribute(attr.name)) {
                    mergeTo.removeAttribute(attr.name)
                }
            });
            forEach(mergeFrom.attributes, function (attr) {
                if (shouldSettleAttribute(attr.name)) {
                    mergeTo.setAttribute(attr.name, attr.value);
                }
            });
        }
        function isInlineSwap(swapStyle, target) {
            var extensions = getExtensions(target);
            for (var i = 0; i < extensions.length; i++) {
                var extension = extensions[i];
                try {
                    if (extension.isInlineSwap(swapStyle)) {
                        return true;
                    }
                } catch(e) {
                    logError(e);
                }
            }
            return swapStyle === "outerHTML";
        }
        /**
         *
         * @param {string} oobValue
         * @param {HTMLElement} oobElement
         * @param {*} settleInfo
         * @returns
         */
        function oobSwap(oobValue, oobElement, settleInfo) {
            var selector = "#" + oobElement.id;
            var swapStyle = "outerHTML";
            if (oobValue === "true") {
                // do nothing
            } else if (oobValue.indexOf(":") > 0) {
                swapStyle = oobValue.substr(0, oobValue.indexOf(":"));
                selector  = oobValue.substr(oobValue.indexOf(":") + 1, oobValue.length);
            } else {
                swapStyle = oobValue;
            }
            var targets = getDocument().querySelectorAll(selector);
            if (targets) {
                forEach(
                    targets,
                    function (target) {
                        var fragment;
                        var oobElementClone = oobElement.cloneNode(true);
                        fragment = getDocument().createDocumentFragment();
                        fragment.appendChild(oobElementClone);
                        if (!isInlineSwap(swapStyle, target)) {
                            fragment = oobElementClone; // if this is not an inline swap, we use the content of the node, not the node itself
                        }
                        swap(swapStyle, target, target, fragment, settleInfo);
                    }
                );
                oobElement.parentNode.removeChild(oobElement);
            } else {
                oobElement.parentNode.removeChild(oobElement);
                triggerErrorEvent(getDocument().body, "htmx:oobErrorNoTarget", {content: oobElement})
            }
            return oobValue;
        }
        function handleOutOfBandSwaps(fragment, settleInfo) {
            forEach(findAll(fragment, '[hx-swap-oob], [data-hx-swap-oob]'), function (oobElement) {
                var oobValue = getAttributeValue(oobElement, "hx-swap-oob");
                if (oobValue != null) {
                    oobSwap(oobValue, oobElement, settleInfo);
                }
            });
        }
        function handlePreservedElements(fragment) {
            forEach(findAll(fragment, '[hx-preserve], [data-hx-preserve]'), function (preservedElt) {
                var id = getAttributeValue(preservedElt, "id");
                var oldElt = getDocument().getElementById(id);
                if (oldElt != null) {
                    preservedElt.parentNode.replaceChild(oldElt, preservedElt);
                }
            });
        }
        function handleAttributes(parentNode, fragment, settleInfo) {
            forEach(fragment.querySelectorAll("[id]"), function (newNode) {
                if (newNode.id && newNode.id.length > 0) {
                    var oldNode = parentNode.querySelector(newNode.tagName + "[id='" + newNode.id + "']");
                    if (oldNode && oldNode !== parentNode) {
                        var newAttributes = newNode.cloneNode();
                        cloneAttributes(newNode, oldNode);
                        settleInfo.tasks.push(function () {
                            cloneAttributes(newNode, newAttributes);
                        });
                    }
                }
            });
        }
        function makeAjaxLoadTask(child) {
            return function () {
                removeClassFromElement(child, htmx.config.addedClass);
                processNode(child);
                processScripts(child);
                processFocus(child)
                triggerEvent(child, 'htmx:load');
            };
        }
        function processFocus(child) {
            var autofocus = "[autofocus]";
            var autoFocusedElt = matches(child, autofocus) ? child : child.querySelector(autofocus)
            if (autoFocusedElt != null) {
                autoFocusedElt.focus();
            }
        }
        function insertNodesBefore(parentNode, insertBefore, fragment, settleInfo) {
            handleAttributes(parentNode, fragment, settleInfo);
            while(fragment.childNodes.length > 0){
                var child = fragment.firstChild;
                addClassToElement(child, htmx.config.addedClass);
                parentNode.insertBefore(child, insertBefore);
                if (child.nodeType !== Node.TEXT_NODE && child.nodeType !== Node.COMMENT_NODE) {
                    settleInfo.tasks.push(makeAjaxLoadTask(child));
                }
            }
        }
        function cleanUpElement(element) {
            var internalData = getInternalData(element);
            triggerEvent(element, "htmx:beforeCleanupElement")
            if (internalData.listenerInfos) {
                forEach(internalData.listenerInfos, function(info) {
                    if (element !== info.on) {
                        info.on.removeEventListener(info.trigger, info.listener);
                    }
                });
            }
            if (element.children) { // IE
                forEach(element.children, function(child) { cleanUpElement(child) });
            }
        }
        function swapOuterHTML(target, fragment, settleInfo) {
            if (target.tagName === "BODY") {
                return swapInnerHTML(target, fragment, settleInfo);
            } else {
                // @type {HTMLElement}
                var newElt
                var eltBeforeNewContent = target.previousSibling;
                insertNodesBefore(parentElt(target), target, fragment, settleInfo);
                if (eltBeforeNewContent == null) {
                    newElt = parentElt(target).firstChild;
                } else {
                    newElt = eltBeforeNewContent.nextSibling;
                }
                getInternalData(target).replacedWith = newElt; // tuck away so we can fire events on it later
                settleInfo.elts = [] // clear existing elements
                while(newElt && newElt !== target) {
                    if (newElt.nodeType === Node.ELEMENT_NODE) {
                        settleInfo.elts.push(newElt);
                    }
                    newElt = newElt.nextElementSibling;
                }
                cleanUpElement(target);
                parentElt(target).removeChild(target);
            }
        }
        function swapAfterBegin(target, fragment, settleInfo) {
            return insertNodesBefore(target, target.firstChild, fragment, settleInfo);
        }
        function swapBeforeBegin(target, fragment, settleInfo) {
            return insertNodesBefore(parentElt(target), target, fragment, settleInfo);
        }
        function swapBeforeEnd(target, fragment, settleInfo) {
            return insertNodesBefore(target, null, fragment, settleInfo);
        }
        function swapAfterEnd(target, fragment, settleInfo) {
            return insertNodesBefore(parentElt(target), target.nextSibling, fragment, settleInfo);
        }
        function swapInnerHTML(target, fragment, settleInfo) {
            var firstChild = target.firstChild;
            insertNodesBefore(target, firstChild, fragment, settleInfo);
            if (firstChild) {
                while (firstChild.nextSibling) {
                    cleanUpElement(firstChild.nextSibling)
                    target.removeChild(firstChild.nextSibling);
                }
                cleanUpElement(firstChild)
                target.removeChild(firstChild);
            }
        }
        function maybeSelectFromResponse(elt, fragment) {
            var selector = getClosestAttributeValue(elt, "hx-select");
            if (selector) {
                var newFragment = getDocument().createDocumentFragment();
                forEach(fragment.querySelectorAll(selector), function (node) {
                    newFragment.appendChild(node);
                });
                fragment = newFragment;
            }
            return fragment;
        }
        function swap(swapStyle, elt, target, fragment, settleInfo) {
            switch (swapStyle) {
                case "none":
                    return;
                case "outerHTML":
                    swapOuterHTML(target, fragment, settleInfo);
                    return;
                case "afterbegin":
                    swapAfterBegin(target, fragment, settleInfo);
                    return;
                case "beforebegin":
                    swapBeforeBegin(target, fragment, settleInfo);
                    return;
                case "beforeend":
                    swapBeforeEnd(target, fragment, settleInfo);
                    return;
                case "afterend":
                    swapAfterEnd(target, fragment, settleInfo);
                    return;
                default:
                    var extensions = getExtensions(elt);
                    for (var i = 0; i < extensions.length; i++) {
                        var ext = extensions[i];
                        try {
                            var newElements = ext.handleSwap(swapStyle, target, fragment, settleInfo);
                            if (newElements) {
                                if (typeof newElements.length !== 'undefined') {
                                    // if handleSwap returns an array (like) of elements, we handle them
                                    for (var j = 0; j < newElements.length; j++) {
                                        var child = newElements[j];
                                        if (child.nodeType !== Node.TEXT_NODE && child.nodeType !== Node.COMMENT_NODE) {
                                            settleInfo.tasks.push(makeAjaxLoadTask(child));
                                        }
                                    }
                                }
                                return;
                            }
                        } catch (e) {
                            logError(e);
                        }
                    }
                    swapInnerHTML(target, fragment, settleInfo);
            }
        }
        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);
                if (result) {
                    return result[2];
                }
            }
        }
        function selectAndSwap(swapStyle, target, elt, responseText, settleInfo) {
            var title = findTitle(responseText);
            if(title) {
                var titleElt = find("title");
                if(titleElt) {
                    titleElt.innerHTML = title;
                } else {
                    window.document.title = title;
                }
            }
            var fragment = makeFragment(responseText);
            if (fragment) {
                handleOutOfBandSwaps(fragment, settleInfo);
                fragment = maybeSelectFromResponse(elt, fragment);
                handlePreservedElements(fragment);
                return swap(swapStyle, elt, target, fragment, settleInfo);
            }
        }
        function handleTrigger(xhr, header, elt) {
            var triggerBody = xhr.getResponseHeader(header);
            if (triggerBody.indexOf("{") === 0) {
                var triggers = parseJSON(triggerBody);
                for (var eventName in triggers) {
                    if (triggers.hasOwnProperty(eventName)) {
                        var detail = triggers[eventName];
                        if (!isRawObject(detail)) {
                            detail = {"value": detail}
                        }
                        triggerEvent(elt, eventName, detail);
                    }
                }
            } else {
                triggerEvent(elt, triggerBody, []);
            }
        }
        var WHITESPACE = /\s/;
        var WHITESPACE_OR_COMMA = /[\s,]/;
        var SYMBOL_START = /[_$a-zA-Z]/;
        var SYMBOL_CONT = /[_$a-zA-Z0-9]/;
        var STRINGISH_START = ['"', "'", "/"];
        var NOT_WHITESPACE = /[^\s]/;
        function tokenizeString(str) {
            var tokens = [];
            var position = 0;
            while (position < str.length) {
                if(SYMBOL_START.exec(str.charAt(position))) {
                    var startPosition = position;
                    while (SYMBOL_CONT.exec(str.charAt(position + 1))) {
                        position++;
                    }
                    tokens.push(str.substr(startPosition, position - startPosition + 1));
                } else if (STRINGISH_START.indexOf(str.charAt(position)) !== -1) {
                    var startChar = str.charAt(position);
                    var startPosition = position;
                    position++;
                    while (position < str.length && str.charAt(position) !== startChar ) {
                        if (str.charAt(position) === "\\") {
                            position++;
                        }
                        position++;
                    }
                    tokens.push(str.substr(startPosition, position - startPosition + 1));
                } else {
                    var symbol = str.charAt(position);
                    tokens.push(symbol);
                }
                position++;
            }
            return tokens;
        }
        function isPossibleRelativeReference(token, last, paramName) {
            return SYMBOL_START.exec(token.charAt(0)) &&
                token !== "true" &&
                token !== "false" &&
                token !== "this" &&
                token !== paramName &&
                last !== ".";
        }
        function maybeGenerateConditional(elt, tokens, paramName) {
            if (tokens[0] === '[') {
                tokens.shift();
                var bracketCount = 1;
                var conditionalSource = " return (function(" + paramName + "){ return (";
                var last = null;
                while (tokens.length > 0) {
                    var token = tokens[0];
                    if (token === "]") {
                        bracketCount--;
                        if (bracketCount === 0) {
                            if (last === null) {
                                conditionalSource = conditionalSource + "true";
                            }
                            tokens.shift();
                            conditionalSource += ")})";
                            try {
                                var conditionFunction = maybeEval(elt,function () {
                                    return Function(conditionalSource)();
                                    },
                                    function(){return true})
                                conditionFunction.source = conditionalSource;
                                return conditionFunction;
                            } catch (e) {
                                triggerErrorEvent(getDocument().body, "htmx:syntax:error", {error:e, source:conditionalSource})
                                return null;
                            }
                        }
                    } else if (token === "[") {
                        bracketCount++;
                    }
                    if (isPossibleRelativeReference(token, last, paramName)) {
                            conditionalSource += "((" + paramName + "." + token + ") ? (" + paramName + "." + token + ") : (window." + token + "))";
                    } else {
                        conditionalSource = conditionalSource + token;
                    }
                    last = tokens.shift();
                }
            }
        }
        function consumeUntil(tokens, match) {
            var result = "";
            while (tokens.length > 0 && !tokens[0].match(match)) {
                result += tokens.shift();
            }
            return result;
        }
        var INPUT_SELECTOR = 'input, textarea, select';
        /**
         * @param {HTMLElement} elt
         * @returns {import("./htmx").HtmxTriggerSpecification[]}
         */
        function getTriggerSpecs(elt) {
            var explicitTrigger = getAttributeValue(elt, 'hx-trigger');
            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 {
                            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();
                                    let from_arg = consumeUntil(tokens, WHITESPACE_OR_COMMA);
                                    if (from_arg === "closest" || from_arg === "find") {
                                        tokens.shift();
                                        from_arg +=
                                            " " +
                                            consumeUntil(
                                                tokens,
                                                WHITESPACE_OR_COMMA
                                            );
                                    }
                                    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()});
                                }
                            }
                            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 (triggerSpecs.length > 0) {
                return triggerSpecs;
            } else if (matches(elt, 'form')) {
                return [{trigger: 'submit'}];
            } else if (matches(elt, INPUT_SELECTOR)) {
                return [{trigger: 'change'}];
            } else {
                return [{trigger: 'click'}];
            }
        }
        function cancelPolling(elt) {
            getInternalData(elt).cancelled = true;
        }
        function processPolling(elt, verb, path, spec) {
            var nodeData = getInternalData(elt);
            nodeData.timeout = setTimeout(function () {
                if (bodyContains(elt) && nodeData.cancelled !== true) {
                    if (!maybeFilterEvent(spec, makeEvent('hx:poll:trigger', {triggerSpec:spec}))) {
                        issueAjaxRequest(verb, path, elt);
                    }
                    processPolling(elt, verb, getAttributeValue(elt, "hx-" + verb), spec);
                }
            }, spec.pollInterval);
        }
        function isLocalLink(elt) {
            return location.hostname === elt.hostname &&
                getRawAttribute(elt,'href') &&
                getRawAttribute(elt,'href').indexOf("#") !== 0;
        }
        function boostElement(elt, nodeData, triggerSpecs) {
            if ((elt.tagName === "A" && isLocalLink(elt) && elt.target === "") || elt.tagName === "FORM") {
                nodeData.boosted = true;
                var verb, path;
                if (elt.tagName === "A") {
                    verb = "get";
                    path = getRawAttribute(elt, 'href');
                    nodeData.pushURL = true;
                } else {
                    var rawAttribute = getRawAttribute(elt, "method");
                    verb = rawAttribute ? rawAttribute.toLowerCase() : "get";
                    if (verb === "get") {
                        nodeData.pushURL = true;
                    }
                    path = getRawAttribute(elt, 'action');
                }
                triggerSpecs.forEach(function(triggerSpec) {
                    addEventListener(elt, verb, path, nodeData, triggerSpec, true);
                });
            }
        }
        /**
         *
         * @param {Event} evt
         * @param {HTMLElement} elt
         * @returns
         */
        function shouldCancel(evt, elt) {
            if (evt.type === "submit" || evt.type === "click") {
                if (elt.tagName === "FORM") {
                    return true;
                }
                if (matches(elt, 'input[type="submit"], button') && closest(elt, 'form') !== null) {
                    return true;
                }
                if (elt.tagName === "A" && elt.href &&
                    (elt.getAttribute('href') === '#' || elt.getAttribute('href').indexOf("#") !== 0)) {
                    return true;
                }
            }
            return false;
        }
        function ignoreBoostedAnchorCtrlClick(elt, evt) {
            return getInternalData(elt).boosted && elt.tagName === "A" && evt.type === "click" && (evt.ctrlKey || evt.metaKey);
        }
        function maybeFilterEvent(triggerSpec, evt) {
            var eventFilter = triggerSpec.eventFilter;
            if(eventFilter){
                try {
                    return eventFilter(evt) !== true;
                } catch(e) {
                    triggerErrorEvent(getDocument().body, "htmx:eventFilter:error", {error: e, source:eventFilter.source});
                    return true;
                }
            }
            return false;
        }
        function addEventListener(elt, verb, path, nodeData, triggerSpec, explicitCancel) {
            var eltsToListenOn;
            if (triggerSpec.from) {
                eltsToListenOn = querySelectorAllExt(elt, triggerSpec.from);
            } else {
                eltsToListenOn = [elt];
            }
            forEach(eltsToListenOn, function (eltToListenOn) {
                var eventListener = function (evt) {
                    if (!bodyContains(elt)) {
                        eltToListenOn.removeEventListener(triggerSpec.trigger, eventListener);
                        return;
                    }
                    if (ignoreBoostedAnchorCtrlClick(elt, evt)) {
                        return;
                    }
                    if (explicitCancel || shouldCancel(evt, elt)) {
                        evt.preventDefault();
                    }
                    if (maybeFilterEvent(triggerSpec, evt)) {
                        return;
                    }
                    var eventData = getInternalData(evt);
                    eventData.triggerSpec = triggerSpec;
                    if (eventData.handledFor == null) {
                        eventData.handledFor = [];
                    }
                    var elementData = getInternalData(elt);
                    if (eventData.handledFor.indexOf(elt) < 0) {
                        eventData.handledFor.push(elt);
                        if (triggerSpec.consume) {
                            evt.stopPropagation();
                        }
                        if (triggerSpec.target && evt.target) {
                            if (!matches(evt.target, triggerSpec.target)) {
                                return;
                            }
                        }
                        if (triggerSpec.once) {
                            if (elementData.triggeredOnce) {
                                return;
                            } else {
                                elementData.triggeredOnce = true;
                            }
                        }
                        if (triggerSpec.changed) {
                            if (elementData.lastValue === elt.value) {
                                return;
                            } else {
                                elementData.lastValue = elt.value;
                            }
                        }
                        if (elementData.delayed) {
                            clearTimeout(elementData.delayed);
                        }
                        if (elementData.throttle) {
                            return;
                        }
                        if (triggerSpec.throttle) {
                            if (!elementData.throttle) {
                                issueAjaxRequest(verb, path, elt, evt);
                                elementData.throttle = setTimeout(function () {
                                    elementData.throttle = null;
                                }, triggerSpec.throttle);
                            }
                        } else if (triggerSpec.delay) {
                            elementData.delayed = setTimeout(function () {
                                issueAjaxRequest(verb, path, elt, evt);
                            }, triggerSpec.delay);
                        } else {
                            issueAjaxRequest(verb, path, elt, evt);
                        }
                    }
                };
                if (nodeData.listenerInfos == null) {
                    nodeData.listenerInfos = [];
                }
                nodeData.listenerInfos.push({
                    trigger: triggerSpec.trigger,
                    listener: eventListener,
                    on: eltToListenOn
                })
                eltToListenOn.addEventListener(triggerSpec.trigger, eventListener);
            })
        }
        var windowIsScrolling = false // used by initScrollHandler
        var scrollHandler = null;
        function initScrollHandler() {
            if (!scrollHandler) {
                scrollHandler = function() {
                    windowIsScrolling = true
                };
                window.addEventListener("scroll", scrollHandler)
                setInterval(function() {
                    if (windowIsScrolling) {
                        windowIsScrolling = false;
                        forEach(getDocument().querySelectorAll("[hx-trigger='revealed'],[data-hx-trigger='revealed']"), function (elt) {
                            maybeReveal(elt);
                        })
                    }
                }, 200);
            }
        }
        function maybeReveal(elt) {
            if (!hasAttribute(elt,'data-hx-revealed') && isScrolledIntoView(elt)) {
                elt.setAttribute('data-hx-revealed', 'true');
                var nodeData = getInternalData(elt);
                if (nodeData.initialized) {
                    issueAjaxRequest(nodeData.verb, nodeData.path, elt);
                } else {
                    // if the node isn't initialized, wait for it before triggering the request
                    elt.addEventListener("htmx:afterProcessNode",
                        function () {
                            issueAjaxRequest(nodeData.verb, nodeData.path, elt);
                        }, {once: true});
                }
            }
        }
        //====================================================================
        function loadImmediately(elt, verb, path, nodeData, delay) {
            var load = function(){
                if (!nodeData.loaded) {
                    nodeData.loaded = true;
                    issueAjaxRequest(verb, path, elt);
                }
            }
            if (delay) {
                setTimeout(load, delay);
            } else {
                load();
            }
        }
        function processVerbs(elt, nodeData, triggerSpecs) {
            var explicitAction = false;
            forEach(VERBS, function (verb) {
                if (hasAttribute(elt,'hx-' + verb)) {
                    var path = getAttributeValue(elt, 'hx-' + verb);
                    explicitAction = true;
                    nodeData.path = path;
                    nodeData.verb = verb;
                    triggerSpecs.forEach(function(triggerSpec) {
                        if (triggerSpec.trigger === "revealed") {
                            initScrollHandler();
                            maybeReveal(elt);
                        } else if (triggerSpec.trigger === "intersect") {
                            var observerOptions = {};
                            if (triggerSpec.root) {
                                observerOptions.root = querySelectorExt(elt, triggerSpec.root)
                            }
                            if (triggerSpec.threshold) {
                                observerOptions.threshold = parseFloat(triggerSpec.threshold);
                            }
                            var observer = new IntersectionObserver(function (entries) {
                                for (var i = 0; i < entries.length; i++) {
                                    var entry = entries[i];
                                    if (entry.isIntersecting) {
                                        triggerEvent(elt, "intersect");
                                        break;
                                    }
                                }
                            }, observerOptions);
                            observer.observe(elt);
                            addEventListener(elt, verb, path, nodeData, triggerSpec);
                        } else if (triggerSpec.trigger === "load") {
                            loadImmediately(elt, verb, path, nodeData, triggerSpec.delay);
                        } else if (triggerSpec.pollInterval) {
                            nodeData.polling = true;
                            processPolling(elt, verb, path, triggerSpec);
                        } else {
                            addEventListener(elt, verb, path, nodeData, triggerSpec);
                        }
                    });
                }
            });
            return explicitAction;
        }
        function evalScript(script) {
            if (script.type === "text/javascript" || script.type === "") {
                var newScript = getDocument().createElement("script");
                forEach(script.attributes, function (attr) {
                    newScript.setAttribute(attr.name, attr.value);
                });
                newScript.textContent = script.textContent;
                newScript.async = false;
                var parent = script.parentElement;
                try {
                    parent.insertBefore(newScript, script);
                } catch (e) {
                    logError(e);
                } finally {
                    parent.removeChild(script);
                }
            }
        }
        function processScripts(elt) {
            if (matches(elt, "script")) {
                evalScript(elt);
            }
            forEach(findAll(elt, "script"), function (script) {
                evalScript(script);
            });
        }
        function isBoosted() {
            return document.querySelector("[hx-boost], [data-hx-boost]");
        }
        function findElementsToProcess(elt) {
            if (elt.querySelectorAll) {
                var boostedElts = isBoosted() ? ", a, form" : "";
                var results = elt.querySelectorAll(VERB_SELECTOR + boostedElts + ", [hx-ext], [data-hx-ext]");
                return results;
            } else {
                return [];
            }
        }
        function initButtonTracking(form){
            var maybeSetLastButtonClicked = function(evt){
                if (matches(evt.target, "button, input[type='submit']")) {
                    var internalData = getInternalData(form);
                    internalData.lastButtonClicked = evt.target;
                }
            };
            // 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;
            })
        }
        function initNode(elt) {
            if (elt.closest && elt.closest(htmx.config.disableSelector)) {
                return;
            }
            var nodeData = getInternalData(elt);
            if (!nodeData.initialized) {
                nodeData.initialized = true;
                triggerEvent(elt, "htmx:beforeProcessNode")
                if (elt.value) {
                    nodeData.lastValue = elt.value;
                }
                var triggerSpecs = getTriggerSpecs(elt);
                var explicitAction = processVerbs(elt, nodeData, triggerSpecs);
                if (!explicitAction && getClosestAttributeValue(elt, "hx-boost") === "true") {
                    boostElement(elt, nodeData, triggerSpecs);
                }
                if (elt.tagName === "FORM") {
                    initButtonTracking(elt);
                }
                triggerEvent(elt, "htmx:afterProcessNode");
            }
        }
        function processNode(elt) {
            elt = resolveTarget(elt);
            initNode(elt);
            forEach(findElementsToProcess(elt), function(child) { initNode(child) });
        }
        //====================================================================
        // Event/Log Support
        //====================================================================
        function kebabEventName(str) {
            return str.replace(/([a-z0-9])([A-Z])/g, '$1-$2').toLowerCase();
        }
        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 = getDocument().createEvent('CustomEvent');
                evt.initCustomEvent(eventName, true, true, detail);
            }
            return evt;
        }
        function triggerErrorEvent(elt, eventName, detail) {
            triggerEvent(elt, eventName, mergeObjects({error:eventName}, detail));
        }
        function ignoreEventForLogging(eventName) {
            return eventName === "htmx:afterProcessNode"
        }
        /**
         * `withExtensions` locates all active extensions for a provided element, then
         * executes the provided function using each of the active extensions.  It should
         * be called internally at every extendable execution point in htmx.
         *
         * @param {HTMLElement} elt
         * @param {(extension:import("./htmx").HtmxExtension) => void} toDo
         * @returns void
         */
        function withExtensions(elt, toDo) {
            forEach(getExtensions(elt), function(extension){
                try {
                    toDo(extension);
                } catch (e) {
                    logError(e);
                }
            });
        }
        function logError(msg) {
            if(console.error) {
                console.error(msg);
            } else if (console.log) {
                console.log("ERROR: ", msg);
            }
        }
        function triggerEvent(elt, eventName, detail) {
            elt = resolveTarget(elt);
            if (detail == null) {
                detail = {};
            }
            detail["elt"] = elt;
            var event = makeEvent(eventName, detail);
            if (htmx.logger && !ignoreEventForLogging(eventName)) {
                htmx.logger(elt, eventName, detail);
            }
            if (detail.error) {
                logError(detail.error);
                triggerEvent(elt, "htmx:error", {errorInfo:detail})
            }
            var eventResult = elt.dispatchEvent(event);
            var kebabName = kebabEventName(eventName);
            if (eventResult && kebabName !== eventName) {
                var kebabedEvent = makeEvent(kebabName, event.detail);
                eventResult = eventResult && elt.dispatchEvent(kebabedEvent)
            }
            withExtensions(elt, function (extension) {
                eventResult = eventResult && (extension.onEvent(eventName, event) !== false)
            });
            return eventResult;
        }
        //====================================================================
        // History Support
        //====================================================================
        var currentPathForHistory = location.pathname+location.search;
        function getHistoryElement() {
            var historyElt = getDocument().querySelector('[hx-history-elt],[data-hx-history-elt]');
            return historyElt || getDocument().body;
        }
        function saveToHistoryCache(url, content, title, scroll) {
            var historyCache = parseJSON(localStorage.getItem("htmx-history-cache")) || [];
            for (var i = 0; i < historyCache.length; i++) {
                if (historyCache[i].url === url) {
                    historyCache.splice(i, 1);
                    break;
                }
            }
            historyCache.push({url:url, content: content, title:title, scroll:scroll})
            while (historyCache.length > htmx.config.historyCacheSize) {
                historyCache.shift();
            }
            while(historyCache.length > 0){
                try {
                    localStorage.setItem("htmx-history-cache", JSON.stringify(historyCache));
                    break;
                } catch (e) {
                    triggerErrorEvent(getDocument().body, "htmx:historyCacheError", {cause:e, cache: historyCache})
                    historyCache.shift(); // shrink the cache and retry
                }
            }
        }
        function getCachedHistory(url) {
            var historyCache = parseJSON(localStorage.getItem("htmx-history-cache")) || [];
            for (var i = 0; i < historyCache.length; i++) {
                if (historyCache[i].url === url) {
                    return historyCache[i];
                }
            }
            return null;
        }
        function cleanInnerHtmlForHistory(elt) {
            var className = htmx.config.requestClass;
            var clone = elt.cloneNode(true);
            forEach(findAll(clone, "." + className), function(child){
                removeClassFromElement(child, className);
            });
            return clone.innerHTML;
        }
        function saveHistory() {
            var elt = getHistoryElement();
            var path = currentPathForHistory || location.pathname+location.search;
            triggerEvent(getDocument().body, "htmx:beforeHistorySave", {path:path, historyElt:elt});
            if(htmx.config.historyEnabled) history.replaceState({htmx:true}, getDocument().title, window.location.href);
            saveToHistoryCache(path, cleanInnerHtmlForHistory(elt), getDocument().title, window.scrollY);
        }
        function pushUrlIntoHistory(path) {
            if(htmx.config.historyEnabled)  history.pushState({htmx:true}, "", path);
            currentPathForHistory = path;
        }
        function settleImmediately(tasks) {
            forEach(tasks, function (task) {
                task.call();
            });
        }
        function loadHistoryFromServer(path) {
            var request = new XMLHttpRequest();
            var details = {path: path, xhr:request};
            triggerEvent(getDocument().body, "htmx:historyCacheMiss", details);
            request.open('GET', path, true);
            request.setRequestHeader("HX-History-Restore-Request", "true");
            request.onload = function () {
                if (this.status >= 200 && this.status < 400) {
                    triggerEvent(getDocument().body, "htmx:historyCacheMissLoad", details);
                    var fragment = makeFragment(this.response);
                    // @ts-ignore
                    fragment = fragment.querySelector('[hx-history-elt],[data-hx-history-elt]') || fragment;
                    var historyElement = getHistoryElement();
                    var settleInfo = makeSettleInfo(historyElement);
                    // @ts-ignore
                    swapInnerHTML(historyElement, fragment, settleInfo)
                    settleImmediately(settleInfo.tasks);
                    currentPathForHistory = path;
                    triggerEvent(getDocument().body, "htmx:historyRestore", {path:path});
                } else {
                    triggerErrorEvent(getDocument().body, "htmx:historyCacheMissLoadError", details);
                }
            };
            request.send();
        }
        function restoreHistory(path) {
            saveHistory();
            path = path || location.pathname+location.search;
            var cached = getCachedHistory(path);
            if (cached) {
                var fragment = makeFragment(cached.content);
                var historyElement = getHistoryElement();
                var settleInfo = makeSettleInfo(historyElement);
                swapInnerHTML(historyElement, fragment, settleInfo)
                settleImmediately(settleInfo.tasks);
                document.title = cached.title;
                window.scrollTo(0, cached.scroll);
                currentPathForHistory = path;
                triggerEvent(getDocument().body, "htmx:historyRestore", {path:path});
            } else {
                if (htmx.config.refreshOnHistoryMiss) {
                    // @ts-ignore: optional parameter in reload() function throws error
                    window.location.reload(true);
                } else {
                    loadHistoryFromServer(path);
                }
            }
        }
        function shouldPush(elt) {
            var pushUrl = getClosestAttributeValue(elt, "hx-push-url");
            return (pushUrl && pushUrl !== "false") ||
                (getInternalData(elt).boosted && getInternalData(elt).pushURL);
        }
        function getPushUrl(elt) {
            var pushUrl = getClosestAttributeValue(elt, "hx-push-url");
            return (pushUrl === "true" || pushUrl === "false") ? null : pushUrl;
        }
        function addRequestIndicatorClasses(elt) {
            var indicator = getClosestAttributeValue(elt, 'hx-indicator');
            if (indicator) {
                var indicators = querySelectorAllExt(elt, indicator);
            } else {
                indicators = [elt];
            }
            forEach(indicators, function (ic) {
                ic.classList["add"].call(ic.classList, htmx.config.requestClass);
            });
            return indicators;
        }
        function removeRequestIndicatorClasses(indicators) {
            forEach(indicators, function (ic) {
                ic.classList["remove"].call(ic.classList, htmx.config.requestClass);
            });
        }
        //====================================================================
        // Input Value Processing
        //====================================================================
        function haveSeenNode(processed, elt) {
            for (var i = 0; i < processed.length; i++) {
                var node = processed[i];
                if (node.isSameNode(elt)) {
                    return true;
                }
            }
            return false;
        }
        function shouldInclude(elt) {
            if(elt.name === "" || elt.name == null || elt.disabled) {
                return false;
            }
            // ignore "submitter" types (see jQuery src/serialize.js)
            if (elt.type === "button" || elt.type === "submit" || elt.tagName === "image" || elt.tagName === "reset" || elt.tagName === "file" ) {
                return false;
            }
            if (elt.type === "checkbox" || elt.type === "radio" ) {
                return elt.checked;
            }
            return true;
        }
        function processInputValue(processed, values, errors, elt, validate) {
            if (elt == null || haveSeenNode(processed, elt)) {
                return;
            } else {
                processed.push(elt);
            }
            if (shouldInclude(elt)) {
                var name = getRawAttribute(elt,"name");
                var value = elt.value;
                if (elt.multiple) {
                    value = toArray(elt.querySelectorAll("option:checked")).map(function (e) { return e.value });
                }
                // include file inputs
                if (elt.files) {
                    value = toArray(elt.files);
                }
                // This is a little ugly because both the current value of the named value in the form
                // and the new value could be arrays, so we have to handle all four cases :/
                if (name != null && value != null) {
                    var current = values[name];
                    if(current) {
                        if (Array.isArray(current)) {
                            if (Array.isArray(value)) {
                                values[name] = current.concat(value);
                            } else {
                                current.push(value);
                            }
                        } else {
                            if (Array.isArray(value)) {
                                values[name] = [current].concat(value);
                            } else {
                                values[name] = [current, value];
                            }
                        }
                    } else {
                        values[name] = value;
                    }
                }
                if (validate) {
                    validateElement(elt, errors);
                }
            }
            if (matches(elt, 'form')) {
                var inputs = elt.elements;
                forEach(inputs, function(input) {
                    processInputValue(processed, values, errors, input, validate);
                });
            }
        }
        function validateElement(element, errors) {
            if (element.willValidate) {
                triggerEvent(element, "htmx:validation:validate")
                if (!element.checkValidity()) {
                    errors.push({elt: element, message:element.validationMessage, validity:element.validity});
                    triggerEvent(element, "htmx:validation:failed", {message:element.validationMessage, validity:element.validity})
                }
            }
        }
        /**
         * @param {HTMLElement} elt
         * @param {string} verb
         */
        function getInputValues(elt, verb) {
            var processed = [];
            var values = {};
            var formValues = {};
            var errors = [];
            // only validate when form is directly submitted and novalidate is not set
            var validate = matches(elt, 'form') && elt.noValidate !== true;
            // for a non-GET include the closest form
            if (verb !== 'get') {
                processInputValue(processed, formValues, errors, closest(elt, 'form'), validate);
            }
            // include the element itself
            processInputValue(processed, values, errors, elt, validate);
            // if a button or submit was clicked last, include its value
            var internalData = getInternalData(elt);
            if (internalData.lastButtonClicked) {
                var name = getRawAttribute(internalData.lastButtonClicked,"name");
                if (name) {
                    values[name] = internalData.lastButtonClicked.value;
                }
            }
            // include any explicit includes
            var includes = getClosestAttributeValue(elt, "hx-include");
            if (includes) {
                var nodes = querySelectorAllExt(elt, includes);
                forEach(nodes, function(node) {
                    processInputValue(processed, values, errors, node, validate);
                    // if a non-form is included, include any input values within it
                    if (!matches(node, 'form')) {
                        forEach(node.querySelectorAll(INPUT_SELECTOR), function (descendant) {
                            processInputValue(processed, values, errors, descendant, validate);
                        })
                    }
                });
            }
            // form values take precedence, overriding the regular values
            values = mergeObjects(values, formValues);
            return {errors:errors, values:values};
        }
        function appendParam(returnStr, name, realValue) {
            if (returnStr !== "") {
                returnStr += "&";
            }
            returnStr += encodeURIComponent(name) + "=" + encodeURIComponent(realValue);
            return returnStr;
        }
        function urlEncode(values) {
            var returnStr = "";
            for (var name in values) {
                if (values.hasOwnProperty(name)) {
                    var value = values[name];
                    if (Array.isArray(value)) {
                        forEach(value, function(v) {
                            returnStr = appendParam(returnStr, name, v);
                        });
                    } else {
                        returnStr = appendParam(returnStr, name, value);
                    }
                }
            }
            return returnStr;
        }
        function makeFormData(values) {
            var formData = new FormData();
            for (var name in values) {
                if (values.hasOwnProperty(name)) {
                    var value = values[name];
                    if (Array.isArray(value)) {
                        forEach(value, function(v) {
                            formData.append(name, v);
                        });
                    } else {
                        formData.append(name, value);
                    }
                }
            }
            return formData;
        }
        //====================================================================
        // Ajax
        //====================================================================
        /**
         * @param {HTMLElement} elt
         * @param {HTMLElement} target
         * @param {string} prompt
         * @returns {Object} // TODO: Define/Improve HtmxHeaderSpecification
         */
        function getHeaders(elt, target, prompt) {
            var headers = {
                "HX-Request" : "true",
                "HX-Trigger" : getRawAttribute(elt, "id"),
                "HX-Trigger-Name" : getRawAttribute(elt, "name"),
                "HX-Target" : getAttributeValue(target, "id"),
                "HX-Current-URL" : getDocument().location.href,
            }
            getValuesForElement(elt, "hx-headers", false, headers)
            if (prompt !== undefined) {
                headers["HX-Prompt"] = prompt;
            }
            if (getInternalData(elt).boosted) {
                headers["HX-Boosted"] = "true";
            }
            return headers;
        }
        /**
         * filterValues takes an object containing form input values
         * and returns a new object that only contains keys that are
         * specified by the closest "hx-params" attribute
         * @param {Object} inputValues
         * @param {HTMLElement} elt
         * @returns {Object}
         */
        function filterValues(inputValues, elt) {
            var paramsValue = getClosestAttributeValue(elt, "hx-params");
            if (paramsValue) {
                if (paramsValue === "none") {
                    return {};
                } else if (paramsValue === "*") {
                    return inputValues;
                } else if(paramsValue.indexOf("not ") === 0) {
                    forEach(paramsValue.substr(4).split(","), function (name) {
                        name = name.trim();
                        delete inputValues[name];
                    });
                    return inputValues;
                } else {
                    var newValues = {}
                    forEach(paramsValue.split(","), function (name) {
                        name = name.trim();
                        newValues[name] = inputValues[name];
                    });
                    return newValues;
                }
            } else {
                return inputValues;
            }
        }
        function isAnchorLink(elt) {
          return getRawAttribute(elt, 'href') && getRawAttribute(elt, 'href').indexOf("#") >=0
        }
        /**
         *
         * @param {HTMLElement} elt
         * @returns {import("./htmx").HtmxSwapSpecification}
         */
        function getSwapSpecification(elt) {
            var swapInfo = getClosestAttributeValue(elt, "hx-swap");
            var swapSpec = {
                "swapStyle" : getInternalData(elt).boosted ? 'innerHTML' : htmx.config.defaultSwapStyle,
                "swapDelay" : htmx.config.defaultSwapDelay,
                "settleDelay" : htmx.config.defaultSettleDelay
            }
            if (getInternalData(elt).boosted && !isAnchorLink(elt)) {
              swapSpec["show"] = "top"
            }
            if (swapInfo) {
                var split = splitOnWhitespace(swapInfo);
                if (split.length > 0) {
                    swapSpec["swapStyle"] = split[0];
                    for (var i = 1; i < split.length; i++) {
                        var modifier = split[i];
                        if (modifier.indexOf("swap:") === 0) {
                            swapSpec["swapDelay"] = parseInterval(modifier.substr(5));
                        }
                        if (modifier.indexOf("settle:") === 0) {
                            swapSpec["settleDelay"] = parseInterval(modifier.substr(7));
                        }
                        if (modifier.indexOf("scroll:") === 0) {
                            var scrollSpec = modifier.substr(7);
                            var splitSpec = scrollSpec.split(":");
                            var scrollVal = splitSpec.pop();
                            var selectorVal = splitSpec.length > 0 ? splitSpec.join(":") : null;
                            swapSpec["scroll"] = scrollVal;
                            swapSpec["scrollTarget"] = selectorVal;
                        }
                        if (modifier.indexOf("show:") === 0) {
                            var showSpec = modifier.substr(5);
                            var splitSpec = showSpec.split(":");
                            var showVal = splitSpec.pop();
                            var selectorVal = splitSpec.length > 0 ? splitSpec.join(":") : null;
                            swapSpec["show"] = showVal;
                            swapSpec["showTarget"] = selectorVal;
                        }
                    }
                }
            }
            return swapSpec;
        }
        function encodeParamsForBody(xhr, elt, filteredParameters) {
            var encodedParameters = null;
            withExtensions(elt, function (extension) {
                if (encodedParameters == null) {
                    encodedParameters = extension.encodeParameters(xhr, filteredParameters, elt);
                }
            });
            if (encodedParameters != null) {
                return encodedParameters;
            } else {
                if (getClosestAttributeValue(elt, "hx-encoding") === "multipart/form-data" ||
                    (matches(elt, "form") && getRawAttribute(elt, 'enctype') === "multipart/form-data")) {
                    return makeFormData(filteredParameters);
                } else {
                    return urlEncode(filteredParameters);
                }
            }
        }
        /**
         *
         * @param {Element} target
         * @returns {import("./htmx").HtmxSettleInfo}
         */
        function makeSettleInfo(target) {
            return {tasks: [], elts: [target]};
        }
        function updateScrollState(content, swapSpec) {
            var first = content[0];
            var last = content[content.length - 1];
            if (swapSpec.scroll) {
                var target = null;
                if (swapSpec.scrollTarget) {
                    target = querySelectorExt(first, swapSpec.scrollTarget);
                }
                if (swapSpec.scroll === "top" && (first || target)) {
                    target = target || first;
                    target.scrollTop = 0;
                }
                if (swapSpec.scroll === "bottom" && (last || target)) {
                    target = target || last;
                    target.scrollTop = target.scrollHeight;
                }
            }
            if (swapSpec.show) {
                var target = null;
                if (swapSpec.showTarget) {
                    var targetStr = swapSpec.showTarget;
                    if (swapSpec.showTarget === "window") {
                        targetStr = "body";
                    }
                    target = querySelectorExt(first, targetStr);
                }
                if (swapSpec.show === "top" && (first || target)) {
                    target = target || first;
                    target.scrollIntoView({block:'start', behavior: htmx.config.scrollBehavior});
                }
                if (swapSpec.show === "bottom" && (last || target)) {
                    target = target || last;
                    target.scrollIntoView({block:'end', behavior: htmx.config.scrollBehavior});
                }
            }
        }
        /**
         * @param {HTMLElement} elt
         * @param {string} attr
         * @param {boolean=} evalAsDefault
         * @param {Object=} values
         * @returns {Object}
         */
        function getValuesForElement(elt, attr, evalAsDefault, values) {
            if (values == null) {
                values = {};
            }
            if (elt == null) {
                return values;
            }
            var attributeValue = getAttributeValue(elt, attr);
            if (attributeValue) {
                var str = attributeValue.trim();
                var evaluateValue = evalAsDefault;
                if (str.indexOf("javascript:") === 0) {
                    str = str.substr(11);
                    evaluateValue = true;
                } else if (str.indexOf("js:") === 0) {
                    str = str.substr(3);
                    evaluateValue = true;
                }
                if (str.indexOf('{') !== 0) {
                    str = "{" + str + "}";
                }
                var varsValues;
                if (evaluateValue) {
                    varsValues = maybeEval(elt,function () {return Function("return (" + str + ")")();}, {});
                } else {
                    varsValues = parseJSON(str);
                }
                for (var key in varsValues) {
                    if (varsValues.hasOwnProperty(key)) {
                        if (values[key] == null) {
                            values[key] = varsValues[key];
                        }
                    }
                }
            }
            return getValuesForElement(parentElt(elt), attr, evalAsDefault, values);
        }
        function maybeEval(elt, toEval, defaultVal) {
            if (htmx.config.allowEval) {
                return toEval();
            } else {
                triggerErrorEvent(elt, 'htmx:evalDisallowedError');
                return defaultVal;
            }
        }
        /**
         * @param {HTMLElement} elt
         * @param {*} expressionVars
         * @returns
         */
        function getHXVarsForElement(elt, expressionVars) {
            return getValuesForElement(elt, "hx-vars", true, expressionVars);
        }
        /**
         * @param {HTMLElement} elt
         * @param {*} expressionVars
         * @returns
         */
        function getHXValsForElement(elt, expressionVars) {
            return getValuesForElement(elt, "hx-vals", false, expressionVars);
        }
        /**
         * @param {HTMLElement} elt
         * @returns {Object}
         */
        function getExpressionVars(elt) {
            return mergeObjects(getHXVarsForElement(elt), getHXValsForElement(elt));
        }
        function safelySetHeaderValue(xhr, header, headerValue) {
            if (headerValue !== null) {
                try {
                    xhr.setRequestHeader(header, headerValue);
                } catch (e) {
                    // On an exception, try to set the header URI encoded instead
                    xhr.setRequestHeader(header, encodeURIComponent(headerValue));
                    xhr.setRequestHeader(header + "-URI-AutoEncoded", "true");
                }
            }
        }
        function getResponseURL(xhr) {
            // NB: IE11 does not support this stuff
            if (xhr.responseURL && typeof(URL) !== "undefined") {
                try {
                    var url = new URL(xhr.responseURL);
                    return url.pathname + url.search;
                } catch (e) {
                    triggerErrorEvent(getDocument().body, "htmx:badResponseUrl", {url: xhr.responseURL});
                }
            }
        }
        function hasHeader(xhr, regexp) {
            return xhr.getAllResponseHeaders().match(regexp);
        }
        function ajaxHelper(verb, path, context) {
            verb = verb.toLowerCase();
            if (context) {
                if (context instanceof Element || isType(context, 'String')) {
                    return issueAjaxRequest(verb, path, null, null, {
                        targetOverride: resolveTarget(context),
                        returnPromise: true
                    });
                } else {
                    return issueAjaxRequest(verb, path, resolveTarget(context.source), context.event,
                        {
                            handler : context.handler,
                            headers : context.headers,
                            values : context.values,
                            targetOverride: resolveTarget(context.target),
                            returnPromise: true
                        });
                }
            } else {
                return issueAjaxRequest(verb, path, null, null, {
                        returnPromise: true
                });
            }
        }
        function hierarchyForElt(elt) {
            var arr = [];
            while (elt) {
                arr.push(elt);
                elt = elt.parentElement;
            }
            return arr;
        }
        function issueAjaxRequest(verb, path, elt, event, etc) {
            var resolve = null;
            var reject = null;
            etc = etc != null ? etc : {};
            if(etc.returnPromise && typeof Promise !== "undefined"){
                var promise = new Promise(function (_resolve, _reject) {
                    resolve = _resolve;
                    reject = _reject;
                });
            }
            if(elt == null) {
                elt = getDocument().body;
            }
            var responseHandler = etc.handler || handleAjaxResponse;
            if (!bodyContains(elt)) {
                return; // do not issue requests for elements removed from the DOM
            }
            var target = etc.targetOverride || getTarget(elt);
            if (target == null) {
                triggerErrorEvent(elt, 'htmx:targetError', {target: getAttributeValue(elt, "hx-target")});
                return;
            }
            var eltData = getInternalData(elt);
            if (eltData.requestInFlight) {
                var queueStrategy = 'last';
                if (event) {
                    var eventData = getInternalData(event);
                    if (eventData && eventData.triggerSpec && eventData.triggerSpec.queue) {
                        queueStrategy = eventData.triggerSpec.queue;
                    }
                }
                if (eltData.queuedRequests == null) {
                    eltData.queuedRequests = [];
                }
                if (queueStrategy === "first" && eltData.queuedRequests.length === 0) {
                    eltData.queuedRequests.push(function () {
                        issueAjaxRequest(verb, path, elt, event, etc)
                    });
                } else if (queueStrategy === "all") {
                    eltData.queuedRequests.push(function () {
                        issueAjaxRequest(verb, path, elt, event, etc)
                    });
                } else if (queueStrategy === "last") {
                    eltData.queuedRequests = []; // dump existing queue
                    eltData.queuedRequests.push(function () {
                        issueAjaxRequest(verb, path, elt, event, etc)
                    });
                }
                return;
            } else {
                eltData.requestInFlight = true;
            }
            var endRequestLock = function(){
                eltData.requestInFlight = false
                if (eltData.queuedRequests != null &&
                    eltData.queuedRequests.length > 0) {
                    var queuedRequest = eltData.queuedRequests.shift();
                    queuedRequest();
                }
            }
            var promptQuestion = getClosestAttributeValue(elt, "hx-prompt");
            if (promptQuestion) {
                var promptResponse = prompt(promptQuestion);
                // prompt returns null if cancelled and empty string if accepted with no entry
                if (promptResponse === null ||
                    !triggerEvent(elt, 'htmx:prompt', {prompt: promptResponse, target:target})) {
                    maybeCall(resolve);
                    endRequestLock();
                    return promise;
                }
            }
            var confirmQuestion = getClosestAttributeValue(elt, "hx-confirm");
            if (confirmQuestion) {
                if(!confirm(confirmQuestion)) {
                    maybeCall(resolve);
                    endRequestLock()
                    return promise;
                }
            }
            var xhr = new XMLHttpRequest();
            var headers = getHeaders(elt, target, promptResponse);
            if (etc.headers) {
                headers = mergeObjects(headers, etc.headers);
            }
            var results = getInputValues(elt, verb);
            var errors = results.errors;
            var rawParameters = results.values;
            if (etc.values) {
                rawParameters = mergeObjects(rawParameters, etc.values);
            }
            var expressionVars = getExpressionVars(elt);
            var allParameters = mergeObjects(rawParameters, expressionVars);
            var filteredParameters = filterValues(allParameters, elt);
            if (verb !== 'get' && getClosestAttributeValue(elt, "hx-encoding") == null) {
                headers['Content-Type'] = 'application/x-www-form-urlencoded; charset=UTF-8';
            }
            // behavior of anchors w/ empty href is to use the current URL
            if (path == null || path === "") {
                path = getDocument().location.href;
            }
            var requestAttrValues = getValuesForElement(elt, 'hx-request');
            var requestConfig = {
                parameters: filteredParameters,
                unfilteredParameters: allParameters,
                headers:headers,
                target:target,
                verb:verb,
                errors:errors,
                withCredentials: etc.credentials || requestAttrValues.credentials || htmx.config.withCredentials,
                timeout:  etc.timeout || requestAttrValues.timeout || htmx.config.timeout,
                path:path,
                triggeringEvent:event
            };
            if(!triggerEvent(elt, 'htmx:configRequest', requestConfig)){
                maybeCall(resolve);
                endRequestLock();
                return promise;
            }
            // copy out in case the object was overwritten
            path = requestConfig.path;
            verb = requestConfig.verb;
            headers = requestConfig.headers;
            filteredParameters = requestConfig.parameters;
            errors = requestConfig.errors;
            if(errors && errors.length > 0){
                triggerEvent(elt, 'htmx:validation:halted', requestConfig)
                maybeCall(resolve);
                endRequestLock();
                return promise;
            }
            var splitPath = path.split("#");
            var pathNoAnchor = splitPath[0];
            var anchor = splitPath[1];
            if (verb === 'get') {
                var finalPathForGet = pathNoAnchor;
                var values = Object.keys(filteredParameters).length !== 0;
                if (values) {
                    if (finalPathForGet.indexOf("?") < 0) {
                        finalPathForGet += "?";
                    } else {
                        finalPathForGet += "&";
                    }
                    finalPathForGet += urlEncode(filteredParameters);
                    if (anchor) {
                        finalPathForGet += "#" + anchor;
                    }
                }
                xhr.open('GET', finalPathForGet, true);
            } else {
                xhr.open(verb.toUpperCase(), path, true);
            }
            xhr.overrideMimeType("text/html");
            xhr.withCredentials = requestConfig.withCredentials;
            xhr.timeout = requestConfig.timeout;
            // request headers
            if (requestAttrValues.noHeaders) {
                // ignore all headers
            } else {
                for (var header in headers) {
                    if (headers.hasOwnProperty(header)) {
                        var headerValue = headers[header];
                        safelySetHeaderValue(xhr, header, headerValue);
                    }
                }
            }
            var responseInfo = {xhr: xhr, target: target, requestConfig: requestConfig, pathInfo:{
                  path:path, finalPath:finalPathForGet, anchor:anchor
                }
            };
            xhr.onload = function () {
                try {
                    var hierarchy = hierarchyForElt(elt);
                    responseHandler(elt, responseInfo);
                    removeRequestIndicatorClasses(indicators);
                    triggerEvent(elt, 'htmx:afterRequest', responseInfo);
                    triggerEvent(elt, 'htmx:afterOnLoad', responseInfo);
                    // if the body no longer contains the element, trigger the even on the closest parent
                    // remaining in the DOM
                    if (!bodyContains(elt)) {
                        var secondaryTriggerElt = null;
                        while (hierarchy.length > 0 && secondaryTriggerElt == null) {
                            var parentEltInHierarchy = hierarchy.shift();
                            if (bodyContains(parentEltInHierarchy)) {
                                secondaryTriggerElt = parentEltInHierarchy;
                            }
                        }
                        if (secondaryTriggerElt) {
                            triggerEvent(secondaryTriggerElt, 'htmx:afterRequest', responseInfo);
                            triggerEvent(secondaryTriggerElt, 'htmx:afterOnLoad', responseInfo);
                        }
                    }
                    maybeCall(resolve);
                    endRequestLock();
                } catch (e) {
                    triggerErrorEvent(elt, 'htmx:onLoadError', mergeObjects({error:e}, responseInfo));
                    throw e;
                }
            }
            xhr.onerror = function () {
                removeRequestIndicatorClasses(indicators);
                triggerErrorEvent(elt, 'htmx:afterRequest', responseInfo);
                triggerErrorEvent(elt, 'htmx:sendError', responseInfo);
                maybeCall(reject);
                endRequestLock();
            }
            xhr.onabort = function() {
                removeRequestIndicatorClasses(indicators);
                triggerErrorEvent(elt, 'htmx:afterRequest', responseInfo);
                triggerErrorEvent(elt, 'htmx:sendAbort', responseInfo);
                maybeCall(reject);
                endRequestLock();
            }
            xhr.ontimeout = function() {
                removeRequestIndicatorClasses(indicators);
                triggerErrorEvent(elt, 'htmx:afterRequest', responseInfo);
                triggerErrorEvent(elt, 'htmx:timeout', responseInfo);
                maybeCall(reject);
                endRequestLock();
            }
            if(!triggerEvent(elt, 'htmx:beforeRequest', responseInfo)){
                maybeCall(resolve);
                endRequestLock()
                return promise
            }
            var indicators = addRequestIndicatorClasses(elt);
            forEach(['loadstart', 'loadend', 'progress', 'abort'], function(eventName) {
                forEach([xhr, xhr.upload], function (target) {
                    target.addEventListener(eventName, function(event){
                        triggerEvent(elt, "htmx:xhr:" + eventName, {
                            lengthComputable:event.lengthComputable,
                            loaded:event.loaded,
                            total:event.total
                        });
                    })
                });
            });
            triggerEvent(elt, 'htmx:beforeSend', responseInfo);
            xhr.send(verb === 'get' ? null : encodeParamsForBody(xhr, elt, filteredParameters));
            return promise;
        }
        function handleAjaxResponse(elt, responseInfo) {
            var xhr = responseInfo.xhr;
            var target = responseInfo.target;
            if (!triggerEvent(elt, 'htmx:beforeOnLoad', responseInfo)) return;
            if (hasHeader(xhr, /HX-Trigger:/i)) {
                handleTrigger(xhr, "HX-Trigger", elt);
            }
            if (hasHeader(xhr,/HX-Push:/i)) {
                var pushedUrl = xhr.getResponseHeader("HX-Push");
            }
            if (hasHeader(xhr, /HX-Redirect:/i)) {
                window.location.href = xhr.getResponseHeader("HX-Redirect");
                return;
            }
            if (hasHeader(xhr,/HX-Refresh:/i)) {
                if ("true" === xhr.getResponseHeader("HX-Refresh")) {
                    location.reload();
                    return;
                }
            }
            if (hasHeader(xhr,/HX-Retarget:/i)) {
                responseInfo.target = getDocument().querySelector(xhr.getResponseHeader("HX-Retarget"));
            }
            var shouldSaveHistory = shouldPush(elt) || pushedUrl;
            // by default htmx only swaps on 200 return codes and does not swap
            // on 204 'No Content'
            // this can be ovverriden by responding to the htmx:beforeSwap event and
            // overriding the detail.shouldSwap property
            var shouldSwap = xhr.status >= 200 && xhr.status < 400 && xhr.status !== 204;
            var serverResponse = xhr.response;
            var isError = xhr.status >= 400;
            var beforeSwapDetails = mergeObjects({shouldSwap: shouldSwap, serverResponse:serverResponse, isError:isError}, responseInfo);
            if (!triggerEvent(target, 'htmx:beforeSwap', beforeSwapDetails)) return;
            target = beforeSwapDetails.target; // allow re-targeting
            serverResponse = beforeSwapDetails.serverResponse; // allow updating content
            isError = beforeSwapDetails.isError; // allow updating error
            responseInfo.failed = isError; // Make failed property available to response events
            responseInfo.successful = !isError; // Make successful property available to response events
            if (beforeSwapDetails.shouldSwap) {
                if (xhr.status === 286) {
                    cancelPolling(elt);
                }
                withExtensions(elt, function (extension) {
                    serverResponse = extension.transformResponse(serverResponse, xhr, elt);
                });
                // Save current page
                if (shouldSaveHistory) {
                    saveHistory();
                }
                var swapSpec = getSwapSpecification(elt);
                target.classList.add(htmx.config.swappingClass);
                var doSwap = function () {
                    try {
                        var activeElt = document.activeElement;
                        var selectionInfo = {};
                        try {
                            selectionInfo = {
                                elt: activeElt,
                                // @ts-ignore
                                start: activeElt ? activeElt.selectionStart : null,
                                // @ts-ignore
                                end: activeElt ? activeElt.selectionEnd : null
                            };
                        } catch (e) {
                            // safari issue - see https://github.com/microsoft/playwright/issues/5894
                        }
                        var settleInfo = makeSettleInfo(target);
                        selectAndSwap(swapSpec.swapStyle, target, elt, serverResponse, settleInfo);
                        if (selectionInfo.elt &&
                            !bodyContains(selectionInfo.elt) &&
                            selectionInfo.elt.id) {
                            var newActiveElt = document.getElementById(selectionInfo.elt.id);
                            if (newActiveElt) {
                                // @ts-ignore
                                if (selectionInfo.start && newActiveElt.setSelectionRange) {
                                    // @ts-ignore
                                    newActiveElt.setSelectionRange(selectionInfo.start, selectionInfo.end);
                                }
                                newActiveElt.focus();
                            }
                        }
                        target.classList.remove(htmx.config.swappingClass);
                        forEach(settleInfo.elts, function (elt) {
                            if (elt.classList) {
                                elt.classList.add(htmx.config.settlingClass);
                            }
                            triggerEvent(elt, 'htmx:afterSwap', responseInfo);
                        });
                        if (responseInfo.pathInfo.anchor) {
                            location.hash = responseInfo.pathInfo.anchor;
                        }
                        if (hasHeader(xhr, /HX-Trigger-After-Swap:/i)) {
                            var finalElt = elt;
                            if (!bodyContains(elt)) {
                                finalElt = getDocument().body;
                            }
                            handleTrigger(xhr, "HX-Trigger-After-Swap", finalElt);
                        }
                        var doSettle = function () {
                            forEach(settleInfo.tasks, function (task) {
                                task.call();
                            });
                            forEach(settleInfo.elts, function (elt) {
                                if (elt.classList) {
                                    elt.classList.remove(htmx.config.settlingClass);
                                }
                                triggerEvent(elt, 'htmx:afterSettle', responseInfo);
                            });
                            // push URL and save new page
                            if (shouldSaveHistory) {
                                var pathToPush = pushedUrl || getPushUrl(elt) || getResponseURL(xhr) || responseInfo.pathInfo.finalPath || responseInfo.pathInfo.path;
                                pushUrlIntoHistory(pathToPush);
                                triggerEvent(getDocument().body, 'htmx:pushedIntoHistory', {path: pathToPush});
                            }
                            updateScrollState(settleInfo.elts, swapSpec);
                            if (hasHeader(xhr, /HX-Trigger-After-Settle:/i)) {
                                var finalElt = elt;
                                if (!bodyContains(elt)) {
                                    finalElt = getDocument().body;
                                }
                                handleTrigger(xhr, "HX-Trigger-After-Settle", finalElt);
                            }
                        }
                        if (swapSpec.settleDelay > 0) {
                            setTimeout(doSettle, swapSpec.settleDelay)
                        } else {
                            doSettle();
                        }
                    } catch (e) {
                        triggerErrorEvent(elt, 'htmx:swapError', responseInfo);
                        throw e;
                    }
                };
                if (swapSpec.swapDelay > 0) {
                    setTimeout(doSwap, swapSpec.swapDelay)
                } else {
                    doSwap();
                }
            }
            if (isError) {
                triggerErrorEvent(elt, 'htmx:responseError', mergeObjects({error: "Response Status Error Code " + xhr.status + " from " + responseInfo.pathInfo.path}, responseInfo));
            }
        }
        //====================================================================
        // Extensions API
        //====================================================================
        /** @type {Object<string, import("./htmx").HtmxExtension>} */
        var extensions = {};
        /**
         * extensionBase defines the default functions for all extensions.
         * @returns {import("./htmx").HtmxExtension}
         */
        function extensionBase() {
            return {
                init: function(api) {return null;},
                onEvent : function(name, evt) {return true;},
                transformResponse : function(text, xhr, elt) {return text;},
                isInlineSwap : function(swapStyle) {return false;},
                handleSwap : function(swapStyle, target, fragment, settleInfo) {return false;},
                encodeParameters : function(xhr, parameters, elt) {return null;}
            }
        }
        /**
         * defineExtension initializes the extension and adds it to the htmx registry
         *
         * @param {string} name
         * @param {import("./htmx").HtmxExtension} extension
         */
        function defineExtension(name, extension) {
            extension.init(internalAPI)
            extensions[name] = mergeObjects(extensionBase(), extension);
        }
        /**
         * removeExtension removes an extension from the htmx registry
         *
         * @param {string} name
         */
        function removeExtension(name) {
            delete extensions[name];
        }
        /**
         * getExtensions searches up the DOM tree to return all extensions that can be applied to a given element
         *
         * @param {HTMLElement} elt
         * @param {import("./htmx").HtmxExtension[]=} extensionsToReturn
         * @param {import("./htmx").HtmxExtension[]=} extensionsToIgnore
         */
         function getExtensions(elt, extensionsToReturn, extensionsToIgnore) {
            if (elt == undefined) {
                return extensionsToReturn;
            }
            if (extensionsToReturn == undefined) {
                extensionsToReturn = [];
            }
            if (extensionsToIgnore == undefined) {
                extensionsToIgnore = [];
            }
            var extensionsForElement = getAttributeValue(elt, "hx-ext");
            if (extensionsForElement) {
                forEach(extensionsForElement.split(","), function(extensionName){
                    extensionName = extensionName.replace(/ /g, '');
                    if (extensionName.slice(0, 7) == "ignore:") {
                        extensionsToIgnore.push(extensionName.slice(7));
                        return;
                    }
                    if (extensionsToIgnore.indexOf(extensionName) < 0) {
                        var extension = extensions[extensionName];
                        if (extension && extensionsToReturn.indexOf(extension) < 0) {
                            extensionsToReturn.push(extension);
                        }
                    }
                });
            }
            return getExtensions(parentElt(elt), extensionsToReturn, extensionsToIgnore);
        }
        //====================================================================
        // Initialization
        //====================================================================
        function ready(fn) {
            if (getDocument().readyState !== 'loading') {
                fn();
            } else {
                getDocument().addEventListener('DOMContentLoaded', fn);
            }
        }
        function insertIndicatorStyles() {
            if (htmx.config.includeIndicatorStyles !== false) {
                getDocument().head.insertAdjacentHTML("beforeend",
                    "<style>\
                      ." + htmx.config.indicatorClass + "{opacity:0;transition: opacity 200ms ease-in;}\
                      ." + htmx.config.requestClass + " ." + htmx.config.indicatorClass + "{opacity:1}\
                      ." + htmx.config.requestClass + "." + htmx.config.indicatorClass + "{opacity:1}\
                    </style>");
            }
        }
        function getMetaConfig() {
            var element = getDocument().querySelector('meta[name="htmx-config"]');
            if (element) {
                // @ts-ignore
                return parseJSON(element.content);
            } else {
                return null;
            }
        }
        function mergeMetaConfig() {
            var metaConfig = getMetaConfig();
            if (metaConfig) {
                htmx.config = mergeObjects(htmx.config , metaConfig)
            }
        }
        // initialize the document
        ready(function () {
            mergeMetaConfig();
            insertIndicatorStyles();
            var body = getDocument().body;
            processNode(body);
            window.onpopstate = function (event) {
                if (event.state && event.state.htmx) {
                    restoreHistory();
                }
            };
            setTimeout(function () {
                triggerEvent(body, 'htmx:load', {}); // give ready handlers a chance to load up before firing this event
            }, 0);
        })
        return htmx;
    }
)()
}));