From fb2a8fc0d32d18a47234e58dfb4004ce9e301521 Mon Sep 17 00:00:00 2001
From: sylhare <sylhare@outlook.com>
Date: Wed, 8 Oct 2025 12:15:39 -0400
Subject: [PATCH 01/10] Initial highlight draft

---
 docs/_includes/search.html                 |  53 ++++-
 docs/_sass/_custom.scss                    |  23 +++
 docs/assets/js/simple-jekyll-search.min.js |   2 +-
 src/SimpleJekyllSearch.ts                  |   8 +-
 src/index.ts                               |   2 +
 src/utils/default.ts                       |   3 +-
 src/utils/highlightMiddleware.ts           | 213 +++++++++++++++++++++
 src/utils/types.ts                         |   1 +
 tests/highlightMiddleware.test.ts          | 187 ++++++++++++++++++
 9 files changed, 488 insertions(+), 4 deletions(-)
 create mode 100644 src/utils/highlightMiddleware.ts
 create mode 100644 tests/highlightMiddleware.test.ts

diff --git a/docs/_includes/search.html b/docs/_includes/search.html
index a9e5150..d3cb7b5 100644
--- a/docs/_includes/search.html
+++ b/docs/_includes/search.html
@@ -7,11 +7,62 @@
   <script src="{{ '/assets/js/simple-jekyll-search.min.js' | relative_url }}"></script>
 
   <script>
+    // Custom highlight middleware with shorter context for search snippets
+    function createSearchSnippetMiddleware() {
+      return function(result, query) {
+        if (!query || !result) return result;
+        
+        const highlightedResult = { ...result };
+        
+        // Process content field with shorter context
+        if (highlightedResult.content && typeof highlightedResult.content === 'string') {
+          const text = highlightedResult.content;
+          const searchTerms = query.trim().toLowerCase().split(/\s+/).filter(term => term.length > 0);
+          
+          if (searchTerms.length > 0) {
+            // Find first match
+            let firstMatch = -1;
+            for (const term of searchTerms) {
+              const found = text.toLowerCase().indexOf(term);
+              if (found !== -1 && (firstMatch === -1 || found < firstMatch)) {
+                firstMatch = found;
+              }
+            }
+            
+            if (firstMatch !== -1) {
+              // Show 30 characters before and after the first match
+              const contextBefore = 30;
+              const contextAfter = 30;
+              const start = Math.max(0, firstMatch - contextBefore);
+              const end = Math.min(text.length, firstMatch + searchTerms[0].length + contextAfter);
+              
+              let snippet = text.substring(start, end);
+              
+              // Add ellipsis if we're not at the beginning/end
+              if (start > 0) snippet = '...' + snippet;
+              if (end < text.length) snippet = snippet + '...';
+              
+              // Highlight search terms
+              for (const term of searchTerms) {
+                const regex = new RegExp(`(${term})`, 'gi');
+                snippet = snippet.replace(regex, '<span class="sjs-highlight">$1</span>');
+              }
+              
+              highlightedResult.content = snippet;
+            }
+          }
+        }
+        
+        return highlightedResult;
+      };
+    }
+
     window.simpleJekyllSearch = new SimpleJekyllSearch({
       searchInput: document.getElementById('search-input'),
       resultsContainer: document.getElementById('results-container'),
       json: '{{ "/assets/data/search.json" | relative_url }}',
-      searchResultTemplate: '<li><a href="{url}?query={query}" title="{desc}">{title}</a></li>',
+      searchResultTemplate: '<li><a href="{url}?query={query}">{title}</a><div class="search-snippet">{content}</div></li>',
+      highlightMiddleware: createSearchSnippetMiddleware(),
       noResultsText: 'No results found',
       limit: 10,
       strategy: 'wildcard',
diff --git a/docs/_sass/_custom.scss b/docs/_sass/_custom.scss
index 4cf1d2a..41a4d0a 100644
--- a/docs/_sass/_custom.scss
+++ b/docs/_sass/_custom.scss
@@ -62,4 +62,27 @@ $on-laptop:        800px;
 
 .info-text {
   margin-top: 20px;
+}
+
+// Highlight middleware styles
+.sjs-highlight {
+  text-decoration: underline;
+  text-decoration-color: #ffeb3b;
+  text-decoration-thickness: 3px;
+  text-underline-offset: 2px;
+  font-weight: bold;
+}
+
+.search-snippet {
+  font-size: 0.9em;
+  color: #666;
+  margin-top: 5px;
+  line-height: 1.4;
+  max-height: 3em;
+  overflow: hidden;
+  text-overflow: ellipsis;
+  display: -webkit-box;
+  -webkit-line-clamp: 2;
+  -webkit-box-orient: vertical;
+  word-wrap: break-word;
 }
\ No newline at end of file
diff --git a/docs/assets/js/simple-jekyll-search.min.js b/docs/assets/js/simple-jekyll-search.min.js
index 58f1487..7767669 100644
--- a/docs/assets/js/simple-jekyll-search.min.js
+++ b/docs/assets/js/simple-jekyll-search.min.js
@@ -4,4 +4,4 @@
   * Copyright 2025-2025, Sylhare
   * Licensed under the MIT License.
   */
-(function(global,factory){typeof exports==="object"&&typeof module!=="undefined"?factory(exports):typeof define==="function"&&define.amd?define(["exports"],factory):(global=typeof globalThis!=="undefined"?globalThis:global||self,factory(global.SimpleJekyllSearch={}))})(this,(function(exports2){"use strict";function load(location,callback){const xhr=getXHR();xhr.open("GET",location,true);xhr.onreadystatechange=createStateChangeListener(xhr,callback);xhr.send()}function createStateChangeListener(xhr,callback){return function(){if(xhr.readyState===4&&xhr.status===200){try{callback(null,JSON.parse(xhr.responseText))}catch(err){callback(err instanceof Error?err:new Error(String(err)),null)}}}}function getXHR(){return window.XMLHttpRequest?new window.XMLHttpRequest:new window.ActiveXObject("Microsoft.XMLHTTP")}class OptionsValidator{constructor(params){if(!this.validateParams(params)){throw new Error("-- OptionsValidator: required options missing")}this.requiredOptions=params.required}getRequiredOptions(){return this.requiredOptions}validate(parameters){const errors=[];this.requiredOptions.forEach((requiredOptionName=>{if(typeof parameters[requiredOptionName]==="undefined"){errors.push(requiredOptionName)}}));return errors}validateParams(params){if(!params){return false}return typeof params.required!=="undefined"&&Array.isArray(params.required)}}function fuzzySearch(text,pattern){pattern=pattern.trimEnd();if(pattern.length===0)return true;pattern=pattern.toLowerCase();text=text.toLowerCase();let remainingText=text,currentIndex=-1;for(const char of pattern){const nextIndex=remainingText.indexOf(char);if(nextIndex===-1||currentIndex!==-1&&remainingText.slice(0,nextIndex).split(" ").length-1>2){return false}currentIndex=nextIndex;remainingText=remainingText.slice(nextIndex+1)}return true}function literalSearch(text,criteria){text=text.trim().toLowerCase();const pattern=criteria.endsWith(" ")?[criteria.toLowerCase()]:criteria.trim().toLowerCase().split(" ");return pattern.filter((word=>text.indexOf(word)>=0)).length===pattern.length}function levenshtein(a,b){const lenA=a.length;const lenB=b.length;const distanceMatrix=Array.from({length:lenA+1},(()=>Array(lenB+1).fill(0)));for(let i=0;i<=lenA;i++)distanceMatrix[i][0]=i;for(let j=0;j<=lenB;j++)distanceMatrix[0][j]=j;for(let i=1;i<=lenA;i++){for(let j=1;j<=lenB;j++){const cost=a[i-1]===b[j-1]?0:1;distanceMatrix[i][j]=Math.min(distanceMatrix[i-1][j]+1,distanceMatrix[i][j-1]+1,distanceMatrix[i-1][j-1]+cost)}}return distanceMatrix[lenA][lenB]}function levenshteinSearch(text,pattern){const distance=levenshtein(pattern,text);const similarity=1-distance/Math.max(pattern.length,text.length);return similarity>=.3}function wildcardSearch(text,pattern){const regexPattern=pattern.replace(/\*/g,".*");const regex=new RegExp(`^${regexPattern}$`,"i");if(regex.test(text))return true;return levenshteinSearch(text,pattern)}class SearchStrategy{constructor(matchFunction){this.matchFunction=matchFunction}matches(text,criteria){if(text===null||text.trim()===""||!criteria){return false}return this.matchFunction(text,criteria)}}const LiteralSearchStrategy=new SearchStrategy(literalSearch);const FuzzySearchStrategy=new SearchStrategy(((text,criteria)=>fuzzySearch(text,criteria)||literalSearch(text,criteria)));const WildcardSearchStrategy=new SearchStrategy(((text,criteria)=>wildcardSearch(text,criteria)||literalSearch(text,criteria)));function merge(target,source){return{...target,...source}}function isJSON(json){try{return!!(json instanceof Object&&JSON.parse(JSON.stringify(json)))}catch(_err){return false}}function NoSort(){return 0}function isObject(obj){return Boolean(obj)&&Object.prototype.toString.call(obj)==="[object Object]"}function clone(input){if(input===null||typeof input!=="object"){return input}if(Array.isArray(input)){return input.map((item=>clone(item)))}const output={};for(const key in input){if(Object.prototype.hasOwnProperty.call(input,key)){output[key]=clone(input[key])}}return output}const DEFAULT_OPTIONS={searchInput:null,resultsContainer:null,json:[],success:function(){},searchResultTemplate:'<li><a href="{url}" title="{desc}">{title}</a></li>',templateMiddleware:(_prop,_value,_template)=>void 0,sortMiddleware:NoSort,noResultsText:"No results found",limit:10,fuzzy:false,strategy:"literal",debounceTime:null,exclude:[],onSearch:()=>{}};const REQUIRED_OPTIONS=["searchInput","resultsContainer","json"];const WHITELISTED_KEYS=new Set(["Enter","Shift","CapsLock","ArrowLeft","ArrowUp","ArrowRight","ArrowDown","Meta"]);class Repository{constructor(initialOptions={}){this.data=[];this.setOptions(initialOptions)}put(input){if(isObject(input)){return this.addObject(input)}if(Array.isArray(input)){return this.addArray(input)}return void 0}clear(){this.data.length=0;return this.data}search(criteria){if(!criteria){return[]}return clone(this.findMatches(this.data,criteria).sort(this.options.sortMiddleware))}setOptions(newOptions){this.options={fuzzy:(newOptions==null?void 0:newOptions.fuzzy)||DEFAULT_OPTIONS.fuzzy,limit:(newOptions==null?void 0:newOptions.limit)||DEFAULT_OPTIONS.limit,searchStrategy:this.searchStrategy((newOptions==null?void 0:newOptions.strategy)||newOptions.fuzzy&&"fuzzy"||DEFAULT_OPTIONS.strategy),sortMiddleware:(newOptions==null?void 0:newOptions.sortMiddleware)||DEFAULT_OPTIONS.sortMiddleware,exclude:(newOptions==null?void 0:newOptions.exclude)||DEFAULT_OPTIONS.exclude,strategy:(newOptions==null?void 0:newOptions.strategy)||DEFAULT_OPTIONS.strategy}}addObject(obj){this.data.push(obj);return this.data}addArray(arr){const added=[];this.clear();for(const item of arr){if(isObject(item)){added.push(this.addObject(item)[0])}}return added}findMatches(data,criteria){const matches=[];for(let i=0;i<data.length&&matches.length<this.options.limit;i++){const match=this.findMatchesInObject(data[i],criteria);if(match){matches.push(match)}}return matches}findMatchesInObject(obj,criteria){for(const key in obj){if(!this.isExcluded(obj[key])&&this.options.searchStrategy.matches(obj[key],criteria)){return obj}}return void 0}isExcluded(term){for(const excludedTerm of this.options.exclude){if(new RegExp(excludedTerm).test(String(term))){return true}}return false}searchStrategy(strategy){switch(strategy){case"fuzzy":return FuzzySearchStrategy;case"wildcard":return WildcardSearchStrategy;default:return LiteralSearchStrategy}}}const options={pattern:/\{(.*?)\}/g,template:"",middleware:function(){return void 0}};function setOptions(_options){if(_options.pattern){options.pattern=_options.pattern}if(_options.template){options.template=_options.template}if(typeof _options.middleware==="function"){options.middleware=_options.middleware}}function compile(data){return options.template.replace(options.pattern,(function(match,prop){const value=options.middleware(prop,data[prop],options.template);if(typeof value!=="undefined"){return value}return data[prop]||match}))}let SimpleJekyllSearch$1=class SimpleJekyllSearch{constructor(){this.debounceTimerHandle=null;this.options={...DEFAULT_OPTIONS};this.repository=new Repository;this.optionsValidator=new OptionsValidator({required:REQUIRED_OPTIONS})}debounce(func,delayMillis){if(delayMillis){if(this.debounceTimerHandle){clearTimeout(this.debounceTimerHandle)}this.debounceTimerHandle=setTimeout(func,delayMillis)}else{func()}}throwError(message){throw new Error(`SimpleJekyllSearch --- ${message}`)}emptyResultsContainer(){this.options.resultsContainer.innerHTML=""}initWithJSON(json){this.repository.put(json);this.registerInput()}initWithURL(url){load(url,((err,json)=>{if(err){this.throwError(`Failed to load JSON from ${url}: ${err.message}`)}this.initWithJSON(json)}))}registerInput(){this.options.searchInput.addEventListener("input",(e=>{const inputEvent=e;if(!WHITELISTED_KEYS.has(inputEvent.key)){this.emptyResultsContainer();this.debounce((()=>{this.search(e.target.value)}),this.options.debounceTime??null)}}))}search(query){var _a,_b;if((query==null?void 0:query.trim().length)>0){this.emptyResultsContainer();const results=this.repository.search(query);this.render(results,query);(_b=(_a=this.options).onSearch)==null?void 0:_b.call(_a)}}render(results,query){if(results.length===0){this.options.resultsContainer.insertAdjacentHTML("beforeend",this.options.noResultsText);return}const fragment=document.createDocumentFragment();results.forEach((result=>{result.query=query;const div=document.createElement("div");div.innerHTML=compile(result);fragment.appendChild(div)}));this.options.resultsContainer.appendChild(fragment)}init(_options){var _a;const errors=this.optionsValidator.validate(_options);if(errors.length>0){this.throwError(`Missing required options: ${REQUIRED_OPTIONS.join(", ")}`)}this.options=merge(this.options,_options);setOptions({template:this.options.searchResultTemplate,middleware:this.options.templateMiddleware});this.repository.setOptions({fuzzy:this.options.fuzzy,limit:this.options.limit,sortMiddleware:this.options.sortMiddleware,strategy:this.options.strategy,exclude:this.options.exclude});if(isJSON(this.options.json)){this.initWithJSON(this.options.json)}else{this.initWithURL(this.options.json)}const rv={search:this.search.bind(this)};(_a=this.options.success)==null?void 0:_a.call(rv);return rv}};function SimpleJekyllSearch(options2){const instance=new SimpleJekyllSearch$1;return instance.init(options2)}if(typeof window!=="undefined"){window.SimpleJekyllSearch=SimpleJekyllSearch}exports2.default=SimpleJekyllSearch;Object.defineProperties(exports2,{__esModule:{value:true},[Symbol.toStringTag]:{value:"Module"}})}));
\ No newline at end of file
+(function(global,factory){typeof exports==="object"&&typeof module!=="undefined"?factory(exports):typeof define==="function"&&define.amd?define(["exports"],factory):(global=typeof globalThis!=="undefined"?globalThis:global||self,factory(global.SimpleJekyllSearch={}))})(this,(function(exports2){"use strict";function load(location,callback){const xhr=getXHR();xhr.open("GET",location,true);xhr.onreadystatechange=createStateChangeListener(xhr,callback);xhr.send()}function createStateChangeListener(xhr,callback){return function(){if(xhr.readyState===4&&xhr.status===200){try{callback(null,JSON.parse(xhr.responseText))}catch(err){callback(err instanceof Error?err:new Error(String(err)),null)}}}}function getXHR(){return window.XMLHttpRequest?new window.XMLHttpRequest:new window.ActiveXObject("Microsoft.XMLHTTP")}class OptionsValidator{constructor(params){if(!this.validateParams(params)){throw new Error("-- OptionsValidator: required options missing")}this.requiredOptions=params.required}getRequiredOptions(){return this.requiredOptions}validate(parameters){const errors=[];this.requiredOptions.forEach((requiredOptionName=>{if(typeof parameters[requiredOptionName]==="undefined"){errors.push(requiredOptionName)}}));return errors}validateParams(params){if(!params){return false}return typeof params.required!=="undefined"&&Array.isArray(params.required)}}function fuzzySearch(text,pattern){pattern=pattern.trimEnd();if(pattern.length===0)return true;pattern=pattern.toLowerCase();text=text.toLowerCase();let remainingText=text,currentIndex=-1;for(const char of pattern){const nextIndex=remainingText.indexOf(char);if(nextIndex===-1||currentIndex!==-1&&remainingText.slice(0,nextIndex).split(" ").length-1>2){return false}currentIndex=nextIndex;remainingText=remainingText.slice(nextIndex+1)}return true}function literalSearch(text,criteria){text=text.trim().toLowerCase();const pattern=criteria.endsWith(" ")?[criteria.toLowerCase()]:criteria.trim().toLowerCase().split(" ");return pattern.filter((word=>text.indexOf(word)>=0)).length===pattern.length}function levenshtein(a,b){const lenA=a.length;const lenB=b.length;const distanceMatrix=Array.from({length:lenA+1},(()=>Array(lenB+1).fill(0)));for(let i=0;i<=lenA;i++)distanceMatrix[i][0]=i;for(let j=0;j<=lenB;j++)distanceMatrix[0][j]=j;for(let i=1;i<=lenA;i++){for(let j=1;j<=lenB;j++){const cost=a[i-1]===b[j-1]?0:1;distanceMatrix[i][j]=Math.min(distanceMatrix[i-1][j]+1,distanceMatrix[i][j-1]+1,distanceMatrix[i-1][j-1]+cost)}}return distanceMatrix[lenA][lenB]}function levenshteinSearch(text,pattern){const distance=levenshtein(pattern,text);const similarity=1-distance/Math.max(pattern.length,text.length);return similarity>=.3}function wildcardSearch(text,pattern){const regexPattern=pattern.replace(/\*/g,".*");const regex=new RegExp(`^${regexPattern}$`,"i");if(regex.test(text))return true;return levenshteinSearch(text,pattern)}class SearchStrategy{constructor(matchFunction){this.matchFunction=matchFunction}matches(text,criteria){if(text===null||text.trim()===""||!criteria){return false}return this.matchFunction(text,criteria)}}const LiteralSearchStrategy=new SearchStrategy(literalSearch);const FuzzySearchStrategy=new SearchStrategy(((text,criteria)=>fuzzySearch(text,criteria)||literalSearch(text,criteria)));const WildcardSearchStrategy=new SearchStrategy(((text,criteria)=>wildcardSearch(text,criteria)||literalSearch(text,criteria)));function merge(target,source){return{...target,...source}}function isJSON(json){try{return!!(json instanceof Object&&JSON.parse(JSON.stringify(json)))}catch(_err){return false}}function NoSort(){return 0}function isObject(obj){return Boolean(obj)&&Object.prototype.toString.call(obj)==="[object Object]"}function clone(input){if(input===null||typeof input!=="object"){return input}if(Array.isArray(input)){return input.map((item=>clone(item)))}const output={};for(const key in input){if(Object.prototype.hasOwnProperty.call(input,key)){output[key]=clone(input[key])}}return output}function createHighlightMiddleware(options2={}){const{highlightClass:highlightClass="sjs-highlight",contextBefore:contextBefore=50,contextAfter:contextAfter=50,maxLength:maxLength=250,ellipsis:ellipsis="..."}=options2;return function(result,query){if(!query||!result){return result}const highlightedResult={...result};const textFields=["title","desc","content","excerpt"];for(const field of textFields){if(highlightedResult[field]&&typeof highlightedResult[field]==="string"){const highlighted=highlightText(highlightedResult[field],query,{highlightClass:highlightClass,contextBefore:contextBefore,contextAfter:contextAfter,maxLength:maxLength,ellipsis:ellipsis});if(highlighted.highlightedText!==highlightedResult[field]){highlightedResult[field]=highlighted.highlightedText}}}return highlightedResult}}function highlightText(text,query,options2={}){const{highlightClass:highlightClass="sjs-highlight",contextBefore:contextBefore=50,contextAfter:contextAfter=50,maxLength:maxLength=250,ellipsis:ellipsis="..."}=options2;if(!text||!query){return{highlightedText:text,matchCount:0}}const originalText=text;const searchTerms=query.trim().toLowerCase().split(/\s+/).filter((term=>term.length>0));if(searchTerms.length===0){return{highlightedText:text,matchCount:0}}const matches=[];for(const term of searchTerms){let index=0;while(index<text.length){const found=text.toLowerCase().indexOf(term,index);if(found===-1)break;matches.push({start:found,end:found+term.length,term:text.substring(found,found+term.length)});index=found+1}}if(matches.length===0){return{highlightedText:text,matchCount:0}}matches.sort(((a,b)=>a.start-b.start));const mergedMatches=[];for(const match of matches){if(mergedMatches.length===0||mergedMatches[mergedMatches.length-1].end<match.start){mergedMatches.push(match)}else{const lastMatch=mergedMatches[mergedMatches.length-1];lastMatch.end=Math.max(lastMatch.end,match.end);lastMatch.term=text.substring(lastMatch.start,lastMatch.end)}}if(text.length<=maxLength){let highlightedText2=text;for(let i=mergedMatches.length-1;i>=0;i--){const match=mergedMatches[i];const before=highlightedText2.substring(0,match.start);const after=highlightedText2.substring(match.end);const matchText=highlightedText2.substring(match.start,match.end);highlightedText2=before+`<span class="${highlightClass}">${matchText}</span>`+after}return{highlightedText:highlightedText2,matchCount:mergedMatches.length}}let highlightedText="";let totalLength=0;let lastEnd=0;for(let i=0;i<mergedMatches.length;i++){const match=mergedMatches[i];const contextStart=Math.max(lastEnd,match.start-contextBefore);const contextEnd=Math.min(text.length,match.end+contextAfter);if(contextStart>lastEnd&&lastEnd>0){highlightedText+=ellipsis;totalLength+=ellipsis.length}if(contextStart<match.start){const beforeText=text.substring(contextStart,match.start);highlightedText+=beforeText;totalLength+=beforeText.length}const matchText=text.substring(match.start,match.end);highlightedText+=`<span class="${highlightClass}">${matchText}</span>`;totalLength+=matchText.length;if(match.end<contextEnd){const afterText=text.substring(match.end,contextEnd);highlightedText+=afterText;totalLength+=afterText.length}lastEnd=contextEnd;if(totalLength>=maxLength){if(contextEnd<text.length){highlightedText+=ellipsis}break}}return{highlightedText:highlightedText||originalText,matchCount:mergedMatches.length}}const defaultHighlightMiddleware=createHighlightMiddleware();const DEFAULT_OPTIONS={searchInput:null,resultsContainer:null,json:[],success:function(){},searchResultTemplate:'<li><a href="{url}" title="{desc}">{title}</a></li>',templateMiddleware:(_prop,_value,_template)=>void 0,highlightMiddleware:defaultHighlightMiddleware,sortMiddleware:NoSort,noResultsText:"No results found",limit:10,fuzzy:false,strategy:"literal",debounceTime:null,exclude:[],onSearch:()=>{}};const REQUIRED_OPTIONS=["searchInput","resultsContainer","json"];const WHITELISTED_KEYS=new Set(["Enter","Shift","CapsLock","ArrowLeft","ArrowUp","ArrowRight","ArrowDown","Meta"]);class Repository{constructor(initialOptions={}){this.data=[];this.setOptions(initialOptions)}put(input){if(isObject(input)){return this.addObject(input)}if(Array.isArray(input)){return this.addArray(input)}return void 0}clear(){this.data.length=0;return this.data}search(criteria){if(!criteria){return[]}return clone(this.findMatches(this.data,criteria).sort(this.options.sortMiddleware))}setOptions(newOptions){this.options={fuzzy:(newOptions==null?void 0:newOptions.fuzzy)||DEFAULT_OPTIONS.fuzzy,limit:(newOptions==null?void 0:newOptions.limit)||DEFAULT_OPTIONS.limit,searchStrategy:this.searchStrategy((newOptions==null?void 0:newOptions.strategy)||newOptions.fuzzy&&"fuzzy"||DEFAULT_OPTIONS.strategy),sortMiddleware:(newOptions==null?void 0:newOptions.sortMiddleware)||DEFAULT_OPTIONS.sortMiddleware,exclude:(newOptions==null?void 0:newOptions.exclude)||DEFAULT_OPTIONS.exclude,strategy:(newOptions==null?void 0:newOptions.strategy)||DEFAULT_OPTIONS.strategy}}addObject(obj){this.data.push(obj);return this.data}addArray(arr){const added=[];this.clear();for(const item of arr){if(isObject(item)){added.push(this.addObject(item)[0])}}return added}findMatches(data,criteria){const matches=[];for(let i=0;i<data.length&&matches.length<this.options.limit;i++){const match=this.findMatchesInObject(data[i],criteria);if(match){matches.push(match)}}return matches}findMatchesInObject(obj,criteria){for(const key in obj){if(!this.isExcluded(obj[key])&&this.options.searchStrategy.matches(obj[key],criteria)){return obj}}return void 0}isExcluded(term){for(const excludedTerm of this.options.exclude){if(new RegExp(excludedTerm).test(String(term))){return true}}return false}searchStrategy(strategy){switch(strategy){case"fuzzy":return FuzzySearchStrategy;case"wildcard":return WildcardSearchStrategy;default:return LiteralSearchStrategy}}}const options={pattern:/\{(.*?)\}/g,template:"",middleware:function(){return void 0}};function setOptions(_options){if(_options.pattern){options.pattern=_options.pattern}if(_options.template){options.template=_options.template}if(typeof _options.middleware==="function"){options.middleware=_options.middleware}}function compile(data){return options.template.replace(options.pattern,(function(match,prop){const value=options.middleware(prop,data[prop],options.template);if(typeof value!=="undefined"){return value}return data[prop]||match}))}let SimpleJekyllSearch$1=class SimpleJekyllSearch{constructor(){this.debounceTimerHandle=null;this.options={...DEFAULT_OPTIONS};this.repository=new Repository;this.optionsValidator=new OptionsValidator({required:REQUIRED_OPTIONS})}debounce(func,delayMillis){if(delayMillis){if(this.debounceTimerHandle){clearTimeout(this.debounceTimerHandle)}this.debounceTimerHandle=setTimeout(func,delayMillis)}else{func()}}throwError(message){throw new Error(`SimpleJekyllSearch --- ${message}`)}emptyResultsContainer(){this.options.resultsContainer.innerHTML=""}initWithJSON(json){this.repository.put(json);this.registerInput()}initWithURL(url){load(url,((err,json)=>{if(err){this.throwError(`Failed to load JSON from ${url}: ${err.message}`)}this.initWithJSON(json)}))}registerInput(){this.options.searchInput.addEventListener("input",(e=>{const inputEvent=e;if(!WHITELISTED_KEYS.has(inputEvent.key)){this.emptyResultsContainer();this.debounce((()=>{this.search(e.target.value)}),this.options.debounceTime??null)}}))}search(query){var _a,_b;if((query==null?void 0:query.trim().length)>0){this.emptyResultsContainer();const results=this.repository.search(query);this.render(results,query);(_b=(_a=this.options).onSearch)==null?void 0:_b.call(_a)}}render(results,query){if(results.length===0){this.options.resultsContainer.insertAdjacentHTML("beforeend",this.options.noResultsText);return}const fragment=document.createDocumentFragment();results.forEach((result=>{result.query=query;const highlightedResult=this.options.highlightMiddleware?this.options.highlightMiddleware(result,query):result;const div=document.createElement("div");div.innerHTML=compile(highlightedResult);fragment.appendChild(div)}));this.options.resultsContainer.appendChild(fragment)}init(_options){var _a;const errors=this.optionsValidator.validate(_options);if(errors.length>0){this.throwError(`Missing required options: ${REQUIRED_OPTIONS.join(", ")}`)}this.options=merge(this.options,_options);setOptions({template:this.options.searchResultTemplate,middleware:this.options.templateMiddleware});this.repository.setOptions({fuzzy:this.options.fuzzy,limit:this.options.limit,sortMiddleware:this.options.sortMiddleware,strategy:this.options.strategy,exclude:this.options.exclude});if(isJSON(this.options.json)){this.initWithJSON(this.options.json)}else{this.initWithURL(this.options.json)}const rv={search:this.search.bind(this)};(_a=this.options.success)==null?void 0:_a.call(rv);return rv}};function SimpleJekyllSearch(options2){const instance=new SimpleJekyllSearch$1;return instance.init(options2)}if(typeof window!=="undefined"){window.SimpleJekyllSearch=SimpleJekyllSearch}exports2.createHighlightMiddleware=createHighlightMiddleware;exports2.default=SimpleJekyllSearch;exports2.defaultHighlightMiddleware=defaultHighlightMiddleware;exports2.highlightText=highlightText;Object.defineProperties(exports2,{__esModule:{value:true},[Symbol.toStringTag]:{value:"Module"}})}));
\ No newline at end of file
diff --git a/src/SimpleJekyllSearch.ts b/src/SimpleJekyllSearch.ts
index c7822b4..2a20995 100644
--- a/src/SimpleJekyllSearch.ts
+++ b/src/SimpleJekyllSearch.ts
@@ -83,8 +83,14 @@ class SimpleJekyllSearch {
     const fragment = document.createDocumentFragment();
     results.forEach(result => {
       result.query = query;
+      
+      // Apply highlight middleware if available
+      const highlightedResult = this.options.highlightMiddleware 
+        ? this.options.highlightMiddleware(result, query)
+        : result;
+      
       const div = document.createElement('div');
-      div.innerHTML = compileTemplate(result);
+      div.innerHTML = compileTemplate(highlightedResult);
       fragment.appendChild(div);
     });
 
diff --git a/src/index.ts b/src/index.ts
index c2ba8af..5e8e122 100644
--- a/src/index.ts
+++ b/src/index.ts
@@ -1,5 +1,7 @@
 import SimpleJekyllSearchClass from './SimpleJekyllSearch';
 import { SearchOptions, SimpleJekyllSearchInstance } from './utils/types';
+export { createHighlightMiddleware, highlightText, defaultHighlightMiddleware } from './utils/highlightMiddleware';
+export type { HighlightOptions, HighlightResult } from './utils/highlightMiddleware';
 
 function SimpleJekyllSearch(options: SearchOptions): SimpleJekyllSearchInstance {
   const instance = new SimpleJekyllSearchClass();
diff --git a/src/utils/default.ts b/src/utils/default.ts
index fcb4c0e..b947fbd 100644
--- a/src/utils/default.ts
+++ b/src/utils/default.ts
@@ -1,13 +1,14 @@
 import { NoSort } from '../utils';
 import { SearchOptions } from './types';
 
-export const DEFAULT_OPTIONS: Required<SearchOptions> = {
+export const DEFAULT_OPTIONS: Required<Omit<SearchOptions, 'highlightMiddleware'>> & Pick<SearchOptions, 'highlightMiddleware'> = {
   searchInput: null!,
   resultsContainer: null!,
   json: [],
   success: function(this: { search: (query: string) => void }) {},
   searchResultTemplate: '<li><a href="{url}" title="{desc}">{title}</a></li>',
   templateMiddleware: (_prop: string, _value: string, _template: string) => undefined,
+  highlightMiddleware: undefined,
   sortMiddleware: NoSort,
   noResultsText: 'No results found',
   limit: 10,
diff --git a/src/utils/highlightMiddleware.ts b/src/utils/highlightMiddleware.ts
new file mode 100644
index 0000000..7278e11
--- /dev/null
+++ b/src/utils/highlightMiddleware.ts
@@ -0,0 +1,213 @@
+/**
+ * Highlight middleware that wraps search matches with HTML spans
+ * and provides context around matches with a configurable character limit
+ */
+
+export interface HighlightOptions {
+  /** CSS class name for highlighted spans (default: 'sjs-highlight') */
+  highlightClass?: string;
+  /** Number of characters to show before each match (default: 50) */
+  contextBefore?: number;
+  /** Number of characters to show after each match (default: 50) */
+  contextAfter?: number;
+  /** Maximum total characters for the highlighted text (default: 250) */
+  maxLength?: number;
+  /** Ellipsis to show when text is truncated (default: '...') */
+  ellipsis?: string;
+}
+
+export interface HighlightResult {
+  /** The highlighted text with HTML spans */
+  highlightedText: string;
+  /** The number of matches found */
+  matchCount: number;
+}
+
+/**
+ * Creates a highlight middleware function that can be used with SimpleJekyllSearch
+ * 
+ * @param options Configuration options for highlighting
+ * @returns A middleware function that processes search results
+ */
+export function createHighlightMiddleware(options: HighlightOptions = {}): (result: any, query: string) => any {
+  const {
+    highlightClass = 'sjs-highlight',
+    contextBefore = 50,
+    contextAfter = 50,
+    maxLength = 250,
+    ellipsis = '...'
+  } = options;
+
+  return function(result: any, query: string): any {
+    if (!query || !result) {
+      return result;
+    }
+
+    // Create a copy of the result to avoid modifying the original
+    const highlightedResult = { ...result };
+
+    // Process each text field in the result
+    const textFields = ['title', 'desc', 'content', 'excerpt'];
+    
+    for (const field of textFields) {
+      if (highlightedResult[field] && typeof highlightedResult[field] === 'string') {
+        const highlighted = highlightText(
+          highlightedResult[field],
+          query,
+          { highlightClass, contextBefore, contextAfter, maxLength, ellipsis }
+        );
+        
+        if (highlighted.highlightedText !== highlightedResult[field]) {
+          highlightedResult[field] = highlighted.highlightedText;
+        }
+      }
+    }
+
+    return highlightedResult;
+  };
+}
+
+/**
+ * Highlights search terms in text with HTML spans and provides context
+ * 
+ * @param text The text to highlight
+ * @param query The search query
+ * @param options Highlighting options
+ * @returns Object containing highlighted text and match count
+ */
+export function highlightText(
+  text: string,
+  query: string,
+  options: HighlightOptions = {}
+): HighlightResult {
+  const {
+    highlightClass = 'sjs-highlight',
+    contextBefore = 50,
+    contextAfter = 50,
+    maxLength = 250,
+    ellipsis = '...'
+  } = options;
+
+  if (!text || !query) {
+    return { highlightedText: text, matchCount: 0 };
+  }
+
+  const originalText = text;
+  const searchTerms = query.trim().toLowerCase().split(/\s+/).filter(term => term.length > 0);
+  
+  if (searchTerms.length === 0) {
+    return { highlightedText: text, matchCount: 0 };
+  }
+
+  // Find all matches with their positions
+  const matches: Array<{ start: number; end: number; term: string }> = [];
+  
+  for (const term of searchTerms) {
+    let index = 0;
+    while (index < text.length) {
+      const found = text.toLowerCase().indexOf(term, index);
+      if (found === -1) break;
+      
+      matches.push({
+        start: found,
+        end: found + term.length,
+        term: text.substring(found, found + term.length)
+      });
+      
+      index = found + 1;
+    }
+  }
+
+  if (matches.length === 0) {
+    return { highlightedText: text, matchCount: 0 };
+  }
+
+  // Sort matches by position
+  matches.sort((a, b) => a.start - b.start);
+
+  // Merge overlapping matches
+  const mergedMatches: Array<{ start: number; end: number; term: string }> = [];
+  for (const match of matches) {
+    if (mergedMatches.length === 0 || mergedMatches[mergedMatches.length - 1].end < match.start) {
+      mergedMatches.push(match);
+    } else {
+      // Extend the previous match
+      const lastMatch = mergedMatches[mergedMatches.length - 1];
+      lastMatch.end = Math.max(lastMatch.end, match.end);
+      lastMatch.term = text.substring(lastMatch.start, lastMatch.end);
+    }
+  }
+
+  // If the text is short enough, just highlight all matches without context
+  if (text.length <= maxLength) {
+    let highlightedText = text;
+    // Process matches in reverse order to maintain positions
+    for (let i = mergedMatches.length - 1; i >= 0; i--) {
+      const match = mergedMatches[i];
+      const before = highlightedText.substring(0, match.start);
+      const after = highlightedText.substring(match.end);
+      const matchText = highlightedText.substring(match.start, match.end);
+      highlightedText = before + `<span class="${highlightClass}">${matchText}</span>` + after;
+    }
+    return { highlightedText, matchCount: mergedMatches.length };
+  }
+
+  // Build highlighted text with context for longer texts
+  let highlightedText = '';
+  let totalLength = 0;
+  let lastEnd = 0;
+
+  for (let i = 0; i < mergedMatches.length; i++) {
+    const match = mergedMatches[i];
+    
+    // Calculate context boundaries for this match
+    const contextStart = Math.max(lastEnd, match.start - contextBefore);
+    const contextEnd = Math.min(text.length, match.end + contextAfter);
+    
+    // Add ellipsis if there's a gap between matches
+    if (contextStart > lastEnd && lastEnd > 0) {
+      highlightedText += ellipsis;
+      totalLength += ellipsis.length;
+    }
+    
+    // Add text before the match
+    if (contextStart < match.start) {
+      const beforeText = text.substring(contextStart, match.start);
+      highlightedText += beforeText;
+      totalLength += beforeText.length;
+    }
+    
+    // Add the highlighted match
+    const matchText = text.substring(match.start, match.end);
+    highlightedText += `<span class="${highlightClass}">${matchText}</span>`;
+    totalLength += matchText.length;
+    
+    // Add text after the match
+    if (match.end < contextEnd) {
+      const afterText = text.substring(match.end, contextEnd);
+      highlightedText += afterText;
+      totalLength += afterText.length;
+    }
+    
+    lastEnd = contextEnd;
+    
+    // Check if we've exceeded the max length
+    if (totalLength >= maxLength) {
+      // Add ellipsis at the end if we're not at the end of the original text
+      if (contextEnd < text.length) {
+        highlightedText += ellipsis;
+      }
+      break;
+    }
+  }
+
+  return {
+    highlightedText: highlightedText || originalText,
+    matchCount: mergedMatches.length
+  };
+}
+
+/**
+ * Default highlight middleware with standard options
+ */
+export const defaultHighlightMiddleware = createHighlightMiddleware();
diff --git a/src/utils/types.ts b/src/utils/types.ts
index 6953478..6d59673 100644
--- a/src/utils/types.ts
+++ b/src/utils/types.ts
@@ -36,6 +36,7 @@ export interface SearchOptions extends Omit<RepositoryOptions, 'searchStrategy'>
   success?: (this: { search: (query: string) => void }) => void;
   searchResultTemplate?: string;
   templateMiddleware?: (prop: string, value: string, template: string) => string | undefined;
+  highlightMiddleware?: (result: any, query: string) => any;
   noResultsText?: string;
   debounceTime?: number | null;
   onSearch?: () => void;
diff --git a/tests/highlightMiddleware.test.ts b/tests/highlightMiddleware.test.ts
new file mode 100644
index 0000000..8919615
--- /dev/null
+++ b/tests/highlightMiddleware.test.ts
@@ -0,0 +1,187 @@
+import { describe, it, expect } from 'vitest';
+import { createHighlightMiddleware, highlightText, HighlightOptions } from '../src/utils/highlightMiddleware';
+
+describe('highlightText', () => {
+  it('should highlight single match with default options', () => {
+    const text = 'This is a test search result';
+    const query = 'search';
+    const result = highlightText(text, query);
+    
+    expect(result.highlightedText).toBe('This is a test <span class="sjs-highlight">search</span> result');
+    expect(result.matchCount).toBe(1);
+  });
+
+  it('should highlight multiple matches', () => {
+    const text = 'This search result contains search terms';
+    const query = 'search';
+    const result = highlightText(text, query);
+    
+    expect(result.highlightedText).toBe('This <span class="sjs-highlight">search</span> result contains <span class="sjs-highlight">search</span> terms');
+    expect(result.matchCount).toBe(2);
+  });
+
+  it('should handle case insensitive matching', () => {
+    const text = 'This is a Search result';
+    const query = 'search';
+    const result = highlightText(text, query);
+    
+    expect(result.highlightedText).toBe('This is a <span class="sjs-highlight">Search</span> result');
+    expect(result.matchCount).toBe(1);
+  });
+
+  it('should handle multiple search terms', () => {
+    const text = 'This is a test search result with multiple terms';
+    const query = 'search result';
+    const result = highlightText(text, query);
+    
+    expect(result.highlightedText).toBe('This is a test <span class="sjs-highlight">search</span> <span class="sjs-highlight">result</span> with multiple terms');
+    expect(result.matchCount).toBe(2);
+  });
+
+  it('should provide context around matches', () => {
+    const text = 'This is a very long text that contains a search term in the middle of it';
+    const query = 'search';
+    const options: HighlightOptions = {
+      contextBefore: 10,
+      contextAfter: 10,
+      maxLength: 50
+    };
+    const result = highlightText(text, query, options);
+    
+    expect(result.highlightedText).toContain('<span class="sjs-highlight">search</span>');
+    // The text is long enough to trigger context mode
+    expect(result.matchCount).toBe(1);
+    // Should show context around the match
+    expect(result.highlightedText.length).toBeLessThan(text.length);
+  });
+
+  it('should respect maxLength option', () => {
+    const text = 'This is a very long text that contains a search term in the middle of it and continues with more text and even more text to make it really long';
+    const query = 'search';
+    const options: HighlightOptions = {
+      maxLength: 30
+    };
+    const result = highlightText(text, query, options);
+    
+    // The result should be truncated
+    expect(result.highlightedText).toContain('<span class="sjs-highlight">search</span>');
+    // The result should be significantly shorter than the original text
+    expect(result.highlightedText.length).toBeLessThan(text.length);
+  });
+
+  it('should use custom highlight class', () => {
+    const text = 'This is a test search result';
+    const query = 'search';
+    const options: HighlightOptions = {
+      highlightClass: 'custom-highlight'
+    };
+    const result = highlightText(text, query, options);
+    
+    expect(result.highlightedText).toBe('This is a test <span class="custom-highlight">search</span> result');
+  });
+
+  it('should handle empty query', () => {
+    const text = 'This is a test search result';
+    const query = '';
+    const result = highlightText(text, query);
+    
+    expect(result.highlightedText).toBe(text);
+    expect(result.matchCount).toBe(0);
+  });
+
+  it('should handle empty text', () => {
+    const text = '';
+    const query = 'search';
+    const result = highlightText(text, query);
+    
+    expect(result.highlightedText).toBe('');
+    expect(result.matchCount).toBe(0);
+  });
+
+  it('should merge overlapping matches', () => {
+    const text = 'searching for search';
+    const query = 'search';
+    const result = highlightText(text, query);
+    
+    // Should merge the overlapping "search" matches
+    expect(result.highlightedText).toBe('<span class="sjs-highlight">search</span>ing for <span class="sjs-highlight">search</span>');
+    expect(result.matchCount).toBe(2);
+  });
+});
+
+describe('createHighlightMiddleware', () => {
+  it('should create a middleware function that processes search results', () => {
+    const middleware = createHighlightMiddleware();
+    const result = {
+      title: 'Test Title',
+      desc: 'This is a test description with search terms',
+      url: '/test'
+    };
+    const query = 'search';
+    
+    const processed = middleware(result, query);
+    
+    expect(processed.title).toBe('Test Title'); // Should not be modified
+    expect(processed.desc).toContain('<span class="sjs-highlight">search</span>');
+    expect(processed.url).toBe('/test'); // Should not be modified
+  });
+
+  it('should handle custom options', () => {
+    const middleware = createHighlightMiddleware({
+      highlightClass: 'custom-highlight',
+      contextBefore: 5,
+      contextAfter: 5
+    });
+    const result = {
+      title: 'Test Title',
+      desc: 'This is a test description with search terms',
+      url: '/test'
+    };
+    const query = 'search';
+    
+    const processed = middleware(result, query);
+    
+    expect(processed.desc).toContain('<span class="custom-highlight">search</span>');
+  });
+
+  it('should not modify non-string fields', () => {
+    const middleware = createHighlightMiddleware();
+    const result = {
+      title: 'Test Title',
+      desc: 'This is a test description with search terms',
+      url: '/test',
+      tags: ['tag1', 'tag2'],
+      date: new Date('2023-01-01')
+    };
+    const query = 'search';
+    
+    const processed = middleware(result, query);
+    
+    expect(processed.tags).toEqual(['tag1', 'tag2']);
+    expect(processed.date).toBeInstanceOf(Date);
+  });
+
+  it('should handle empty query', () => {
+    const middleware = createHighlightMiddleware();
+    const result = {
+      title: 'Test Title',
+      desc: 'This is a test description',
+      url: '/test'
+    };
+    const query = '';
+    
+    const processed = middleware(result, query);
+    
+    expect(processed).toEqual(result);
+  });
+
+  it('should handle null/undefined result', () => {
+    const middleware = createHighlightMiddleware();
+    const result = null;
+    const query = 'search';
+    
+    const processed = middleware(result, query);
+    
+    expect(processed).toBeNull();
+  });
+});

From 08d678b313dd82470c19031e5e8e1ad3c3bc6ffa Mon Sep 17 00:00:00 2001
From: sylhare <sylhare@outlook.com>
Date: Wed, 8 Oct 2025 15:55:07 -0400
Subject: [PATCH 02/10] Update the highlight middleware for fuzzy match

---
 README.md                         |  69 +++++
 dest/simple-jekyll-search.js      | 129 +++++++++-
 dest/simple-jekyll-search.min.js  |   2 +-
 docs/_includes/search.html        |  96 ++++---
 src/SimpleJekyllSearch.ts         |   7 +-
 src/Templater.ts                  |   6 +-
 src/index.ts                      |   8 +-
 src/utils/default.ts              |   5 +-
 src/utils/highlightMiddleware.ts  | 161 ++++++++++++
 src/utils/types.ts                |   3 +-
 tests/highlightMiddleware.test.ts | 406 +++++++++++++++++++++++++++++-
 11 files changed, 838 insertions(+), 54 deletions(-)

diff --git a/README.md b/README.md
index 28da376..50b0e3b 100644
--- a/README.md
+++ b/README.md
@@ -97,6 +97,7 @@ Here is a table for the available options, usage questions, troubleshooting & gu
 | `success`              | Function       | No       | A function called once the data has been loaded.                                                                                                                                   |
 | `debounceTime`         | Number         | No       | Limit how many times the search function can be executed over the given time window. If no `debounceTime` (milliseconds) is provided a search will be triggered on each keystroke. |
 | `searchResultTemplate` | String         | No       | The template of a single rendered search result. (match liquid value eg: `'<li><a href="{{ site.url }}{url}">{title}</a></li>'`                                                    |
+| `templateMiddleware`   | Function       | No       | A function that processes template placeholders and can include highlighting functionality. The function receives (prop, value, template, query) parameters. |
 
 ## Middleware
 
@@ -139,3 +140,71 @@ SimpleJekyllSearch({
   },
 })
 ```
+
+### templateMiddleware with Highlighting (Function) [optional]
+
+The `templateMiddleware` function now supports highlighting functionality. It processes template placeholders and can add HTML highlighting to search results.
+
+The function receives four parameters:
+- `prop`: The property name being processed (e.g., 'title', 'content', 'desc')
+- `value`: The value of the property
+- `template`: The full template string
+- `query`: The search query (optional)
+
+Example with built-in highlight template middleware:
+
+```js
+import { createHighlightTemplateMiddleware } from 'simple-jekyll-search';
+
+SimpleJekyllSearch({
+  // ...other config
+  templateMiddleware: createHighlightTemplateMiddleware({
+    highlightClass: 'my-highlight',  // Custom CSS class
+    contextBefore: 30,               // Characters before match
+    contextAfter: 30,                // Characters after match
+    maxLength: 200,                  // Maximum total length
+    ellipsis: '...'                  // Text to show when truncated
+  }),
+})
+```
+
+You can also create a custom template middleware with highlighting:
+
+```js
+SimpleJekyllSearch({
+  // ...other config
+  templateMiddleware: function(prop, value, template, query) {
+    // Only highlight content and desc fields
+    if ((prop === 'content' || prop === 'desc') && query && typeof value === 'string') {
+      return value.replace(
+        new RegExp(`(${query})`, 'gi'),
+        '<span class="highlight">$1</span>'
+      );
+    }
+    return undefined; // Use default value for other properties
+  },
+})
+```
+
+The template middleware should return a string to replace the placeholder, or `undefined` to use the default value.
+
+#### Search Strategy Compatibility
+
+The highlight template middleware works with all search strategies:
+
+- **Literal Search**: Highlights exact word matches
+- **Wildcard Search**: Highlights exact matches (supports regex patterns)
+- **Fuzzy Search**: Highlights both exact matches and fuzzy matches (e.g., "test" matches "tst", "testing")
+
+The middleware intelligently handles different search types:
+1. First tries exact word matching (for literal and wildcard searches)
+2. Falls back to fuzzy matching if no exact matches found
+3. Prefers exact matches over fuzzy matches when both are available
+
+Example with fuzzy search:
+```js
+// Searching for "test" will highlight:
+// - "test" (exact match)
+// - "testing" (fuzzy match - highlights "test" part)
+// - "tst" (fuzzy match - highlights "tst")
+```
diff --git a/dest/simple-jekyll-search.js b/dest/simple-jekyll-search.js
index ce5759d..f870033 100644
--- a/dest/simple-jekyll-search.js
+++ b/dest/simple-jekyll-search.js
@@ -150,6 +150,128 @@
     }
     return output;
   }
+  function createHighlightMiddleware(options2 = {}) {
+    const {
+      highlightClass = "sjs-highlight",
+      contextBefore = 50,
+      contextAfter = 50,
+      maxLength = 250,
+      ellipsis = "..."
+    } = options2;
+    return function(result, query) {
+      if (!query || !result) {
+        return result;
+      }
+      const highlightedResult = { ...result };
+      const textFields = ["title", "desc", "content", "excerpt"];
+      for (const field of textFields) {
+        if (highlightedResult[field] && typeof highlightedResult[field] === "string") {
+          const highlighted = highlightText(
+            highlightedResult[field],
+            query,
+            { highlightClass, contextBefore, contextAfter, maxLength, ellipsis }
+          );
+          if (highlighted.highlightedText !== highlightedResult[field]) {
+            highlightedResult[field] = highlighted.highlightedText;
+          }
+        }
+      }
+      return highlightedResult;
+    };
+  }
+  function highlightText(text, query, options2 = {}) {
+    const {
+      highlightClass = "sjs-highlight",
+      contextBefore = 50,
+      contextAfter = 50,
+      maxLength = 250,
+      ellipsis = "..."
+    } = options2;
+    if (!text || !query) {
+      return { highlightedText: text, matchCount: 0 };
+    }
+    const originalText = text;
+    const searchTerms = query.trim().toLowerCase().split(/\s+/).filter((term) => term.length > 0);
+    if (searchTerms.length === 0) {
+      return { highlightedText: text, matchCount: 0 };
+    }
+    const matches = [];
+    for (const term of searchTerms) {
+      let index = 0;
+      while (index < text.length) {
+        const found = text.toLowerCase().indexOf(term, index);
+        if (found === -1) break;
+        matches.push({
+          start: found,
+          end: found + term.length,
+          term: text.substring(found, found + term.length)
+        });
+        index = found + 1;
+      }
+    }
+    if (matches.length === 0) {
+      return { highlightedText: text, matchCount: 0 };
+    }
+    matches.sort((a, b) => a.start - b.start);
+    const mergedMatches = [];
+    for (const match of matches) {
+      if (mergedMatches.length === 0 || mergedMatches[mergedMatches.length - 1].end < match.start) {
+        mergedMatches.push(match);
+      } else {
+        const lastMatch = mergedMatches[mergedMatches.length - 1];
+        lastMatch.end = Math.max(lastMatch.end, match.end);
+        lastMatch.term = text.substring(lastMatch.start, lastMatch.end);
+      }
+    }
+    if (text.length <= maxLength) {
+      let highlightedText2 = text;
+      for (let i = mergedMatches.length - 1; i >= 0; i--) {
+        const match = mergedMatches[i];
+        const before = highlightedText2.substring(0, match.start);
+        const after = highlightedText2.substring(match.end);
+        const matchText = highlightedText2.substring(match.start, match.end);
+        highlightedText2 = before + `<span class="${highlightClass}">${matchText}</span>` + after;
+      }
+      return { highlightedText: highlightedText2, matchCount: mergedMatches.length };
+    }
+    let highlightedText = "";
+    let totalLength = 0;
+    let lastEnd = 0;
+    for (let i = 0; i < mergedMatches.length; i++) {
+      const match = mergedMatches[i];
+      const contextStart = Math.max(lastEnd, match.start - contextBefore);
+      const contextEnd = Math.min(text.length, match.end + contextAfter);
+      if (contextStart > lastEnd && lastEnd > 0) {
+        highlightedText += ellipsis;
+        totalLength += ellipsis.length;
+      }
+      if (contextStart < match.start) {
+        const beforeText = text.substring(contextStart, match.start);
+        highlightedText += beforeText;
+        totalLength += beforeText.length;
+      }
+      const matchText = text.substring(match.start, match.end);
+      highlightedText += `<span class="${highlightClass}">${matchText}</span>`;
+      totalLength += matchText.length;
+      if (match.end < contextEnd) {
+        const afterText = text.substring(match.end, contextEnd);
+        highlightedText += afterText;
+        totalLength += afterText.length;
+      }
+      lastEnd = contextEnd;
+      if (totalLength >= maxLength) {
+        if (contextEnd < text.length) {
+          highlightedText += ellipsis;
+        }
+        break;
+      }
+    }
+    return {
+      highlightedText: highlightedText || originalText,
+      matchCount: mergedMatches.length
+    };
+  }
+  const defaultHighlightMiddleware = createHighlightMiddleware();
   const DEFAULT_OPTIONS = {
     searchInput: null,
     resultsContainer: null,
@@ -158,6 +280,7 @@
     },
     searchResultTemplate: '<li><a href="{url}" title="{desc}">{title}</a></li>',
     templateMiddleware: (_prop, _value, _template) => void 0,
+    highlightMiddleware: defaultHighlightMiddleware,
     sortMiddleware: NoSort,
     noResultsText: "No results found",
     limit: 10,
@@ -356,8 +479,9 @@
       const fragment = document.createDocumentFragment();
       results.forEach((result) => {
         result.query = query;
+        const highlightedResult = this.options.highlightMiddleware ? this.options.highlightMiddleware(result, query) : result;
         const div = document.createElement("div");
-        div.innerHTML = compile(result);
+        div.innerHTML = compile(highlightedResult);
         fragment.appendChild(div);
       });
       this.options.resultsContainer.appendChild(fragment);
@@ -399,6 +523,9 @@
   if (typeof window !== "undefined") {
     window.SimpleJekyllSearch = SimpleJekyllSearch;
   }
+  exports2.createHighlightMiddleware = createHighlightMiddleware;
   exports2.default = SimpleJekyllSearch;
+  exports2.defaultHighlightMiddleware = defaultHighlightMiddleware;
+  exports2.highlightText = highlightText;
   Object.defineProperties(exports2, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
 });
diff --git a/dest/simple-jekyll-search.min.js b/dest/simple-jekyll-search.min.js
index 58f1487..7767669 100644
--- a/dest/simple-jekyll-search.min.js
+++ b/dest/simple-jekyll-search.min.js
@@ -4,4 +4,4 @@
   * Copyright 2025-2025, Sylhare
   * Licensed under the MIT License.
   */
-(function(global,factory){typeof exports==="object"&&typeof module!=="undefined"?factory(exports):typeof define==="function"&&define.amd?define(["exports"],factory):(global=typeof globalThis!=="undefined"?globalThis:global||self,factory(global.SimpleJekyllSearch={}))})(this,(function(exports2){"use strict";function load(location,callback){const xhr=getXHR();xhr.open("GET",location,true);xhr.onreadystatechange=createStateChangeListener(xhr,callback);xhr.send()}function createStateChangeListener(xhr,callback){return function(){if(xhr.readyState===4&&xhr.status===200){try{callback(null,JSON.parse(xhr.responseText))}catch(err){callback(err instanceof Error?err:new Error(String(err)),null)}}}}function getXHR(){return window.XMLHttpRequest?new window.XMLHttpRequest:new window.ActiveXObject("Microsoft.XMLHTTP")}class OptionsValidator{constructor(params){if(!this.validateParams(params)){throw new Error("-- OptionsValidator: required options missing")}this.requiredOptions=params.required}getRequiredOptions(){return this.requiredOptions}validate(parameters){const errors=[];this.requiredOptions.forEach((requiredOptionName=>{if(typeof parameters[requiredOptionName]==="undefined"){errors.push(requiredOptionName)}}));return errors}validateParams(params){if(!params){return false}return typeof params.required!=="undefined"&&Array.isArray(params.required)}}function fuzzySearch(text,pattern){pattern=pattern.trimEnd();if(pattern.length===0)return true;pattern=pattern.toLowerCase();text=text.toLowerCase();let remainingText=text,currentIndex=-1;for(const char of pattern){const nextIndex=remainingText.indexOf(char);if(nextIndex===-1||currentIndex!==-1&&remainingText.slice(0,nextIndex).split(" ").length-1>2){return false}currentIndex=nextIndex;remainingText=remainingText.slice(nextIndex+1)}return true}function literalSearch(text,criteria){text=text.trim().toLowerCase();const pattern=criteria.endsWith(" ")?[criteria.toLowerCase()]:criteria.trim().toLowerCase().split(" ");return pattern.filter((word=>text.indexOf(word)>=0)).length===pattern.length}function levenshtein(a,b){const lenA=a.length;const lenB=b.length;const distanceMatrix=Array.from({length:lenA+1},(()=>Array(lenB+1).fill(0)));for(let i=0;i<=lenA;i++)distanceMatrix[i][0]=i;for(let j=0;j<=lenB;j++)distanceMatrix[0][j]=j;for(let i=1;i<=lenA;i++){for(let j=1;j<=lenB;j++){const cost=a[i-1]===b[j-1]?0:1;distanceMatrix[i][j]=Math.min(distanceMatrix[i-1][j]+1,distanceMatrix[i][j-1]+1,distanceMatrix[i-1][j-1]+cost)}}return distanceMatrix[lenA][lenB]}function levenshteinSearch(text,pattern){const distance=levenshtein(pattern,text);const similarity=1-distance/Math.max(pattern.length,text.length);return similarity>=.3}function wildcardSearch(text,pattern){const regexPattern=pattern.replace(/\*/g,".*");const regex=new RegExp(`^${regexPattern}$`,"i");if(regex.test(text))return true;return levenshteinSearch(text,pattern)}class SearchStrategy{constructor(matchFunction){this.matchFunction=matchFunction}matches(text,criteria){if(text===null||text.trim()===""||!criteria){return false}return this.matchFunction(text,criteria)}}const LiteralSearchStrategy=new SearchStrategy(literalSearch);const FuzzySearchStrategy=new SearchStrategy(((text,criteria)=>fuzzySearch(text,criteria)||literalSearch(text,criteria)));const WildcardSearchStrategy=new SearchStrategy(((text,criteria)=>wildcardSearch(text,criteria)||literalSearch(text,criteria)));function merge(target,source){return{...target,...source}}function isJSON(json){try{return!!(json instanceof Object&&JSON.parse(JSON.stringify(json)))}catch(_err){return false}}function NoSort(){return 0}function isObject(obj){return Boolean(obj)&&Object.prototype.toString.call(obj)==="[object Object]"}function clone(input){if(input===null||typeof input!=="object"){return input}if(Array.isArray(input)){return input.map((item=>clone(item)))}const output={};for(const key in input){if(Object.prototype.hasOwnProperty.call(input,key)){output[key]=clone(input[key])}}return output}const DEFAULT_OPTIONS={searchInput:null,resultsContainer:null,json:[],success:function(){},searchResultTemplate:'<li><a href="{url}" title="{desc}">{title}</a></li>',templateMiddleware:(_prop,_value,_template)=>void 0,sortMiddleware:NoSort,noResultsText:"No results found",limit:10,fuzzy:false,strategy:"literal",debounceTime:null,exclude:[],onSearch:()=>{}};const REQUIRED_OPTIONS=["searchInput","resultsContainer","json"];const WHITELISTED_KEYS=new Set(["Enter","Shift","CapsLock","ArrowLeft","ArrowUp","ArrowRight","ArrowDown","Meta"]);class Repository{constructor(initialOptions={}){this.data=[];this.setOptions(initialOptions)}put(input){if(isObject(input)){return this.addObject(input)}if(Array.isArray(input)){return this.addArray(input)}return void 0}clear(){this.data.length=0;return this.data}search(criteria){if(!criteria){return[]}return clone(this.findMatches(this.data,criteria).sort(this.options.sortMiddleware))}setOptions(newOptions){this.options={fuzzy:(newOptions==null?void 0:newOptions.fuzzy)||DEFAULT_OPTIONS.fuzzy,limit:(newOptions==null?void 0:newOptions.limit)||DEFAULT_OPTIONS.limit,searchStrategy:this.searchStrategy((newOptions==null?void 0:newOptions.strategy)||newOptions.fuzzy&&"fuzzy"||DEFAULT_OPTIONS.strategy),sortMiddleware:(newOptions==null?void 0:newOptions.sortMiddleware)||DEFAULT_OPTIONS.sortMiddleware,exclude:(newOptions==null?void 0:newOptions.exclude)||DEFAULT_OPTIONS.exclude,strategy:(newOptions==null?void 0:newOptions.strategy)||DEFAULT_OPTIONS.strategy}}addObject(obj){this.data.push(obj);return this.data}addArray(arr){const added=[];this.clear();for(const item of arr){if(isObject(item)){added.push(this.addObject(item)[0])}}return added}findMatches(data,criteria){const matches=[];for(let i=0;i<data.length&&matches.length<this.options.limit;i++){const match=this.findMatchesInObject(data[i],criteria);if(match){matches.push(match)}}return matches}findMatchesInObject(obj,criteria){for(const key in obj){if(!this.isExcluded(obj[key])&&this.options.searchStrategy.matches(obj[key],criteria)){return obj}}return void 0}isExcluded(term){for(const excludedTerm of this.options.exclude){if(new RegExp(excludedTerm).test(String(term))){return true}}return false}searchStrategy(strategy){switch(strategy){case"fuzzy":return FuzzySearchStrategy;case"wildcard":return WildcardSearchStrategy;default:return LiteralSearchStrategy}}}const options={pattern:/\{(.*?)\}/g,template:"",middleware:function(){return void 0}};function setOptions(_options){if(_options.pattern){options.pattern=_options.pattern}if(_options.template){options.template=_options.template}if(typeof _options.middleware==="function"){options.middleware=_options.middleware}}function compile(data){return options.template.replace(options.pattern,(function(match,prop){const value=options.middleware(prop,data[prop],options.template);if(typeof value!=="undefined"){return value}return data[prop]||match}))}let SimpleJekyllSearch$1=class SimpleJekyllSearch{constructor(){this.debounceTimerHandle=null;this.options={...DEFAULT_OPTIONS};this.repository=new Repository;this.optionsValidator=new OptionsValidator({required:REQUIRED_OPTIONS})}debounce(func,delayMillis){if(delayMillis){if(this.debounceTimerHandle){clearTimeout(this.debounceTimerHandle)}this.debounceTimerHandle=setTimeout(func,delayMillis)}else{func()}}throwError(message){throw new Error(`SimpleJekyllSearch --- ${message}`)}emptyResultsContainer(){this.options.resultsContainer.innerHTML=""}initWithJSON(json){this.repository.put(json);this.registerInput()}initWithURL(url){load(url,((err,json)=>{if(err){this.throwError(`Failed to load JSON from ${url}: ${err.message}`)}this.initWithJSON(json)}))}registerInput(){this.options.searchInput.addEventListener("input",(e=>{const inputEvent=e;if(!WHITELISTED_KEYS.has(inputEvent.key)){this.emptyResultsContainer();this.debounce((()=>{this.search(e.target.value)}),this.options.debounceTime??null)}}))}search(query){var _a,_b;if((query==null?void 0:query.trim().length)>0){this.emptyResultsContainer();const results=this.repository.search(query);this.render(results,query);(_b=(_a=this.options).onSearch)==null?void 0:_b.call(_a)}}render(results,query){if(results.length===0){this.options.resultsContainer.insertAdjacentHTML("beforeend",this.options.noResultsText);return}const fragment=document.createDocumentFragment();results.forEach((result=>{result.query=query;const div=document.createElement("div");div.innerHTML=compile(result);fragment.appendChild(div)}));this.options.resultsContainer.appendChild(fragment)}init(_options){var _a;const errors=this.optionsValidator.validate(_options);if(errors.length>0){this.throwError(`Missing required options: ${REQUIRED_OPTIONS.join(", ")}`)}this.options=merge(this.options,_options);setOptions({template:this.options.searchResultTemplate,middleware:this.options.templateMiddleware});this.repository.setOptions({fuzzy:this.options.fuzzy,limit:this.options.limit,sortMiddleware:this.options.sortMiddleware,strategy:this.options.strategy,exclude:this.options.exclude});if(isJSON(this.options.json)){this.initWithJSON(this.options.json)}else{this.initWithURL(this.options.json)}const rv={search:this.search.bind(this)};(_a=this.options.success)==null?void 0:_a.call(rv);return rv}};function SimpleJekyllSearch(options2){const instance=new SimpleJekyllSearch$1;return instance.init(options2)}if(typeof window!=="undefined"){window.SimpleJekyllSearch=SimpleJekyllSearch}exports2.default=SimpleJekyllSearch;Object.defineProperties(exports2,{__esModule:{value:true},[Symbol.toStringTag]:{value:"Module"}})}));
\ No newline at end of file
+(function(global,factory){typeof exports==="object"&&typeof module!=="undefined"?factory(exports):typeof define==="function"&&define.amd?define(["exports"],factory):(global=typeof globalThis!=="undefined"?globalThis:global||self,factory(global.SimpleJekyllSearch={}))})(this,(function(exports2){"use strict";function load(location,callback){const xhr=getXHR();xhr.open("GET",location,true);xhr.onreadystatechange=createStateChangeListener(xhr,callback);xhr.send()}function createStateChangeListener(xhr,callback){return function(){if(xhr.readyState===4&&xhr.status===200){try{callback(null,JSON.parse(xhr.responseText))}catch(err){callback(err instanceof Error?err:new Error(String(err)),null)}}}}function getXHR(){return window.XMLHttpRequest?new window.XMLHttpRequest:new window.ActiveXObject("Microsoft.XMLHTTP")}class OptionsValidator{constructor(params){if(!this.validateParams(params)){throw new Error("-- OptionsValidator: required options missing")}this.requiredOptions=params.required}getRequiredOptions(){return this.requiredOptions}validate(parameters){const errors=[];this.requiredOptions.forEach((requiredOptionName=>{if(typeof parameters[requiredOptionName]==="undefined"){errors.push(requiredOptionName)}}));return errors}validateParams(params){if(!params){return false}return typeof params.required!=="undefined"&&Array.isArray(params.required)}}function fuzzySearch(text,pattern){pattern=pattern.trimEnd();if(pattern.length===0)return true;pattern=pattern.toLowerCase();text=text.toLowerCase();let remainingText=text,currentIndex=-1;for(const char of pattern){const nextIndex=remainingText.indexOf(char);if(nextIndex===-1||currentIndex!==-1&&remainingText.slice(0,nextIndex).split(" ").length-1>2){return false}currentIndex=nextIndex;remainingText=remainingText.slice(nextIndex+1)}return true}function literalSearch(text,criteria){text=text.trim().toLowerCase();const pattern=criteria.endsWith(" ")?[criteria.toLowerCase()]:criteria.trim().toLowerCase().split(" ");return pattern.filter((word=>text.indexOf(word)>=0)).length===pattern.length}function levenshtein(a,b){const lenA=a.length;const lenB=b.length;const distanceMatrix=Array.from({length:lenA+1},(()=>Array(lenB+1).fill(0)));for(let i=0;i<=lenA;i++)distanceMatrix[i][0]=i;for(let j=0;j<=lenB;j++)distanceMatrix[0][j]=j;for(let i=1;i<=lenA;i++){for(let j=1;j<=lenB;j++){const cost=a[i-1]===b[j-1]?0:1;distanceMatrix[i][j]=Math.min(distanceMatrix[i-1][j]+1,distanceMatrix[i][j-1]+1,distanceMatrix[i-1][j-1]+cost)}}return distanceMatrix[lenA][lenB]}function levenshteinSearch(text,pattern){const distance=levenshtein(pattern,text);const similarity=1-distance/Math.max(pattern.length,text.length);return similarity>=.3}function wildcardSearch(text,pattern){const regexPattern=pattern.replace(/\*/g,".*");const regex=new RegExp(`^${regexPattern}$`,"i");if(regex.test(text))return true;return levenshteinSearch(text,pattern)}class SearchStrategy{constructor(matchFunction){this.matchFunction=matchFunction}matches(text,criteria){if(text===null||text.trim()===""||!criteria){return false}return this.matchFunction(text,criteria)}}const LiteralSearchStrategy=new SearchStrategy(literalSearch);const FuzzySearchStrategy=new SearchStrategy(((text,criteria)=>fuzzySearch(text,criteria)||literalSearch(text,criteria)));const WildcardSearchStrategy=new SearchStrategy(((text,criteria)=>wildcardSearch(text,criteria)||literalSearch(text,criteria)));function merge(target,source){return{...target,...source}}function isJSON(json){try{return!!(json instanceof Object&&JSON.parse(JSON.stringify(json)))}catch(_err){return false}}function NoSort(){return 0}function isObject(obj){return Boolean(obj)&&Object.prototype.toString.call(obj)==="[object Object]"}function clone(input){if(input===null||typeof input!=="object"){return input}if(Array.isArray(input)){return input.map((item=>clone(item)))}const output={};for(const key in input){if(Object.prototype.hasOwnProperty.call(input,key)){output[key]=clone(input[key])}}return output}function createHighlightMiddleware(options2={}){const{highlightClass:highlightClass="sjs-highlight",contextBefore:contextBefore=50,contextAfter:contextAfter=50,maxLength:maxLength=250,ellipsis:ellipsis="..."}=options2;return function(result,query){if(!query||!result){return result}const highlightedResult={...result};const textFields=["title","desc","content","excerpt"];for(const field of textFields){if(highlightedResult[field]&&typeof highlightedResult[field]==="string"){const highlighted=highlightText(highlightedResult[field],query,{highlightClass:highlightClass,contextBefore:contextBefore,contextAfter:contextAfter,maxLength:maxLength,ellipsis:ellipsis});if(highlighted.highlightedText!==highlightedResult[field]){highlightedResult[field]=highlighted.highlightedText}}}return highlightedResult}}function highlightText(text,query,options2={}){const{highlightClass:highlightClass="sjs-highlight",contextBefore:contextBefore=50,contextAfter:contextAfter=50,maxLength:maxLength=250,ellipsis:ellipsis="..."}=options2;if(!text||!query){return{highlightedText:text,matchCount:0}}const originalText=text;const searchTerms=query.trim().toLowerCase().split(/\s+/).filter((term=>term.length>0));if(searchTerms.length===0){return{highlightedText:text,matchCount:0}}const matches=[];for(const term of searchTerms){let index=0;while(index<text.length){const found=text.toLowerCase().indexOf(term,index);if(found===-1)break;matches.push({start:found,end:found+term.length,term:text.substring(found,found+term.length)});index=found+1}}if(matches.length===0){return{highlightedText:text,matchCount:0}}matches.sort(((a,b)=>a.start-b.start));const mergedMatches=[];for(const match of matches){if(mergedMatches.length===0||mergedMatches[mergedMatches.length-1].end<match.start){mergedMatches.push(match)}else{const lastMatch=mergedMatches[mergedMatches.length-1];lastMatch.end=Math.max(lastMatch.end,match.end);lastMatch.term=text.substring(lastMatch.start,lastMatch.end)}}if(text.length<=maxLength){let highlightedText2=text;for(let i=mergedMatches.length-1;i>=0;i--){const match=mergedMatches[i];const before=highlightedText2.substring(0,match.start);const after=highlightedText2.substring(match.end);const matchText=highlightedText2.substring(match.start,match.end);highlightedText2=before+`<span class="${highlightClass}">${matchText}</span>`+after}return{highlightedText:highlightedText2,matchCount:mergedMatches.length}}let highlightedText="";let totalLength=0;let lastEnd=0;for(let i=0;i<mergedMatches.length;i++){const match=mergedMatches[i];const contextStart=Math.max(lastEnd,match.start-contextBefore);const contextEnd=Math.min(text.length,match.end+contextAfter);if(contextStart>lastEnd&&lastEnd>0){highlightedText+=ellipsis;totalLength+=ellipsis.length}if(contextStart<match.start){const beforeText=text.substring(contextStart,match.start);highlightedText+=beforeText;totalLength+=beforeText.length}const matchText=text.substring(match.start,match.end);highlightedText+=`<span class="${highlightClass}">${matchText}</span>`;totalLength+=matchText.length;if(match.end<contextEnd){const afterText=text.substring(match.end,contextEnd);highlightedText+=afterText;totalLength+=afterText.length}lastEnd=contextEnd;if(totalLength>=maxLength){if(contextEnd<text.length){highlightedText+=ellipsis}break}}return{highlightedText:highlightedText||originalText,matchCount:mergedMatches.length}}const defaultHighlightMiddleware=createHighlightMiddleware();const DEFAULT_OPTIONS={searchInput:null,resultsContainer:null,json:[],success:function(){},searchResultTemplate:'<li><a href="{url}" title="{desc}">{title}</a></li>',templateMiddleware:(_prop,_value,_template)=>void 0,highlightMiddleware:defaultHighlightMiddleware,sortMiddleware:NoSort,noResultsText:"No results found",limit:10,fuzzy:false,strategy:"literal",debounceTime:null,exclude:[],onSearch:()=>{}};const REQUIRED_OPTIONS=["searchInput","resultsContainer","json"];const WHITELISTED_KEYS=new Set(["Enter","Shift","CapsLock","ArrowLeft","ArrowUp","ArrowRight","ArrowDown","Meta"]);class Repository{constructor(initialOptions={}){this.data=[];this.setOptions(initialOptions)}put(input){if(isObject(input)){return this.addObject(input)}if(Array.isArray(input)){return this.addArray(input)}return void 0}clear(){this.data.length=0;return this.data}search(criteria){if(!criteria){return[]}return clone(this.findMatches(this.data,criteria).sort(this.options.sortMiddleware))}setOptions(newOptions){this.options={fuzzy:(newOptions==null?void 0:newOptions.fuzzy)||DEFAULT_OPTIONS.fuzzy,limit:(newOptions==null?void 0:newOptions.limit)||DEFAULT_OPTIONS.limit,searchStrategy:this.searchStrategy((newOptions==null?void 0:newOptions.strategy)||newOptions.fuzzy&&"fuzzy"||DEFAULT_OPTIONS.strategy),sortMiddleware:(newOptions==null?void 0:newOptions.sortMiddleware)||DEFAULT_OPTIONS.sortMiddleware,exclude:(newOptions==null?void 0:newOptions.exclude)||DEFAULT_OPTIONS.exclude,strategy:(newOptions==null?void 0:newOptions.strategy)||DEFAULT_OPTIONS.strategy}}addObject(obj){this.data.push(obj);return this.data}addArray(arr){const added=[];this.clear();for(const item of arr){if(isObject(item)){added.push(this.addObject(item)[0])}}return added}findMatches(data,criteria){const matches=[];for(let i=0;i<data.length&&matches.length<this.options.limit;i++){const match=this.findMatchesInObject(data[i],criteria);if(match){matches.push(match)}}return matches}findMatchesInObject(obj,criteria){for(const key in obj){if(!this.isExcluded(obj[key])&&this.options.searchStrategy.matches(obj[key],criteria)){return obj}}return void 0}isExcluded(term){for(const excludedTerm of this.options.exclude){if(new RegExp(excludedTerm).test(String(term))){return true}}return false}searchStrategy(strategy){switch(strategy){case"fuzzy":return FuzzySearchStrategy;case"wildcard":return WildcardSearchStrategy;default:return LiteralSearchStrategy}}}const options={pattern:/\{(.*?)\}/g,template:"",middleware:function(){return void 0}};function setOptions(_options){if(_options.pattern){options.pattern=_options.pattern}if(_options.template){options.template=_options.template}if(typeof _options.middleware==="function"){options.middleware=_options.middleware}}function compile(data){return options.template.replace(options.pattern,(function(match,prop){const value=options.middleware(prop,data[prop],options.template);if(typeof value!=="undefined"){return value}return data[prop]||match}))}let SimpleJekyllSearch$1=class SimpleJekyllSearch{constructor(){this.debounceTimerHandle=null;this.options={...DEFAULT_OPTIONS};this.repository=new Repository;this.optionsValidator=new OptionsValidator({required:REQUIRED_OPTIONS})}debounce(func,delayMillis){if(delayMillis){if(this.debounceTimerHandle){clearTimeout(this.debounceTimerHandle)}this.debounceTimerHandle=setTimeout(func,delayMillis)}else{func()}}throwError(message){throw new Error(`SimpleJekyllSearch --- ${message}`)}emptyResultsContainer(){this.options.resultsContainer.innerHTML=""}initWithJSON(json){this.repository.put(json);this.registerInput()}initWithURL(url){load(url,((err,json)=>{if(err){this.throwError(`Failed to load JSON from ${url}: ${err.message}`)}this.initWithJSON(json)}))}registerInput(){this.options.searchInput.addEventListener("input",(e=>{const inputEvent=e;if(!WHITELISTED_KEYS.has(inputEvent.key)){this.emptyResultsContainer();this.debounce((()=>{this.search(e.target.value)}),this.options.debounceTime??null)}}))}search(query){var _a,_b;if((query==null?void 0:query.trim().length)>0){this.emptyResultsContainer();const results=this.repository.search(query);this.render(results,query);(_b=(_a=this.options).onSearch)==null?void 0:_b.call(_a)}}render(results,query){if(results.length===0){this.options.resultsContainer.insertAdjacentHTML("beforeend",this.options.noResultsText);return}const fragment=document.createDocumentFragment();results.forEach((result=>{result.query=query;const highlightedResult=this.options.highlightMiddleware?this.options.highlightMiddleware(result,query):result;const div=document.createElement("div");div.innerHTML=compile(highlightedResult);fragment.appendChild(div)}));this.options.resultsContainer.appendChild(fragment)}init(_options){var _a;const errors=this.optionsValidator.validate(_options);if(errors.length>0){this.throwError(`Missing required options: ${REQUIRED_OPTIONS.join(", ")}`)}this.options=merge(this.options,_options);setOptions({template:this.options.searchResultTemplate,middleware:this.options.templateMiddleware});this.repository.setOptions({fuzzy:this.options.fuzzy,limit:this.options.limit,sortMiddleware:this.options.sortMiddleware,strategy:this.options.strategy,exclude:this.options.exclude});if(isJSON(this.options.json)){this.initWithJSON(this.options.json)}else{this.initWithURL(this.options.json)}const rv={search:this.search.bind(this)};(_a=this.options.success)==null?void 0:_a.call(rv);return rv}};function SimpleJekyllSearch(options2){const instance=new SimpleJekyllSearch$1;return instance.init(options2)}if(typeof window!=="undefined"){window.SimpleJekyllSearch=SimpleJekyllSearch}exports2.createHighlightMiddleware=createHighlightMiddleware;exports2.default=SimpleJekyllSearch;exports2.defaultHighlightMiddleware=defaultHighlightMiddleware;exports2.highlightText=highlightText;Object.defineProperties(exports2,{__esModule:{value:true},[Symbol.toStringTag]:{value:"Module"}})}));
\ No newline at end of file
diff --git a/docs/_includes/search.html b/docs/_includes/search.html
index d3cb7b5..289125d 100644
--- a/docs/_includes/search.html
+++ b/docs/_includes/search.html
@@ -7,53 +7,77 @@
   <script src="{{ '/assets/js/simple-jekyll-search.min.js' | relative_url }}"></script>
 
   <script>
-    // Custom highlight middleware with shorter context for search snippets
-    function createSearchSnippetMiddleware() {
-      return function(result, query) {
-        if (!query || !result) return result;
-        
-        const highlightedResult = { ...result };
-        
-        // Process content field with shorter context
-        if (highlightedResult.content && typeof highlightedResult.content === 'string') {
-          const text = highlightedResult.content;
+    // Custom template middleware with fuzzy-aware highlighting for search snippets
+    function createSearchSnippetTemplateMiddleware() {
+      return function(prop, value, template, query) {
+        // Only process content field with shorter context
+        if (prop === 'content' && query && typeof value === 'string') {
+          const text = value;
           const searchTerms = query.trim().toLowerCase().split(/\s+/).filter(term => term.length > 0);
           
           if (searchTerms.length > 0) {
-            // Find first match
-            let firstMatch = -1;
+            let highlightedText = text;
+            let hasMatches = false;
+            
+            // Try exact word matching first
             for (const term of searchTerms) {
-              const found = text.toLowerCase().indexOf(term);
-              if (found !== -1 && (firstMatch === -1 || found < firstMatch)) {
-                firstMatch = found;
+              const regex = new RegExp(`\\b(${term.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')})\\b`, 'gi');
+              if (regex.test(highlightedText)) {
+                highlightedText = highlightedText.replace(regex, '<span class="sjs-highlight">$1</span>');
+                hasMatches = true;
               }
             }
             
-            if (firstMatch !== -1) {
-              // Show 30 characters before and after the first match
-              const contextBefore = 30;
-              const contextAfter = 30;
-              const start = Math.max(0, firstMatch - contextBefore);
-              const end = Math.min(text.length, firstMatch + searchTerms[0].length + contextAfter);
-              
-              let snippet = text.substring(start, end);
-              
-              // Add ellipsis if we're not at the beginning/end
-              if (start > 0) snippet = '...' + snippet;
-              if (end < text.length) snippet = snippet + '...';
-              
-              // Highlight search terms
+            // If no exact matches, try fuzzy matching
+            if (!hasMatches) {
               for (const term of searchTerms) {
-                const regex = new RegExp(`(${term})`, 'gi');
-                snippet = snippet.replace(regex, '<span class="sjs-highlight">$1</span>');
+                // Simple fuzzy matching - find characters in order
+                const lowerText = highlightedText.toLowerCase();
+                const lowerTerm = term.toLowerCase();
+                let textIndex = 0;
+                let termIndex = 0;
+                let matchStart = -1;
+                
+                while (textIndex < lowerText.length && termIndex < lowerTerm.length) {
+                  if (lowerText[textIndex] === lowerTerm[termIndex]) {
+                    if (matchStart === -1) matchStart = textIndex;
+                    termIndex++;
+                  }
+                  textIndex++;
+                }
+                
+                if (termIndex === lowerTerm.length && matchStart !== -1) {
+                  const matchEnd = textIndex;
+                  const before = highlightedText.substring(0, matchStart);
+                  const after = highlightedText.substring(matchEnd);
+                  const matchText = highlightedText.substring(matchStart, matchEnd);
+                  highlightedText = before + '<span class="sjs-highlight">' + matchText + '</span>' + after;
+                  hasMatches = true;
+                }
+              }
+            }
+            
+            if (hasMatches) {
+              // Find first highlighted match for context
+              const firstHighlight = highlightedText.indexOf('<span class="sjs-highlight">');
+              if (firstHighlight !== -1) {
+                const contextBefore = 30;
+                const contextAfter = 30;
+                const start = Math.max(0, firstHighlight - contextBefore);
+                const end = Math.min(highlightedText.length, firstHighlight + 100 + contextAfter);
+                
+                let snippet = highlightedText.substring(start, end);
+                
+                // Add ellipsis if we're not at the beginning/end
+                if (start > 0) snippet = '...' + snippet;
+                if (end < highlightedText.length) snippet = snippet + '...';
+                
+                return snippet;
               }
-              
-              highlightedResult.content = snippet;
             }
           }
         }
-        
-        return highlightedResult;
+        return undefined;
       };
     }
 
@@ -62,7 +86,7 @@
       resultsContainer: document.getElementById('results-container'),
       json: '{{ "/assets/data/search.json" | relative_url }}',
       searchResultTemplate: '<li><a href="{url}?query={query}">{title}</a><div class="search-snippet">{content}</div></li>',
-      highlightMiddleware: createSearchSnippetMiddleware(),
+      templateMiddleware: createSearchSnippetTemplateMiddleware(),
       noResultsText: 'No results found',
       limit: 10,
       strategy: 'wildcard',
diff --git a/src/SimpleJekyllSearch.ts b/src/SimpleJekyllSearch.ts
index 2a20995..1f9a9aa 100644
--- a/src/SimpleJekyllSearch.ts
+++ b/src/SimpleJekyllSearch.ts
@@ -84,13 +84,8 @@ class SimpleJekyllSearch {
     results.forEach(result => {
       result.query = query;
       
-      // Apply highlight middleware if available
-      const highlightedResult = this.options.highlightMiddleware 
-        ? this.options.highlightMiddleware(result, query)
-        : result;
-      
       const div = document.createElement('div');
-      div.innerHTML = compileTemplate(highlightedResult);
+      div.innerHTML = compileTemplate(result, query);
       fragment.appendChild(div);
     });
 
diff --git a/src/Templater.ts b/src/Templater.ts
index cb721ff..cb5f7d0 100644
--- a/src/Templater.ts
+++ b/src/Templater.ts
@@ -1,4 +1,4 @@
-type MiddlewareFunction = (prop: string, value: any, template: string) => any;
+type MiddlewareFunction = (prop: string, value: any, template: string, query?: string) => any;
 
 interface TemplaterOptions {
   pattern?: RegExp;
@@ -28,9 +28,9 @@ export function setOptions(_options: TemplaterOptions): void {
   }
 }
 
-export function compile(data: Data): string {
+export function compile(data: Data, query?: string): string {
   return options.template.replace(options.pattern, function(match: string, prop: string) {
-    const value = options.middleware(prop, data[prop], options.template);
+    const value = options.middleware(prop, data[prop], options.template, query);
     if (typeof value !== 'undefined') {
       return value;
     }
diff --git a/src/index.ts b/src/index.ts
index 5e8e122..8b844f5 100644
--- a/src/index.ts
+++ b/src/index.ts
@@ -1,6 +1,12 @@
 import SimpleJekyllSearchClass from './SimpleJekyllSearch';
 import { SearchOptions, SimpleJekyllSearchInstance } from './utils/types';
-export { createHighlightMiddleware, highlightText, defaultHighlightMiddleware } from './utils/highlightMiddleware';
+export { 
+  createHighlightMiddleware, 
+  createHighlightTemplateMiddleware,
+  highlightText, 
+  defaultHighlightMiddleware,
+  defaultHighlightTemplateMiddleware
+} from './utils/highlightMiddleware';
 export type { HighlightOptions, HighlightResult } from './utils/highlightMiddleware';
 
 function SimpleJekyllSearch(options: SearchOptions): SimpleJekyllSearchInstance {
diff --git a/src/utils/default.ts b/src/utils/default.ts
index b947fbd..e5e32a0 100644
--- a/src/utils/default.ts
+++ b/src/utils/default.ts
@@ -1,14 +1,13 @@
 import { NoSort } from '../utils';
 import { SearchOptions } from './types';
 
-export const DEFAULT_OPTIONS: Required<Omit<SearchOptions, 'highlightMiddleware'>> & Pick<SearchOptions, 'highlightMiddleware'> = {
+export const DEFAULT_OPTIONS: Required<SearchOptions> = {
   searchInput: null!,
   resultsContainer: null!,
   json: [],
   success: function(this: { search: (query: string) => void }) {},
   searchResultTemplate: '<li><a href="{url}" title="{desc}">{title}</a></li>',
-  templateMiddleware: (_prop: string, _value: string, _template: string) => undefined,
-  highlightMiddleware: undefined,
+  templateMiddleware: (_prop: string, _value: string, _template: string, _query?: string) => undefined,
   sortMiddleware: NoSort,
   noResultsText: 'No results found',
   limit: 10,
diff --git a/src/utils/highlightMiddleware.ts b/src/utils/highlightMiddleware.ts
index 7278e11..d961e19 100644
--- a/src/utils/highlightMiddleware.ts
+++ b/src/utils/highlightMiddleware.ts
@@ -211,3 +211,164 @@ export function highlightText(
  * Default highlight middleware with standard options
  */
 export const defaultHighlightMiddleware = createHighlightMiddleware();
+
+/**
+ * Finds fuzzy match positions in text for highlighting
+ * @param text - The text to search in
+ * @param pattern - The search pattern
+ * @returns Array of match positions
+ */
+function findFuzzyMatches(text: string, pattern: string): Array<{ start: number; end: number; text: string }> {
+  const matches: Array<{ start: number; end: number; text: string }> = [];
+  const lowerText = text.toLowerCase();
+  const lowerPattern = pattern.toLowerCase().trim();
+  
+  if (lowerPattern.length === 0) return matches;
+  
+  // Split pattern into words for multi-word fuzzy matching
+  const patternWords = lowerPattern.split(/\s+/);
+  
+  for (const word of patternWords) {
+    if (word.length === 0) continue;
+    
+    // Find fuzzy matches for each word
+    const wordMatches = findFuzzyWordMatches(lowerText, word);
+    matches.push(...wordMatches);
+  }
+  
+  return matches;
+}
+
+/**
+ * Finds fuzzy matches for a single word
+ */
+function findFuzzyWordMatches(text: string, word: string): Array<{ start: number; end: number; text: string }> {
+  const matches: Array<{ start: number; end: number; text: string }> = [];
+  
+  // First try to find exact word matches
+  const exactRegex = new RegExp(`\\b${word.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}\\b`, 'gi');
+  let match;
+  while ((match = exactRegex.exec(text)) !== null) {
+    matches.push({
+      start: match.index,
+      end: match.index + match[0].length,
+      text: match[0]
+    });
+  }
+  
+  // If no exact matches, try fuzzy matching
+  if (matches.length === 0) {
+    // Simple fuzzy matching: find characters in sequence
+    for (let i = 0; i < text.length; i++) {
+      const fuzzyMatch = findFuzzySequenceMatch(text, word, i);
+      if (fuzzyMatch) {
+        matches.push(fuzzyMatch);
+        i = fuzzyMatch.end - 1; // Skip to end of match
+      }
+    }
+  }
+  
+  return matches;
+}
+
+/**
+ * Finds a fuzzy sequence match starting from a given position
+ */
+function findFuzzySequenceMatch(text: string, pattern: string, startPos: number): { start: number; end: number; text: string } | null {
+  let textIndex = startPos;
+  let patternIndex = 0;
+  let matchStart = -1;
+  let maxGap = 3; // Maximum characters between pattern characters
+  const matchedPositions: number[] = [];
+  
+  while (textIndex < text.length && patternIndex < pattern.length) {
+    if (text[textIndex] === pattern[patternIndex]) {
+      if (matchStart === -1) {
+        matchStart = textIndex;
+      }
+      matchedPositions.push(textIndex);
+      patternIndex++;
+    } else if (matchStart !== -1) {
+      // Check if we've gone too far from the last match
+      if (textIndex - matchStart > maxGap * pattern.length) {
+        return null;
+      }
+    }
+    textIndex++;
+  }
+  
+  // If we found a complete match, return only the actual matched characters
+  if (patternIndex === pattern.length && matchStart !== -1 && matchedPositions.length > 0) {
+    const actualStart = matchedPositions[0];
+    const actualEnd = matchedPositions[matchedPositions.length - 1] + 1;
+    
+    return {
+      start: actualStart,
+      end: actualEnd,
+      text: text.substring(actualStart, actualEnd)
+    };
+  }
+  
+  return null;
+}
+
+/**
+ * Creates a templateMiddleware that includes highlighting functionality
+ * @param options - Highlighting options
+ * @returns A templateMiddleware function that can highlight text
+ */
+export function createHighlightTemplateMiddleware(options: HighlightOptions = {}) {
+  const highlightOptions = {
+    highlightClass: 'sjs-highlight',
+    contextBefore: 50,
+    contextAfter: 50,
+    maxLength: 250,
+    ellipsis: '...',
+    ...options
+  };
+
+  return function(prop: string, value: string, _template: string, query?: string): string | undefined {
+    // Only highlight content and desc fields
+    if ((prop === 'content' || prop === 'desc') && query && typeof value === 'string') {
+      // For fuzzy search, we need to find the actual matched characters
+      // First try exact matching (for literal and wildcard searches)
+      let highlightedText = value;
+      let hasMatches = false;
+      
+      // Try exact word matching first
+      const searchTerms = query.trim().split(/\s+/).filter(term => term.length > 0);
+      for (const term of searchTerms) {
+        const regex = new RegExp(`\\b(${term.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')})\\b`, 'gi');
+        if (regex.test(highlightedText)) {
+          highlightedText = highlightedText.replace(regex, `<span class="${highlightOptions.highlightClass}">$1</span>`);
+          hasMatches = true;
+        }
+      }
+      
+      // If no exact matches found, try fuzzy matching
+      if (!hasMatches) {
+        const fuzzyMatches = findFuzzyMatches(value, query);
+        if (fuzzyMatches.length > 0) {
+          // Sort matches by position (reverse order to maintain positions when replacing)
+          fuzzyMatches.sort((a, b) => b.start - a.start);
+          
+          for (const match of fuzzyMatches) {
+            const before = highlightedText.substring(0, match.start);
+            const after = highlightedText.substring(match.end);
+            const matchText = highlightedText.substring(match.start, match.end);
+            highlightedText = before + `<span class="${highlightOptions.highlightClass}">${matchText}</span>` + after;
+          }
+          hasMatches = true;
+        }
+      }
+      
+      // If we have matches, return the highlighted text
+      if (hasMatches) {
+        return highlightedText;
+      }
+    }
+    return undefined;
+  };
+}
+
+export const defaultHighlightTemplateMiddleware = createHighlightTemplateMiddleware();
diff --git a/src/utils/types.ts b/src/utils/types.ts
index 6d59673..420ea83 100644
--- a/src/utils/types.ts
+++ b/src/utils/types.ts
@@ -35,8 +35,7 @@ export interface SearchOptions extends Omit<RepositoryOptions, 'searchStrategy'>
   json: SearchData[] | string;
   success?: (this: { search: (query: string) => void }) => void;
   searchResultTemplate?: string;
-  templateMiddleware?: (prop: string, value: string, template: string) => string | undefined;
-  highlightMiddleware?: (result: any, query: string) => any;
+  templateMiddleware?: (prop: string, value: string, template: string, query?: string) => string | undefined;
   noResultsText?: string;
   debounceTime?: number | null;
   onSearch?: () => void;
diff --git a/tests/highlightMiddleware.test.ts b/tests/highlightMiddleware.test.ts
index 8919615..4bdfa61 100644
--- a/tests/highlightMiddleware.test.ts
+++ b/tests/highlightMiddleware.test.ts
@@ -1,5 +1,5 @@
 import { describe, it, expect } from 'vitest';
-import { createHighlightMiddleware, highlightText, HighlightOptions } from '../src/utils/highlightMiddleware';
+import { createHighlightMiddleware, createHighlightTemplateMiddleware, highlightText, HighlightOptions } from '../src/utils/highlightMiddleware';
 
 describe('highlightText', () => {
   it('should highlight single match with default options', () => {
@@ -185,3 +185,407 @@ describe('createHighlightMiddleware', () => {
     expect(processed).toBeNull();
   });
 });
+
+describe('createHighlightTemplateMiddleware', () => {
+  it('should create a template middleware that highlights content field', () => {
+    const middleware = createHighlightTemplateMiddleware();
+    const result = middleware('content', 'This is a test search result', '<div>{content}</div>', 'search');
+    
+    expect(result).toContain('<span class="sjs-highlight">search</span>');
+  });
+
+  it('should create a template middleware that highlights desc field', () => {
+    const middleware = createHighlightTemplateMiddleware();
+    const result = middleware('desc', 'This is a test search result', '<div>{desc}</div>', 'search');
+    
+    expect(result).toContain('<span class="sjs-highlight">search</span>');
+  });
+
+  it('should not highlight other fields', () => {
+    const middleware = createHighlightTemplateMiddleware();
+    const result = middleware('title', 'This is a test search result', '<div>{title}</div>', 'search');
+    
+    expect(result).toBeUndefined();
+  });
+
+  it('should not highlight when no query provided', () => {
+    const middleware = createHighlightTemplateMiddleware();
+    const result = middleware('content', 'This is a test search result', '<div>{content}</div>');
+    
+    expect(result).toBeUndefined();
+  });
+
+  it('should use custom highlight class', () => {
+    const middleware = createHighlightTemplateMiddleware({ highlightClass: 'custom-highlight' });
+    const result = middleware('content', 'This is a test search result', '<div>{content}</div>', 'search');
+    
+    expect(result).toContain('<span class="custom-highlight">search</span>');
+  });
+
+  it('should handle multiple search terms', () => {
+    const middleware = createHighlightTemplateMiddleware();
+    const result = middleware('content', 'This is a test search result with multiple terms', '<div>{content}</div>', 'test search');
+    
+    expect(result).toContain('<span class="sjs-highlight">test</span>');
+    expect(result).toContain('<span class="sjs-highlight">search</span>');
+  });
+
+  it('should handle case insensitive matching', () => {
+    const middleware = createHighlightTemplateMiddleware();
+    const result = middleware('content', 'This is a TEST search result', '<div>{content}</div>', 'test');
+    
+    expect(result).toContain('<span class="sjs-highlight">TEST</span>');
+  });
+
+  it('should return undefined for non-string values', () => {
+    const middleware = createHighlightTemplateMiddleware();
+    // @ts-expect-error - Testing runtime behavior with non-string value
+    const result = middleware('content', 123, '<div>{content}</div>', 'search');
+    
+    expect(result).toBeUndefined();
+  });
+
+  it('should handle fuzzy search highlighting', () => {
+    const middleware = createHighlightTemplateMiddleware();
+    const result = middleware('content', 'This is a testing result', '<div>{content}</div>', 'test');
+    
+    // Should highlight the fuzzy match span that contains "test"
+    expect(result).toContain('<span class="sjs-highlight">');
+    expect(result).toContain('test');
+  });
+
+  it('should handle fuzzy search with partial matches', () => {
+    const middleware = createHighlightTemplateMiddleware();
+    const result = middleware('content', 'This is a tst result', '<div>{content}</div>', 'test');
+    
+    // Should highlight the fuzzy match span that contains "tst"
+    expect(result).toContain('<span class="sjs-highlight">');
+    expect(result).toContain('tst');
+  });
+
+  it('should prefer exact matches over fuzzy matches', () => {
+    const middleware = createHighlightTemplateMiddleware();
+    const result = middleware('content', 'This is a test and testing result', '<div>{content}</div>', 'test');
+    
+    // Should highlight exact "test" word, not fuzzy match in "testing"
+    expect(result).toContain('<span class="sjs-highlight">test</span>');
+    expect(result).not.toContain('<span class="sjs-highlight">testing</span>');
+  });
+
+  it('should handle fuzzy search with multiple words', () => {
+    const middleware = createHighlightTemplateMiddleware();
+    const result = middleware('content', 'This is a tst srch result', '<div>{content}</div>', 'test search');
+    
+    // Should highlight fuzzy matches
+    expect(result).toContain('<span class="sjs-highlight">');
+  });
+
+  describe('Search Strategy Compatibility', () => {
+    const testCases = [
+      // Literal Search Test Cases
+      {
+        strategy: 'literal',
+        description: 'should highlight exact word matches for literal search',
+        content: 'This is a test search result with exact matches',
+        query: 'test search',
+        expectedHighlights: ['<span class="sjs-highlight">test</span>', '<span class="sjs-highlight">search</span>'],
+        shouldNotContain: []
+      },
+      {
+        strategy: 'literal',
+        description: 'should not highlight partial word matches for literal search',
+        content: 'This is a testing searching result',
+        query: 'test search',
+        expectedHighlights: ['<span class="sjs-highlight">'],
+        shouldNotContain: ['<span class="sjs-highlight">testing</span>', '<span class="sjs-highlight">searching</span>']
+      },
+      {
+        strategy: 'literal',
+        description: 'should handle case insensitive literal search',
+        content: 'This is a TEST SEARCH result',
+        query: 'test search',
+        expectedHighlights: ['<span class="sjs-highlight">TEST</span>', '<span class="sjs-highlight">SEARCH</span>'],
+        shouldNotContain: []
+      },
+      {
+        strategy: 'literal',
+        description: 'should highlight all words in multi-word literal search',
+        content: 'This is a test search result with multiple words',
+        query: 'test search result',
+        expectedHighlights: ['<span class="sjs-highlight">test</span>', '<span class="sjs-highlight">search</span>', '<span class="sjs-highlight">result</span>'],
+        shouldNotContain: []
+      },
+      
+      // Fuzzy Search Test Cases
+      {
+        strategy: 'fuzzy',
+        description: 'should highlight exact matches when available for fuzzy search',
+        content: 'This is a test search result with exact matches',
+        query: 'test search',
+        expectedHighlights: ['<span class="sjs-highlight">test</span>', '<span class="sjs-highlight">search</span>'],
+        shouldNotContain: []
+      },
+      {
+        strategy: 'fuzzy',
+        description: 'should highlight fuzzy character sequence matches',
+        content: 'This is a tst srch result with fuzzy matches',
+        query: 'test search',
+        expectedHighlights: ['<span class="sjs-highlight">'],
+        shouldNotContain: []
+      },
+      {
+        strategy: 'fuzzy',
+        description: 'should prefer exact matches over fuzzy matches',
+        content: 'This is a test and tst result with both exact and fuzzy',
+        query: 'test',
+        expectedHighlights: ['<span class="sjs-highlight">test</span>'],
+        shouldNotContain: ['<span class="sjs-highlight">tst</span>']
+      },
+      {
+        strategy: 'fuzzy',
+        description: 'should handle partial word matches in fuzzy search',
+        content: 'This is a testing result with partial matches',
+        query: 'test',
+        expectedHighlights: ['<span class="sjs-highlight">'],
+        shouldNotContain: []
+      },
+      {
+        strategy: 'fuzzy',
+        description: 'should handle case insensitive fuzzy matching',
+        content: 'This is a TEST result with different case',
+        query: 'test',
+        expectedHighlights: ['<span class="sjs-highlight">TEST</span>'],
+        shouldNotContain: []
+      },
+      {
+        strategy: 'fuzzy',
+        description: 'should handle mixed exact and fuzzy matches',
+        content: 'This is a test srch result with mixed matches',
+        query: 'test search result',
+        expectedHighlights: ['<span class="sjs-highlight">'],
+        shouldNotContain: []
+      },
+      
+      // Wildcard Search Test Cases
+      {
+        strategy: 'wildcard',
+        description: 'should highlight exact matches for wildcard search',
+        content: 'This is a test search result with wildcard patterns',
+        query: 'test search',
+        expectedHighlights: ['<span class="sjs-highlight">test</span>', '<span class="sjs-highlight">search</span>'],
+        shouldNotContain: []
+      },
+      {
+        strategy: 'wildcard',
+        description: 'should handle wildcard patterns in highlighting',
+        content: 'This is a test* search? result with wildcards',
+        query: 'test* search?',
+        expectedHighlights: ['<span class="sjs-highlight">'],
+        shouldNotContain: []
+      },
+      {
+        strategy: 'wildcard',
+        description: 'should fallback to levenshtein for wildcard search',
+        content: 'This is a tst srch result with similar words',
+        query: 'test search',
+        expectedHighlights: ['<span class="sjs-highlight">'],
+        shouldNotContain: []
+      },
+      {
+        strategy: 'wildcard',
+        description: 'should handle case insensitive wildcard search',
+        content: 'This is a TEST SEARCH result',
+        query: 'test search',
+        expectedHighlights: ['<span class="sjs-highlight">TEST</span>', '<span class="sjs-highlight">SEARCH</span>'],
+        shouldNotContain: []
+      },
+      
+      // Levenshtein Search Test Cases (fallback for wildcard)
+      {
+        strategy: 'levenshtein',
+        description: 'should highlight similar words using levenshtein distance',
+        content: 'This is a tst srch result with similar words',
+        query: 'test search',
+        expectedHighlights: ['<span class="sjs-highlight">'],
+        shouldNotContain: []
+      },
+      {
+        strategy: 'levenshtein',
+        description: 'should handle single character differences',
+        content: 'This is a tesr srch result with typos',
+        query: 'test search',
+        expectedHighlights: [],
+        shouldNotContain: []
+      },
+      {
+        strategy: 'levenshtein',
+        description: 'should handle case insensitive levenshtein matching',
+        content: 'This is a TST SRCH result with different case',
+        query: 'test search',
+        expectedHighlights: ['<span class="sjs-highlight">'],
+        shouldNotContain: []
+      },
+      
+      // Edge Cases
+      {
+        strategy: 'all',
+        description: 'should handle empty query',
+        content: 'This is a test result',
+        query: '',
+        expectedHighlights: [],
+        shouldNotContain: ['<span class="sjs-highlight">']
+      },
+      {
+        strategy: 'all',
+        description: 'should handle query with only spaces',
+        content: 'This is a test result',
+        query: '   ',
+        expectedHighlights: [],
+        shouldNotContain: ['<span class="sjs-highlight">']
+      },
+      {
+        strategy: 'all',
+        description: 'should handle special characters in query',
+        content: 'This is a test-result with special chars',
+        query: 'test-result',
+        expectedHighlights: ['<span class="sjs-highlight">test-result</span>'],
+        shouldNotContain: []
+      },
+      {
+        strategy: 'all',
+        description: 'should handle regex special characters safely',
+        content: 'This is a test.result with regex chars',
+        query: 'test.result',
+        expectedHighlights: ['<span class="sjs-highlight">test.result</span>'],
+        shouldNotContain: []
+      },
+      {
+        strategy: 'all',
+        description: 'should handle punctuation in search terms',
+        content: 'This is a test, search! result with punctuation',
+        query: 'test, search!',
+        expectedHighlights: ['<span class="sjs-highlight">'],
+        shouldNotContain: []
+      },
+      {
+        strategy: 'all',
+        description: 'should handle numbers in search terms',
+        content: 'This is a test123 search456 result with numbers',
+        query: 'test123 search456',
+        expectedHighlights: ['<span class="sjs-highlight">test123</span>', '<span class="sjs-highlight">search456</span>'],
+        shouldNotContain: []
+      }
+    ];
+
+    it.each(testCases)('$strategy: $description', ({ content, query, expectedHighlights, shouldNotContain }) => {
+      const middleware = createHighlightTemplateMiddleware();
+      const result = middleware('content', content, '<div>{content}</div>', query);
+      
+      if (expectedHighlights.length > 0) {
+        expectedHighlights.forEach(highlight => {
+          expect(result).toContain(highlight);
+        });
+      } else {
+        expect(result).toBeUndefined();
+      }
+      
+      shouldNotContain.forEach(notExpected => {
+        if (result) {
+          expect(result).not.toContain(notExpected);
+        }
+      });
+    });
+  });
+
+  describe('Multi-word Search Strategy Tests', () => {
+    const multiWordTestCases = [
+      {
+        strategy: 'literal',
+        description: 'should highlight all exact words for literal search',
+        content: 'This is a test search result with multiple words',
+        query: 'test search result',
+        expectedWords: ['test', 'search', 'result'],
+        shouldNotHighlight: ['testing', 'searching', 'results']
+      },
+      {
+        strategy: 'literal',
+        description: 'should handle partial word matches in literal search',
+        content: 'This is a testing searching results with partial words',
+        query: 'test search result',
+        expectedWords: [],
+        shouldNotHighlight: ['testing', 'searching', 'results']
+      },
+      {
+        strategy: 'fuzzy',
+        description: 'should highlight all fuzzy matches for fuzzy search',
+        content: 'This is a tst srch rslt with fuzzy matches',
+        query: 'test search result',
+        expectedWords: [],
+        shouldNotHighlight: []
+      },
+      {
+        strategy: 'fuzzy',
+        description: 'should mix exact and fuzzy matches for fuzzy search',
+        content: 'This is a test srch result with mixed matches',
+        query: 'test search result',
+        expectedWords: ['test', 'result'],
+        shouldNotHighlight: ['search']
+      },
+      {
+        strategy: 'fuzzy',
+        description: 'should handle case insensitive multi-word fuzzy search',
+        content: 'This is a TEST SRCH RESULT with different case',
+        query: 'test search result',
+        expectedWords: ['TEST', 'RESULT'],
+        shouldNotHighlight: []
+      },
+      {
+        strategy: 'wildcard',
+        description: 'should highlight exact matches for wildcard search',
+        content: 'This is a test search result with wildcard patterns',
+        query: 'test search result',
+        expectedWords: ['test', 'search', 'result'],
+        shouldNotHighlight: []
+      },
+      {
+        strategy: 'wildcard',
+        description: 'should fallback to levenshtein for wildcard search',
+        content: 'This is a tst srch rslt with similar words',
+        query: 'test search result',
+        expectedWords: [],
+        shouldNotHighlight: []
+      },
+      {
+        strategy: 'levenshtein',
+        description: 'should highlight similar words using levenshtein distance',
+        content: 'This is a tesr srch rslt with typos',
+        query: 'test search result',
+        expectedWords: [],
+        shouldNotHighlight: []
+      },
+      {
+        strategy: 'levenshtein',
+        description: 'should handle mixed exact and similar words',
+        content: 'This is a test srch result with mixed accuracy',
+        query: 'test search result',
+        expectedWords: ['test', 'result'],
+        shouldNotHighlight: ['search']
+      }
+    ];
+
+    it.each(multiWordTestCases)('$strategy: $description', ({ content, query, expectedWords, shouldNotHighlight }) => {
+      const middleware = createHighlightTemplateMiddleware();
+      const result = middleware('content', content, '<div>{content}</div>', query);
+      
+      expectedWords.forEach(word => {
+        expect(result).toContain(`<span class="sjs-highlight">${word}</span>`);
+      });
+      
+      shouldNotHighlight.forEach(word => {
+        if (result) {
+          expect(result).not.toContain(`<span class="sjs-highlight">${word}</span>`);
+        }
+      });
+    });
+  });
+});

From cd2d84926bd13af2e50df8c47ceee4ce22932d66 Mon Sep 17 00:00:00 2001
From: sylhare <sylhare@outlook.com>
Date: Wed, 8 Oct 2025 15:56:03 -0400
Subject: [PATCH 03/10] Use createHighlightTemplateMiddleware

---
 dest/simple-jekyll-search.js               | 368 +++++++++++++--------
 dest/simple-jekyll-search.min.js           |   2 +-
 docs/_includes/search.html                 |  82 +----
 docs/assets/js/simple-jekyll-search.min.js |   2 +-
 package.json                               |   1 +
 src/SearchStrategies/search/fuzzySearch.ts |   3 -
 src/SearchStrategies/search/levenshtein.ts |   9 +-
 src/index.ts                               |  16 +-
 src/utils/highlightMiddleware.ts           |  33 +-
 tests/highlightMiddleware.test.ts          |  14 -
 10 files changed, 266 insertions(+), 264 deletions(-)

diff --git a/dest/simple-jekyll-search.js b/dest/simple-jekyll-search.js
index f870033..679fe02 100644
--- a/dest/simple-jekyll-search.js
+++ b/dest/simple-jekyll-search.js
@@ -80,11 +80,8 @@
         const cost = a[i - 1] === b[j - 1] ? 0 : 1;
         distanceMatrix[i][j] = Math.min(
           distanceMatrix[i - 1][j] + 1,
-          // Removing a character from one string
           distanceMatrix[i][j - 1] + 1,
-          // Adding a character to one string to make it closer to the other string.
           distanceMatrix[i - 1][j - 1] + cost
-          // Replacing one character in a string with another
         );
       }
     }
@@ -150,128 +147,6 @@
     }
     return output;
   }
-  function createHighlightMiddleware(options2 = {}) {
-    const {
-      highlightClass = "sjs-highlight",
-      contextBefore = 50,
-      contextAfter = 50,
-      maxLength = 250,
-      ellipsis = "..."
-    } = options2;
-    return function(result, query) {
-      if (!query || !result) {
-        return result;
-      }
-      const highlightedResult = { ...result };
-      const textFields = ["title", "desc", "content", "excerpt"];
-      for (const field of textFields) {
-        if (highlightedResult[field] && typeof highlightedResult[field] === "string") {
-          const highlighted = highlightText(
-            highlightedResult[field],
-            query,
-            { highlightClass, contextBefore, contextAfter, maxLength, ellipsis }
-          );
-          if (highlighted.highlightedText !== highlightedResult[field]) {
-            highlightedResult[field] = highlighted.highlightedText;
-          }
-        }
-      }
-      return highlightedResult;
-    };
-  }
-  function highlightText(text, query, options2 = {}) {
-    const {
-      highlightClass = "sjs-highlight",
-      contextBefore = 50,
-      contextAfter = 50,
-      maxLength = 250,
-      ellipsis = "..."
-    } = options2;
-    if (!text || !query) {
-      return { highlightedText: text, matchCount: 0 };
-    }
-    const originalText = text;
-    const searchTerms = query.trim().toLowerCase().split(/\s+/).filter((term) => term.length > 0);
-    if (searchTerms.length === 0) {
-      return { highlightedText: text, matchCount: 0 };
-    }
-    const matches = [];
-    for (const term of searchTerms) {
-      let index = 0;
-      while (index < text.length) {
-        const found = text.toLowerCase().indexOf(term, index);
-        if (found === -1) break;
-        matches.push({
-          start: found,
-          end: found + term.length,
-          term: text.substring(found, found + term.length)
-        });
-        index = found + 1;
-      }
-    }
-    if (matches.length === 0) {
-      return { highlightedText: text, matchCount: 0 };
-    }
-    matches.sort((a, b) => a.start - b.start);
-    const mergedMatches = [];
-    for (const match of matches) {
-      if (mergedMatches.length === 0 || mergedMatches[mergedMatches.length - 1].end < match.start) {
-        mergedMatches.push(match);
-      } else {
-        const lastMatch = mergedMatches[mergedMatches.length - 1];
-        lastMatch.end = Math.max(lastMatch.end, match.end);
-        lastMatch.term = text.substring(lastMatch.start, lastMatch.end);
-      }
-    }
-    if (text.length <= maxLength) {
-      let highlightedText2 = text;
-      for (let i = mergedMatches.length - 1; i >= 0; i--) {
-        const match = mergedMatches[i];
-        const before = highlightedText2.substring(0, match.start);
-        const after = highlightedText2.substring(match.end);
-        const matchText = highlightedText2.substring(match.start, match.end);
-        highlightedText2 = before + `<span class="${highlightClass}">${matchText}</span>` + after;
-      }
-      return { highlightedText: highlightedText2, matchCount: mergedMatches.length };
-    }
-    let highlightedText = "";
-    let totalLength = 0;
-    let lastEnd = 0;
-    for (let i = 0; i < mergedMatches.length; i++) {
-      const match = mergedMatches[i];
-      const contextStart = Math.max(lastEnd, match.start - contextBefore);
-      const contextEnd = Math.min(text.length, match.end + contextAfter);
-      if (contextStart > lastEnd && lastEnd > 0) {
-        highlightedText += ellipsis;
-        totalLength += ellipsis.length;
-      }
-      if (contextStart < match.start) {
-        const beforeText = text.substring(contextStart, match.start);
-        highlightedText += beforeText;
-        totalLength += beforeText.length;
-      }
-      const matchText = text.substring(match.start, match.end);
-      highlightedText += `<span class="${highlightClass}">${matchText}</span>`;
-      totalLength += matchText.length;
-      if (match.end < contextEnd) {
-        const afterText = text.substring(match.end, contextEnd);
-        highlightedText += afterText;
-        totalLength += afterText.length;
-      }
-      lastEnd = contextEnd;
-      if (totalLength >= maxLength) {
-        if (contextEnd < text.length) {
-          highlightedText += ellipsis;
-        }
-        break;
-      }
-    }
-    return {
-      highlightedText: highlightedText || originalText,
-      matchCount: mergedMatches.length
-    };
-  }
-  const defaultHighlightMiddleware = createHighlightMiddleware();
   const DEFAULT_OPTIONS = {
     searchInput: null,
     resultsContainer: null,
@@ -279,8 +154,7 @@
     success: function() {
     },
     searchResultTemplate: '<li><a href="{url}" title="{desc}">{title}</a></li>',
-    templateMiddleware: (_prop, _value, _template) => void 0,
-    highlightMiddleware: defaultHighlightMiddleware,
+    templateMiddleware: (_prop, _value, _template, _query) => void 0,
     sortMiddleware: NoSort,
     noResultsText: "No results found",
     limit: 10,
@@ -405,9 +279,9 @@
       options.middleware = _options.middleware;
     }
   }
-  function compile(data) {
+  function compile(data, query) {
     return options.template.replace(options.pattern, function(match, prop) {
-      const value = options.middleware(prop, data[prop], options.template);
+      const value = options.middleware(prop, data[prop], options.template, query);
       if (typeof value !== "undefined") {
         return value;
       }
@@ -479,9 +353,8 @@
       const fragment = document.createDocumentFragment();
       results.forEach((result) => {
         result.query = query;
-        const highlightedResult = this.options.highlightMiddleware ? this.options.highlightMiddleware(result, query) : result;
         const div = document.createElement("div");
-        div.innerHTML = compile(highlightedResult);
+        div.innerHTML = compile(result, query);
         fragment.appendChild(div);
       });
       this.options.resultsContainer.appendChild(fragment);
@@ -516,16 +389,249 @@
       return rv;
     }
   };
+  function createHighlightMiddleware(options2 = {}) {
+    const {
+      highlightClass = "sjs-highlight",
+      contextBefore = 50,
+      contextAfter = 50,
+      maxLength = 250,
+      ellipsis = "..."
+    } = options2;
+    return function(result, query) {
+      if (!query || !result) {
+        return result;
+      }
+      const highlightedResult = { ...result };
+      const textFields = ["title", "desc", "content", "excerpt"];
+      for (const field of textFields) {
+        if (highlightedResult[field] && typeof highlightedResult[field] === "string") {
+          const highlighted = highlightText(
+            highlightedResult[field],
+            query,
+            { highlightClass, contextBefore, contextAfter, maxLength, ellipsis }
+          );
+          if (highlighted.highlightedText !== highlightedResult[field]) {
+            highlightedResult[field] = highlighted.highlightedText;
+          }
+        }
+      }
+      return highlightedResult;
+    };
+  }
+  function highlightText(text, query, options2 = {}) {
+    const {
+      highlightClass = "sjs-highlight",
+      contextBefore = 50,
+      contextAfter = 50,
+      maxLength = 250,
+      ellipsis = "..."
+    } = options2;
+    if (!text || !query) {
+      return { highlightedText: text, matchCount: 0 };
+    }
+    const originalText = text;
+    const searchTerms = query.trim().toLowerCase().split(/\s+/).filter((term) => term.length > 0);
+    if (searchTerms.length === 0) {
+      return { highlightedText: text, matchCount: 0 };
+    }
+    const matches = [];
+    for (const term of searchTerms) {
+      let index = 0;
+      while (index < text.length) {
+        const found = text.toLowerCase().indexOf(term, index);
+        if (found === -1) break;
+        matches.push({
+          start: found,
+          end: found + term.length,
+          term: text.substring(found, found + term.length)
+        });
+        index = found + 1;
+      }
+    }
+    if (matches.length === 0) {
+      return { highlightedText: text, matchCount: 0 };
+    }
+    matches.sort((a, b) => a.start - b.start);
+    const mergedMatches = [];
+    for (const match of matches) {
+      if (mergedMatches.length === 0 || mergedMatches[mergedMatches.length - 1].end < match.start) {
+        mergedMatches.push(match);
+      } else {
+        const lastMatch = mergedMatches[mergedMatches.length - 1];
+        lastMatch.end = Math.max(lastMatch.end, match.end);
+        lastMatch.term = text.substring(lastMatch.start, lastMatch.end);
+      }
+    }
+    if (text.length <= maxLength) {
+      let highlightedText2 = text;
+      for (let i = mergedMatches.length - 1; i >= 0; i--) {
+        const match = mergedMatches[i];
+        const before = highlightedText2.substring(0, match.start);
+        const after = highlightedText2.substring(match.end);
+        const matchText = highlightedText2.substring(match.start, match.end);
+        highlightedText2 = before + `<span class="${highlightClass}">${matchText}</span>` + after;
+      }
+      return { highlightedText: highlightedText2, matchCount: mergedMatches.length };
+    }
+    let highlightedText = "";
+    let totalLength = 0;
+    let lastEnd = 0;
+    for (let i = 0; i < mergedMatches.length; i++) {
+      const match = mergedMatches[i];
+      const contextStart = Math.max(lastEnd, match.start - contextBefore);
+      const contextEnd = Math.min(text.length, match.end + contextAfter);
+      if (contextStart > lastEnd && lastEnd > 0) {
+        highlightedText += ellipsis;
+        totalLength += ellipsis.length;
+      }
+      if (contextStart < match.start) {
+        const beforeText = text.substring(contextStart, match.start);
+        highlightedText += beforeText;
+        totalLength += beforeText.length;
+      }
+      const matchText = text.substring(match.start, match.end);
+      highlightedText += `<span class="${highlightClass}">${matchText}</span>`;
+      totalLength += matchText.length;
+      if (match.end < contextEnd) {
+        const afterText = text.substring(match.end, contextEnd);
+        highlightedText += afterText;
+        totalLength += afterText.length;
+      }
+      lastEnd = contextEnd;
+      if (totalLength >= maxLength) {
+        if (contextEnd < text.length) {
+          highlightedText += ellipsis;
+        }
+        break;
+      }
+    }
+    return {
+      highlightedText: highlightedText || originalText,
+      matchCount: mergedMatches.length
+    };
+  }
+  const defaultHighlightMiddleware = createHighlightMiddleware();
+  function findFuzzyMatches(text, pattern) {
+    const matches = [];
+    const lowerText = text.toLowerCase();
+    const lowerPattern = pattern.toLowerCase().trim();
+    if (lowerPattern.length === 0) return matches;
+    const patternWords = lowerPattern.split(/\s+/);
+    for (const word of patternWords) {
+      if (word.length === 0) continue;
+      const wordMatches = findFuzzyWordMatches(lowerText, word);
+      matches.push(...wordMatches);
+    }
+    return matches;
+  }
+  function findFuzzyWordMatches(text, word) {
+    const matches = [];
+    const exactRegex = new RegExp(`\\b${word.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}\\b`, "gi");
+    let match;
+    while ((match = exactRegex.exec(text)) !== null) {
+      matches.push({
+        start: match.index,
+        end: match.index + match[0].length,
+        text: match[0]
+      });
+    }
+    if (matches.length === 0) {
+      for (let i = 0; i < text.length; i++) {
+        const fuzzyMatch = findFuzzySequenceMatch(text, word, i);
+        if (fuzzyMatch) {
+          matches.push(fuzzyMatch);
+          i = fuzzyMatch.end - 1;
+        }
+      }
+    }
+    return matches;
+  }
+  function findFuzzySequenceMatch(text, pattern, startPos) {
+    let textIndex = startPos;
+    let patternIndex = 0;
+    let matchStart = -1;
+    let maxGap = 3;
+    const matchedPositions = [];
+    while (textIndex < text.length && patternIndex < pattern.length) {
+      if (text[textIndex] === pattern[patternIndex]) {
+        if (matchStart === -1) {
+          matchStart = textIndex;
+        }
+        matchedPositions.push(textIndex);
+        patternIndex++;
+      } else if (matchStart !== -1) {
+        if (textIndex - matchStart > maxGap * pattern.length) {
+          return null;
+        }
+      }
+      textIndex++;
+    }
+    if (patternIndex === pattern.length && matchStart !== -1 && matchedPositions.length > 0) {
+      const actualStart = matchedPositions[0];
+      const actualEnd = matchedPositions[matchedPositions.length - 1] + 1;
+      return {
+        start: actualStart,
+        end: actualEnd,
+        text: text.substring(actualStart, actualEnd)
+      };
+    }
+    return null;
+  }
+  function createHighlightTemplateMiddleware(options2 = {}) {
+    const highlightOptions = {
+      highlightClass: "sjs-highlight",
+      ...options2
+    };
+    return function(prop, value, _template, query) {
+      if ((prop === "content" || prop === "desc") && query && typeof value === "string") {
+        let highlightedText = value;
+        let hasMatches = false;
+        const searchTerms = query.trim().split(/\s+/).filter((term) => term.length > 0);
+        for (const term of searchTerms) {
+          const regex = new RegExp(`\\b(${term.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")})\\b`, "gi");
+          if (regex.test(highlightedText)) {
+            highlightedText = highlightedText.replace(regex, `<span class="${highlightOptions.highlightClass}">$1</span>`);
+            hasMatches = true;
+          }
+        }
+        if (!hasMatches) {
+          const fuzzyMatches = findFuzzyMatches(value, query);
+          if (fuzzyMatches.length > 0) {
+            fuzzyMatches.sort((a, b) => b.start - a.start);
+            for (const match of fuzzyMatches) {
+              const before = highlightedText.substring(0, match.start);
+              const after = highlightedText.substring(match.end);
+              const matchText = highlightedText.substring(match.start, match.end);
+              highlightedText = before + `<span class="${highlightOptions.highlightClass}">${matchText}</span>` + after;
+            }
+            hasMatches = true;
+          }
+        }
+        if (hasMatches) {
+          return highlightedText;
+        }
+      }
+      return void 0;
+    };
+  }
+  const defaultHighlightTemplateMiddleware = createHighlightTemplateMiddleware();
   function SimpleJekyllSearch(options2) {
     const instance = new SimpleJekyllSearch$1();
     return instance.init(options2);
   }
   if (typeof window !== "undefined") {
     window.SimpleJekyllSearch = SimpleJekyllSearch;
+    window.SimpleJekyllSearch.createHighlightMiddleware = createHighlightMiddleware;
+    window.SimpleJekyllSearch.createHighlightTemplateMiddleware = createHighlightTemplateMiddleware;
+    window.SimpleJekyllSearch.highlightText = highlightText;
+    window.SimpleJekyllSearch.defaultHighlightMiddleware = defaultHighlightMiddleware;
+    window.SimpleJekyllSearch.defaultHighlightTemplateMiddleware = defaultHighlightTemplateMiddleware;
   }
   exports2.createHighlightMiddleware = createHighlightMiddleware;
+  exports2.createHighlightTemplateMiddleware = createHighlightTemplateMiddleware;
   exports2.default = SimpleJekyllSearch;
   exports2.defaultHighlightMiddleware = defaultHighlightMiddleware;
+  exports2.defaultHighlightTemplateMiddleware = defaultHighlightTemplateMiddleware;
   exports2.highlightText = highlightText;
   Object.defineProperties(exports2, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
 });
diff --git a/dest/simple-jekyll-search.min.js b/dest/simple-jekyll-search.min.js
index 7767669..62446e1 100644
--- a/dest/simple-jekyll-search.min.js
+++ b/dest/simple-jekyll-search.min.js
@@ -4,4 +4,4 @@
   * Copyright 2025-2025, Sylhare
   * Licensed under the MIT License.
   */
-(function(global,factory){typeof exports==="object"&&typeof module!=="undefined"?factory(exports):typeof define==="function"&&define.amd?define(["exports"],factory):(global=typeof globalThis!=="undefined"?globalThis:global||self,factory(global.SimpleJekyllSearch={}))})(this,(function(exports2){"use strict";function load(location,callback){const xhr=getXHR();xhr.open("GET",location,true);xhr.onreadystatechange=createStateChangeListener(xhr,callback);xhr.send()}function createStateChangeListener(xhr,callback){return function(){if(xhr.readyState===4&&xhr.status===200){try{callback(null,JSON.parse(xhr.responseText))}catch(err){callback(err instanceof Error?err:new Error(String(err)),null)}}}}function getXHR(){return window.XMLHttpRequest?new window.XMLHttpRequest:new window.ActiveXObject("Microsoft.XMLHTTP")}class OptionsValidator{constructor(params){if(!this.validateParams(params)){throw new Error("-- OptionsValidator: required options missing")}this.requiredOptions=params.required}getRequiredOptions(){return this.requiredOptions}validate(parameters){const errors=[];this.requiredOptions.forEach((requiredOptionName=>{if(typeof parameters[requiredOptionName]==="undefined"){errors.push(requiredOptionName)}}));return errors}validateParams(params){if(!params){return false}return typeof params.required!=="undefined"&&Array.isArray(params.required)}}function fuzzySearch(text,pattern){pattern=pattern.trimEnd();if(pattern.length===0)return true;pattern=pattern.toLowerCase();text=text.toLowerCase();let remainingText=text,currentIndex=-1;for(const char of pattern){const nextIndex=remainingText.indexOf(char);if(nextIndex===-1||currentIndex!==-1&&remainingText.slice(0,nextIndex).split(" ").length-1>2){return false}currentIndex=nextIndex;remainingText=remainingText.slice(nextIndex+1)}return true}function literalSearch(text,criteria){text=text.trim().toLowerCase();const pattern=criteria.endsWith(" ")?[criteria.toLowerCase()]:criteria.trim().toLowerCase().split(" ");return pattern.filter((word=>text.indexOf(word)>=0)).length===pattern.length}function levenshtein(a,b){const lenA=a.length;const lenB=b.length;const distanceMatrix=Array.from({length:lenA+1},(()=>Array(lenB+1).fill(0)));for(let i=0;i<=lenA;i++)distanceMatrix[i][0]=i;for(let j=0;j<=lenB;j++)distanceMatrix[0][j]=j;for(let i=1;i<=lenA;i++){for(let j=1;j<=lenB;j++){const cost=a[i-1]===b[j-1]?0:1;distanceMatrix[i][j]=Math.min(distanceMatrix[i-1][j]+1,distanceMatrix[i][j-1]+1,distanceMatrix[i-1][j-1]+cost)}}return distanceMatrix[lenA][lenB]}function levenshteinSearch(text,pattern){const distance=levenshtein(pattern,text);const similarity=1-distance/Math.max(pattern.length,text.length);return similarity>=.3}function wildcardSearch(text,pattern){const regexPattern=pattern.replace(/\*/g,".*");const regex=new RegExp(`^${regexPattern}$`,"i");if(regex.test(text))return true;return levenshteinSearch(text,pattern)}class SearchStrategy{constructor(matchFunction){this.matchFunction=matchFunction}matches(text,criteria){if(text===null||text.trim()===""||!criteria){return false}return this.matchFunction(text,criteria)}}const LiteralSearchStrategy=new SearchStrategy(literalSearch);const FuzzySearchStrategy=new SearchStrategy(((text,criteria)=>fuzzySearch(text,criteria)||literalSearch(text,criteria)));const WildcardSearchStrategy=new SearchStrategy(((text,criteria)=>wildcardSearch(text,criteria)||literalSearch(text,criteria)));function merge(target,source){return{...target,...source}}function isJSON(json){try{return!!(json instanceof Object&&JSON.parse(JSON.stringify(json)))}catch(_err){return false}}function NoSort(){return 0}function isObject(obj){return Boolean(obj)&&Object.prototype.toString.call(obj)==="[object Object]"}function clone(input){if(input===null||typeof input!=="object"){return input}if(Array.isArray(input)){return input.map((item=>clone(item)))}const output={};for(const key in input){if(Object.prototype.hasOwnProperty.call(input,key)){output[key]=clone(input[key])}}return output}function createHighlightMiddleware(options2={}){const{highlightClass:highlightClass="sjs-highlight",contextBefore:contextBefore=50,contextAfter:contextAfter=50,maxLength:maxLength=250,ellipsis:ellipsis="..."}=options2;return function(result,query){if(!query||!result){return result}const highlightedResult={...result};const textFields=["title","desc","content","excerpt"];for(const field of textFields){if(highlightedResult[field]&&typeof highlightedResult[field]==="string"){const highlighted=highlightText(highlightedResult[field],query,{highlightClass:highlightClass,contextBefore:contextBefore,contextAfter:contextAfter,maxLength:maxLength,ellipsis:ellipsis});if(highlighted.highlightedText!==highlightedResult[field]){highlightedResult[field]=highlighted.highlightedText}}}return highlightedResult}}function highlightText(text,query,options2={}){const{highlightClass:highlightClass="sjs-highlight",contextBefore:contextBefore=50,contextAfter:contextAfter=50,maxLength:maxLength=250,ellipsis:ellipsis="..."}=options2;if(!text||!query){return{highlightedText:text,matchCount:0}}const originalText=text;const searchTerms=query.trim().toLowerCase().split(/\s+/).filter((term=>term.length>0));if(searchTerms.length===0){return{highlightedText:text,matchCount:0}}const matches=[];for(const term of searchTerms){let index=0;while(index<text.length){const found=text.toLowerCase().indexOf(term,index);if(found===-1)break;matches.push({start:found,end:found+term.length,term:text.substring(found,found+term.length)});index=found+1}}if(matches.length===0){return{highlightedText:text,matchCount:0}}matches.sort(((a,b)=>a.start-b.start));const mergedMatches=[];for(const match of matches){if(mergedMatches.length===0||mergedMatches[mergedMatches.length-1].end<match.start){mergedMatches.push(match)}else{const lastMatch=mergedMatches[mergedMatches.length-1];lastMatch.end=Math.max(lastMatch.end,match.end);lastMatch.term=text.substring(lastMatch.start,lastMatch.end)}}if(text.length<=maxLength){let highlightedText2=text;for(let i=mergedMatches.length-1;i>=0;i--){const match=mergedMatches[i];const before=highlightedText2.substring(0,match.start);const after=highlightedText2.substring(match.end);const matchText=highlightedText2.substring(match.start,match.end);highlightedText2=before+`<span class="${highlightClass}">${matchText}</span>`+after}return{highlightedText:highlightedText2,matchCount:mergedMatches.length}}let highlightedText="";let totalLength=0;let lastEnd=0;for(let i=0;i<mergedMatches.length;i++){const match=mergedMatches[i];const contextStart=Math.max(lastEnd,match.start-contextBefore);const contextEnd=Math.min(text.length,match.end+contextAfter);if(contextStart>lastEnd&&lastEnd>0){highlightedText+=ellipsis;totalLength+=ellipsis.length}if(contextStart<match.start){const beforeText=text.substring(contextStart,match.start);highlightedText+=beforeText;totalLength+=beforeText.length}const matchText=text.substring(match.start,match.end);highlightedText+=`<span class="${highlightClass}">${matchText}</span>`;totalLength+=matchText.length;if(match.end<contextEnd){const afterText=text.substring(match.end,contextEnd);highlightedText+=afterText;totalLength+=afterText.length}lastEnd=contextEnd;if(totalLength>=maxLength){if(contextEnd<text.length){highlightedText+=ellipsis}break}}return{highlightedText:highlightedText||originalText,matchCount:mergedMatches.length}}const defaultHighlightMiddleware=createHighlightMiddleware();const DEFAULT_OPTIONS={searchInput:null,resultsContainer:null,json:[],success:function(){},searchResultTemplate:'<li><a href="{url}" title="{desc}">{title}</a></li>',templateMiddleware:(_prop,_value,_template)=>void 0,highlightMiddleware:defaultHighlightMiddleware,sortMiddleware:NoSort,noResultsText:"No results found",limit:10,fuzzy:false,strategy:"literal",debounceTime:null,exclude:[],onSearch:()=>{}};const REQUIRED_OPTIONS=["searchInput","resultsContainer","json"];const WHITELISTED_KEYS=new Set(["Enter","Shift","CapsLock","ArrowLeft","ArrowUp","ArrowRight","ArrowDown","Meta"]);class Repository{constructor(initialOptions={}){this.data=[];this.setOptions(initialOptions)}put(input){if(isObject(input)){return this.addObject(input)}if(Array.isArray(input)){return this.addArray(input)}return void 0}clear(){this.data.length=0;return this.data}search(criteria){if(!criteria){return[]}return clone(this.findMatches(this.data,criteria).sort(this.options.sortMiddleware))}setOptions(newOptions){this.options={fuzzy:(newOptions==null?void 0:newOptions.fuzzy)||DEFAULT_OPTIONS.fuzzy,limit:(newOptions==null?void 0:newOptions.limit)||DEFAULT_OPTIONS.limit,searchStrategy:this.searchStrategy((newOptions==null?void 0:newOptions.strategy)||newOptions.fuzzy&&"fuzzy"||DEFAULT_OPTIONS.strategy),sortMiddleware:(newOptions==null?void 0:newOptions.sortMiddleware)||DEFAULT_OPTIONS.sortMiddleware,exclude:(newOptions==null?void 0:newOptions.exclude)||DEFAULT_OPTIONS.exclude,strategy:(newOptions==null?void 0:newOptions.strategy)||DEFAULT_OPTIONS.strategy}}addObject(obj){this.data.push(obj);return this.data}addArray(arr){const added=[];this.clear();for(const item of arr){if(isObject(item)){added.push(this.addObject(item)[0])}}return added}findMatches(data,criteria){const matches=[];for(let i=0;i<data.length&&matches.length<this.options.limit;i++){const match=this.findMatchesInObject(data[i],criteria);if(match){matches.push(match)}}return matches}findMatchesInObject(obj,criteria){for(const key in obj){if(!this.isExcluded(obj[key])&&this.options.searchStrategy.matches(obj[key],criteria)){return obj}}return void 0}isExcluded(term){for(const excludedTerm of this.options.exclude){if(new RegExp(excludedTerm).test(String(term))){return true}}return false}searchStrategy(strategy){switch(strategy){case"fuzzy":return FuzzySearchStrategy;case"wildcard":return WildcardSearchStrategy;default:return LiteralSearchStrategy}}}const options={pattern:/\{(.*?)\}/g,template:"",middleware:function(){return void 0}};function setOptions(_options){if(_options.pattern){options.pattern=_options.pattern}if(_options.template){options.template=_options.template}if(typeof _options.middleware==="function"){options.middleware=_options.middleware}}function compile(data){return options.template.replace(options.pattern,(function(match,prop){const value=options.middleware(prop,data[prop],options.template);if(typeof value!=="undefined"){return value}return data[prop]||match}))}let SimpleJekyllSearch$1=class SimpleJekyllSearch{constructor(){this.debounceTimerHandle=null;this.options={...DEFAULT_OPTIONS};this.repository=new Repository;this.optionsValidator=new OptionsValidator({required:REQUIRED_OPTIONS})}debounce(func,delayMillis){if(delayMillis){if(this.debounceTimerHandle){clearTimeout(this.debounceTimerHandle)}this.debounceTimerHandle=setTimeout(func,delayMillis)}else{func()}}throwError(message){throw new Error(`SimpleJekyllSearch --- ${message}`)}emptyResultsContainer(){this.options.resultsContainer.innerHTML=""}initWithJSON(json){this.repository.put(json);this.registerInput()}initWithURL(url){load(url,((err,json)=>{if(err){this.throwError(`Failed to load JSON from ${url}: ${err.message}`)}this.initWithJSON(json)}))}registerInput(){this.options.searchInput.addEventListener("input",(e=>{const inputEvent=e;if(!WHITELISTED_KEYS.has(inputEvent.key)){this.emptyResultsContainer();this.debounce((()=>{this.search(e.target.value)}),this.options.debounceTime??null)}}))}search(query){var _a,_b;if((query==null?void 0:query.trim().length)>0){this.emptyResultsContainer();const results=this.repository.search(query);this.render(results,query);(_b=(_a=this.options).onSearch)==null?void 0:_b.call(_a)}}render(results,query){if(results.length===0){this.options.resultsContainer.insertAdjacentHTML("beforeend",this.options.noResultsText);return}const fragment=document.createDocumentFragment();results.forEach((result=>{result.query=query;const highlightedResult=this.options.highlightMiddleware?this.options.highlightMiddleware(result,query):result;const div=document.createElement("div");div.innerHTML=compile(highlightedResult);fragment.appendChild(div)}));this.options.resultsContainer.appendChild(fragment)}init(_options){var _a;const errors=this.optionsValidator.validate(_options);if(errors.length>0){this.throwError(`Missing required options: ${REQUIRED_OPTIONS.join(", ")}`)}this.options=merge(this.options,_options);setOptions({template:this.options.searchResultTemplate,middleware:this.options.templateMiddleware});this.repository.setOptions({fuzzy:this.options.fuzzy,limit:this.options.limit,sortMiddleware:this.options.sortMiddleware,strategy:this.options.strategy,exclude:this.options.exclude});if(isJSON(this.options.json)){this.initWithJSON(this.options.json)}else{this.initWithURL(this.options.json)}const rv={search:this.search.bind(this)};(_a=this.options.success)==null?void 0:_a.call(rv);return rv}};function SimpleJekyllSearch(options2){const instance=new SimpleJekyllSearch$1;return instance.init(options2)}if(typeof window!=="undefined"){window.SimpleJekyllSearch=SimpleJekyllSearch}exports2.createHighlightMiddleware=createHighlightMiddleware;exports2.default=SimpleJekyllSearch;exports2.defaultHighlightMiddleware=defaultHighlightMiddleware;exports2.highlightText=highlightText;Object.defineProperties(exports2,{__esModule:{value:true},[Symbol.toStringTag]:{value:"Module"}})}));
\ No newline at end of file
+(function(global,factory){typeof exports==="object"&&typeof module!=="undefined"?factory(exports):typeof define==="function"&&define.amd?define(["exports"],factory):(global=typeof globalThis!=="undefined"?globalThis:global||self,factory(global.SimpleJekyllSearch={}))})(this,(function(exports2){"use strict";function load(location,callback){const xhr=getXHR();xhr.open("GET",location,true);xhr.onreadystatechange=createStateChangeListener(xhr,callback);xhr.send()}function createStateChangeListener(xhr,callback){return function(){if(xhr.readyState===4&&xhr.status===200){try{callback(null,JSON.parse(xhr.responseText))}catch(err){callback(err instanceof Error?err:new Error(String(err)),null)}}}}function getXHR(){return window.XMLHttpRequest?new window.XMLHttpRequest:new window.ActiveXObject("Microsoft.XMLHTTP")}class OptionsValidator{constructor(params){if(!this.validateParams(params)){throw new Error("-- OptionsValidator: required options missing")}this.requiredOptions=params.required}getRequiredOptions(){return this.requiredOptions}validate(parameters){const errors=[];this.requiredOptions.forEach((requiredOptionName=>{if(typeof parameters[requiredOptionName]==="undefined"){errors.push(requiredOptionName)}}));return errors}validateParams(params){if(!params){return false}return typeof params.required!=="undefined"&&Array.isArray(params.required)}}function fuzzySearch(text,pattern){pattern=pattern.trimEnd();if(pattern.length===0)return true;pattern=pattern.toLowerCase();text=text.toLowerCase();let remainingText=text,currentIndex=-1;for(const char of pattern){const nextIndex=remainingText.indexOf(char);if(nextIndex===-1||currentIndex!==-1&&remainingText.slice(0,nextIndex).split(" ").length-1>2){return false}currentIndex=nextIndex;remainingText=remainingText.slice(nextIndex+1)}return true}function literalSearch(text,criteria){text=text.trim().toLowerCase();const pattern=criteria.endsWith(" ")?[criteria.toLowerCase()]:criteria.trim().toLowerCase().split(" ");return pattern.filter((word=>text.indexOf(word)>=0)).length===pattern.length}function levenshtein(a,b){const lenA=a.length;const lenB=b.length;const distanceMatrix=Array.from({length:lenA+1},(()=>Array(lenB+1).fill(0)));for(let i=0;i<=lenA;i++)distanceMatrix[i][0]=i;for(let j=0;j<=lenB;j++)distanceMatrix[0][j]=j;for(let i=1;i<=lenA;i++){for(let j=1;j<=lenB;j++){const cost=a[i-1]===b[j-1]?0:1;distanceMatrix[i][j]=Math.min(distanceMatrix[i-1][j]+1,distanceMatrix[i][j-1]+1,distanceMatrix[i-1][j-1]+cost)}}return distanceMatrix[lenA][lenB]}function levenshteinSearch(text,pattern){const distance=levenshtein(pattern,text);const similarity=1-distance/Math.max(pattern.length,text.length);return similarity>=.3}function wildcardSearch(text,pattern){const regexPattern=pattern.replace(/\*/g,".*");const regex=new RegExp(`^${regexPattern}$`,"i");if(regex.test(text))return true;return levenshteinSearch(text,pattern)}class SearchStrategy{constructor(matchFunction){this.matchFunction=matchFunction}matches(text,criteria){if(text===null||text.trim()===""||!criteria){return false}return this.matchFunction(text,criteria)}}const LiteralSearchStrategy=new SearchStrategy(literalSearch);const FuzzySearchStrategy=new SearchStrategy(((text,criteria)=>fuzzySearch(text,criteria)||literalSearch(text,criteria)));const WildcardSearchStrategy=new SearchStrategy(((text,criteria)=>wildcardSearch(text,criteria)||literalSearch(text,criteria)));function merge(target,source){return{...target,...source}}function isJSON(json){try{return!!(json instanceof Object&&JSON.parse(JSON.stringify(json)))}catch(_err){return false}}function NoSort(){return 0}function isObject(obj){return Boolean(obj)&&Object.prototype.toString.call(obj)==="[object Object]"}function clone(input){if(input===null||typeof input!=="object"){return input}if(Array.isArray(input)){return input.map((item=>clone(item)))}const output={};for(const key in input){if(Object.prototype.hasOwnProperty.call(input,key)){output[key]=clone(input[key])}}return output}const DEFAULT_OPTIONS={searchInput:null,resultsContainer:null,json:[],success:function(){},searchResultTemplate:'<li><a href="{url}" title="{desc}">{title}</a></li>',templateMiddleware:(_prop,_value,_template,_query)=>void 0,sortMiddleware:NoSort,noResultsText:"No results found",limit:10,fuzzy:false,strategy:"literal",debounceTime:null,exclude:[],onSearch:()=>{}};const REQUIRED_OPTIONS=["searchInput","resultsContainer","json"];const WHITELISTED_KEYS=new Set(["Enter","Shift","CapsLock","ArrowLeft","ArrowUp","ArrowRight","ArrowDown","Meta"]);class Repository{constructor(initialOptions={}){this.data=[];this.setOptions(initialOptions)}put(input){if(isObject(input)){return this.addObject(input)}if(Array.isArray(input)){return this.addArray(input)}return void 0}clear(){this.data.length=0;return this.data}search(criteria){if(!criteria){return[]}return clone(this.findMatches(this.data,criteria).sort(this.options.sortMiddleware))}setOptions(newOptions){this.options={fuzzy:(newOptions==null?void 0:newOptions.fuzzy)||DEFAULT_OPTIONS.fuzzy,limit:(newOptions==null?void 0:newOptions.limit)||DEFAULT_OPTIONS.limit,searchStrategy:this.searchStrategy((newOptions==null?void 0:newOptions.strategy)||newOptions.fuzzy&&"fuzzy"||DEFAULT_OPTIONS.strategy),sortMiddleware:(newOptions==null?void 0:newOptions.sortMiddleware)||DEFAULT_OPTIONS.sortMiddleware,exclude:(newOptions==null?void 0:newOptions.exclude)||DEFAULT_OPTIONS.exclude,strategy:(newOptions==null?void 0:newOptions.strategy)||DEFAULT_OPTIONS.strategy}}addObject(obj){this.data.push(obj);return this.data}addArray(arr){const added=[];this.clear();for(const item of arr){if(isObject(item)){added.push(this.addObject(item)[0])}}return added}findMatches(data,criteria){const matches=[];for(let i=0;i<data.length&&matches.length<this.options.limit;i++){const match=this.findMatchesInObject(data[i],criteria);if(match){matches.push(match)}}return matches}findMatchesInObject(obj,criteria){for(const key in obj){if(!this.isExcluded(obj[key])&&this.options.searchStrategy.matches(obj[key],criteria)){return obj}}return void 0}isExcluded(term){for(const excludedTerm of this.options.exclude){if(new RegExp(excludedTerm).test(String(term))){return true}}return false}searchStrategy(strategy){switch(strategy){case"fuzzy":return FuzzySearchStrategy;case"wildcard":return WildcardSearchStrategy;default:return LiteralSearchStrategy}}}const options={pattern:/\{(.*?)\}/g,template:"",middleware:function(){return void 0}};function setOptions(_options){if(_options.pattern){options.pattern=_options.pattern}if(_options.template){options.template=_options.template}if(typeof _options.middleware==="function"){options.middleware=_options.middleware}}function compile(data,query){return options.template.replace(options.pattern,(function(match,prop){const value=options.middleware(prop,data[prop],options.template,query);if(typeof value!=="undefined"){return value}return data[prop]||match}))}let SimpleJekyllSearch$1=class SimpleJekyllSearch{constructor(){this.debounceTimerHandle=null;this.options={...DEFAULT_OPTIONS};this.repository=new Repository;this.optionsValidator=new OptionsValidator({required:REQUIRED_OPTIONS})}debounce(func,delayMillis){if(delayMillis){if(this.debounceTimerHandle){clearTimeout(this.debounceTimerHandle)}this.debounceTimerHandle=setTimeout(func,delayMillis)}else{func()}}throwError(message){throw new Error(`SimpleJekyllSearch --- ${message}`)}emptyResultsContainer(){this.options.resultsContainer.innerHTML=""}initWithJSON(json){this.repository.put(json);this.registerInput()}initWithURL(url){load(url,((err,json)=>{if(err){this.throwError(`Failed to load JSON from ${url}: ${err.message}`)}this.initWithJSON(json)}))}registerInput(){this.options.searchInput.addEventListener("input",(e=>{const inputEvent=e;if(!WHITELISTED_KEYS.has(inputEvent.key)){this.emptyResultsContainer();this.debounce((()=>{this.search(e.target.value)}),this.options.debounceTime??null)}}))}search(query){var _a,_b;if((query==null?void 0:query.trim().length)>0){this.emptyResultsContainer();const results=this.repository.search(query);this.render(results,query);(_b=(_a=this.options).onSearch)==null?void 0:_b.call(_a)}}render(results,query){if(results.length===0){this.options.resultsContainer.insertAdjacentHTML("beforeend",this.options.noResultsText);return}const fragment=document.createDocumentFragment();results.forEach((result=>{result.query=query;const div=document.createElement("div");div.innerHTML=compile(result,query);fragment.appendChild(div)}));this.options.resultsContainer.appendChild(fragment)}init(_options){var _a;const errors=this.optionsValidator.validate(_options);if(errors.length>0){this.throwError(`Missing required options: ${REQUIRED_OPTIONS.join(", ")}`)}this.options=merge(this.options,_options);setOptions({template:this.options.searchResultTemplate,middleware:this.options.templateMiddleware});this.repository.setOptions({fuzzy:this.options.fuzzy,limit:this.options.limit,sortMiddleware:this.options.sortMiddleware,strategy:this.options.strategy,exclude:this.options.exclude});if(isJSON(this.options.json)){this.initWithJSON(this.options.json)}else{this.initWithURL(this.options.json)}const rv={search:this.search.bind(this)};(_a=this.options.success)==null?void 0:_a.call(rv);return rv}};function createHighlightMiddleware(options2={}){const{highlightClass:highlightClass="sjs-highlight",contextBefore:contextBefore=50,contextAfter:contextAfter=50,maxLength:maxLength=250,ellipsis:ellipsis="..."}=options2;return function(result,query){if(!query||!result){return result}const highlightedResult={...result};const textFields=["title","desc","content","excerpt"];for(const field of textFields){if(highlightedResult[field]&&typeof highlightedResult[field]==="string"){const highlighted=highlightText(highlightedResult[field],query,{highlightClass:highlightClass,contextBefore:contextBefore,contextAfter:contextAfter,maxLength:maxLength,ellipsis:ellipsis});if(highlighted.highlightedText!==highlightedResult[field]){highlightedResult[field]=highlighted.highlightedText}}}return highlightedResult}}function highlightText(text,query,options2={}){const{highlightClass:highlightClass="sjs-highlight",contextBefore:contextBefore=50,contextAfter:contextAfter=50,maxLength:maxLength=250,ellipsis:ellipsis="..."}=options2;if(!text||!query){return{highlightedText:text,matchCount:0}}const originalText=text;const searchTerms=query.trim().toLowerCase().split(/\s+/).filter((term=>term.length>0));if(searchTerms.length===0){return{highlightedText:text,matchCount:0}}const matches=[];for(const term of searchTerms){let index=0;while(index<text.length){const found=text.toLowerCase().indexOf(term,index);if(found===-1)break;matches.push({start:found,end:found+term.length,term:text.substring(found,found+term.length)});index=found+1}}if(matches.length===0){return{highlightedText:text,matchCount:0}}matches.sort(((a,b)=>a.start-b.start));const mergedMatches=[];for(const match of matches){if(mergedMatches.length===0||mergedMatches[mergedMatches.length-1].end<match.start){mergedMatches.push(match)}else{const lastMatch=mergedMatches[mergedMatches.length-1];lastMatch.end=Math.max(lastMatch.end,match.end);lastMatch.term=text.substring(lastMatch.start,lastMatch.end)}}if(text.length<=maxLength){let highlightedText2=text;for(let i=mergedMatches.length-1;i>=0;i--){const match=mergedMatches[i];const before=highlightedText2.substring(0,match.start);const after=highlightedText2.substring(match.end);const matchText=highlightedText2.substring(match.start,match.end);highlightedText2=before+`<span class="${highlightClass}">${matchText}</span>`+after}return{highlightedText:highlightedText2,matchCount:mergedMatches.length}}let highlightedText="";let totalLength=0;let lastEnd=0;for(let i=0;i<mergedMatches.length;i++){const match=mergedMatches[i];const contextStart=Math.max(lastEnd,match.start-contextBefore);const contextEnd=Math.min(text.length,match.end+contextAfter);if(contextStart>lastEnd&&lastEnd>0){highlightedText+=ellipsis;totalLength+=ellipsis.length}if(contextStart<match.start){const beforeText=text.substring(contextStart,match.start);highlightedText+=beforeText;totalLength+=beforeText.length}const matchText=text.substring(match.start,match.end);highlightedText+=`<span class="${highlightClass}">${matchText}</span>`;totalLength+=matchText.length;if(match.end<contextEnd){const afterText=text.substring(match.end,contextEnd);highlightedText+=afterText;totalLength+=afterText.length}lastEnd=contextEnd;if(totalLength>=maxLength){if(contextEnd<text.length){highlightedText+=ellipsis}break}}return{highlightedText:highlightedText||originalText,matchCount:mergedMatches.length}}const defaultHighlightMiddleware=createHighlightMiddleware();function findFuzzyMatches(text,pattern){const matches=[];const lowerText=text.toLowerCase();const lowerPattern=pattern.toLowerCase().trim();if(lowerPattern.length===0)return matches;const patternWords=lowerPattern.split(/\s+/);for(const word of patternWords){if(word.length===0)continue;const wordMatches=findFuzzyWordMatches(lowerText,word);matches.push(...wordMatches)}return matches}function findFuzzyWordMatches(text,word){const matches=[];const exactRegex=new RegExp(`\\b${word.replace(/[.*+?^${}()|[\]\\]/g,"\\$&")}\\b`,"gi");let match;while((match=exactRegex.exec(text))!==null){matches.push({start:match.index,end:match.index+match[0].length,text:match[0]})}if(matches.length===0){for(let i=0;i<text.length;i++){const fuzzyMatch=findFuzzySequenceMatch(text,word,i);if(fuzzyMatch){matches.push(fuzzyMatch);i=fuzzyMatch.end-1}}}return matches}function findFuzzySequenceMatch(text,pattern,startPos){let textIndex=startPos;let patternIndex=0;let matchStart=-1;let maxGap=3;const matchedPositions=[];while(textIndex<text.length&&patternIndex<pattern.length){if(text[textIndex]===pattern[patternIndex]){if(matchStart===-1){matchStart=textIndex}matchedPositions.push(textIndex);patternIndex++}else if(matchStart!==-1){if(textIndex-matchStart>maxGap*pattern.length){return null}}textIndex++}if(patternIndex===pattern.length&&matchStart!==-1&&matchedPositions.length>0){const actualStart=matchedPositions[0];const actualEnd=matchedPositions[matchedPositions.length-1]+1;return{start:actualStart,end:actualEnd,text:text.substring(actualStart,actualEnd)}}return null}function createHighlightTemplateMiddleware(options2={}){const highlightOptions={highlightClass:"sjs-highlight",...options2};return function(prop,value,_template,query){if((prop==="content"||prop==="desc")&&query&&typeof value==="string"){let highlightedText=value;let hasMatches=false;const searchTerms=query.trim().split(/\s+/).filter((term=>term.length>0));for(const term of searchTerms){const regex=new RegExp(`\\b(${term.replace(/[.*+?^${}()|[\]\\]/g,"\\$&")})\\b`,"gi");if(regex.test(highlightedText)){highlightedText=highlightedText.replace(regex,`<span class="${highlightOptions.highlightClass}">$1</span>`);hasMatches=true}}if(!hasMatches){const fuzzyMatches=findFuzzyMatches(value,query);if(fuzzyMatches.length>0){fuzzyMatches.sort(((a,b)=>b.start-a.start));for(const match of fuzzyMatches){const before=highlightedText.substring(0,match.start);const after=highlightedText.substring(match.end);const matchText=highlightedText.substring(match.start,match.end);highlightedText=before+`<span class="${highlightOptions.highlightClass}">${matchText}</span>`+after}hasMatches=true}}if(hasMatches){return highlightedText}}return void 0}}const defaultHighlightTemplateMiddleware=createHighlightTemplateMiddleware();function SimpleJekyllSearch(options2){const instance=new SimpleJekyllSearch$1;return instance.init(options2)}if(typeof window!=="undefined"){window.SimpleJekyllSearch=SimpleJekyllSearch;window.SimpleJekyllSearch.createHighlightMiddleware=createHighlightMiddleware;window.SimpleJekyllSearch.createHighlightTemplateMiddleware=createHighlightTemplateMiddleware;window.SimpleJekyllSearch.highlightText=highlightText;window.SimpleJekyllSearch.defaultHighlightMiddleware=defaultHighlightMiddleware;window.SimpleJekyllSearch.defaultHighlightTemplateMiddleware=defaultHighlightTemplateMiddleware}exports2.createHighlightMiddleware=createHighlightMiddleware;exports2.createHighlightTemplateMiddleware=createHighlightTemplateMiddleware;exports2.default=SimpleJekyllSearch;exports2.defaultHighlightMiddleware=defaultHighlightMiddleware;exports2.defaultHighlightTemplateMiddleware=defaultHighlightTemplateMiddleware;exports2.highlightText=highlightText;Object.defineProperties(exports2,{__esModule:{value:true},[Symbol.toStringTag]:{value:"Module"}})}));
\ No newline at end of file
diff --git a/docs/_includes/search.html b/docs/_includes/search.html
index 289125d..c5c2b65 100644
--- a/docs/_includes/search.html
+++ b/docs/_includes/search.html
@@ -7,86 +7,20 @@
   <script src="{{ '/assets/js/simple-jekyll-search.min.js' | relative_url }}"></script>
 
   <script>
-    // Custom template middleware with fuzzy-aware highlighting for search snippets
-    function createSearchSnippetTemplateMiddleware() {
-      return function(prop, value, template, query) {
-        // Only process content field with shorter context
-        if (prop === 'content' && query && typeof value === 'string') {
-          const text = value;
-          const searchTerms = query.trim().toLowerCase().split(/\s+/).filter(term => term.length > 0);
-          
-          if (searchTerms.length > 0) {
-            let highlightedText = text;
-            let hasMatches = false;
-            
-            // Try exact word matching first
-            for (const term of searchTerms) {
-              const regex = new RegExp(`\\b(${term.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')})\\b`, 'gi');
-              if (regex.test(highlightedText)) {
-                highlightedText = highlightedText.replace(regex, '<span class="sjs-highlight">$1</span>');
-                hasMatches = true;
-              }
-            }
-            
-            // If no exact matches, try fuzzy matching
-            if (!hasMatches) {
-              for (const term of searchTerms) {
-                // Simple fuzzy matching - find characters in order
-                const lowerText = highlightedText.toLowerCase();
-                const lowerTerm = term.toLowerCase();
-                let textIndex = 0;
-                let termIndex = 0;
-                let matchStart = -1;
-                
-                while (textIndex < lowerText.length && termIndex < lowerTerm.length) {
-                  if (lowerText[textIndex] === lowerTerm[termIndex]) {
-                    if (matchStart === -1) matchStart = textIndex;
-                    termIndex++;
-                  }
-                  textIndex++;
-                }
-                
-                if (termIndex === lowerTerm.length && matchStart !== -1) {
-                  const matchEnd = textIndex;
-                  const before = highlightedText.substring(0, matchStart);
-                  const after = highlightedText.substring(matchEnd);
-                  const matchText = highlightedText.substring(matchStart, matchEnd);
-                  highlightedText = before + '<span class="sjs-highlight">' + matchText + '</span>' + after;
-                  hasMatches = true;
-                }
-              }
-            }
-            
-            if (hasMatches) {
-              // Find first highlighted match for context
-              const firstHighlight = highlightedText.indexOf('<span class="sjs-highlight">');
-              if (firstHighlight !== -1) {
-                const contextBefore = 30;
-                const contextAfter = 30;
-                const start = Math.max(0, firstHighlight - contextBefore);
-                const end = Math.min(highlightedText.length, firstHighlight + 100 + contextAfter);
-                
-                let snippet = highlightedText.substring(start, end);
-                
-                // Add ellipsis if we're not at the beginning/end
-                if (start > 0) snippet = '...' + snippet;
-                if (end < highlightedText.length) snippet = snippet + '...';
-                
-                return snippet;
-              }
-            }
-          }
-        }
-        return undefined;
-      };
-    }
+    const searchSnippetMiddleware = SimpleJekyllSearch.createHighlightTemplateMiddleware({
+      highlightClass: 'sjs-highlight',
+      contextBefore: 30,
+      contextAfter: 30,
+      maxLength: 100,
+      ellipsis: '...'
+    });
 
     window.simpleJekyllSearch = new SimpleJekyllSearch({
       searchInput: document.getElementById('search-input'),
       resultsContainer: document.getElementById('results-container'),
       json: '{{ "/assets/data/search.json" | relative_url }}',
       searchResultTemplate: '<li><a href="{url}?query={query}">{title}</a><div class="search-snippet">{content}</div></li>',
-      templateMiddleware: createSearchSnippetTemplateMiddleware(),
+      templateMiddleware: searchSnippetMiddleware,
       noResultsText: 'No results found',
       limit: 10,
       strategy: 'wildcard',
diff --git a/docs/assets/js/simple-jekyll-search.min.js b/docs/assets/js/simple-jekyll-search.min.js
index 7767669..62446e1 100644
--- a/docs/assets/js/simple-jekyll-search.min.js
+++ b/docs/assets/js/simple-jekyll-search.min.js
@@ -4,4 +4,4 @@
   * Copyright 2025-2025, Sylhare
   * Licensed under the MIT License.
   */
-(function(global,factory){typeof exports==="object"&&typeof module!=="undefined"?factory(exports):typeof define==="function"&&define.amd?define(["exports"],factory):(global=typeof globalThis!=="undefined"?globalThis:global||self,factory(global.SimpleJekyllSearch={}))})(this,(function(exports2){"use strict";function load(location,callback){const xhr=getXHR();xhr.open("GET",location,true);xhr.onreadystatechange=createStateChangeListener(xhr,callback);xhr.send()}function createStateChangeListener(xhr,callback){return function(){if(xhr.readyState===4&&xhr.status===200){try{callback(null,JSON.parse(xhr.responseText))}catch(err){callback(err instanceof Error?err:new Error(String(err)),null)}}}}function getXHR(){return window.XMLHttpRequest?new window.XMLHttpRequest:new window.ActiveXObject("Microsoft.XMLHTTP")}class OptionsValidator{constructor(params){if(!this.validateParams(params)){throw new Error("-- OptionsValidator: required options missing")}this.requiredOptions=params.required}getRequiredOptions(){return this.requiredOptions}validate(parameters){const errors=[];this.requiredOptions.forEach((requiredOptionName=>{if(typeof parameters[requiredOptionName]==="undefined"){errors.push(requiredOptionName)}}));return errors}validateParams(params){if(!params){return false}return typeof params.required!=="undefined"&&Array.isArray(params.required)}}function fuzzySearch(text,pattern){pattern=pattern.trimEnd();if(pattern.length===0)return true;pattern=pattern.toLowerCase();text=text.toLowerCase();let remainingText=text,currentIndex=-1;for(const char of pattern){const nextIndex=remainingText.indexOf(char);if(nextIndex===-1||currentIndex!==-1&&remainingText.slice(0,nextIndex).split(" ").length-1>2){return false}currentIndex=nextIndex;remainingText=remainingText.slice(nextIndex+1)}return true}function literalSearch(text,criteria){text=text.trim().toLowerCase();const pattern=criteria.endsWith(" ")?[criteria.toLowerCase()]:criteria.trim().toLowerCase().split(" ");return pattern.filter((word=>text.indexOf(word)>=0)).length===pattern.length}function levenshtein(a,b){const lenA=a.length;const lenB=b.length;const distanceMatrix=Array.from({length:lenA+1},(()=>Array(lenB+1).fill(0)));for(let i=0;i<=lenA;i++)distanceMatrix[i][0]=i;for(let j=0;j<=lenB;j++)distanceMatrix[0][j]=j;for(let i=1;i<=lenA;i++){for(let j=1;j<=lenB;j++){const cost=a[i-1]===b[j-1]?0:1;distanceMatrix[i][j]=Math.min(distanceMatrix[i-1][j]+1,distanceMatrix[i][j-1]+1,distanceMatrix[i-1][j-1]+cost)}}return distanceMatrix[lenA][lenB]}function levenshteinSearch(text,pattern){const distance=levenshtein(pattern,text);const similarity=1-distance/Math.max(pattern.length,text.length);return similarity>=.3}function wildcardSearch(text,pattern){const regexPattern=pattern.replace(/\*/g,".*");const regex=new RegExp(`^${regexPattern}$`,"i");if(regex.test(text))return true;return levenshteinSearch(text,pattern)}class SearchStrategy{constructor(matchFunction){this.matchFunction=matchFunction}matches(text,criteria){if(text===null||text.trim()===""||!criteria){return false}return this.matchFunction(text,criteria)}}const LiteralSearchStrategy=new SearchStrategy(literalSearch);const FuzzySearchStrategy=new SearchStrategy(((text,criteria)=>fuzzySearch(text,criteria)||literalSearch(text,criteria)));const WildcardSearchStrategy=new SearchStrategy(((text,criteria)=>wildcardSearch(text,criteria)||literalSearch(text,criteria)));function merge(target,source){return{...target,...source}}function isJSON(json){try{return!!(json instanceof Object&&JSON.parse(JSON.stringify(json)))}catch(_err){return false}}function NoSort(){return 0}function isObject(obj){return Boolean(obj)&&Object.prototype.toString.call(obj)==="[object Object]"}function clone(input){if(input===null||typeof input!=="object"){return input}if(Array.isArray(input)){return input.map((item=>clone(item)))}const output={};for(const key in input){if(Object.prototype.hasOwnProperty.call(input,key)){output[key]=clone(input[key])}}return output}function createHighlightMiddleware(options2={}){const{highlightClass:highlightClass="sjs-highlight",contextBefore:contextBefore=50,contextAfter:contextAfter=50,maxLength:maxLength=250,ellipsis:ellipsis="..."}=options2;return function(result,query){if(!query||!result){return result}const highlightedResult={...result};const textFields=["title","desc","content","excerpt"];for(const field of textFields){if(highlightedResult[field]&&typeof highlightedResult[field]==="string"){const highlighted=highlightText(highlightedResult[field],query,{highlightClass:highlightClass,contextBefore:contextBefore,contextAfter:contextAfter,maxLength:maxLength,ellipsis:ellipsis});if(highlighted.highlightedText!==highlightedResult[field]){highlightedResult[field]=highlighted.highlightedText}}}return highlightedResult}}function highlightText(text,query,options2={}){const{highlightClass:highlightClass="sjs-highlight",contextBefore:contextBefore=50,contextAfter:contextAfter=50,maxLength:maxLength=250,ellipsis:ellipsis="..."}=options2;if(!text||!query){return{highlightedText:text,matchCount:0}}const originalText=text;const searchTerms=query.trim().toLowerCase().split(/\s+/).filter((term=>term.length>0));if(searchTerms.length===0){return{highlightedText:text,matchCount:0}}const matches=[];for(const term of searchTerms){let index=0;while(index<text.length){const found=text.toLowerCase().indexOf(term,index);if(found===-1)break;matches.push({start:found,end:found+term.length,term:text.substring(found,found+term.length)});index=found+1}}if(matches.length===0){return{highlightedText:text,matchCount:0}}matches.sort(((a,b)=>a.start-b.start));const mergedMatches=[];for(const match of matches){if(mergedMatches.length===0||mergedMatches[mergedMatches.length-1].end<match.start){mergedMatches.push(match)}else{const lastMatch=mergedMatches[mergedMatches.length-1];lastMatch.end=Math.max(lastMatch.end,match.end);lastMatch.term=text.substring(lastMatch.start,lastMatch.end)}}if(text.length<=maxLength){let highlightedText2=text;for(let i=mergedMatches.length-1;i>=0;i--){const match=mergedMatches[i];const before=highlightedText2.substring(0,match.start);const after=highlightedText2.substring(match.end);const matchText=highlightedText2.substring(match.start,match.end);highlightedText2=before+`<span class="${highlightClass}">${matchText}</span>`+after}return{highlightedText:highlightedText2,matchCount:mergedMatches.length}}let highlightedText="";let totalLength=0;let lastEnd=0;for(let i=0;i<mergedMatches.length;i++){const match=mergedMatches[i];const contextStart=Math.max(lastEnd,match.start-contextBefore);const contextEnd=Math.min(text.length,match.end+contextAfter);if(contextStart>lastEnd&&lastEnd>0){highlightedText+=ellipsis;totalLength+=ellipsis.length}if(contextStart<match.start){const beforeText=text.substring(contextStart,match.start);highlightedText+=beforeText;totalLength+=beforeText.length}const matchText=text.substring(match.start,match.end);highlightedText+=`<span class="${highlightClass}">${matchText}</span>`;totalLength+=matchText.length;if(match.end<contextEnd){const afterText=text.substring(match.end,contextEnd);highlightedText+=afterText;totalLength+=afterText.length}lastEnd=contextEnd;if(totalLength>=maxLength){if(contextEnd<text.length){highlightedText+=ellipsis}break}}return{highlightedText:highlightedText||originalText,matchCount:mergedMatches.length}}const defaultHighlightMiddleware=createHighlightMiddleware();const DEFAULT_OPTIONS={searchInput:null,resultsContainer:null,json:[],success:function(){},searchResultTemplate:'<li><a href="{url}" title="{desc}">{title}</a></li>',templateMiddleware:(_prop,_value,_template)=>void 0,highlightMiddleware:defaultHighlightMiddleware,sortMiddleware:NoSort,noResultsText:"No results found",limit:10,fuzzy:false,strategy:"literal",debounceTime:null,exclude:[],onSearch:()=>{}};const REQUIRED_OPTIONS=["searchInput","resultsContainer","json"];const WHITELISTED_KEYS=new Set(["Enter","Shift","CapsLock","ArrowLeft","ArrowUp","ArrowRight","ArrowDown","Meta"]);class Repository{constructor(initialOptions={}){this.data=[];this.setOptions(initialOptions)}put(input){if(isObject(input)){return this.addObject(input)}if(Array.isArray(input)){return this.addArray(input)}return void 0}clear(){this.data.length=0;return this.data}search(criteria){if(!criteria){return[]}return clone(this.findMatches(this.data,criteria).sort(this.options.sortMiddleware))}setOptions(newOptions){this.options={fuzzy:(newOptions==null?void 0:newOptions.fuzzy)||DEFAULT_OPTIONS.fuzzy,limit:(newOptions==null?void 0:newOptions.limit)||DEFAULT_OPTIONS.limit,searchStrategy:this.searchStrategy((newOptions==null?void 0:newOptions.strategy)||newOptions.fuzzy&&"fuzzy"||DEFAULT_OPTIONS.strategy),sortMiddleware:(newOptions==null?void 0:newOptions.sortMiddleware)||DEFAULT_OPTIONS.sortMiddleware,exclude:(newOptions==null?void 0:newOptions.exclude)||DEFAULT_OPTIONS.exclude,strategy:(newOptions==null?void 0:newOptions.strategy)||DEFAULT_OPTIONS.strategy}}addObject(obj){this.data.push(obj);return this.data}addArray(arr){const added=[];this.clear();for(const item of arr){if(isObject(item)){added.push(this.addObject(item)[0])}}return added}findMatches(data,criteria){const matches=[];for(let i=0;i<data.length&&matches.length<this.options.limit;i++){const match=this.findMatchesInObject(data[i],criteria);if(match){matches.push(match)}}return matches}findMatchesInObject(obj,criteria){for(const key in obj){if(!this.isExcluded(obj[key])&&this.options.searchStrategy.matches(obj[key],criteria)){return obj}}return void 0}isExcluded(term){for(const excludedTerm of this.options.exclude){if(new RegExp(excludedTerm).test(String(term))){return true}}return false}searchStrategy(strategy){switch(strategy){case"fuzzy":return FuzzySearchStrategy;case"wildcard":return WildcardSearchStrategy;default:return LiteralSearchStrategy}}}const options={pattern:/\{(.*?)\}/g,template:"",middleware:function(){return void 0}};function setOptions(_options){if(_options.pattern){options.pattern=_options.pattern}if(_options.template){options.template=_options.template}if(typeof _options.middleware==="function"){options.middleware=_options.middleware}}function compile(data){return options.template.replace(options.pattern,(function(match,prop){const value=options.middleware(prop,data[prop],options.template);if(typeof value!=="undefined"){return value}return data[prop]||match}))}let SimpleJekyllSearch$1=class SimpleJekyllSearch{constructor(){this.debounceTimerHandle=null;this.options={...DEFAULT_OPTIONS};this.repository=new Repository;this.optionsValidator=new OptionsValidator({required:REQUIRED_OPTIONS})}debounce(func,delayMillis){if(delayMillis){if(this.debounceTimerHandle){clearTimeout(this.debounceTimerHandle)}this.debounceTimerHandle=setTimeout(func,delayMillis)}else{func()}}throwError(message){throw new Error(`SimpleJekyllSearch --- ${message}`)}emptyResultsContainer(){this.options.resultsContainer.innerHTML=""}initWithJSON(json){this.repository.put(json);this.registerInput()}initWithURL(url){load(url,((err,json)=>{if(err){this.throwError(`Failed to load JSON from ${url}: ${err.message}`)}this.initWithJSON(json)}))}registerInput(){this.options.searchInput.addEventListener("input",(e=>{const inputEvent=e;if(!WHITELISTED_KEYS.has(inputEvent.key)){this.emptyResultsContainer();this.debounce((()=>{this.search(e.target.value)}),this.options.debounceTime??null)}}))}search(query){var _a,_b;if((query==null?void 0:query.trim().length)>0){this.emptyResultsContainer();const results=this.repository.search(query);this.render(results,query);(_b=(_a=this.options).onSearch)==null?void 0:_b.call(_a)}}render(results,query){if(results.length===0){this.options.resultsContainer.insertAdjacentHTML("beforeend",this.options.noResultsText);return}const fragment=document.createDocumentFragment();results.forEach((result=>{result.query=query;const highlightedResult=this.options.highlightMiddleware?this.options.highlightMiddleware(result,query):result;const div=document.createElement("div");div.innerHTML=compile(highlightedResult);fragment.appendChild(div)}));this.options.resultsContainer.appendChild(fragment)}init(_options){var _a;const errors=this.optionsValidator.validate(_options);if(errors.length>0){this.throwError(`Missing required options: ${REQUIRED_OPTIONS.join(", ")}`)}this.options=merge(this.options,_options);setOptions({template:this.options.searchResultTemplate,middleware:this.options.templateMiddleware});this.repository.setOptions({fuzzy:this.options.fuzzy,limit:this.options.limit,sortMiddleware:this.options.sortMiddleware,strategy:this.options.strategy,exclude:this.options.exclude});if(isJSON(this.options.json)){this.initWithJSON(this.options.json)}else{this.initWithURL(this.options.json)}const rv={search:this.search.bind(this)};(_a=this.options.success)==null?void 0:_a.call(rv);return rv}};function SimpleJekyllSearch(options2){const instance=new SimpleJekyllSearch$1;return instance.init(options2)}if(typeof window!=="undefined"){window.SimpleJekyllSearch=SimpleJekyllSearch}exports2.createHighlightMiddleware=createHighlightMiddleware;exports2.default=SimpleJekyllSearch;exports2.defaultHighlightMiddleware=defaultHighlightMiddleware;exports2.highlightText=highlightText;Object.defineProperties(exports2,{__esModule:{value:true},[Symbol.toStringTag]:{value:"Module"}})}));
\ No newline at end of file
+(function(global,factory){typeof exports==="object"&&typeof module!=="undefined"?factory(exports):typeof define==="function"&&define.amd?define(["exports"],factory):(global=typeof globalThis!=="undefined"?globalThis:global||self,factory(global.SimpleJekyllSearch={}))})(this,(function(exports2){"use strict";function load(location,callback){const xhr=getXHR();xhr.open("GET",location,true);xhr.onreadystatechange=createStateChangeListener(xhr,callback);xhr.send()}function createStateChangeListener(xhr,callback){return function(){if(xhr.readyState===4&&xhr.status===200){try{callback(null,JSON.parse(xhr.responseText))}catch(err){callback(err instanceof Error?err:new Error(String(err)),null)}}}}function getXHR(){return window.XMLHttpRequest?new window.XMLHttpRequest:new window.ActiveXObject("Microsoft.XMLHTTP")}class OptionsValidator{constructor(params){if(!this.validateParams(params)){throw new Error("-- OptionsValidator: required options missing")}this.requiredOptions=params.required}getRequiredOptions(){return this.requiredOptions}validate(parameters){const errors=[];this.requiredOptions.forEach((requiredOptionName=>{if(typeof parameters[requiredOptionName]==="undefined"){errors.push(requiredOptionName)}}));return errors}validateParams(params){if(!params){return false}return typeof params.required!=="undefined"&&Array.isArray(params.required)}}function fuzzySearch(text,pattern){pattern=pattern.trimEnd();if(pattern.length===0)return true;pattern=pattern.toLowerCase();text=text.toLowerCase();let remainingText=text,currentIndex=-1;for(const char of pattern){const nextIndex=remainingText.indexOf(char);if(nextIndex===-1||currentIndex!==-1&&remainingText.slice(0,nextIndex).split(" ").length-1>2){return false}currentIndex=nextIndex;remainingText=remainingText.slice(nextIndex+1)}return true}function literalSearch(text,criteria){text=text.trim().toLowerCase();const pattern=criteria.endsWith(" ")?[criteria.toLowerCase()]:criteria.trim().toLowerCase().split(" ");return pattern.filter((word=>text.indexOf(word)>=0)).length===pattern.length}function levenshtein(a,b){const lenA=a.length;const lenB=b.length;const distanceMatrix=Array.from({length:lenA+1},(()=>Array(lenB+1).fill(0)));for(let i=0;i<=lenA;i++)distanceMatrix[i][0]=i;for(let j=0;j<=lenB;j++)distanceMatrix[0][j]=j;for(let i=1;i<=lenA;i++){for(let j=1;j<=lenB;j++){const cost=a[i-1]===b[j-1]?0:1;distanceMatrix[i][j]=Math.min(distanceMatrix[i-1][j]+1,distanceMatrix[i][j-1]+1,distanceMatrix[i-1][j-1]+cost)}}return distanceMatrix[lenA][lenB]}function levenshteinSearch(text,pattern){const distance=levenshtein(pattern,text);const similarity=1-distance/Math.max(pattern.length,text.length);return similarity>=.3}function wildcardSearch(text,pattern){const regexPattern=pattern.replace(/\*/g,".*");const regex=new RegExp(`^${regexPattern}$`,"i");if(regex.test(text))return true;return levenshteinSearch(text,pattern)}class SearchStrategy{constructor(matchFunction){this.matchFunction=matchFunction}matches(text,criteria){if(text===null||text.trim()===""||!criteria){return false}return this.matchFunction(text,criteria)}}const LiteralSearchStrategy=new SearchStrategy(literalSearch);const FuzzySearchStrategy=new SearchStrategy(((text,criteria)=>fuzzySearch(text,criteria)||literalSearch(text,criteria)));const WildcardSearchStrategy=new SearchStrategy(((text,criteria)=>wildcardSearch(text,criteria)||literalSearch(text,criteria)));function merge(target,source){return{...target,...source}}function isJSON(json){try{return!!(json instanceof Object&&JSON.parse(JSON.stringify(json)))}catch(_err){return false}}function NoSort(){return 0}function isObject(obj){return Boolean(obj)&&Object.prototype.toString.call(obj)==="[object Object]"}function clone(input){if(input===null||typeof input!=="object"){return input}if(Array.isArray(input)){return input.map((item=>clone(item)))}const output={};for(const key in input){if(Object.prototype.hasOwnProperty.call(input,key)){output[key]=clone(input[key])}}return output}const DEFAULT_OPTIONS={searchInput:null,resultsContainer:null,json:[],success:function(){},searchResultTemplate:'<li><a href="{url}" title="{desc}">{title}</a></li>',templateMiddleware:(_prop,_value,_template,_query)=>void 0,sortMiddleware:NoSort,noResultsText:"No results found",limit:10,fuzzy:false,strategy:"literal",debounceTime:null,exclude:[],onSearch:()=>{}};const REQUIRED_OPTIONS=["searchInput","resultsContainer","json"];const WHITELISTED_KEYS=new Set(["Enter","Shift","CapsLock","ArrowLeft","ArrowUp","ArrowRight","ArrowDown","Meta"]);class Repository{constructor(initialOptions={}){this.data=[];this.setOptions(initialOptions)}put(input){if(isObject(input)){return this.addObject(input)}if(Array.isArray(input)){return this.addArray(input)}return void 0}clear(){this.data.length=0;return this.data}search(criteria){if(!criteria){return[]}return clone(this.findMatches(this.data,criteria).sort(this.options.sortMiddleware))}setOptions(newOptions){this.options={fuzzy:(newOptions==null?void 0:newOptions.fuzzy)||DEFAULT_OPTIONS.fuzzy,limit:(newOptions==null?void 0:newOptions.limit)||DEFAULT_OPTIONS.limit,searchStrategy:this.searchStrategy((newOptions==null?void 0:newOptions.strategy)||newOptions.fuzzy&&"fuzzy"||DEFAULT_OPTIONS.strategy),sortMiddleware:(newOptions==null?void 0:newOptions.sortMiddleware)||DEFAULT_OPTIONS.sortMiddleware,exclude:(newOptions==null?void 0:newOptions.exclude)||DEFAULT_OPTIONS.exclude,strategy:(newOptions==null?void 0:newOptions.strategy)||DEFAULT_OPTIONS.strategy}}addObject(obj){this.data.push(obj);return this.data}addArray(arr){const added=[];this.clear();for(const item of arr){if(isObject(item)){added.push(this.addObject(item)[0])}}return added}findMatches(data,criteria){const matches=[];for(let i=0;i<data.length&&matches.length<this.options.limit;i++){const match=this.findMatchesInObject(data[i],criteria);if(match){matches.push(match)}}return matches}findMatchesInObject(obj,criteria){for(const key in obj){if(!this.isExcluded(obj[key])&&this.options.searchStrategy.matches(obj[key],criteria)){return obj}}return void 0}isExcluded(term){for(const excludedTerm of this.options.exclude){if(new RegExp(excludedTerm).test(String(term))){return true}}return false}searchStrategy(strategy){switch(strategy){case"fuzzy":return FuzzySearchStrategy;case"wildcard":return WildcardSearchStrategy;default:return LiteralSearchStrategy}}}const options={pattern:/\{(.*?)\}/g,template:"",middleware:function(){return void 0}};function setOptions(_options){if(_options.pattern){options.pattern=_options.pattern}if(_options.template){options.template=_options.template}if(typeof _options.middleware==="function"){options.middleware=_options.middleware}}function compile(data,query){return options.template.replace(options.pattern,(function(match,prop){const value=options.middleware(prop,data[prop],options.template,query);if(typeof value!=="undefined"){return value}return data[prop]||match}))}let SimpleJekyllSearch$1=class SimpleJekyllSearch{constructor(){this.debounceTimerHandle=null;this.options={...DEFAULT_OPTIONS};this.repository=new Repository;this.optionsValidator=new OptionsValidator({required:REQUIRED_OPTIONS})}debounce(func,delayMillis){if(delayMillis){if(this.debounceTimerHandle){clearTimeout(this.debounceTimerHandle)}this.debounceTimerHandle=setTimeout(func,delayMillis)}else{func()}}throwError(message){throw new Error(`SimpleJekyllSearch --- ${message}`)}emptyResultsContainer(){this.options.resultsContainer.innerHTML=""}initWithJSON(json){this.repository.put(json);this.registerInput()}initWithURL(url){load(url,((err,json)=>{if(err){this.throwError(`Failed to load JSON from ${url}: ${err.message}`)}this.initWithJSON(json)}))}registerInput(){this.options.searchInput.addEventListener("input",(e=>{const inputEvent=e;if(!WHITELISTED_KEYS.has(inputEvent.key)){this.emptyResultsContainer();this.debounce((()=>{this.search(e.target.value)}),this.options.debounceTime??null)}}))}search(query){var _a,_b;if((query==null?void 0:query.trim().length)>0){this.emptyResultsContainer();const results=this.repository.search(query);this.render(results,query);(_b=(_a=this.options).onSearch)==null?void 0:_b.call(_a)}}render(results,query){if(results.length===0){this.options.resultsContainer.insertAdjacentHTML("beforeend",this.options.noResultsText);return}const fragment=document.createDocumentFragment();results.forEach((result=>{result.query=query;const div=document.createElement("div");div.innerHTML=compile(result,query);fragment.appendChild(div)}));this.options.resultsContainer.appendChild(fragment)}init(_options){var _a;const errors=this.optionsValidator.validate(_options);if(errors.length>0){this.throwError(`Missing required options: ${REQUIRED_OPTIONS.join(", ")}`)}this.options=merge(this.options,_options);setOptions({template:this.options.searchResultTemplate,middleware:this.options.templateMiddleware});this.repository.setOptions({fuzzy:this.options.fuzzy,limit:this.options.limit,sortMiddleware:this.options.sortMiddleware,strategy:this.options.strategy,exclude:this.options.exclude});if(isJSON(this.options.json)){this.initWithJSON(this.options.json)}else{this.initWithURL(this.options.json)}const rv={search:this.search.bind(this)};(_a=this.options.success)==null?void 0:_a.call(rv);return rv}};function createHighlightMiddleware(options2={}){const{highlightClass:highlightClass="sjs-highlight",contextBefore:contextBefore=50,contextAfter:contextAfter=50,maxLength:maxLength=250,ellipsis:ellipsis="..."}=options2;return function(result,query){if(!query||!result){return result}const highlightedResult={...result};const textFields=["title","desc","content","excerpt"];for(const field of textFields){if(highlightedResult[field]&&typeof highlightedResult[field]==="string"){const highlighted=highlightText(highlightedResult[field],query,{highlightClass:highlightClass,contextBefore:contextBefore,contextAfter:contextAfter,maxLength:maxLength,ellipsis:ellipsis});if(highlighted.highlightedText!==highlightedResult[field]){highlightedResult[field]=highlighted.highlightedText}}}return highlightedResult}}function highlightText(text,query,options2={}){const{highlightClass:highlightClass="sjs-highlight",contextBefore:contextBefore=50,contextAfter:contextAfter=50,maxLength:maxLength=250,ellipsis:ellipsis="..."}=options2;if(!text||!query){return{highlightedText:text,matchCount:0}}const originalText=text;const searchTerms=query.trim().toLowerCase().split(/\s+/).filter((term=>term.length>0));if(searchTerms.length===0){return{highlightedText:text,matchCount:0}}const matches=[];for(const term of searchTerms){let index=0;while(index<text.length){const found=text.toLowerCase().indexOf(term,index);if(found===-1)break;matches.push({start:found,end:found+term.length,term:text.substring(found,found+term.length)});index=found+1}}if(matches.length===0){return{highlightedText:text,matchCount:0}}matches.sort(((a,b)=>a.start-b.start));const mergedMatches=[];for(const match of matches){if(mergedMatches.length===0||mergedMatches[mergedMatches.length-1].end<match.start){mergedMatches.push(match)}else{const lastMatch=mergedMatches[mergedMatches.length-1];lastMatch.end=Math.max(lastMatch.end,match.end);lastMatch.term=text.substring(lastMatch.start,lastMatch.end)}}if(text.length<=maxLength){let highlightedText2=text;for(let i=mergedMatches.length-1;i>=0;i--){const match=mergedMatches[i];const before=highlightedText2.substring(0,match.start);const after=highlightedText2.substring(match.end);const matchText=highlightedText2.substring(match.start,match.end);highlightedText2=before+`<span class="${highlightClass}">${matchText}</span>`+after}return{highlightedText:highlightedText2,matchCount:mergedMatches.length}}let highlightedText="";let totalLength=0;let lastEnd=0;for(let i=0;i<mergedMatches.length;i++){const match=mergedMatches[i];const contextStart=Math.max(lastEnd,match.start-contextBefore);const contextEnd=Math.min(text.length,match.end+contextAfter);if(contextStart>lastEnd&&lastEnd>0){highlightedText+=ellipsis;totalLength+=ellipsis.length}if(contextStart<match.start){const beforeText=text.substring(contextStart,match.start);highlightedText+=beforeText;totalLength+=beforeText.length}const matchText=text.substring(match.start,match.end);highlightedText+=`<span class="${highlightClass}">${matchText}</span>`;totalLength+=matchText.length;if(match.end<contextEnd){const afterText=text.substring(match.end,contextEnd);highlightedText+=afterText;totalLength+=afterText.length}lastEnd=contextEnd;if(totalLength>=maxLength){if(contextEnd<text.length){highlightedText+=ellipsis}break}}return{highlightedText:highlightedText||originalText,matchCount:mergedMatches.length}}const defaultHighlightMiddleware=createHighlightMiddleware();function findFuzzyMatches(text,pattern){const matches=[];const lowerText=text.toLowerCase();const lowerPattern=pattern.toLowerCase().trim();if(lowerPattern.length===0)return matches;const patternWords=lowerPattern.split(/\s+/);for(const word of patternWords){if(word.length===0)continue;const wordMatches=findFuzzyWordMatches(lowerText,word);matches.push(...wordMatches)}return matches}function findFuzzyWordMatches(text,word){const matches=[];const exactRegex=new RegExp(`\\b${word.replace(/[.*+?^${}()|[\]\\]/g,"\\$&")}\\b`,"gi");let match;while((match=exactRegex.exec(text))!==null){matches.push({start:match.index,end:match.index+match[0].length,text:match[0]})}if(matches.length===0){for(let i=0;i<text.length;i++){const fuzzyMatch=findFuzzySequenceMatch(text,word,i);if(fuzzyMatch){matches.push(fuzzyMatch);i=fuzzyMatch.end-1}}}return matches}function findFuzzySequenceMatch(text,pattern,startPos){let textIndex=startPos;let patternIndex=0;let matchStart=-1;let maxGap=3;const matchedPositions=[];while(textIndex<text.length&&patternIndex<pattern.length){if(text[textIndex]===pattern[patternIndex]){if(matchStart===-1){matchStart=textIndex}matchedPositions.push(textIndex);patternIndex++}else if(matchStart!==-1){if(textIndex-matchStart>maxGap*pattern.length){return null}}textIndex++}if(patternIndex===pattern.length&&matchStart!==-1&&matchedPositions.length>0){const actualStart=matchedPositions[0];const actualEnd=matchedPositions[matchedPositions.length-1]+1;return{start:actualStart,end:actualEnd,text:text.substring(actualStart,actualEnd)}}return null}function createHighlightTemplateMiddleware(options2={}){const highlightOptions={highlightClass:"sjs-highlight",...options2};return function(prop,value,_template,query){if((prop==="content"||prop==="desc")&&query&&typeof value==="string"){let highlightedText=value;let hasMatches=false;const searchTerms=query.trim().split(/\s+/).filter((term=>term.length>0));for(const term of searchTerms){const regex=new RegExp(`\\b(${term.replace(/[.*+?^${}()|[\]\\]/g,"\\$&")})\\b`,"gi");if(regex.test(highlightedText)){highlightedText=highlightedText.replace(regex,`<span class="${highlightOptions.highlightClass}">$1</span>`);hasMatches=true}}if(!hasMatches){const fuzzyMatches=findFuzzyMatches(value,query);if(fuzzyMatches.length>0){fuzzyMatches.sort(((a,b)=>b.start-a.start));for(const match of fuzzyMatches){const before=highlightedText.substring(0,match.start);const after=highlightedText.substring(match.end);const matchText=highlightedText.substring(match.start,match.end);highlightedText=before+`<span class="${highlightOptions.highlightClass}">${matchText}</span>`+after}hasMatches=true}}if(hasMatches){return highlightedText}}return void 0}}const defaultHighlightTemplateMiddleware=createHighlightTemplateMiddleware();function SimpleJekyllSearch(options2){const instance=new SimpleJekyllSearch$1;return instance.init(options2)}if(typeof window!=="undefined"){window.SimpleJekyllSearch=SimpleJekyllSearch;window.SimpleJekyllSearch.createHighlightMiddleware=createHighlightMiddleware;window.SimpleJekyllSearch.createHighlightTemplateMiddleware=createHighlightTemplateMiddleware;window.SimpleJekyllSearch.highlightText=highlightText;window.SimpleJekyllSearch.defaultHighlightMiddleware=defaultHighlightMiddleware;window.SimpleJekyllSearch.defaultHighlightTemplateMiddleware=defaultHighlightTemplateMiddleware}exports2.createHighlightMiddleware=createHighlightMiddleware;exports2.createHighlightTemplateMiddleware=createHighlightTemplateMiddleware;exports2.default=SimpleJekyllSearch;exports2.defaultHighlightMiddleware=defaultHighlightMiddleware;exports2.defaultHighlightTemplateMiddleware=defaultHighlightTemplateMiddleware;exports2.highlightText=highlightText;Object.defineProperties(exports2,{__esModule:{value:true},[Symbol.toStringTag]:{value:"Module"}})}));
\ No newline at end of file
diff --git a/package.json b/package.json
index 8f96e30..ca489fd 100644
--- a/package.json
+++ b/package.json
@@ -9,6 +9,7 @@
     "cypress:ci": "node scripts/start-jekyll.js & sleep 5 && cypress run",
     "cypress:run": "node scripts/start-jekyll.js & sleep 5 && cypress run && node scripts/kill-jekyll.js",
     "lint": "eslint . --ext .ts",
+    "lint:fix": "eslint . --ext .ts --fix",
     "pretest": "yarn run lint",
     "build": "tsc && vite build && terser dest/simple-jekyll-search.js -o dest/simple-jekyll-search.min.js",
     "prebuild": "yarn run test",
diff --git a/src/SearchStrategies/search/fuzzySearch.ts b/src/SearchStrategies/search/fuzzySearch.ts
index f54467c..b7221cc 100644
--- a/src/SearchStrategies/search/fuzzySearch.ts
+++ b/src/SearchStrategies/search/fuzzySearch.ts
@@ -20,12 +20,9 @@ export function fuzzySearch(text: string, pattern: string): boolean {
 
   let remainingText = text, currentIndex = -1;
   
-  // For each character in the pattern
   for (const char of pattern) {
-    // Find the next occurrence of this character in the remaining text
     const nextIndex = remainingText.indexOf(char);
 
-    // If the character is not found or is too far from the current character
     if (nextIndex === -1 || (currentIndex !== -1 && remainingText.slice(0, nextIndex).split(' ').length - 1 > 2)) {
       return false;
     }
diff --git a/src/SearchStrategies/search/levenshtein.ts b/src/SearchStrategies/search/levenshtein.ts
index f4da263..e88d356 100644
--- a/src/SearchStrategies/search/levenshtein.ts
+++ b/src/SearchStrategies/search/levenshtein.ts
@@ -18,23 +18,20 @@ export function levenshtein(a: string, b: string): number {
   const lenB = b.length;
   const distanceMatrix: number[][] = Array.from({ length: lenA + 1 }, () => Array(lenB + 1).fill(0));
 
-  // Initialize the first row and column
   for (let i = 0; i <= lenA; i++) distanceMatrix[i][0] = i;
   for (let j = 0; j <= lenB; j++) distanceMatrix[0][j] = j;
 
   for (let i = 1; i <= lenA; i++) {
     for (let j = 1; j <= lenB; j++) {
       const cost = a[i - 1] === b[j - 1] ? 0 : 1;
-      // Calculate the minimum cost of the three possible operations to make it closer to the other string
       distanceMatrix[i][j] = Math.min(
-        distanceMatrix[i - 1][j] + 1,        // Removing a character from one string
-        distanceMatrix[i][j - 1] + 1,        // Adding a character to one string to make it closer to the other string.
-        distanceMatrix[i - 1][j - 1] + cost  // Replacing one character in a string with another
+        distanceMatrix[i - 1][j] + 1,
+        distanceMatrix[i][j - 1] + 1,
+        distanceMatrix[i - 1][j - 1] + cost
       );
     }
   }
 
-  // Return the distance between the two strings
   return distanceMatrix[lenA][lenB];
 }
 
diff --git a/src/index.ts b/src/index.ts
index 8b844f5..2e37011 100644
--- a/src/index.ts
+++ b/src/index.ts
@@ -1,12 +1,20 @@
 import SimpleJekyllSearchClass from './SimpleJekyllSearch';
 import { SearchOptions, SimpleJekyllSearchInstance } from './utils/types';
-export { 
+import { 
   createHighlightMiddleware, 
   createHighlightTemplateMiddleware,
   highlightText, 
   defaultHighlightMiddleware,
   defaultHighlightTemplateMiddleware
 } from './utils/highlightMiddleware';
+
+export { 
+  createHighlightMiddleware, 
+  createHighlightTemplateMiddleware,
+  highlightText, 
+  defaultHighlightMiddleware,
+  defaultHighlightTemplateMiddleware
+};
 export type { HighlightOptions, HighlightResult } from './utils/highlightMiddleware';
 
 function SimpleJekyllSearch(options: SearchOptions): SimpleJekyllSearchInstance {
@@ -16,7 +24,11 @@ function SimpleJekyllSearch(options: SearchOptions): SimpleJekyllSearchInstance
 
 export default SimpleJekyllSearch;
 
-// Add to window if in browser environment
 if (typeof window !== 'undefined') {
   (window as any).SimpleJekyllSearch = SimpleJekyllSearch;
+  (window as any).SimpleJekyllSearch.createHighlightMiddleware = createHighlightMiddleware;
+  (window as any).SimpleJekyllSearch.createHighlightTemplateMiddleware = createHighlightTemplateMiddleware;
+  (window as any).SimpleJekyllSearch.highlightText = highlightText;
+  (window as any).SimpleJekyllSearch.defaultHighlightMiddleware = defaultHighlightMiddleware;
+  (window as any).SimpleJekyllSearch.defaultHighlightTemplateMiddleware = defaultHighlightTemplateMiddleware;
 }
diff --git a/src/utils/highlightMiddleware.ts b/src/utils/highlightMiddleware.ts
index d961e19..239013f 100644
--- a/src/utils/highlightMiddleware.ts
+++ b/src/utils/highlightMiddleware.ts
@@ -43,10 +43,7 @@ export function createHighlightMiddleware(options: HighlightOptions = {}): (resu
       return result;
     }
 
-    // Create a copy of the result to avoid modifying the original
     const highlightedResult = { ...result };
-
-    // Process each text field in the result
     const textFields = ['title', 'desc', 'content', 'excerpt'];
     
     for (const field of textFields) {
@@ -99,7 +96,6 @@ export function highlightText(
     return { highlightedText: text, matchCount: 0 };
   }
 
-  // Find all matches with their positions
   const matches: Array<{ start: number; end: number; term: string }> = [];
   
   for (const term of searchTerms) {
@@ -122,26 +118,21 @@ export function highlightText(
     return { highlightedText: text, matchCount: 0 };
   }
 
-  // Sort matches by position
   matches.sort((a, b) => a.start - b.start);
 
-  // Merge overlapping matches
   const mergedMatches: Array<{ start: number; end: number; term: string }> = [];
   for (const match of matches) {
     if (mergedMatches.length === 0 || mergedMatches[mergedMatches.length - 1].end < match.start) {
       mergedMatches.push(match);
     } else {
-      // Extend the previous match
       const lastMatch = mergedMatches[mergedMatches.length - 1];
       lastMatch.end = Math.max(lastMatch.end, match.end);
       lastMatch.term = text.substring(lastMatch.start, lastMatch.end);
     }
   }
 
-  // If the text is short enough, just highlight all matches without context
   if (text.length <= maxLength) {
     let highlightedText = text;
-    // Process matches in reverse order to maintain positions
     for (let i = mergedMatches.length - 1; i >= 0; i--) {
       const match = mergedMatches[i];
       const before = highlightedText.substring(0, match.start);
@@ -152,7 +143,6 @@ export function highlightText(
     return { highlightedText, matchCount: mergedMatches.length };
   }
 
-  // Build highlighted text with context for longer texts
   let highlightedText = '';
   let totalLength = 0;
   let lastEnd = 0;
@@ -160,29 +150,24 @@ export function highlightText(
   for (let i = 0; i < mergedMatches.length; i++) {
     const match = mergedMatches[i];
     
-    // Calculate context boundaries for this match
     const contextStart = Math.max(lastEnd, match.start - contextBefore);
     const contextEnd = Math.min(text.length, match.end + contextAfter);
     
-    // Add ellipsis if there's a gap between matches
     if (contextStart > lastEnd && lastEnd > 0) {
       highlightedText += ellipsis;
       totalLength += ellipsis.length;
     }
     
-    // Add text before the match
     if (contextStart < match.start) {
       const beforeText = text.substring(contextStart, match.start);
       highlightedText += beforeText;
       totalLength += beforeText.length;
     }
     
-    // Add the highlighted match
     const matchText = text.substring(match.start, match.end);
     highlightedText += `<span class="${highlightClass}">${matchText}</span>`;
     totalLength += matchText.length;
     
-    // Add text after the match
     if (match.end < contextEnd) {
       const afterText = text.substring(match.end, contextEnd);
       highlightedText += afterText;
@@ -191,9 +176,7 @@ export function highlightText(
     
     lastEnd = contextEnd;
     
-    // Check if we've exceeded the max length
     if (totalLength >= maxLength) {
-      // Add ellipsis at the end if we're not at the end of the original text
       if (contextEnd < text.length) {
         highlightedText += ellipsis;
       }
@@ -225,13 +208,11 @@ function findFuzzyMatches(text: string, pattern: string): Array<{ start: number;
   
   if (lowerPattern.length === 0) return matches;
   
-  // Split pattern into words for multi-word fuzzy matching
   const patternWords = lowerPattern.split(/\s+/);
   
   for (const word of patternWords) {
     if (word.length === 0) continue;
     
-    // Find fuzzy matches for each word
     const wordMatches = findFuzzyWordMatches(lowerText, word);
     matches.push(...wordMatches);
   }
@@ -245,7 +226,6 @@ function findFuzzyMatches(text: string, pattern: string): Array<{ start: number;
 function findFuzzyWordMatches(text: string, word: string): Array<{ start: number; end: number; text: string }> {
   const matches: Array<{ start: number; end: number; text: string }> = [];
   
-  // First try to find exact word matches
   const exactRegex = new RegExp(`\\b${word.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}\\b`, 'gi');
   let match;
   while ((match = exactRegex.exec(text)) !== null) {
@@ -256,9 +236,7 @@ function findFuzzyWordMatches(text: string, word: string): Array<{ start: number
     });
   }
   
-  // If no exact matches, try fuzzy matching
   if (matches.length === 0) {
-    // Simple fuzzy matching: find characters in sequence
     for (let i = 0; i < text.length; i++) {
       const fuzzyMatch = findFuzzySequenceMatch(text, word, i);
       if (fuzzyMatch) {
@@ -278,7 +256,7 @@ function findFuzzySequenceMatch(text: string, pattern: string, startPos: number)
   let textIndex = startPos;
   let patternIndex = 0;
   let matchStart = -1;
-  let maxGap = 3; // Maximum characters between pattern characters
+  let maxGap = 3;
   const matchedPositions: number[] = [];
   
   while (textIndex < text.length && patternIndex < pattern.length) {
@@ -289,7 +267,6 @@ function findFuzzySequenceMatch(text: string, pattern: string, startPos: number)
       matchedPositions.push(textIndex);
       patternIndex++;
     } else if (matchStart !== -1) {
-      // Check if we've gone too far from the last match
       if (textIndex - matchStart > maxGap * pattern.length) {
         return null;
       }
@@ -297,7 +274,6 @@ function findFuzzySequenceMatch(text: string, pattern: string, startPos: number)
     textIndex++;
   }
   
-  // If we found a complete match, return only the actual matched characters
   if (patternIndex === pattern.length && matchStart !== -1 && matchedPositions.length > 0) {
     const actualStart = matchedPositions[0];
     const actualEnd = matchedPositions[matchedPositions.length - 1] + 1;
@@ -328,14 +304,10 @@ export function createHighlightTemplateMiddleware(options: HighlightOptions = {}
   };
 
   return function(prop: string, value: string, _template: string, query?: string): string | undefined {
-    // Only highlight content and desc fields
     if ((prop === 'content' || prop === 'desc') && query && typeof value === 'string') {
-      // For fuzzy search, we need to find the actual matched characters
-      // First try exact matching (for literal and wildcard searches)
       let highlightedText = value;
       let hasMatches = false;
       
-      // Try exact word matching first
       const searchTerms = query.trim().split(/\s+/).filter(term => term.length > 0);
       for (const term of searchTerms) {
         const regex = new RegExp(`\\b(${term.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')})\\b`, 'gi');
@@ -345,11 +317,9 @@ export function createHighlightTemplateMiddleware(options: HighlightOptions = {}
         }
       }
       
-      // If no exact matches found, try fuzzy matching
       if (!hasMatches) {
         const fuzzyMatches = findFuzzyMatches(value, query);
         if (fuzzyMatches.length > 0) {
-          // Sort matches by position (reverse order to maintain positions when replacing)
           fuzzyMatches.sort((a, b) => b.start - a.start);
           
           for (const match of fuzzyMatches) {
@@ -362,7 +332,6 @@ export function createHighlightTemplateMiddleware(options: HighlightOptions = {}
         }
       }
       
-      // If we have matches, return the highlighted text
       if (hasMatches) {
         return highlightedText;
       }
diff --git a/tests/highlightMiddleware.test.ts b/tests/highlightMiddleware.test.ts
index 4bdfa61..5dbf4a5 100644
--- a/tests/highlightMiddleware.test.ts
+++ b/tests/highlightMiddleware.test.ts
@@ -49,9 +49,7 @@ describe('highlightText', () => {
     const result = highlightText(text, query, options);
     
     expect(result.highlightedText).toContain('<span class="sjs-highlight">search</span>');
-    // The text is long enough to trigger context mode
     expect(result.matchCount).toBe(1);
-    // Should show context around the match
     expect(result.highlightedText.length).toBeLessThan(text.length);
   });
 
@@ -63,9 +61,7 @@ describe('highlightText', () => {
     };
     const result = highlightText(text, query, options);
     
-    // The result should be truncated
     expect(result.highlightedText).toContain('<span class="sjs-highlight">search</span>');
-    // The result should be significantly shorter than the original text
     expect(result.highlightedText.length).toBeLessThan(text.length);
   });
 
@@ -103,7 +99,6 @@ describe('highlightText', () => {
     const query = 'search';
     const result = highlightText(text, query);
     
-    // Should merge the overlapping "search" matches
     expect(result.highlightedText).toBe('<span class="sjs-highlight">search</span>ing for <span class="sjs-highlight">search</span>');
     expect(result.matchCount).toBe(2);
   });
@@ -249,7 +244,6 @@ describe('createHighlightTemplateMiddleware', () => {
     const middleware = createHighlightTemplateMiddleware();
     const result = middleware('content', 'This is a testing result', '<div>{content}</div>', 'test');
     
-    // Should highlight the fuzzy match span that contains "test"
     expect(result).toContain('<span class="sjs-highlight">');
     expect(result).toContain('test');
   });
@@ -258,7 +252,6 @@ describe('createHighlightTemplateMiddleware', () => {
     const middleware = createHighlightTemplateMiddleware();
     const result = middleware('content', 'This is a tst result', '<div>{content}</div>', 'test');
     
-    // Should highlight the fuzzy match span that contains "tst"
     expect(result).toContain('<span class="sjs-highlight">');
     expect(result).toContain('tst');
   });
@@ -267,7 +260,6 @@ describe('createHighlightTemplateMiddleware', () => {
     const middleware = createHighlightTemplateMiddleware();
     const result = middleware('content', 'This is a test and testing result', '<div>{content}</div>', 'test');
     
-    // Should highlight exact "test" word, not fuzzy match in "testing"
     expect(result).toContain('<span class="sjs-highlight">test</span>');
     expect(result).not.toContain('<span class="sjs-highlight">testing</span>');
   });
@@ -276,13 +268,11 @@ describe('createHighlightTemplateMiddleware', () => {
     const middleware = createHighlightTemplateMiddleware();
     const result = middleware('content', 'This is a tst srch result', '<div>{content}</div>', 'test search');
     
-    // Should highlight fuzzy matches
     expect(result).toContain('<span class="sjs-highlight">');
   });
 
   describe('Search Strategy Compatibility', () => {
     const testCases = [
-      // Literal Search Test Cases
       {
         strategy: 'literal',
         description: 'should highlight exact word matches for literal search',
@@ -316,7 +306,6 @@ describe('createHighlightTemplateMiddleware', () => {
         shouldNotContain: []
       },
       
-      // Fuzzy Search Test Cases
       {
         strategy: 'fuzzy',
         description: 'should highlight exact matches when available for fuzzy search',
@@ -366,7 +355,6 @@ describe('createHighlightTemplateMiddleware', () => {
         shouldNotContain: []
       },
       
-      // Wildcard Search Test Cases
       {
         strategy: 'wildcard',
         description: 'should highlight exact matches for wildcard search',
@@ -400,7 +388,6 @@ describe('createHighlightTemplateMiddleware', () => {
         shouldNotContain: []
       },
       
-      // Levenshtein Search Test Cases (fallback for wildcard)
       {
         strategy: 'levenshtein',
         description: 'should highlight similar words using levenshtein distance',
@@ -426,7 +413,6 @@ describe('createHighlightTemplateMiddleware', () => {
         shouldNotContain: []
       },
       
-      // Edge Cases
       {
         strategy: 'all',
         description: 'should handle empty query',

From ddc0d35c9d52391da3d6f8c4373d1d2e776cd5ad Mon Sep 17 00:00:00 2001
From: sylhare <sylhare@outlook.com>
Date: Thu, 9 Oct 2025 08:59:49 -0400
Subject: [PATCH 04/10] Use match info for template on search

---
 dest/simple-jekyll-search.js                  | 185 +++++++++++++++++-
 dest/simple-jekyll-search.min.js              |   2 +-
 docs/assets/js/simple-jekyll-search.min.js    |   2 +-
 src/Repository.ts                             |   8 +-
 src/SearchStrategies/SearchStrategy.ts        |  42 +++-
 src/SearchStrategies/search/fuzzySearch.ts    | 100 ++++++++++
 src/SearchStrategies/search/levenshtein.ts    |  30 +++
 src/SearchStrategies/search/literalSearch.ts  |  34 ++++
 src/SearchStrategies/search/wildcardSearch.ts |  45 ++++-
 src/SearchStrategies/types.ts                 |  20 +-
 src/Templater.ts                              |   9 +
 src/index.ts                                  |   1 +
 src/utils/types.ts                            |   4 +-
 tests/Repository.test.ts                      |  40 ++--
 14 files changed, 481 insertions(+), 41 deletions(-)

diff --git a/dest/simple-jekyll-search.js b/dest/simple-jekyll-search.js
index 679fe02..b5bab03 100644
--- a/dest/simple-jekyll-search.js
+++ b/dest/simple-jekyll-search.js
@@ -64,11 +64,100 @@
     }
     return true;
   }
+  function findFuzzyMatches$1(text, pattern) {
+    if (!text || !pattern) return [];
+    const lowerText = text.toLowerCase();
+    const lowerPattern = pattern.toLowerCase().trim();
+    if (lowerPattern.length === 0) return [];
+    const patternWords = lowerPattern.split(/\s+/);
+    const matches = [];
+    for (const word of patternWords) {
+      if (word.length === 0) continue;
+      const wordMatches = findFuzzyWordMatches$1(lowerText, word);
+      matches.push(...wordMatches);
+    }
+    return matches;
+  }
+  function findFuzzyWordMatches$1(text, word) {
+    const matches = [];
+    const exactRegex = new RegExp(`\\b${word.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}\\b`, "gi");
+    let match;
+    while ((match = exactRegex.exec(text)) !== null) {
+      matches.push({
+        start: match.index,
+        end: match.index + match[0].length,
+        text: match[0],
+        type: "exact"
+      });
+    }
+    if (matches.length === 0) {
+      for (let i = 0; i < text.length; i++) {
+        const fuzzyMatch = findFuzzySequenceMatch$1(text, word, i);
+        if (fuzzyMatch) {
+          matches.push({ ...fuzzyMatch, type: "fuzzy" });
+          i = fuzzyMatch.end - 1;
+        }
+      }
+    }
+    return matches;
+  }
+  function findFuzzySequenceMatch$1(text, pattern, startPos) {
+    let textIndex = startPos;
+    let patternIndex = 0;
+    let matchStart = -1;
+    let maxGap = 3;
+    const matchedPositions = [];
+    while (textIndex < text.length && patternIndex < pattern.length) {
+      if (text[textIndex] === pattern[patternIndex]) {
+        if (matchStart === -1) {
+          matchStart = textIndex;
+        }
+        matchedPositions.push(textIndex);
+        patternIndex++;
+      } else if (matchStart !== -1) {
+        if (textIndex - matchStart > maxGap * pattern.length) {
+          return null;
+        }
+      }
+      textIndex++;
+    }
+    if (patternIndex === pattern.length && matchStart !== -1 && matchedPositions.length > 0) {
+      const actualStart = matchedPositions[0];
+      const actualEnd = matchedPositions[matchedPositions.length - 1] + 1;
+      return {
+        start: actualStart,
+        end: actualEnd,
+        text: text.substring(actualStart, actualEnd)
+      };
+    }
+    return null;
+  }
   function literalSearch(text, criteria) {
     text = text.trim().toLowerCase();
     const pattern = criteria.endsWith(" ") ? [criteria.toLowerCase()] : criteria.trim().toLowerCase().split(" ");
     return pattern.filter((word) => text.indexOf(word) >= 0).length === pattern.length;
   }
+  function findLiteralMatches(text, criteria) {
+    if (!text || !criteria) return [];
+    const lowerText = text.toLowerCase();
+    const words = criteria.trim().toLowerCase().split(/\s+/);
+    const matches = [];
+    let textIndex = 0;
+    for (const word of words) {
+      if (word.length === 0) continue;
+      const wordIndex = lowerText.indexOf(word, textIndex);
+      if (wordIndex !== -1) {
+        matches.push({
+          start: wordIndex,
+          end: wordIndex + word.length,
+          text: text.substring(wordIndex, wordIndex + word.length),
+          type: "exact"
+        });
+        textIndex = wordIndex + word.length;
+      }
+    }
+    return matches;
+  }
   function levenshtein(a, b) {
     const lenA = a.length;
     const lenB = b.length;
@@ -92,15 +181,57 @@
     const similarity = 1 - distance / Math.max(pattern.length, text.length);
     return similarity >= 0.3;
   }
+  function findLevenshteinMatches(text, pattern) {
+    if (!text || !pattern) return [];
+    const matches = [];
+    const words = text.split(/\s+/);
+    for (let i = 0; i < words.length; i++) {
+      const word = words[i];
+      if (levenshteinSearch(word, pattern)) {
+        const start = text.indexOf(word);
+        matches.push({
+          start,
+          end: start + word.length,
+          text: word,
+          type: "wildcard"
+        });
+      }
+    }
+    return matches;
+  }
   function wildcardSearch(text, pattern) {
     const regexPattern = pattern.replace(/\*/g, ".*");
     const regex = new RegExp(`^${regexPattern}$`, "i");
     if (regex.test(text)) return true;
     return levenshteinSearch(text, pattern);
   }
+  function findWildcardMatches(text, pattern) {
+    if (!text || !pattern) return [];
+    const wildcardMatches = findWildcardPatternMatches(text, pattern);
+    if (wildcardMatches.length > 0) {
+      return wildcardMatches;
+    }
+    return findLevenshteinMatches(text, pattern);
+  }
+  function findWildcardPatternMatches(text, pattern) {
+    const matches = [];
+    const regexPattern = pattern.replace(/\*/g, ".*");
+    const regex = new RegExp(regexPattern, "gi");
+    let match;
+    while ((match = regex.exec(text)) !== null) {
+      matches.push({
+        start: match.index,
+        end: match.index + match[0].length,
+        text: match[0],
+        type: "wildcard"
+      });
+    }
+    return matches;
+  }
   class SearchStrategy {
-    constructor(matchFunction) {
+    constructor(matchFunction, findMatchesFunction) {
       this.matchFunction = matchFunction;
+      this.findMatchesFunction = findMatchesFunction;
     }
     matches(text, criteria) {
       if (text === null || text.trim() === "" || !criteria) {
@@ -108,14 +239,38 @@
       }
       return this.matchFunction(text, criteria);
     }
+    findMatches(text, criteria) {
+      if (text === null || text.trim() === "" || !criteria || !this.findMatchesFunction) {
+        return [];
+      }
+      return this.findMatchesFunction(text, criteria);
+    }
   }
-  const LiteralSearchStrategy = new SearchStrategy(literalSearch);
-  const FuzzySearchStrategy = new SearchStrategy((text, criteria) => {
-    return fuzzySearch(text, criteria) || literalSearch(text, criteria);
-  });
-  const WildcardSearchStrategy = new SearchStrategy((text, criteria) => {
-    return wildcardSearch(text, criteria) || literalSearch(text, criteria);
-  });
+  const LiteralSearchStrategy = new SearchStrategy(literalSearch, findLiteralMatches);
+  const FuzzySearchStrategy = new SearchStrategy(
+    (text, criteria) => {
+      return fuzzySearch(text, criteria) || literalSearch(text, criteria);
+    },
+    (text, criteria) => {
+      const fuzzyMatches = findFuzzyMatches$1(text, criteria);
+      if (fuzzyMatches.length > 0) {
+        return fuzzyMatches;
+      }
+      return findLiteralMatches(text, criteria);
+    }
+  );
+  const WildcardSearchStrategy = new SearchStrategy(
+    (text, criteria) => {
+      return wildcardSearch(text, criteria) || literalSearch(text, criteria);
+    },
+    (text, criteria) => {
+      const wildcardMatches = findWildcardMatches(text, criteria);
+      if (wildcardMatches.length > 0) {
+        return wildcardMatches;
+      }
+      return findLiteralMatches(text, criteria);
+    }
+  );
   function merge(target, source) {
     return { ...target, ...source };
   }
@@ -235,9 +390,15 @@
       return matches;
     }
     findMatchesInObject(obj, criteria) {
+      var _a, _b;
       for (const key in obj) {
         if (!this.isExcluded(obj[key]) && this.options.searchStrategy.matches(obj[key], criteria)) {
-          return obj;
+          const matchInfo = (_b = (_a = this.options.searchStrategy).findMatches) == null ? void 0 : _b.call(_a, obj[key], criteria);
+          const result = { ...obj };
+          if (matchInfo && matchInfo.length > 0) {
+            result._matchInfo = { [key]: matchInfo };
+          }
+          return result;
         }
       }
       return void 0;
@@ -281,6 +442,12 @@
   }
   function compile(data, query) {
     return options.template.replace(options.pattern, function(match, prop) {
+      if (options.middleware.length >= 5 && data._matchInfo && data._matchInfo[prop]) {
+        const value2 = options.middleware(prop, data[prop], options.template, query, data._matchInfo[prop]);
+        if (typeof value2 !== "undefined") {
+          return value2;
+        }
+      }
       const value = options.middleware(prop, data[prop], options.template, query);
       if (typeof value !== "undefined") {
         return value;
diff --git a/dest/simple-jekyll-search.min.js b/dest/simple-jekyll-search.min.js
index 62446e1..84bfcd8 100644
--- a/dest/simple-jekyll-search.min.js
+++ b/dest/simple-jekyll-search.min.js
@@ -4,4 +4,4 @@
   * Copyright 2025-2025, Sylhare
   * Licensed under the MIT License.
   */
-(function(global,factory){typeof exports==="object"&&typeof module!=="undefined"?factory(exports):typeof define==="function"&&define.amd?define(["exports"],factory):(global=typeof globalThis!=="undefined"?globalThis:global||self,factory(global.SimpleJekyllSearch={}))})(this,(function(exports2){"use strict";function load(location,callback){const xhr=getXHR();xhr.open("GET",location,true);xhr.onreadystatechange=createStateChangeListener(xhr,callback);xhr.send()}function createStateChangeListener(xhr,callback){return function(){if(xhr.readyState===4&&xhr.status===200){try{callback(null,JSON.parse(xhr.responseText))}catch(err){callback(err instanceof Error?err:new Error(String(err)),null)}}}}function getXHR(){return window.XMLHttpRequest?new window.XMLHttpRequest:new window.ActiveXObject("Microsoft.XMLHTTP")}class OptionsValidator{constructor(params){if(!this.validateParams(params)){throw new Error("-- OptionsValidator: required options missing")}this.requiredOptions=params.required}getRequiredOptions(){return this.requiredOptions}validate(parameters){const errors=[];this.requiredOptions.forEach((requiredOptionName=>{if(typeof parameters[requiredOptionName]==="undefined"){errors.push(requiredOptionName)}}));return errors}validateParams(params){if(!params){return false}return typeof params.required!=="undefined"&&Array.isArray(params.required)}}function fuzzySearch(text,pattern){pattern=pattern.trimEnd();if(pattern.length===0)return true;pattern=pattern.toLowerCase();text=text.toLowerCase();let remainingText=text,currentIndex=-1;for(const char of pattern){const nextIndex=remainingText.indexOf(char);if(nextIndex===-1||currentIndex!==-1&&remainingText.slice(0,nextIndex).split(" ").length-1>2){return false}currentIndex=nextIndex;remainingText=remainingText.slice(nextIndex+1)}return true}function literalSearch(text,criteria){text=text.trim().toLowerCase();const pattern=criteria.endsWith(" ")?[criteria.toLowerCase()]:criteria.trim().toLowerCase().split(" ");return pattern.filter((word=>text.indexOf(word)>=0)).length===pattern.length}function levenshtein(a,b){const lenA=a.length;const lenB=b.length;const distanceMatrix=Array.from({length:lenA+1},(()=>Array(lenB+1).fill(0)));for(let i=0;i<=lenA;i++)distanceMatrix[i][0]=i;for(let j=0;j<=lenB;j++)distanceMatrix[0][j]=j;for(let i=1;i<=lenA;i++){for(let j=1;j<=lenB;j++){const cost=a[i-1]===b[j-1]?0:1;distanceMatrix[i][j]=Math.min(distanceMatrix[i-1][j]+1,distanceMatrix[i][j-1]+1,distanceMatrix[i-1][j-1]+cost)}}return distanceMatrix[lenA][lenB]}function levenshteinSearch(text,pattern){const distance=levenshtein(pattern,text);const similarity=1-distance/Math.max(pattern.length,text.length);return similarity>=.3}function wildcardSearch(text,pattern){const regexPattern=pattern.replace(/\*/g,".*");const regex=new RegExp(`^${regexPattern}$`,"i");if(regex.test(text))return true;return levenshteinSearch(text,pattern)}class SearchStrategy{constructor(matchFunction){this.matchFunction=matchFunction}matches(text,criteria){if(text===null||text.trim()===""||!criteria){return false}return this.matchFunction(text,criteria)}}const LiteralSearchStrategy=new SearchStrategy(literalSearch);const FuzzySearchStrategy=new SearchStrategy(((text,criteria)=>fuzzySearch(text,criteria)||literalSearch(text,criteria)));const WildcardSearchStrategy=new SearchStrategy(((text,criteria)=>wildcardSearch(text,criteria)||literalSearch(text,criteria)));function merge(target,source){return{...target,...source}}function isJSON(json){try{return!!(json instanceof Object&&JSON.parse(JSON.stringify(json)))}catch(_err){return false}}function NoSort(){return 0}function isObject(obj){return Boolean(obj)&&Object.prototype.toString.call(obj)==="[object Object]"}function clone(input){if(input===null||typeof input!=="object"){return input}if(Array.isArray(input)){return input.map((item=>clone(item)))}const output={};for(const key in input){if(Object.prototype.hasOwnProperty.call(input,key)){output[key]=clone(input[key])}}return output}const DEFAULT_OPTIONS={searchInput:null,resultsContainer:null,json:[],success:function(){},searchResultTemplate:'<li><a href="{url}" title="{desc}">{title}</a></li>',templateMiddleware:(_prop,_value,_template,_query)=>void 0,sortMiddleware:NoSort,noResultsText:"No results found",limit:10,fuzzy:false,strategy:"literal",debounceTime:null,exclude:[],onSearch:()=>{}};const REQUIRED_OPTIONS=["searchInput","resultsContainer","json"];const WHITELISTED_KEYS=new Set(["Enter","Shift","CapsLock","ArrowLeft","ArrowUp","ArrowRight","ArrowDown","Meta"]);class Repository{constructor(initialOptions={}){this.data=[];this.setOptions(initialOptions)}put(input){if(isObject(input)){return this.addObject(input)}if(Array.isArray(input)){return this.addArray(input)}return void 0}clear(){this.data.length=0;return this.data}search(criteria){if(!criteria){return[]}return clone(this.findMatches(this.data,criteria).sort(this.options.sortMiddleware))}setOptions(newOptions){this.options={fuzzy:(newOptions==null?void 0:newOptions.fuzzy)||DEFAULT_OPTIONS.fuzzy,limit:(newOptions==null?void 0:newOptions.limit)||DEFAULT_OPTIONS.limit,searchStrategy:this.searchStrategy((newOptions==null?void 0:newOptions.strategy)||newOptions.fuzzy&&"fuzzy"||DEFAULT_OPTIONS.strategy),sortMiddleware:(newOptions==null?void 0:newOptions.sortMiddleware)||DEFAULT_OPTIONS.sortMiddleware,exclude:(newOptions==null?void 0:newOptions.exclude)||DEFAULT_OPTIONS.exclude,strategy:(newOptions==null?void 0:newOptions.strategy)||DEFAULT_OPTIONS.strategy}}addObject(obj){this.data.push(obj);return this.data}addArray(arr){const added=[];this.clear();for(const item of arr){if(isObject(item)){added.push(this.addObject(item)[0])}}return added}findMatches(data,criteria){const matches=[];for(let i=0;i<data.length&&matches.length<this.options.limit;i++){const match=this.findMatchesInObject(data[i],criteria);if(match){matches.push(match)}}return matches}findMatchesInObject(obj,criteria){for(const key in obj){if(!this.isExcluded(obj[key])&&this.options.searchStrategy.matches(obj[key],criteria)){return obj}}return void 0}isExcluded(term){for(const excludedTerm of this.options.exclude){if(new RegExp(excludedTerm).test(String(term))){return true}}return false}searchStrategy(strategy){switch(strategy){case"fuzzy":return FuzzySearchStrategy;case"wildcard":return WildcardSearchStrategy;default:return LiteralSearchStrategy}}}const options={pattern:/\{(.*?)\}/g,template:"",middleware:function(){return void 0}};function setOptions(_options){if(_options.pattern){options.pattern=_options.pattern}if(_options.template){options.template=_options.template}if(typeof _options.middleware==="function"){options.middleware=_options.middleware}}function compile(data,query){return options.template.replace(options.pattern,(function(match,prop){const value=options.middleware(prop,data[prop],options.template,query);if(typeof value!=="undefined"){return value}return data[prop]||match}))}let SimpleJekyllSearch$1=class SimpleJekyllSearch{constructor(){this.debounceTimerHandle=null;this.options={...DEFAULT_OPTIONS};this.repository=new Repository;this.optionsValidator=new OptionsValidator({required:REQUIRED_OPTIONS})}debounce(func,delayMillis){if(delayMillis){if(this.debounceTimerHandle){clearTimeout(this.debounceTimerHandle)}this.debounceTimerHandle=setTimeout(func,delayMillis)}else{func()}}throwError(message){throw new Error(`SimpleJekyllSearch --- ${message}`)}emptyResultsContainer(){this.options.resultsContainer.innerHTML=""}initWithJSON(json){this.repository.put(json);this.registerInput()}initWithURL(url){load(url,((err,json)=>{if(err){this.throwError(`Failed to load JSON from ${url}: ${err.message}`)}this.initWithJSON(json)}))}registerInput(){this.options.searchInput.addEventListener("input",(e=>{const inputEvent=e;if(!WHITELISTED_KEYS.has(inputEvent.key)){this.emptyResultsContainer();this.debounce((()=>{this.search(e.target.value)}),this.options.debounceTime??null)}}))}search(query){var _a,_b;if((query==null?void 0:query.trim().length)>0){this.emptyResultsContainer();const results=this.repository.search(query);this.render(results,query);(_b=(_a=this.options).onSearch)==null?void 0:_b.call(_a)}}render(results,query){if(results.length===0){this.options.resultsContainer.insertAdjacentHTML("beforeend",this.options.noResultsText);return}const fragment=document.createDocumentFragment();results.forEach((result=>{result.query=query;const div=document.createElement("div");div.innerHTML=compile(result,query);fragment.appendChild(div)}));this.options.resultsContainer.appendChild(fragment)}init(_options){var _a;const errors=this.optionsValidator.validate(_options);if(errors.length>0){this.throwError(`Missing required options: ${REQUIRED_OPTIONS.join(", ")}`)}this.options=merge(this.options,_options);setOptions({template:this.options.searchResultTemplate,middleware:this.options.templateMiddleware});this.repository.setOptions({fuzzy:this.options.fuzzy,limit:this.options.limit,sortMiddleware:this.options.sortMiddleware,strategy:this.options.strategy,exclude:this.options.exclude});if(isJSON(this.options.json)){this.initWithJSON(this.options.json)}else{this.initWithURL(this.options.json)}const rv={search:this.search.bind(this)};(_a=this.options.success)==null?void 0:_a.call(rv);return rv}};function createHighlightMiddleware(options2={}){const{highlightClass:highlightClass="sjs-highlight",contextBefore:contextBefore=50,contextAfter:contextAfter=50,maxLength:maxLength=250,ellipsis:ellipsis="..."}=options2;return function(result,query){if(!query||!result){return result}const highlightedResult={...result};const textFields=["title","desc","content","excerpt"];for(const field of textFields){if(highlightedResult[field]&&typeof highlightedResult[field]==="string"){const highlighted=highlightText(highlightedResult[field],query,{highlightClass:highlightClass,contextBefore:contextBefore,contextAfter:contextAfter,maxLength:maxLength,ellipsis:ellipsis});if(highlighted.highlightedText!==highlightedResult[field]){highlightedResult[field]=highlighted.highlightedText}}}return highlightedResult}}function highlightText(text,query,options2={}){const{highlightClass:highlightClass="sjs-highlight",contextBefore:contextBefore=50,contextAfter:contextAfter=50,maxLength:maxLength=250,ellipsis:ellipsis="..."}=options2;if(!text||!query){return{highlightedText:text,matchCount:0}}const originalText=text;const searchTerms=query.trim().toLowerCase().split(/\s+/).filter((term=>term.length>0));if(searchTerms.length===0){return{highlightedText:text,matchCount:0}}const matches=[];for(const term of searchTerms){let index=0;while(index<text.length){const found=text.toLowerCase().indexOf(term,index);if(found===-1)break;matches.push({start:found,end:found+term.length,term:text.substring(found,found+term.length)});index=found+1}}if(matches.length===0){return{highlightedText:text,matchCount:0}}matches.sort(((a,b)=>a.start-b.start));const mergedMatches=[];for(const match of matches){if(mergedMatches.length===0||mergedMatches[mergedMatches.length-1].end<match.start){mergedMatches.push(match)}else{const lastMatch=mergedMatches[mergedMatches.length-1];lastMatch.end=Math.max(lastMatch.end,match.end);lastMatch.term=text.substring(lastMatch.start,lastMatch.end)}}if(text.length<=maxLength){let highlightedText2=text;for(let i=mergedMatches.length-1;i>=0;i--){const match=mergedMatches[i];const before=highlightedText2.substring(0,match.start);const after=highlightedText2.substring(match.end);const matchText=highlightedText2.substring(match.start,match.end);highlightedText2=before+`<span class="${highlightClass}">${matchText}</span>`+after}return{highlightedText:highlightedText2,matchCount:mergedMatches.length}}let highlightedText="";let totalLength=0;let lastEnd=0;for(let i=0;i<mergedMatches.length;i++){const match=mergedMatches[i];const contextStart=Math.max(lastEnd,match.start-contextBefore);const contextEnd=Math.min(text.length,match.end+contextAfter);if(contextStart>lastEnd&&lastEnd>0){highlightedText+=ellipsis;totalLength+=ellipsis.length}if(contextStart<match.start){const beforeText=text.substring(contextStart,match.start);highlightedText+=beforeText;totalLength+=beforeText.length}const matchText=text.substring(match.start,match.end);highlightedText+=`<span class="${highlightClass}">${matchText}</span>`;totalLength+=matchText.length;if(match.end<contextEnd){const afterText=text.substring(match.end,contextEnd);highlightedText+=afterText;totalLength+=afterText.length}lastEnd=contextEnd;if(totalLength>=maxLength){if(contextEnd<text.length){highlightedText+=ellipsis}break}}return{highlightedText:highlightedText||originalText,matchCount:mergedMatches.length}}const defaultHighlightMiddleware=createHighlightMiddleware();function findFuzzyMatches(text,pattern){const matches=[];const lowerText=text.toLowerCase();const lowerPattern=pattern.toLowerCase().trim();if(lowerPattern.length===0)return matches;const patternWords=lowerPattern.split(/\s+/);for(const word of patternWords){if(word.length===0)continue;const wordMatches=findFuzzyWordMatches(lowerText,word);matches.push(...wordMatches)}return matches}function findFuzzyWordMatches(text,word){const matches=[];const exactRegex=new RegExp(`\\b${word.replace(/[.*+?^${}()|[\]\\]/g,"\\$&")}\\b`,"gi");let match;while((match=exactRegex.exec(text))!==null){matches.push({start:match.index,end:match.index+match[0].length,text:match[0]})}if(matches.length===0){for(let i=0;i<text.length;i++){const fuzzyMatch=findFuzzySequenceMatch(text,word,i);if(fuzzyMatch){matches.push(fuzzyMatch);i=fuzzyMatch.end-1}}}return matches}function findFuzzySequenceMatch(text,pattern,startPos){let textIndex=startPos;let patternIndex=0;let matchStart=-1;let maxGap=3;const matchedPositions=[];while(textIndex<text.length&&patternIndex<pattern.length){if(text[textIndex]===pattern[patternIndex]){if(matchStart===-1){matchStart=textIndex}matchedPositions.push(textIndex);patternIndex++}else if(matchStart!==-1){if(textIndex-matchStart>maxGap*pattern.length){return null}}textIndex++}if(patternIndex===pattern.length&&matchStart!==-1&&matchedPositions.length>0){const actualStart=matchedPositions[0];const actualEnd=matchedPositions[matchedPositions.length-1]+1;return{start:actualStart,end:actualEnd,text:text.substring(actualStart,actualEnd)}}return null}function createHighlightTemplateMiddleware(options2={}){const highlightOptions={highlightClass:"sjs-highlight",...options2};return function(prop,value,_template,query){if((prop==="content"||prop==="desc")&&query&&typeof value==="string"){let highlightedText=value;let hasMatches=false;const searchTerms=query.trim().split(/\s+/).filter((term=>term.length>0));for(const term of searchTerms){const regex=new RegExp(`\\b(${term.replace(/[.*+?^${}()|[\]\\]/g,"\\$&")})\\b`,"gi");if(regex.test(highlightedText)){highlightedText=highlightedText.replace(regex,`<span class="${highlightOptions.highlightClass}">$1</span>`);hasMatches=true}}if(!hasMatches){const fuzzyMatches=findFuzzyMatches(value,query);if(fuzzyMatches.length>0){fuzzyMatches.sort(((a,b)=>b.start-a.start));for(const match of fuzzyMatches){const before=highlightedText.substring(0,match.start);const after=highlightedText.substring(match.end);const matchText=highlightedText.substring(match.start,match.end);highlightedText=before+`<span class="${highlightOptions.highlightClass}">${matchText}</span>`+after}hasMatches=true}}if(hasMatches){return highlightedText}}return void 0}}const defaultHighlightTemplateMiddleware=createHighlightTemplateMiddleware();function SimpleJekyllSearch(options2){const instance=new SimpleJekyllSearch$1;return instance.init(options2)}if(typeof window!=="undefined"){window.SimpleJekyllSearch=SimpleJekyllSearch;window.SimpleJekyllSearch.createHighlightMiddleware=createHighlightMiddleware;window.SimpleJekyllSearch.createHighlightTemplateMiddleware=createHighlightTemplateMiddleware;window.SimpleJekyllSearch.highlightText=highlightText;window.SimpleJekyllSearch.defaultHighlightMiddleware=defaultHighlightMiddleware;window.SimpleJekyllSearch.defaultHighlightTemplateMiddleware=defaultHighlightTemplateMiddleware}exports2.createHighlightMiddleware=createHighlightMiddleware;exports2.createHighlightTemplateMiddleware=createHighlightTemplateMiddleware;exports2.default=SimpleJekyllSearch;exports2.defaultHighlightMiddleware=defaultHighlightMiddleware;exports2.defaultHighlightTemplateMiddleware=defaultHighlightTemplateMiddleware;exports2.highlightText=highlightText;Object.defineProperties(exports2,{__esModule:{value:true},[Symbol.toStringTag]:{value:"Module"}})}));
\ No newline at end of file
+(function(global,factory){typeof exports==="object"&&typeof module!=="undefined"?factory(exports):typeof define==="function"&&define.amd?define(["exports"],factory):(global=typeof globalThis!=="undefined"?globalThis:global||self,factory(global.SimpleJekyllSearch={}))})(this,(function(exports2){"use strict";function load(location,callback){const xhr=getXHR();xhr.open("GET",location,true);xhr.onreadystatechange=createStateChangeListener(xhr,callback);xhr.send()}function createStateChangeListener(xhr,callback){return function(){if(xhr.readyState===4&&xhr.status===200){try{callback(null,JSON.parse(xhr.responseText))}catch(err){callback(err instanceof Error?err:new Error(String(err)),null)}}}}function getXHR(){return window.XMLHttpRequest?new window.XMLHttpRequest:new window.ActiveXObject("Microsoft.XMLHTTP")}class OptionsValidator{constructor(params){if(!this.validateParams(params)){throw new Error("-- OptionsValidator: required options missing")}this.requiredOptions=params.required}getRequiredOptions(){return this.requiredOptions}validate(parameters){const errors=[];this.requiredOptions.forEach((requiredOptionName=>{if(typeof parameters[requiredOptionName]==="undefined"){errors.push(requiredOptionName)}}));return errors}validateParams(params){if(!params){return false}return typeof params.required!=="undefined"&&Array.isArray(params.required)}}function fuzzySearch(text,pattern){pattern=pattern.trimEnd();if(pattern.length===0)return true;pattern=pattern.toLowerCase();text=text.toLowerCase();let remainingText=text,currentIndex=-1;for(const char of pattern){const nextIndex=remainingText.indexOf(char);if(nextIndex===-1||currentIndex!==-1&&remainingText.slice(0,nextIndex).split(" ").length-1>2){return false}currentIndex=nextIndex;remainingText=remainingText.slice(nextIndex+1)}return true}function findFuzzyMatches$1(text,pattern){if(!text||!pattern)return[];const lowerText=text.toLowerCase();const lowerPattern=pattern.toLowerCase().trim();if(lowerPattern.length===0)return[];const patternWords=lowerPattern.split(/\s+/);const matches=[];for(const word of patternWords){if(word.length===0)continue;const wordMatches=findFuzzyWordMatches$1(lowerText,word);matches.push(...wordMatches)}return matches}function findFuzzyWordMatches$1(text,word){const matches=[];const exactRegex=new RegExp(`\\b${word.replace(/[.*+?^${}()|[\]\\]/g,"\\$&")}\\b`,"gi");let match;while((match=exactRegex.exec(text))!==null){matches.push({start:match.index,end:match.index+match[0].length,text:match[0],type:"exact"})}if(matches.length===0){for(let i=0;i<text.length;i++){const fuzzyMatch=findFuzzySequenceMatch$1(text,word,i);if(fuzzyMatch){matches.push({...fuzzyMatch,type:"fuzzy"});i=fuzzyMatch.end-1}}}return matches}function findFuzzySequenceMatch$1(text,pattern,startPos){let textIndex=startPos;let patternIndex=0;let matchStart=-1;let maxGap=3;const matchedPositions=[];while(textIndex<text.length&&patternIndex<pattern.length){if(text[textIndex]===pattern[patternIndex]){if(matchStart===-1){matchStart=textIndex}matchedPositions.push(textIndex);patternIndex++}else if(matchStart!==-1){if(textIndex-matchStart>maxGap*pattern.length){return null}}textIndex++}if(patternIndex===pattern.length&&matchStart!==-1&&matchedPositions.length>0){const actualStart=matchedPositions[0];const actualEnd=matchedPositions[matchedPositions.length-1]+1;return{start:actualStart,end:actualEnd,text:text.substring(actualStart,actualEnd)}}return null}function literalSearch(text,criteria){text=text.trim().toLowerCase();const pattern=criteria.endsWith(" ")?[criteria.toLowerCase()]:criteria.trim().toLowerCase().split(" ");return pattern.filter((word=>text.indexOf(word)>=0)).length===pattern.length}function findLiteralMatches(text,criteria){if(!text||!criteria)return[];const lowerText=text.toLowerCase();const words=criteria.trim().toLowerCase().split(/\s+/);const matches=[];let textIndex=0;for(const word of words){if(word.length===0)continue;const wordIndex=lowerText.indexOf(word,textIndex);if(wordIndex!==-1){matches.push({start:wordIndex,end:wordIndex+word.length,text:text.substring(wordIndex,wordIndex+word.length),type:"exact"});textIndex=wordIndex+word.length}}return matches}function levenshtein(a,b){const lenA=a.length;const lenB=b.length;const distanceMatrix=Array.from({length:lenA+1},(()=>Array(lenB+1).fill(0)));for(let i=0;i<=lenA;i++)distanceMatrix[i][0]=i;for(let j=0;j<=lenB;j++)distanceMatrix[0][j]=j;for(let i=1;i<=lenA;i++){for(let j=1;j<=lenB;j++){const cost=a[i-1]===b[j-1]?0:1;distanceMatrix[i][j]=Math.min(distanceMatrix[i-1][j]+1,distanceMatrix[i][j-1]+1,distanceMatrix[i-1][j-1]+cost)}}return distanceMatrix[lenA][lenB]}function levenshteinSearch(text,pattern){const distance=levenshtein(pattern,text);const similarity=1-distance/Math.max(pattern.length,text.length);return similarity>=.3}function findLevenshteinMatches(text,pattern){if(!text||!pattern)return[];const matches=[];const words=text.split(/\s+/);for(let i=0;i<words.length;i++){const word=words[i];if(levenshteinSearch(word,pattern)){const start=text.indexOf(word);matches.push({start:start,end:start+word.length,text:word,type:"wildcard"})}}return matches}function wildcardSearch(text,pattern){const regexPattern=pattern.replace(/\*/g,".*");const regex=new RegExp(`^${regexPattern}$`,"i");if(regex.test(text))return true;return levenshteinSearch(text,pattern)}function findWildcardMatches(text,pattern){if(!text||!pattern)return[];const wildcardMatches=findWildcardPatternMatches(text,pattern);if(wildcardMatches.length>0){return wildcardMatches}return findLevenshteinMatches(text,pattern)}function findWildcardPatternMatches(text,pattern){const matches=[];const regexPattern=pattern.replace(/\*/g,".*");const regex=new RegExp(regexPattern,"gi");let match;while((match=regex.exec(text))!==null){matches.push({start:match.index,end:match.index+match[0].length,text:match[0],type:"wildcard"})}return matches}class SearchStrategy{constructor(matchFunction,findMatchesFunction){this.matchFunction=matchFunction;this.findMatchesFunction=findMatchesFunction}matches(text,criteria){if(text===null||text.trim()===""||!criteria){return false}return this.matchFunction(text,criteria)}findMatches(text,criteria){if(text===null||text.trim()===""||!criteria||!this.findMatchesFunction){return[]}return this.findMatchesFunction(text,criteria)}}const LiteralSearchStrategy=new SearchStrategy(literalSearch,findLiteralMatches);const FuzzySearchStrategy=new SearchStrategy(((text,criteria)=>fuzzySearch(text,criteria)||literalSearch(text,criteria)),((text,criteria)=>{const fuzzyMatches=findFuzzyMatches$1(text,criteria);if(fuzzyMatches.length>0){return fuzzyMatches}return findLiteralMatches(text,criteria)}));const WildcardSearchStrategy=new SearchStrategy(((text,criteria)=>wildcardSearch(text,criteria)||literalSearch(text,criteria)),((text,criteria)=>{const wildcardMatches=findWildcardMatches(text,criteria);if(wildcardMatches.length>0){return wildcardMatches}return findLiteralMatches(text,criteria)}));function merge(target,source){return{...target,...source}}function isJSON(json){try{return!!(json instanceof Object&&JSON.parse(JSON.stringify(json)))}catch(_err){return false}}function NoSort(){return 0}function isObject(obj){return Boolean(obj)&&Object.prototype.toString.call(obj)==="[object Object]"}function clone(input){if(input===null||typeof input!=="object"){return input}if(Array.isArray(input)){return input.map((item=>clone(item)))}const output={};for(const key in input){if(Object.prototype.hasOwnProperty.call(input,key)){output[key]=clone(input[key])}}return output}const DEFAULT_OPTIONS={searchInput:null,resultsContainer:null,json:[],success:function(){},searchResultTemplate:'<li><a href="{url}" title="{desc}">{title}</a></li>',templateMiddleware:(_prop,_value,_template,_query)=>void 0,sortMiddleware:NoSort,noResultsText:"No results found",limit:10,fuzzy:false,strategy:"literal",debounceTime:null,exclude:[],onSearch:()=>{}};const REQUIRED_OPTIONS=["searchInput","resultsContainer","json"];const WHITELISTED_KEYS=new Set(["Enter","Shift","CapsLock","ArrowLeft","ArrowUp","ArrowRight","ArrowDown","Meta"]);class Repository{constructor(initialOptions={}){this.data=[];this.setOptions(initialOptions)}put(input){if(isObject(input)){return this.addObject(input)}if(Array.isArray(input)){return this.addArray(input)}return void 0}clear(){this.data.length=0;return this.data}search(criteria){if(!criteria){return[]}return clone(this.findMatches(this.data,criteria).sort(this.options.sortMiddleware))}setOptions(newOptions){this.options={fuzzy:(newOptions==null?void 0:newOptions.fuzzy)||DEFAULT_OPTIONS.fuzzy,limit:(newOptions==null?void 0:newOptions.limit)||DEFAULT_OPTIONS.limit,searchStrategy:this.searchStrategy((newOptions==null?void 0:newOptions.strategy)||newOptions.fuzzy&&"fuzzy"||DEFAULT_OPTIONS.strategy),sortMiddleware:(newOptions==null?void 0:newOptions.sortMiddleware)||DEFAULT_OPTIONS.sortMiddleware,exclude:(newOptions==null?void 0:newOptions.exclude)||DEFAULT_OPTIONS.exclude,strategy:(newOptions==null?void 0:newOptions.strategy)||DEFAULT_OPTIONS.strategy}}addObject(obj){this.data.push(obj);return this.data}addArray(arr){const added=[];this.clear();for(const item of arr){if(isObject(item)){added.push(this.addObject(item)[0])}}return added}findMatches(data,criteria){const matches=[];for(let i=0;i<data.length&&matches.length<this.options.limit;i++){const match=this.findMatchesInObject(data[i],criteria);if(match){matches.push(match)}}return matches}findMatchesInObject(obj,criteria){var _a,_b;for(const key in obj){if(!this.isExcluded(obj[key])&&this.options.searchStrategy.matches(obj[key],criteria)){const matchInfo=(_b=(_a=this.options.searchStrategy).findMatches)==null?void 0:_b.call(_a,obj[key],criteria);const result={...obj};if(matchInfo&&matchInfo.length>0){result._matchInfo={[key]:matchInfo}}return result}}return void 0}isExcluded(term){for(const excludedTerm of this.options.exclude){if(new RegExp(excludedTerm).test(String(term))){return true}}return false}searchStrategy(strategy){switch(strategy){case"fuzzy":return FuzzySearchStrategy;case"wildcard":return WildcardSearchStrategy;default:return LiteralSearchStrategy}}}const options={pattern:/\{(.*?)\}/g,template:"",middleware:function(){return void 0}};function setOptions(_options){if(_options.pattern){options.pattern=_options.pattern}if(_options.template){options.template=_options.template}if(typeof _options.middleware==="function"){options.middleware=_options.middleware}}function compile(data,query){return options.template.replace(options.pattern,(function(match,prop){if(options.middleware.length>=5&&data._matchInfo&&data._matchInfo[prop]){const value2=options.middleware(prop,data[prop],options.template,query,data._matchInfo[prop]);if(typeof value2!=="undefined"){return value2}}const value=options.middleware(prop,data[prop],options.template,query);if(typeof value!=="undefined"){return value}return data[prop]||match}))}let SimpleJekyllSearch$1=class SimpleJekyllSearch{constructor(){this.debounceTimerHandle=null;this.options={...DEFAULT_OPTIONS};this.repository=new Repository;this.optionsValidator=new OptionsValidator({required:REQUIRED_OPTIONS})}debounce(func,delayMillis){if(delayMillis){if(this.debounceTimerHandle){clearTimeout(this.debounceTimerHandle)}this.debounceTimerHandle=setTimeout(func,delayMillis)}else{func()}}throwError(message){throw new Error(`SimpleJekyllSearch --- ${message}`)}emptyResultsContainer(){this.options.resultsContainer.innerHTML=""}initWithJSON(json){this.repository.put(json);this.registerInput()}initWithURL(url){load(url,((err,json)=>{if(err){this.throwError(`Failed to load JSON from ${url}: ${err.message}`)}this.initWithJSON(json)}))}registerInput(){this.options.searchInput.addEventListener("input",(e=>{const inputEvent=e;if(!WHITELISTED_KEYS.has(inputEvent.key)){this.emptyResultsContainer();this.debounce((()=>{this.search(e.target.value)}),this.options.debounceTime??null)}}))}search(query){var _a,_b;if((query==null?void 0:query.trim().length)>0){this.emptyResultsContainer();const results=this.repository.search(query);this.render(results,query);(_b=(_a=this.options).onSearch)==null?void 0:_b.call(_a)}}render(results,query){if(results.length===0){this.options.resultsContainer.insertAdjacentHTML("beforeend",this.options.noResultsText);return}const fragment=document.createDocumentFragment();results.forEach((result=>{result.query=query;const div=document.createElement("div");div.innerHTML=compile(result,query);fragment.appendChild(div)}));this.options.resultsContainer.appendChild(fragment)}init(_options){var _a;const errors=this.optionsValidator.validate(_options);if(errors.length>0){this.throwError(`Missing required options: ${REQUIRED_OPTIONS.join(", ")}`)}this.options=merge(this.options,_options);setOptions({template:this.options.searchResultTemplate,middleware:this.options.templateMiddleware});this.repository.setOptions({fuzzy:this.options.fuzzy,limit:this.options.limit,sortMiddleware:this.options.sortMiddleware,strategy:this.options.strategy,exclude:this.options.exclude});if(isJSON(this.options.json)){this.initWithJSON(this.options.json)}else{this.initWithURL(this.options.json)}const rv={search:this.search.bind(this)};(_a=this.options.success)==null?void 0:_a.call(rv);return rv}};function createHighlightMiddleware(options2={}){const{highlightClass:highlightClass="sjs-highlight",contextBefore:contextBefore=50,contextAfter:contextAfter=50,maxLength:maxLength=250,ellipsis:ellipsis="..."}=options2;return function(result,query){if(!query||!result){return result}const highlightedResult={...result};const textFields=["title","desc","content","excerpt"];for(const field of textFields){if(highlightedResult[field]&&typeof highlightedResult[field]==="string"){const highlighted=highlightText(highlightedResult[field],query,{highlightClass:highlightClass,contextBefore:contextBefore,contextAfter:contextAfter,maxLength:maxLength,ellipsis:ellipsis});if(highlighted.highlightedText!==highlightedResult[field]){highlightedResult[field]=highlighted.highlightedText}}}return highlightedResult}}function highlightText(text,query,options2={}){const{highlightClass:highlightClass="sjs-highlight",contextBefore:contextBefore=50,contextAfter:contextAfter=50,maxLength:maxLength=250,ellipsis:ellipsis="..."}=options2;if(!text||!query){return{highlightedText:text,matchCount:0}}const originalText=text;const searchTerms=query.trim().toLowerCase().split(/\s+/).filter((term=>term.length>0));if(searchTerms.length===0){return{highlightedText:text,matchCount:0}}const matches=[];for(const term of searchTerms){let index=0;while(index<text.length){const found=text.toLowerCase().indexOf(term,index);if(found===-1)break;matches.push({start:found,end:found+term.length,term:text.substring(found,found+term.length)});index=found+1}}if(matches.length===0){return{highlightedText:text,matchCount:0}}matches.sort(((a,b)=>a.start-b.start));const mergedMatches=[];for(const match of matches){if(mergedMatches.length===0||mergedMatches[mergedMatches.length-1].end<match.start){mergedMatches.push(match)}else{const lastMatch=mergedMatches[mergedMatches.length-1];lastMatch.end=Math.max(lastMatch.end,match.end);lastMatch.term=text.substring(lastMatch.start,lastMatch.end)}}if(text.length<=maxLength){let highlightedText2=text;for(let i=mergedMatches.length-1;i>=0;i--){const match=mergedMatches[i];const before=highlightedText2.substring(0,match.start);const after=highlightedText2.substring(match.end);const matchText=highlightedText2.substring(match.start,match.end);highlightedText2=before+`<span class="${highlightClass}">${matchText}</span>`+after}return{highlightedText:highlightedText2,matchCount:mergedMatches.length}}let highlightedText="";let totalLength=0;let lastEnd=0;for(let i=0;i<mergedMatches.length;i++){const match=mergedMatches[i];const contextStart=Math.max(lastEnd,match.start-contextBefore);const contextEnd=Math.min(text.length,match.end+contextAfter);if(contextStart>lastEnd&&lastEnd>0){highlightedText+=ellipsis;totalLength+=ellipsis.length}if(contextStart<match.start){const beforeText=text.substring(contextStart,match.start);highlightedText+=beforeText;totalLength+=beforeText.length}const matchText=text.substring(match.start,match.end);highlightedText+=`<span class="${highlightClass}">${matchText}</span>`;totalLength+=matchText.length;if(match.end<contextEnd){const afterText=text.substring(match.end,contextEnd);highlightedText+=afterText;totalLength+=afterText.length}lastEnd=contextEnd;if(totalLength>=maxLength){if(contextEnd<text.length){highlightedText+=ellipsis}break}}return{highlightedText:highlightedText||originalText,matchCount:mergedMatches.length}}const defaultHighlightMiddleware=createHighlightMiddleware();function findFuzzyMatches(text,pattern){const matches=[];const lowerText=text.toLowerCase();const lowerPattern=pattern.toLowerCase().trim();if(lowerPattern.length===0)return matches;const patternWords=lowerPattern.split(/\s+/);for(const word of patternWords){if(word.length===0)continue;const wordMatches=findFuzzyWordMatches(lowerText,word);matches.push(...wordMatches)}return matches}function findFuzzyWordMatches(text,word){const matches=[];const exactRegex=new RegExp(`\\b${word.replace(/[.*+?^${}()|[\]\\]/g,"\\$&")}\\b`,"gi");let match;while((match=exactRegex.exec(text))!==null){matches.push({start:match.index,end:match.index+match[0].length,text:match[0]})}if(matches.length===0){for(let i=0;i<text.length;i++){const fuzzyMatch=findFuzzySequenceMatch(text,word,i);if(fuzzyMatch){matches.push(fuzzyMatch);i=fuzzyMatch.end-1}}}return matches}function findFuzzySequenceMatch(text,pattern,startPos){let textIndex=startPos;let patternIndex=0;let matchStart=-1;let maxGap=3;const matchedPositions=[];while(textIndex<text.length&&patternIndex<pattern.length){if(text[textIndex]===pattern[patternIndex]){if(matchStart===-1){matchStart=textIndex}matchedPositions.push(textIndex);patternIndex++}else if(matchStart!==-1){if(textIndex-matchStart>maxGap*pattern.length){return null}}textIndex++}if(patternIndex===pattern.length&&matchStart!==-1&&matchedPositions.length>0){const actualStart=matchedPositions[0];const actualEnd=matchedPositions[matchedPositions.length-1]+1;return{start:actualStart,end:actualEnd,text:text.substring(actualStart,actualEnd)}}return null}function createHighlightTemplateMiddleware(options2={}){const highlightOptions={highlightClass:"sjs-highlight",...options2};return function(prop,value,_template,query){if((prop==="content"||prop==="desc")&&query&&typeof value==="string"){let highlightedText=value;let hasMatches=false;const searchTerms=query.trim().split(/\s+/).filter((term=>term.length>0));for(const term of searchTerms){const regex=new RegExp(`\\b(${term.replace(/[.*+?^${}()|[\]\\]/g,"\\$&")})\\b`,"gi");if(regex.test(highlightedText)){highlightedText=highlightedText.replace(regex,`<span class="${highlightOptions.highlightClass}">$1</span>`);hasMatches=true}}if(!hasMatches){const fuzzyMatches=findFuzzyMatches(value,query);if(fuzzyMatches.length>0){fuzzyMatches.sort(((a,b)=>b.start-a.start));for(const match of fuzzyMatches){const before=highlightedText.substring(0,match.start);const after=highlightedText.substring(match.end);const matchText=highlightedText.substring(match.start,match.end);highlightedText=before+`<span class="${highlightOptions.highlightClass}">${matchText}</span>`+after}hasMatches=true}}if(hasMatches){return highlightedText}}return void 0}}const defaultHighlightTemplateMiddleware=createHighlightTemplateMiddleware();function SimpleJekyllSearch(options2){const instance=new SimpleJekyllSearch$1;return instance.init(options2)}if(typeof window!=="undefined"){window.SimpleJekyllSearch=SimpleJekyllSearch;window.SimpleJekyllSearch.createHighlightMiddleware=createHighlightMiddleware;window.SimpleJekyllSearch.createHighlightTemplateMiddleware=createHighlightTemplateMiddleware;window.SimpleJekyllSearch.highlightText=highlightText;window.SimpleJekyllSearch.defaultHighlightMiddleware=defaultHighlightMiddleware;window.SimpleJekyllSearch.defaultHighlightTemplateMiddleware=defaultHighlightTemplateMiddleware}exports2.createHighlightMiddleware=createHighlightMiddleware;exports2.createHighlightTemplateMiddleware=createHighlightTemplateMiddleware;exports2.default=SimpleJekyllSearch;exports2.defaultHighlightMiddleware=defaultHighlightMiddleware;exports2.defaultHighlightTemplateMiddleware=defaultHighlightTemplateMiddleware;exports2.highlightText=highlightText;Object.defineProperties(exports2,{__esModule:{value:true},[Symbol.toStringTag]:{value:"Module"}})}));
\ No newline at end of file
diff --git a/docs/assets/js/simple-jekyll-search.min.js b/docs/assets/js/simple-jekyll-search.min.js
index 62446e1..84bfcd8 100644
--- a/docs/assets/js/simple-jekyll-search.min.js
+++ b/docs/assets/js/simple-jekyll-search.min.js
@@ -4,4 +4,4 @@
   * Copyright 2025-2025, Sylhare
   * Licensed under the MIT License.
   */
-(function(global,factory){typeof exports==="object"&&typeof module!=="undefined"?factory(exports):typeof define==="function"&&define.amd?define(["exports"],factory):(global=typeof globalThis!=="undefined"?globalThis:global||self,factory(global.SimpleJekyllSearch={}))})(this,(function(exports2){"use strict";function load(location,callback){const xhr=getXHR();xhr.open("GET",location,true);xhr.onreadystatechange=createStateChangeListener(xhr,callback);xhr.send()}function createStateChangeListener(xhr,callback){return function(){if(xhr.readyState===4&&xhr.status===200){try{callback(null,JSON.parse(xhr.responseText))}catch(err){callback(err instanceof Error?err:new Error(String(err)),null)}}}}function getXHR(){return window.XMLHttpRequest?new window.XMLHttpRequest:new window.ActiveXObject("Microsoft.XMLHTTP")}class OptionsValidator{constructor(params){if(!this.validateParams(params)){throw new Error("-- OptionsValidator: required options missing")}this.requiredOptions=params.required}getRequiredOptions(){return this.requiredOptions}validate(parameters){const errors=[];this.requiredOptions.forEach((requiredOptionName=>{if(typeof parameters[requiredOptionName]==="undefined"){errors.push(requiredOptionName)}}));return errors}validateParams(params){if(!params){return false}return typeof params.required!=="undefined"&&Array.isArray(params.required)}}function fuzzySearch(text,pattern){pattern=pattern.trimEnd();if(pattern.length===0)return true;pattern=pattern.toLowerCase();text=text.toLowerCase();let remainingText=text,currentIndex=-1;for(const char of pattern){const nextIndex=remainingText.indexOf(char);if(nextIndex===-1||currentIndex!==-1&&remainingText.slice(0,nextIndex).split(" ").length-1>2){return false}currentIndex=nextIndex;remainingText=remainingText.slice(nextIndex+1)}return true}function literalSearch(text,criteria){text=text.trim().toLowerCase();const pattern=criteria.endsWith(" ")?[criteria.toLowerCase()]:criteria.trim().toLowerCase().split(" ");return pattern.filter((word=>text.indexOf(word)>=0)).length===pattern.length}function levenshtein(a,b){const lenA=a.length;const lenB=b.length;const distanceMatrix=Array.from({length:lenA+1},(()=>Array(lenB+1).fill(0)));for(let i=0;i<=lenA;i++)distanceMatrix[i][0]=i;for(let j=0;j<=lenB;j++)distanceMatrix[0][j]=j;for(let i=1;i<=lenA;i++){for(let j=1;j<=lenB;j++){const cost=a[i-1]===b[j-1]?0:1;distanceMatrix[i][j]=Math.min(distanceMatrix[i-1][j]+1,distanceMatrix[i][j-1]+1,distanceMatrix[i-1][j-1]+cost)}}return distanceMatrix[lenA][lenB]}function levenshteinSearch(text,pattern){const distance=levenshtein(pattern,text);const similarity=1-distance/Math.max(pattern.length,text.length);return similarity>=.3}function wildcardSearch(text,pattern){const regexPattern=pattern.replace(/\*/g,".*");const regex=new RegExp(`^${regexPattern}$`,"i");if(regex.test(text))return true;return levenshteinSearch(text,pattern)}class SearchStrategy{constructor(matchFunction){this.matchFunction=matchFunction}matches(text,criteria){if(text===null||text.trim()===""||!criteria){return false}return this.matchFunction(text,criteria)}}const LiteralSearchStrategy=new SearchStrategy(literalSearch);const FuzzySearchStrategy=new SearchStrategy(((text,criteria)=>fuzzySearch(text,criteria)||literalSearch(text,criteria)));const WildcardSearchStrategy=new SearchStrategy(((text,criteria)=>wildcardSearch(text,criteria)||literalSearch(text,criteria)));function merge(target,source){return{...target,...source}}function isJSON(json){try{return!!(json instanceof Object&&JSON.parse(JSON.stringify(json)))}catch(_err){return false}}function NoSort(){return 0}function isObject(obj){return Boolean(obj)&&Object.prototype.toString.call(obj)==="[object Object]"}function clone(input){if(input===null||typeof input!=="object"){return input}if(Array.isArray(input)){return input.map((item=>clone(item)))}const output={};for(const key in input){if(Object.prototype.hasOwnProperty.call(input,key)){output[key]=clone(input[key])}}return output}const DEFAULT_OPTIONS={searchInput:null,resultsContainer:null,json:[],success:function(){},searchResultTemplate:'<li><a href="{url}" title="{desc}">{title}</a></li>',templateMiddleware:(_prop,_value,_template,_query)=>void 0,sortMiddleware:NoSort,noResultsText:"No results found",limit:10,fuzzy:false,strategy:"literal",debounceTime:null,exclude:[],onSearch:()=>{}};const REQUIRED_OPTIONS=["searchInput","resultsContainer","json"];const WHITELISTED_KEYS=new Set(["Enter","Shift","CapsLock","ArrowLeft","ArrowUp","ArrowRight","ArrowDown","Meta"]);class Repository{constructor(initialOptions={}){this.data=[];this.setOptions(initialOptions)}put(input){if(isObject(input)){return this.addObject(input)}if(Array.isArray(input)){return this.addArray(input)}return void 0}clear(){this.data.length=0;return this.data}search(criteria){if(!criteria){return[]}return clone(this.findMatches(this.data,criteria).sort(this.options.sortMiddleware))}setOptions(newOptions){this.options={fuzzy:(newOptions==null?void 0:newOptions.fuzzy)||DEFAULT_OPTIONS.fuzzy,limit:(newOptions==null?void 0:newOptions.limit)||DEFAULT_OPTIONS.limit,searchStrategy:this.searchStrategy((newOptions==null?void 0:newOptions.strategy)||newOptions.fuzzy&&"fuzzy"||DEFAULT_OPTIONS.strategy),sortMiddleware:(newOptions==null?void 0:newOptions.sortMiddleware)||DEFAULT_OPTIONS.sortMiddleware,exclude:(newOptions==null?void 0:newOptions.exclude)||DEFAULT_OPTIONS.exclude,strategy:(newOptions==null?void 0:newOptions.strategy)||DEFAULT_OPTIONS.strategy}}addObject(obj){this.data.push(obj);return this.data}addArray(arr){const added=[];this.clear();for(const item of arr){if(isObject(item)){added.push(this.addObject(item)[0])}}return added}findMatches(data,criteria){const matches=[];for(let i=0;i<data.length&&matches.length<this.options.limit;i++){const match=this.findMatchesInObject(data[i],criteria);if(match){matches.push(match)}}return matches}findMatchesInObject(obj,criteria){for(const key in obj){if(!this.isExcluded(obj[key])&&this.options.searchStrategy.matches(obj[key],criteria)){return obj}}return void 0}isExcluded(term){for(const excludedTerm of this.options.exclude){if(new RegExp(excludedTerm).test(String(term))){return true}}return false}searchStrategy(strategy){switch(strategy){case"fuzzy":return FuzzySearchStrategy;case"wildcard":return WildcardSearchStrategy;default:return LiteralSearchStrategy}}}const options={pattern:/\{(.*?)\}/g,template:"",middleware:function(){return void 0}};function setOptions(_options){if(_options.pattern){options.pattern=_options.pattern}if(_options.template){options.template=_options.template}if(typeof _options.middleware==="function"){options.middleware=_options.middleware}}function compile(data,query){return options.template.replace(options.pattern,(function(match,prop){const value=options.middleware(prop,data[prop],options.template,query);if(typeof value!=="undefined"){return value}return data[prop]||match}))}let SimpleJekyllSearch$1=class SimpleJekyllSearch{constructor(){this.debounceTimerHandle=null;this.options={...DEFAULT_OPTIONS};this.repository=new Repository;this.optionsValidator=new OptionsValidator({required:REQUIRED_OPTIONS})}debounce(func,delayMillis){if(delayMillis){if(this.debounceTimerHandle){clearTimeout(this.debounceTimerHandle)}this.debounceTimerHandle=setTimeout(func,delayMillis)}else{func()}}throwError(message){throw new Error(`SimpleJekyllSearch --- ${message}`)}emptyResultsContainer(){this.options.resultsContainer.innerHTML=""}initWithJSON(json){this.repository.put(json);this.registerInput()}initWithURL(url){load(url,((err,json)=>{if(err){this.throwError(`Failed to load JSON from ${url}: ${err.message}`)}this.initWithJSON(json)}))}registerInput(){this.options.searchInput.addEventListener("input",(e=>{const inputEvent=e;if(!WHITELISTED_KEYS.has(inputEvent.key)){this.emptyResultsContainer();this.debounce((()=>{this.search(e.target.value)}),this.options.debounceTime??null)}}))}search(query){var _a,_b;if((query==null?void 0:query.trim().length)>0){this.emptyResultsContainer();const results=this.repository.search(query);this.render(results,query);(_b=(_a=this.options).onSearch)==null?void 0:_b.call(_a)}}render(results,query){if(results.length===0){this.options.resultsContainer.insertAdjacentHTML("beforeend",this.options.noResultsText);return}const fragment=document.createDocumentFragment();results.forEach((result=>{result.query=query;const div=document.createElement("div");div.innerHTML=compile(result,query);fragment.appendChild(div)}));this.options.resultsContainer.appendChild(fragment)}init(_options){var _a;const errors=this.optionsValidator.validate(_options);if(errors.length>0){this.throwError(`Missing required options: ${REQUIRED_OPTIONS.join(", ")}`)}this.options=merge(this.options,_options);setOptions({template:this.options.searchResultTemplate,middleware:this.options.templateMiddleware});this.repository.setOptions({fuzzy:this.options.fuzzy,limit:this.options.limit,sortMiddleware:this.options.sortMiddleware,strategy:this.options.strategy,exclude:this.options.exclude});if(isJSON(this.options.json)){this.initWithJSON(this.options.json)}else{this.initWithURL(this.options.json)}const rv={search:this.search.bind(this)};(_a=this.options.success)==null?void 0:_a.call(rv);return rv}};function createHighlightMiddleware(options2={}){const{highlightClass:highlightClass="sjs-highlight",contextBefore:contextBefore=50,contextAfter:contextAfter=50,maxLength:maxLength=250,ellipsis:ellipsis="..."}=options2;return function(result,query){if(!query||!result){return result}const highlightedResult={...result};const textFields=["title","desc","content","excerpt"];for(const field of textFields){if(highlightedResult[field]&&typeof highlightedResult[field]==="string"){const highlighted=highlightText(highlightedResult[field],query,{highlightClass:highlightClass,contextBefore:contextBefore,contextAfter:contextAfter,maxLength:maxLength,ellipsis:ellipsis});if(highlighted.highlightedText!==highlightedResult[field]){highlightedResult[field]=highlighted.highlightedText}}}return highlightedResult}}function highlightText(text,query,options2={}){const{highlightClass:highlightClass="sjs-highlight",contextBefore:contextBefore=50,contextAfter:contextAfter=50,maxLength:maxLength=250,ellipsis:ellipsis="..."}=options2;if(!text||!query){return{highlightedText:text,matchCount:0}}const originalText=text;const searchTerms=query.trim().toLowerCase().split(/\s+/).filter((term=>term.length>0));if(searchTerms.length===0){return{highlightedText:text,matchCount:0}}const matches=[];for(const term of searchTerms){let index=0;while(index<text.length){const found=text.toLowerCase().indexOf(term,index);if(found===-1)break;matches.push({start:found,end:found+term.length,term:text.substring(found,found+term.length)});index=found+1}}if(matches.length===0){return{highlightedText:text,matchCount:0}}matches.sort(((a,b)=>a.start-b.start));const mergedMatches=[];for(const match of matches){if(mergedMatches.length===0||mergedMatches[mergedMatches.length-1].end<match.start){mergedMatches.push(match)}else{const lastMatch=mergedMatches[mergedMatches.length-1];lastMatch.end=Math.max(lastMatch.end,match.end);lastMatch.term=text.substring(lastMatch.start,lastMatch.end)}}if(text.length<=maxLength){let highlightedText2=text;for(let i=mergedMatches.length-1;i>=0;i--){const match=mergedMatches[i];const before=highlightedText2.substring(0,match.start);const after=highlightedText2.substring(match.end);const matchText=highlightedText2.substring(match.start,match.end);highlightedText2=before+`<span class="${highlightClass}">${matchText}</span>`+after}return{highlightedText:highlightedText2,matchCount:mergedMatches.length}}let highlightedText="";let totalLength=0;let lastEnd=0;for(let i=0;i<mergedMatches.length;i++){const match=mergedMatches[i];const contextStart=Math.max(lastEnd,match.start-contextBefore);const contextEnd=Math.min(text.length,match.end+contextAfter);if(contextStart>lastEnd&&lastEnd>0){highlightedText+=ellipsis;totalLength+=ellipsis.length}if(contextStart<match.start){const beforeText=text.substring(contextStart,match.start);highlightedText+=beforeText;totalLength+=beforeText.length}const matchText=text.substring(match.start,match.end);highlightedText+=`<span class="${highlightClass}">${matchText}</span>`;totalLength+=matchText.length;if(match.end<contextEnd){const afterText=text.substring(match.end,contextEnd);highlightedText+=afterText;totalLength+=afterText.length}lastEnd=contextEnd;if(totalLength>=maxLength){if(contextEnd<text.length){highlightedText+=ellipsis}break}}return{highlightedText:highlightedText||originalText,matchCount:mergedMatches.length}}const defaultHighlightMiddleware=createHighlightMiddleware();function findFuzzyMatches(text,pattern){const matches=[];const lowerText=text.toLowerCase();const lowerPattern=pattern.toLowerCase().trim();if(lowerPattern.length===0)return matches;const patternWords=lowerPattern.split(/\s+/);for(const word of patternWords){if(word.length===0)continue;const wordMatches=findFuzzyWordMatches(lowerText,word);matches.push(...wordMatches)}return matches}function findFuzzyWordMatches(text,word){const matches=[];const exactRegex=new RegExp(`\\b${word.replace(/[.*+?^${}()|[\]\\]/g,"\\$&")}\\b`,"gi");let match;while((match=exactRegex.exec(text))!==null){matches.push({start:match.index,end:match.index+match[0].length,text:match[0]})}if(matches.length===0){for(let i=0;i<text.length;i++){const fuzzyMatch=findFuzzySequenceMatch(text,word,i);if(fuzzyMatch){matches.push(fuzzyMatch);i=fuzzyMatch.end-1}}}return matches}function findFuzzySequenceMatch(text,pattern,startPos){let textIndex=startPos;let patternIndex=0;let matchStart=-1;let maxGap=3;const matchedPositions=[];while(textIndex<text.length&&patternIndex<pattern.length){if(text[textIndex]===pattern[patternIndex]){if(matchStart===-1){matchStart=textIndex}matchedPositions.push(textIndex);patternIndex++}else if(matchStart!==-1){if(textIndex-matchStart>maxGap*pattern.length){return null}}textIndex++}if(patternIndex===pattern.length&&matchStart!==-1&&matchedPositions.length>0){const actualStart=matchedPositions[0];const actualEnd=matchedPositions[matchedPositions.length-1]+1;return{start:actualStart,end:actualEnd,text:text.substring(actualStart,actualEnd)}}return null}function createHighlightTemplateMiddleware(options2={}){const highlightOptions={highlightClass:"sjs-highlight",...options2};return function(prop,value,_template,query){if((prop==="content"||prop==="desc")&&query&&typeof value==="string"){let highlightedText=value;let hasMatches=false;const searchTerms=query.trim().split(/\s+/).filter((term=>term.length>0));for(const term of searchTerms){const regex=new RegExp(`\\b(${term.replace(/[.*+?^${}()|[\]\\]/g,"\\$&")})\\b`,"gi");if(regex.test(highlightedText)){highlightedText=highlightedText.replace(regex,`<span class="${highlightOptions.highlightClass}">$1</span>`);hasMatches=true}}if(!hasMatches){const fuzzyMatches=findFuzzyMatches(value,query);if(fuzzyMatches.length>0){fuzzyMatches.sort(((a,b)=>b.start-a.start));for(const match of fuzzyMatches){const before=highlightedText.substring(0,match.start);const after=highlightedText.substring(match.end);const matchText=highlightedText.substring(match.start,match.end);highlightedText=before+`<span class="${highlightOptions.highlightClass}">${matchText}</span>`+after}hasMatches=true}}if(hasMatches){return highlightedText}}return void 0}}const defaultHighlightTemplateMiddleware=createHighlightTemplateMiddleware();function SimpleJekyllSearch(options2){const instance=new SimpleJekyllSearch$1;return instance.init(options2)}if(typeof window!=="undefined"){window.SimpleJekyllSearch=SimpleJekyllSearch;window.SimpleJekyllSearch.createHighlightMiddleware=createHighlightMiddleware;window.SimpleJekyllSearch.createHighlightTemplateMiddleware=createHighlightTemplateMiddleware;window.SimpleJekyllSearch.highlightText=highlightText;window.SimpleJekyllSearch.defaultHighlightMiddleware=defaultHighlightMiddleware;window.SimpleJekyllSearch.defaultHighlightTemplateMiddleware=defaultHighlightTemplateMiddleware}exports2.createHighlightMiddleware=createHighlightMiddleware;exports2.createHighlightTemplateMiddleware=createHighlightTemplateMiddleware;exports2.default=SimpleJekyllSearch;exports2.defaultHighlightMiddleware=defaultHighlightMiddleware;exports2.defaultHighlightTemplateMiddleware=defaultHighlightTemplateMiddleware;exports2.highlightText=highlightText;Object.defineProperties(exports2,{__esModule:{value:true},[Symbol.toStringTag]:{value:"Module"}})}));
\ No newline at end of file
+(function(global,factory){typeof exports==="object"&&typeof module!=="undefined"?factory(exports):typeof define==="function"&&define.amd?define(["exports"],factory):(global=typeof globalThis!=="undefined"?globalThis:global||self,factory(global.SimpleJekyllSearch={}))})(this,(function(exports2){"use strict";function load(location,callback){const xhr=getXHR();xhr.open("GET",location,true);xhr.onreadystatechange=createStateChangeListener(xhr,callback);xhr.send()}function createStateChangeListener(xhr,callback){return function(){if(xhr.readyState===4&&xhr.status===200){try{callback(null,JSON.parse(xhr.responseText))}catch(err){callback(err instanceof Error?err:new Error(String(err)),null)}}}}function getXHR(){return window.XMLHttpRequest?new window.XMLHttpRequest:new window.ActiveXObject("Microsoft.XMLHTTP")}class OptionsValidator{constructor(params){if(!this.validateParams(params)){throw new Error("-- OptionsValidator: required options missing")}this.requiredOptions=params.required}getRequiredOptions(){return this.requiredOptions}validate(parameters){const errors=[];this.requiredOptions.forEach((requiredOptionName=>{if(typeof parameters[requiredOptionName]==="undefined"){errors.push(requiredOptionName)}}));return errors}validateParams(params){if(!params){return false}return typeof params.required!=="undefined"&&Array.isArray(params.required)}}function fuzzySearch(text,pattern){pattern=pattern.trimEnd();if(pattern.length===0)return true;pattern=pattern.toLowerCase();text=text.toLowerCase();let remainingText=text,currentIndex=-1;for(const char of pattern){const nextIndex=remainingText.indexOf(char);if(nextIndex===-1||currentIndex!==-1&&remainingText.slice(0,nextIndex).split(" ").length-1>2){return false}currentIndex=nextIndex;remainingText=remainingText.slice(nextIndex+1)}return true}function findFuzzyMatches$1(text,pattern){if(!text||!pattern)return[];const lowerText=text.toLowerCase();const lowerPattern=pattern.toLowerCase().trim();if(lowerPattern.length===0)return[];const patternWords=lowerPattern.split(/\s+/);const matches=[];for(const word of patternWords){if(word.length===0)continue;const wordMatches=findFuzzyWordMatches$1(lowerText,word);matches.push(...wordMatches)}return matches}function findFuzzyWordMatches$1(text,word){const matches=[];const exactRegex=new RegExp(`\\b${word.replace(/[.*+?^${}()|[\]\\]/g,"\\$&")}\\b`,"gi");let match;while((match=exactRegex.exec(text))!==null){matches.push({start:match.index,end:match.index+match[0].length,text:match[0],type:"exact"})}if(matches.length===0){for(let i=0;i<text.length;i++){const fuzzyMatch=findFuzzySequenceMatch$1(text,word,i);if(fuzzyMatch){matches.push({...fuzzyMatch,type:"fuzzy"});i=fuzzyMatch.end-1}}}return matches}function findFuzzySequenceMatch$1(text,pattern,startPos){let textIndex=startPos;let patternIndex=0;let matchStart=-1;let maxGap=3;const matchedPositions=[];while(textIndex<text.length&&patternIndex<pattern.length){if(text[textIndex]===pattern[patternIndex]){if(matchStart===-1){matchStart=textIndex}matchedPositions.push(textIndex);patternIndex++}else if(matchStart!==-1){if(textIndex-matchStart>maxGap*pattern.length){return null}}textIndex++}if(patternIndex===pattern.length&&matchStart!==-1&&matchedPositions.length>0){const actualStart=matchedPositions[0];const actualEnd=matchedPositions[matchedPositions.length-1]+1;return{start:actualStart,end:actualEnd,text:text.substring(actualStart,actualEnd)}}return null}function literalSearch(text,criteria){text=text.trim().toLowerCase();const pattern=criteria.endsWith(" ")?[criteria.toLowerCase()]:criteria.trim().toLowerCase().split(" ");return pattern.filter((word=>text.indexOf(word)>=0)).length===pattern.length}function findLiteralMatches(text,criteria){if(!text||!criteria)return[];const lowerText=text.toLowerCase();const words=criteria.trim().toLowerCase().split(/\s+/);const matches=[];let textIndex=0;for(const word of words){if(word.length===0)continue;const wordIndex=lowerText.indexOf(word,textIndex);if(wordIndex!==-1){matches.push({start:wordIndex,end:wordIndex+word.length,text:text.substring(wordIndex,wordIndex+word.length),type:"exact"});textIndex=wordIndex+word.length}}return matches}function levenshtein(a,b){const lenA=a.length;const lenB=b.length;const distanceMatrix=Array.from({length:lenA+1},(()=>Array(lenB+1).fill(0)));for(let i=0;i<=lenA;i++)distanceMatrix[i][0]=i;for(let j=0;j<=lenB;j++)distanceMatrix[0][j]=j;for(let i=1;i<=lenA;i++){for(let j=1;j<=lenB;j++){const cost=a[i-1]===b[j-1]?0:1;distanceMatrix[i][j]=Math.min(distanceMatrix[i-1][j]+1,distanceMatrix[i][j-1]+1,distanceMatrix[i-1][j-1]+cost)}}return distanceMatrix[lenA][lenB]}function levenshteinSearch(text,pattern){const distance=levenshtein(pattern,text);const similarity=1-distance/Math.max(pattern.length,text.length);return similarity>=.3}function findLevenshteinMatches(text,pattern){if(!text||!pattern)return[];const matches=[];const words=text.split(/\s+/);for(let i=0;i<words.length;i++){const word=words[i];if(levenshteinSearch(word,pattern)){const start=text.indexOf(word);matches.push({start:start,end:start+word.length,text:word,type:"wildcard"})}}return matches}function wildcardSearch(text,pattern){const regexPattern=pattern.replace(/\*/g,".*");const regex=new RegExp(`^${regexPattern}$`,"i");if(regex.test(text))return true;return levenshteinSearch(text,pattern)}function findWildcardMatches(text,pattern){if(!text||!pattern)return[];const wildcardMatches=findWildcardPatternMatches(text,pattern);if(wildcardMatches.length>0){return wildcardMatches}return findLevenshteinMatches(text,pattern)}function findWildcardPatternMatches(text,pattern){const matches=[];const regexPattern=pattern.replace(/\*/g,".*");const regex=new RegExp(regexPattern,"gi");let match;while((match=regex.exec(text))!==null){matches.push({start:match.index,end:match.index+match[0].length,text:match[0],type:"wildcard"})}return matches}class SearchStrategy{constructor(matchFunction,findMatchesFunction){this.matchFunction=matchFunction;this.findMatchesFunction=findMatchesFunction}matches(text,criteria){if(text===null||text.trim()===""||!criteria){return false}return this.matchFunction(text,criteria)}findMatches(text,criteria){if(text===null||text.trim()===""||!criteria||!this.findMatchesFunction){return[]}return this.findMatchesFunction(text,criteria)}}const LiteralSearchStrategy=new SearchStrategy(literalSearch,findLiteralMatches);const FuzzySearchStrategy=new SearchStrategy(((text,criteria)=>fuzzySearch(text,criteria)||literalSearch(text,criteria)),((text,criteria)=>{const fuzzyMatches=findFuzzyMatches$1(text,criteria);if(fuzzyMatches.length>0){return fuzzyMatches}return findLiteralMatches(text,criteria)}));const WildcardSearchStrategy=new SearchStrategy(((text,criteria)=>wildcardSearch(text,criteria)||literalSearch(text,criteria)),((text,criteria)=>{const wildcardMatches=findWildcardMatches(text,criteria);if(wildcardMatches.length>0){return wildcardMatches}return findLiteralMatches(text,criteria)}));function merge(target,source){return{...target,...source}}function isJSON(json){try{return!!(json instanceof Object&&JSON.parse(JSON.stringify(json)))}catch(_err){return false}}function NoSort(){return 0}function isObject(obj){return Boolean(obj)&&Object.prototype.toString.call(obj)==="[object Object]"}function clone(input){if(input===null||typeof input!=="object"){return input}if(Array.isArray(input)){return input.map((item=>clone(item)))}const output={};for(const key in input){if(Object.prototype.hasOwnProperty.call(input,key)){output[key]=clone(input[key])}}return output}const DEFAULT_OPTIONS={searchInput:null,resultsContainer:null,json:[],success:function(){},searchResultTemplate:'<li><a href="{url}" title="{desc}">{title}</a></li>',templateMiddleware:(_prop,_value,_template,_query)=>void 0,sortMiddleware:NoSort,noResultsText:"No results found",limit:10,fuzzy:false,strategy:"literal",debounceTime:null,exclude:[],onSearch:()=>{}};const REQUIRED_OPTIONS=["searchInput","resultsContainer","json"];const WHITELISTED_KEYS=new Set(["Enter","Shift","CapsLock","ArrowLeft","ArrowUp","ArrowRight","ArrowDown","Meta"]);class Repository{constructor(initialOptions={}){this.data=[];this.setOptions(initialOptions)}put(input){if(isObject(input)){return this.addObject(input)}if(Array.isArray(input)){return this.addArray(input)}return void 0}clear(){this.data.length=0;return this.data}search(criteria){if(!criteria){return[]}return clone(this.findMatches(this.data,criteria).sort(this.options.sortMiddleware))}setOptions(newOptions){this.options={fuzzy:(newOptions==null?void 0:newOptions.fuzzy)||DEFAULT_OPTIONS.fuzzy,limit:(newOptions==null?void 0:newOptions.limit)||DEFAULT_OPTIONS.limit,searchStrategy:this.searchStrategy((newOptions==null?void 0:newOptions.strategy)||newOptions.fuzzy&&"fuzzy"||DEFAULT_OPTIONS.strategy),sortMiddleware:(newOptions==null?void 0:newOptions.sortMiddleware)||DEFAULT_OPTIONS.sortMiddleware,exclude:(newOptions==null?void 0:newOptions.exclude)||DEFAULT_OPTIONS.exclude,strategy:(newOptions==null?void 0:newOptions.strategy)||DEFAULT_OPTIONS.strategy}}addObject(obj){this.data.push(obj);return this.data}addArray(arr){const added=[];this.clear();for(const item of arr){if(isObject(item)){added.push(this.addObject(item)[0])}}return added}findMatches(data,criteria){const matches=[];for(let i=0;i<data.length&&matches.length<this.options.limit;i++){const match=this.findMatchesInObject(data[i],criteria);if(match){matches.push(match)}}return matches}findMatchesInObject(obj,criteria){var _a,_b;for(const key in obj){if(!this.isExcluded(obj[key])&&this.options.searchStrategy.matches(obj[key],criteria)){const matchInfo=(_b=(_a=this.options.searchStrategy).findMatches)==null?void 0:_b.call(_a,obj[key],criteria);const result={...obj};if(matchInfo&&matchInfo.length>0){result._matchInfo={[key]:matchInfo}}return result}}return void 0}isExcluded(term){for(const excludedTerm of this.options.exclude){if(new RegExp(excludedTerm).test(String(term))){return true}}return false}searchStrategy(strategy){switch(strategy){case"fuzzy":return FuzzySearchStrategy;case"wildcard":return WildcardSearchStrategy;default:return LiteralSearchStrategy}}}const options={pattern:/\{(.*?)\}/g,template:"",middleware:function(){return void 0}};function setOptions(_options){if(_options.pattern){options.pattern=_options.pattern}if(_options.template){options.template=_options.template}if(typeof _options.middleware==="function"){options.middleware=_options.middleware}}function compile(data,query){return options.template.replace(options.pattern,(function(match,prop){if(options.middleware.length>=5&&data._matchInfo&&data._matchInfo[prop]){const value2=options.middleware(prop,data[prop],options.template,query,data._matchInfo[prop]);if(typeof value2!=="undefined"){return value2}}const value=options.middleware(prop,data[prop],options.template,query);if(typeof value!=="undefined"){return value}return data[prop]||match}))}let SimpleJekyllSearch$1=class SimpleJekyllSearch{constructor(){this.debounceTimerHandle=null;this.options={...DEFAULT_OPTIONS};this.repository=new Repository;this.optionsValidator=new OptionsValidator({required:REQUIRED_OPTIONS})}debounce(func,delayMillis){if(delayMillis){if(this.debounceTimerHandle){clearTimeout(this.debounceTimerHandle)}this.debounceTimerHandle=setTimeout(func,delayMillis)}else{func()}}throwError(message){throw new Error(`SimpleJekyllSearch --- ${message}`)}emptyResultsContainer(){this.options.resultsContainer.innerHTML=""}initWithJSON(json){this.repository.put(json);this.registerInput()}initWithURL(url){load(url,((err,json)=>{if(err){this.throwError(`Failed to load JSON from ${url}: ${err.message}`)}this.initWithJSON(json)}))}registerInput(){this.options.searchInput.addEventListener("input",(e=>{const inputEvent=e;if(!WHITELISTED_KEYS.has(inputEvent.key)){this.emptyResultsContainer();this.debounce((()=>{this.search(e.target.value)}),this.options.debounceTime??null)}}))}search(query){var _a,_b;if((query==null?void 0:query.trim().length)>0){this.emptyResultsContainer();const results=this.repository.search(query);this.render(results,query);(_b=(_a=this.options).onSearch)==null?void 0:_b.call(_a)}}render(results,query){if(results.length===0){this.options.resultsContainer.insertAdjacentHTML("beforeend",this.options.noResultsText);return}const fragment=document.createDocumentFragment();results.forEach((result=>{result.query=query;const div=document.createElement("div");div.innerHTML=compile(result,query);fragment.appendChild(div)}));this.options.resultsContainer.appendChild(fragment)}init(_options){var _a;const errors=this.optionsValidator.validate(_options);if(errors.length>0){this.throwError(`Missing required options: ${REQUIRED_OPTIONS.join(", ")}`)}this.options=merge(this.options,_options);setOptions({template:this.options.searchResultTemplate,middleware:this.options.templateMiddleware});this.repository.setOptions({fuzzy:this.options.fuzzy,limit:this.options.limit,sortMiddleware:this.options.sortMiddleware,strategy:this.options.strategy,exclude:this.options.exclude});if(isJSON(this.options.json)){this.initWithJSON(this.options.json)}else{this.initWithURL(this.options.json)}const rv={search:this.search.bind(this)};(_a=this.options.success)==null?void 0:_a.call(rv);return rv}};function createHighlightMiddleware(options2={}){const{highlightClass:highlightClass="sjs-highlight",contextBefore:contextBefore=50,contextAfter:contextAfter=50,maxLength:maxLength=250,ellipsis:ellipsis="..."}=options2;return function(result,query){if(!query||!result){return result}const highlightedResult={...result};const textFields=["title","desc","content","excerpt"];for(const field of textFields){if(highlightedResult[field]&&typeof highlightedResult[field]==="string"){const highlighted=highlightText(highlightedResult[field],query,{highlightClass:highlightClass,contextBefore:contextBefore,contextAfter:contextAfter,maxLength:maxLength,ellipsis:ellipsis});if(highlighted.highlightedText!==highlightedResult[field]){highlightedResult[field]=highlighted.highlightedText}}}return highlightedResult}}function highlightText(text,query,options2={}){const{highlightClass:highlightClass="sjs-highlight",contextBefore:contextBefore=50,contextAfter:contextAfter=50,maxLength:maxLength=250,ellipsis:ellipsis="..."}=options2;if(!text||!query){return{highlightedText:text,matchCount:0}}const originalText=text;const searchTerms=query.trim().toLowerCase().split(/\s+/).filter((term=>term.length>0));if(searchTerms.length===0){return{highlightedText:text,matchCount:0}}const matches=[];for(const term of searchTerms){let index=0;while(index<text.length){const found=text.toLowerCase().indexOf(term,index);if(found===-1)break;matches.push({start:found,end:found+term.length,term:text.substring(found,found+term.length)});index=found+1}}if(matches.length===0){return{highlightedText:text,matchCount:0}}matches.sort(((a,b)=>a.start-b.start));const mergedMatches=[];for(const match of matches){if(mergedMatches.length===0||mergedMatches[mergedMatches.length-1].end<match.start){mergedMatches.push(match)}else{const lastMatch=mergedMatches[mergedMatches.length-1];lastMatch.end=Math.max(lastMatch.end,match.end);lastMatch.term=text.substring(lastMatch.start,lastMatch.end)}}if(text.length<=maxLength){let highlightedText2=text;for(let i=mergedMatches.length-1;i>=0;i--){const match=mergedMatches[i];const before=highlightedText2.substring(0,match.start);const after=highlightedText2.substring(match.end);const matchText=highlightedText2.substring(match.start,match.end);highlightedText2=before+`<span class="${highlightClass}">${matchText}</span>`+after}return{highlightedText:highlightedText2,matchCount:mergedMatches.length}}let highlightedText="";let totalLength=0;let lastEnd=0;for(let i=0;i<mergedMatches.length;i++){const match=mergedMatches[i];const contextStart=Math.max(lastEnd,match.start-contextBefore);const contextEnd=Math.min(text.length,match.end+contextAfter);if(contextStart>lastEnd&&lastEnd>0){highlightedText+=ellipsis;totalLength+=ellipsis.length}if(contextStart<match.start){const beforeText=text.substring(contextStart,match.start);highlightedText+=beforeText;totalLength+=beforeText.length}const matchText=text.substring(match.start,match.end);highlightedText+=`<span class="${highlightClass}">${matchText}</span>`;totalLength+=matchText.length;if(match.end<contextEnd){const afterText=text.substring(match.end,contextEnd);highlightedText+=afterText;totalLength+=afterText.length}lastEnd=contextEnd;if(totalLength>=maxLength){if(contextEnd<text.length){highlightedText+=ellipsis}break}}return{highlightedText:highlightedText||originalText,matchCount:mergedMatches.length}}const defaultHighlightMiddleware=createHighlightMiddleware();function findFuzzyMatches(text,pattern){const matches=[];const lowerText=text.toLowerCase();const lowerPattern=pattern.toLowerCase().trim();if(lowerPattern.length===0)return matches;const patternWords=lowerPattern.split(/\s+/);for(const word of patternWords){if(word.length===0)continue;const wordMatches=findFuzzyWordMatches(lowerText,word);matches.push(...wordMatches)}return matches}function findFuzzyWordMatches(text,word){const matches=[];const exactRegex=new RegExp(`\\b${word.replace(/[.*+?^${}()|[\]\\]/g,"\\$&")}\\b`,"gi");let match;while((match=exactRegex.exec(text))!==null){matches.push({start:match.index,end:match.index+match[0].length,text:match[0]})}if(matches.length===0){for(let i=0;i<text.length;i++){const fuzzyMatch=findFuzzySequenceMatch(text,word,i);if(fuzzyMatch){matches.push(fuzzyMatch);i=fuzzyMatch.end-1}}}return matches}function findFuzzySequenceMatch(text,pattern,startPos){let textIndex=startPos;let patternIndex=0;let matchStart=-1;let maxGap=3;const matchedPositions=[];while(textIndex<text.length&&patternIndex<pattern.length){if(text[textIndex]===pattern[patternIndex]){if(matchStart===-1){matchStart=textIndex}matchedPositions.push(textIndex);patternIndex++}else if(matchStart!==-1){if(textIndex-matchStart>maxGap*pattern.length){return null}}textIndex++}if(patternIndex===pattern.length&&matchStart!==-1&&matchedPositions.length>0){const actualStart=matchedPositions[0];const actualEnd=matchedPositions[matchedPositions.length-1]+1;return{start:actualStart,end:actualEnd,text:text.substring(actualStart,actualEnd)}}return null}function createHighlightTemplateMiddleware(options2={}){const highlightOptions={highlightClass:"sjs-highlight",...options2};return function(prop,value,_template,query){if((prop==="content"||prop==="desc")&&query&&typeof value==="string"){let highlightedText=value;let hasMatches=false;const searchTerms=query.trim().split(/\s+/).filter((term=>term.length>0));for(const term of searchTerms){const regex=new RegExp(`\\b(${term.replace(/[.*+?^${}()|[\]\\]/g,"\\$&")})\\b`,"gi");if(regex.test(highlightedText)){highlightedText=highlightedText.replace(regex,`<span class="${highlightOptions.highlightClass}">$1</span>`);hasMatches=true}}if(!hasMatches){const fuzzyMatches=findFuzzyMatches(value,query);if(fuzzyMatches.length>0){fuzzyMatches.sort(((a,b)=>b.start-a.start));for(const match of fuzzyMatches){const before=highlightedText.substring(0,match.start);const after=highlightedText.substring(match.end);const matchText=highlightedText.substring(match.start,match.end);highlightedText=before+`<span class="${highlightOptions.highlightClass}">${matchText}</span>`+after}hasMatches=true}}if(hasMatches){return highlightedText}}return void 0}}const defaultHighlightTemplateMiddleware=createHighlightTemplateMiddleware();function SimpleJekyllSearch(options2){const instance=new SimpleJekyllSearch$1;return instance.init(options2)}if(typeof window!=="undefined"){window.SimpleJekyllSearch=SimpleJekyllSearch;window.SimpleJekyllSearch.createHighlightMiddleware=createHighlightMiddleware;window.SimpleJekyllSearch.createHighlightTemplateMiddleware=createHighlightTemplateMiddleware;window.SimpleJekyllSearch.highlightText=highlightText;window.SimpleJekyllSearch.defaultHighlightMiddleware=defaultHighlightMiddleware;window.SimpleJekyllSearch.defaultHighlightTemplateMiddleware=defaultHighlightTemplateMiddleware}exports2.createHighlightMiddleware=createHighlightMiddleware;exports2.createHighlightTemplateMiddleware=createHighlightTemplateMiddleware;exports2.default=SimpleJekyllSearch;exports2.defaultHighlightMiddleware=defaultHighlightMiddleware;exports2.defaultHighlightTemplateMiddleware=defaultHighlightTemplateMiddleware;exports2.highlightText=highlightText;Object.defineProperties(exports2,{__esModule:{value:true},[Symbol.toStringTag]:{value:"Module"}})}));
\ No newline at end of file
diff --git a/src/Repository.ts b/src/Repository.ts
index de6b96c..32afea3 100644
--- a/src/Repository.ts
+++ b/src/Repository.ts
@@ -75,7 +75,13 @@ export class Repository {
   private findMatchesInObject(obj: RepositoryData, criteria: string): RepositoryData | undefined {
     for (const key in obj) {
       if (!this.isExcluded(obj[key]) && this.options.searchStrategy.matches(obj[key], criteria)) {
-        return obj;
+        // Get match information if available
+        const matchInfo = this.options.searchStrategy.findMatches?.(obj[key], criteria);
+        const result = { ...obj };
+        if (matchInfo && matchInfo.length > 0) {
+          result._matchInfo = { [key]: matchInfo };
+        }
+        return result;
       }
     }
     return undefined;
diff --git a/src/SearchStrategies/SearchStrategy.ts b/src/SearchStrategies/SearchStrategy.ts
index e51f266..e68e70e 100644
--- a/src/SearchStrategies/SearchStrategy.ts
+++ b/src/SearchStrategies/SearchStrategy.ts
@@ -1,12 +1,34 @@
-import { fuzzySearch } from './search/fuzzySearch';
-import { literalSearch } from './search/literalSearch';
-import { wildcardSearch } from './search/wildcardSearch';
+import { fuzzySearch, findFuzzyMatches } from './search/fuzzySearch';
+import { literalSearch, findLiteralMatches } from './search/literalSearch';
+import { wildcardSearch, findWildcardMatches } from './search/wildcardSearch';
 import { SearchStrategy } from './types';
 
-export const LiteralSearchStrategy = new SearchStrategy(literalSearch);
-export const FuzzySearchStrategy = new SearchStrategy((text: string, criteria: string) => {
-  return fuzzySearch(text, criteria) || literalSearch(text, criteria);
-});
-export const WildcardSearchStrategy = new SearchStrategy((text: string, criteria: string) => {
-  return wildcardSearch(text, criteria) || literalSearch(text, criteria);
-});
\ No newline at end of file
+export const LiteralSearchStrategy = new SearchStrategy(literalSearch, findLiteralMatches);
+
+export const FuzzySearchStrategy = new SearchStrategy(
+  (text: string, criteria: string) => {
+    return fuzzySearch(text, criteria) || literalSearch(text, criteria);
+  },
+  (text: string, criteria: string) => {
+    // Try fuzzy matches first, then fall back to literal matches
+    const fuzzyMatches = findFuzzyMatches(text, criteria);
+    if (fuzzyMatches.length > 0) {
+      return fuzzyMatches;
+    }
+    return findLiteralMatches(text, criteria);
+  }
+);
+
+export const WildcardSearchStrategy = new SearchStrategy(
+  (text: string, criteria: string) => {
+    return wildcardSearch(text, criteria) || literalSearch(text, criteria);
+  },
+  (text: string, criteria: string) => {
+    // Try wildcard matches first, then fall back to literal matches
+    const wildcardMatches = findWildcardMatches(text, criteria);
+    if (wildcardMatches.length > 0) {
+      return wildcardMatches;
+    }
+    return findLiteralMatches(text, criteria);
+  }
+);
\ No newline at end of file
diff --git a/src/SearchStrategies/search/fuzzySearch.ts b/src/SearchStrategies/search/fuzzySearch.ts
index b7221cc..f305c35 100644
--- a/src/SearchStrategies/search/fuzzySearch.ts
+++ b/src/SearchStrategies/search/fuzzySearch.ts
@@ -1,3 +1,5 @@
+import { MatchInfo } from '../types';
+
 /**
  * A simple fuzzy search implementation that checks if characters in the pattern appear
  * in order (but not necessarily consecutively) in the text.
@@ -32,4 +34,102 @@ export function fuzzySearch(text: string, pattern: string): boolean {
   }
 
   return true;
+}
+
+/**
+ * Finds fuzzy matches in text and returns their positions
+ * @param text The text to search in
+ * @param pattern The search pattern
+ * @returns Array of match information
+ */
+export function findFuzzyMatches(text: string, pattern: string): MatchInfo[] {
+  if (!text || !pattern) return [];
+  
+  const lowerText = text.toLowerCase();
+  const lowerPattern = pattern.toLowerCase().trim();
+  
+  if (lowerPattern.length === 0) return [];
+  
+  const patternWords = lowerPattern.split(/\s+/);
+  const matches: MatchInfo[] = [];
+  
+  for (const word of patternWords) {
+    if (word.length === 0) continue;
+    
+    const wordMatches = findFuzzyWordMatches(lowerText, word);
+    matches.push(...wordMatches);
+  }
+  
+  return matches;
+}
+
+/**
+ * Finds fuzzy matches for a single word
+ */
+function findFuzzyWordMatches(text: string, word: string): MatchInfo[] {
+  const matches: MatchInfo[] = [];
+  
+  // Try exact word matches first
+  const exactRegex = new RegExp(`\\b${word.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}\\b`, 'gi');
+  let match;
+  while ((match = exactRegex.exec(text)) !== null) {
+    matches.push({
+      start: match.index,
+      end: match.index + match[0].length,
+      text: match[0],
+      type: 'exact'
+    });
+  }
+  
+  // If no exact matches, try fuzzy matching
+  if (matches.length === 0) {
+    for (let i = 0; i < text.length; i++) {
+      const fuzzyMatch = findFuzzySequenceMatch(text, word, i);
+      if (fuzzyMatch) {
+        matches.push({ ...fuzzyMatch, type: 'fuzzy' });
+        i = fuzzyMatch.end - 1;
+      }
+    }
+  }
+  
+  return matches;
+}
+
+/**
+ * Finds a fuzzy sequence match starting from a given position
+ */
+function findFuzzySequenceMatch(text: string, pattern: string, startPos: number): { start: number; end: number; text: string } | null {
+  let textIndex = startPos;
+  let patternIndex = 0;
+  let matchStart = -1;
+  let maxGap = 3;
+  const matchedPositions: number[] = [];
+  
+  while (textIndex < text.length && patternIndex < pattern.length) {
+    if (text[textIndex] === pattern[patternIndex]) {
+      if (matchStart === -1) {
+        matchStart = textIndex;
+      }
+      matchedPositions.push(textIndex);
+      patternIndex++;
+    } else if (matchStart !== -1) {
+      if (textIndex - matchStart > maxGap * pattern.length) {
+        return null;
+      }
+    }
+    textIndex++;
+  }
+  
+  if (patternIndex === pattern.length && matchStart !== -1 && matchedPositions.length > 0) {
+    const actualStart = matchedPositions[0];
+    const actualEnd = matchedPositions[matchedPositions.length - 1] + 1;
+    
+    return {
+      start: actualStart,
+      end: actualEnd,
+      text: text.substring(actualStart, actualEnd)
+    };
+  }
+  
+  return null;
 } 
\ No newline at end of file
diff --git a/src/SearchStrategies/search/levenshtein.ts b/src/SearchStrategies/search/levenshtein.ts
index e88d356..6658b44 100644
--- a/src/SearchStrategies/search/levenshtein.ts
+++ b/src/SearchStrategies/search/levenshtein.ts
@@ -1,3 +1,5 @@
+import { MatchInfo } from '../types';
+
 /**
  * Calculates the Levenshtein distance between two strings.
  *
@@ -47,4 +49,32 @@ export function levenshteinSearch(text: string, pattern: string): boolean {
   const similarity = 1 - distance / Math.max(pattern.length, text.length);
 
   return similarity >= 0.3;
+}
+
+/**
+ * Finds levenshtein matches in text and returns their positions
+ * @param text The text to search in
+ * @param pattern The search pattern
+ * @returns Array of match information
+ */
+export function findLevenshteinMatches(text: string, pattern: string): MatchInfo[] {
+  if (!text || !pattern) return [];
+  
+  const matches: MatchInfo[] = [];
+  const words = text.split(/\s+/);
+  
+  for (let i = 0; i < words.length; i++) {
+    const word = words[i];
+    if (levenshteinSearch(word, pattern)) {
+      const start = text.indexOf(word);
+      matches.push({
+        start: start,
+        end: start + word.length,
+        text: word,
+        type: 'wildcard'
+      });
+    }
+  }
+  
+  return matches;
 }
\ No newline at end of file
diff --git a/src/SearchStrategies/search/literalSearch.ts b/src/SearchStrategies/search/literalSearch.ts
index a2dbb21..f56ed84 100644
--- a/src/SearchStrategies/search/literalSearch.ts
+++ b/src/SearchStrategies/search/literalSearch.ts
@@ -1,3 +1,5 @@
+import { MatchInfo } from '../types';
+
 /**
  * This function performs a literal search (look for the exact sequence of characters)
  * on the given text using the provided criteria.
@@ -10,4 +12,36 @@ export function literalSearch(text: string, criteria: string): boolean {
   const pattern = criteria.endsWith(' ') ? [criteria.toLowerCase()] : criteria.trim().toLowerCase().split(' ');
 
   return pattern.filter((word: string) => text.indexOf(word) >= 0).length === pattern.length;
+}
+
+/**
+ * Finds all literal matches in text and returns their positions
+ * @param text The text to search in
+ * @param criteria The search criteria
+ * @returns Array of match information
+ */
+export function findLiteralMatches(text: string, criteria: string): MatchInfo[] {
+  if (!text || !criteria) return [];
+  
+  const lowerText = text.toLowerCase();
+  const words = criteria.trim().toLowerCase().split(/\s+/);
+  const matches: MatchInfo[] = [];
+  
+  let textIndex = 0;
+  for (const word of words) {
+    if (word.length === 0) continue;
+    
+    const wordIndex = lowerText.indexOf(word, textIndex);
+    if (wordIndex !== -1) {
+      matches.push({
+        start: wordIndex,
+        end: wordIndex + word.length,
+        text: text.substring(wordIndex, wordIndex + word.length),
+        type: 'exact'
+      });
+      textIndex = wordIndex + word.length;
+    }
+  }
+  
+  return matches;
 }
\ No newline at end of file
diff --git a/src/SearchStrategies/search/wildcardSearch.ts b/src/SearchStrategies/search/wildcardSearch.ts
index 8228475..538bd11 100644
--- a/src/SearchStrategies/search/wildcardSearch.ts
+++ b/src/SearchStrategies/search/wildcardSearch.ts
@@ -1,4 +1,5 @@
-import { levenshteinSearch } from './levenshtein';
+import { levenshteinSearch, findLevenshteinMatches } from './levenshtein';
+import { MatchInfo } from '../types';
 
 /**
  * Matches a pattern with wildcards (*) against a text.
@@ -14,4 +15,44 @@ export function wildcardSearch(text: string, pattern: string): boolean {
   if (regex.test(text)) return true;
 
   return levenshteinSearch(text, pattern);
-}
\ No newline at end of file
+}
+
+/**
+ * Finds wildcard matches in text and returns their positions
+ * @param text The text to search in
+ * @param pattern The search pattern
+ * @returns Array of match information
+ */
+export function findWildcardMatches(text: string, pattern: string): MatchInfo[] {
+  if (!text || !pattern) return [];
+  
+  // Try wildcard matching first
+  const wildcardMatches = findWildcardPatternMatches(text, pattern);
+  if (wildcardMatches.length > 0) {
+    return wildcardMatches;
+  }
+  
+  // Fall back to levenshtein matching
+  return findLevenshteinMatches(text, pattern);
+}
+
+/**
+ * Finds wildcard pattern matches
+ */
+function findWildcardPatternMatches(text: string, pattern: string): MatchInfo[] {
+  const matches: MatchInfo[] = [];
+  const regexPattern = pattern.replace(/\*/g, '.*');
+  const regex = new RegExp(regexPattern, 'gi');
+  let match;
+  
+  while ((match = regex.exec(text)) !== null) {
+    matches.push({
+      start: match.index,
+      end: match.index + match[0].length,
+      text: match[0],
+      type: 'wildcard'
+    });
+  }
+  
+  return matches;
+}
diff --git a/src/SearchStrategies/types.ts b/src/SearchStrategies/types.ts
index c1715e0..80108e2 100644
--- a/src/SearchStrategies/types.ts
+++ b/src/SearchStrategies/types.ts
@@ -1,12 +1,22 @@
+export interface MatchInfo {
+  start: number;
+  end: number;
+  text: string;
+  type: 'exact' | 'fuzzy' | 'wildcard';
+}
+
 export interface Matcher {
   matches(text: string | null, criteria: string): boolean;
+  findMatches?(text: string | null, criteria: string): MatchInfo[];
 }
 
 export class SearchStrategy implements Matcher {
   private readonly matchFunction: (text: string, criteria: string) => boolean;
+  private readonly findMatchesFunction?: (text: string, criteria: string) => MatchInfo[];
 
-  constructor(matchFunction: (text: string, criteria: string) => boolean) {
+  constructor(matchFunction: (text: string, criteria: string) => boolean, findMatchesFunction?: (text: string, criteria: string) => MatchInfo[]) {
     this.matchFunction = matchFunction;
+    this.findMatchesFunction = findMatchesFunction;
   }
 
   matches(text: string | null, criteria: string): boolean {
@@ -16,4 +26,12 @@ export class SearchStrategy implements Matcher {
 
     return this.matchFunction(text, criteria);
   }
+
+  findMatches?(text: string | null, criteria: string): MatchInfo[] {
+    if (text === null || text.trim() === '' || !criteria || !this.findMatchesFunction) {
+      return [];
+    }
+
+    return this.findMatchesFunction(text, criteria);
+  }
 }
\ No newline at end of file
diff --git a/src/Templater.ts b/src/Templater.ts
index cb5f7d0..6bcd75e 100644
--- a/src/Templater.ts
+++ b/src/Templater.ts
@@ -30,6 +30,15 @@ export function setOptions(_options: TemplaterOptions): void {
 
 export function compile(data: Data, query?: string): string {
   return options.template.replace(options.pattern, function(match: string, prop: string) {
+    // Check if middleware supports matchInfo parameter (5 parameters including matchInfo)
+    if (options.middleware.length >= 5 && data._matchInfo && data._matchInfo[prop]) {
+      const value = (options.middleware as any)(prop, data[prop], options.template, query, data._matchInfo[prop]);
+      if (typeof value !== 'undefined') {
+        return value;
+      }
+    }
+    
+    // Fallback to current behavior
     const value = options.middleware(prop, data[prop], options.template, query);
     if (typeof value !== 'undefined') {
       return value;
diff --git a/src/index.ts b/src/index.ts
index 2e37011..f9f704f 100644
--- a/src/index.ts
+++ b/src/index.ts
@@ -16,6 +16,7 @@ export {
   defaultHighlightTemplateMiddleware
 };
 export type { HighlightOptions, HighlightResult } from './utils/highlightMiddleware';
+export type { MatchInfo } from './SearchStrategies/types';
 
 function SimpleJekyllSearch(options: SearchOptions): SimpleJekyllSearchInstance {
   const instance = new SimpleJekyllSearchClass();
diff --git a/src/utils/types.ts b/src/utils/types.ts
index 420ea83..acc9f99 100644
--- a/src/utils/types.ts
+++ b/src/utils/types.ts
@@ -1,4 +1,4 @@
-import { Matcher } from '../SearchStrategies/types';
+import { Matcher, MatchInfo } from '../SearchStrategies/types';
 
 export interface SearchResult {
   url: string;
@@ -35,7 +35,7 @@ export interface SearchOptions extends Omit<RepositoryOptions, 'searchStrategy'>
   json: SearchData[] | string;
   success?: (this: { search: (query: string) => void }) => void;
   searchResultTemplate?: string;
-  templateMiddleware?: (prop: string, value: string, template: string, query?: string) => string | undefined;
+  templateMiddleware?: (prop: string, value: string, template: string, query?: string, matchInfo?: MatchInfo[]) => string | undefined;
   noResultsText?: string;
   debounceTime?: number | null;
   onSearch?: () => void;
diff --git a/tests/Repository.test.ts b/tests/Repository.test.ts
index 10bd50a..7807094 100644
--- a/tests/Repository.test.ts
+++ b/tests/Repository.test.ts
@@ -1,18 +1,30 @@
 import { afterEach, beforeEach, describe, expect, it } from 'vitest';
 import { Repository } from '../src/Repository';
-import { SearchResult } from '../src/utils/types';
 
 interface TestElement {
   title: string;
   content: string;
 }
 
+interface EmployeeElement {
+  name: string;
+  role: string;
+}
+
 const barElement: TestElement = { title: 'bar', content: 'bar' };
 const almostBarElement: TestElement = { title: 'almostbar', content: 'almostbar' };
 const loremElement: TestElement = { title: 'lorem', content: 'lorem ipsum' };
 
 const data: TestElement[] = [barElement, almostBarElement, loremElement];
 
+// Helper function to strip _matchInfo for backward compatibility testing
+function stripMatchInfo(results: any[]): any[] {
+  return results.map(result => {
+    const { _matchInfo, ...cleanResult } = result;
+    return cleanResult;
+  });
+}
+
 describe('Repository', () => {
   let repository: Repository;
 
@@ -26,32 +38,32 @@ describe('Repository', () => {
   });
 
   it('finds a simple string', () => {
-    expect(repository.search('bar')).toEqual([barElement, almostBarElement]);
+    expect(stripMatchInfo(repository.search('bar'))).toEqual([barElement, almostBarElement]);
   });
 
   it('limits the search results to one even if found more', () => {
     repository.setOptions({ limit: 1 });
-    expect(repository.search('bar')).toEqual([barElement]);
+    expect(stripMatchInfo(repository.search('bar'))).toEqual([barElement]);
   });
 
   it('finds a long string', () => {
-    expect(repository.search('lorem ipsum')).toEqual([loremElement]);
+    expect(stripMatchInfo(repository.search('lorem ipsum'))).toEqual([loremElement]);
   });
 
   it('[deprecated] finds a fuzzy string', () => {
     repository.setOptions({ fuzzy: true });
-    expect(repository.search('lrm ism')).toEqual([loremElement]);
+    expect(stripMatchInfo(repository.search('lrm ism'))).toEqual([loremElement]);
   });
 
   it('finds a fuzzy string', () => {
     repository.setOptions({ strategy: 'fuzzy' });
-    expect(repository.search('lrm ism')).toEqual([loremElement]);
+    expect(stripMatchInfo(repository.search('lrm ism'))).toEqual([loremElement]);
   });
 
   it('finds items using a wildcard pattern', () => {
     repository.setOptions({ strategy: 'wildcard' });
-    expect(repository.search('* ispum')).toEqual([loremElement]);
-    expect(repository.search('*bar')).toEqual([barElement, almostBarElement]);
+    expect(stripMatchInfo(repository.search('* ispum'))).toEqual([loremElement]);
+    expect(stripMatchInfo(repository.search('*bar'))).toEqual([barElement, almostBarElement]);
   });
 
   it('returns empty search results when an empty criteria is provided', () => {
@@ -71,24 +83,24 @@ describe('Repository', () => {
         return a.title.localeCompare(b.title);
       },
     });
-    expect(repository.search('r')).toEqual([almostBarElement, barElement, loremElement]);
+    expect(stripMatchInfo(repository.search('r'))).toEqual([almostBarElement, barElement, loremElement]);
   });
 
   it('search results should be a clone and not a reference to repository data', () => {
     const query = 'Developer';
-    repository.put(
+    repository.put([
       { name: 'Alice', role: 'Developer' },
       { name: 'Bob', role: 'Designer' },
-    );
+    ]);
 
     const results = repository.search(query);
-    expect(results).toEqual([{ name: 'Alice', role: 'Developer' }]);
+    expect(stripMatchInfo(results)).toEqual([{ name: 'Alice', role: 'Developer' }]);
 
-    (results as SearchResult[]).forEach(result => {
+    (results as EmployeeElement[]).forEach(result => {
       result.role = 'Modified Role';
     });
 
     const originalData = repository.search(query);
-    expect(originalData).toEqual([{ name: 'Alice', role: 'Developer' }]);
+    expect(stripMatchInfo(originalData)).toEqual([{ name: 'Alice', role: 'Developer' }]);
   });
 });
\ No newline at end of file

From db78553be5c1c8dfd183131141b369f5b9c7f1ff Mon Sep 17 00:00:00 2001
From: sylhare <sylhare@outlook.com>
Date: Thu, 9 Oct 2025 09:41:07 -0400
Subject: [PATCH 05/10] Update templater

---
 dest/simple-jekyll-search.js                  | 107 +++++++++++++-----
 dest/simple-jekyll-search.min.js              |   2 +-
 docs/assets/js/simple-jekyll-search.min.js    |   2 +-
 src/SearchStrategies/search/fuzzySearch.ts    |  28 ++++-
 src/SearchStrategies/search/wildcardSearch.ts |  30 ++++-
 src/Templater.ts                              |  17 ++-
 src/utils/highlightMiddleware.ts              |  94 ++++++++++-----
 7 files changed, 211 insertions(+), 69 deletions(-)

diff --git a/dest/simple-jekyll-search.js b/dest/simple-jekyll-search.js
index b5bab03..d165b7b 100644
--- a/dest/simple-jekyll-search.js
+++ b/dest/simple-jekyll-search.js
@@ -76,7 +76,7 @@
       const wordMatches = findFuzzyWordMatches$1(lowerText, word);
       matches.push(...wordMatches);
     }
-    return matches;
+    return mergeAndSortMatches$1(matches);
   }
   function findFuzzyWordMatches$1(text, word) {
     const matches = [];
@@ -132,6 +132,21 @@
     }
     return null;
   }
+  function mergeAndSortMatches$1(matches) {
+    if (matches.length === 0) return [];
+    const sortedMatches = matches.sort((a, b) => a.start - b.start);
+    const merged = [];
+    for (const match of sortedMatches) {
+      const lastMerged = merged[merged.length - 1];
+      if (lastMerged && match.start <= lastMerged.end) {
+        lastMerged.end = Math.max(lastMerged.end, match.end);
+        lastMerged.text = lastMerged.text + match.text.slice(lastMerged.end - match.start);
+      } else {
+        merged.push({ ...match });
+      }
+    }
+    return merged;
+  }
   function literalSearch(text, criteria) {
     text = text.trim().toLowerCase();
     const pattern = criteria.endsWith(" ") ? [criteria.toLowerCase()] : criteria.trim().toLowerCase().split(" ");
@@ -209,9 +224,10 @@
     if (!text || !pattern) return [];
     const wildcardMatches = findWildcardPatternMatches(text, pattern);
     if (wildcardMatches.length > 0) {
-      return wildcardMatches;
+      return mergeAndSortMatches(wildcardMatches);
     }
-    return findLevenshteinMatches(text, pattern);
+    const levenshteinMatches = findLevenshteinMatches(text, pattern);
+    return mergeAndSortMatches(levenshteinMatches);
   }
   function findWildcardPatternMatches(text, pattern) {
     const matches = [];
@@ -228,6 +244,21 @@
     }
     return matches;
   }
+  function mergeAndSortMatches(matches) {
+    if (matches.length === 0) return [];
+    const sortedMatches = matches.sort((a, b) => a.start - b.start);
+    const merged = [];
+    for (const match of sortedMatches) {
+      const lastMerged = merged[merged.length - 1];
+      if (lastMerged && match.start <= lastMerged.end) {
+        lastMerged.end = Math.max(lastMerged.end, match.end);
+        lastMerged.text = lastMerged.text + match.text.slice(lastMerged.end - match.start);
+      } else {
+        merged.push({ ...match });
+      }
+    }
+    return merged;
+  }
   class SearchStrategy {
     constructor(matchFunction, findMatchesFunction) {
       this.matchFunction = matchFunction;
@@ -744,39 +775,57 @@
     }
     return null;
   }
+  function highlightWithMatchInfo(text, matchInfo, options2) {
+    if (matchInfo.length === 0) return text;
+    const sortedMatches = [...matchInfo].sort((a, b) => b.start - a.start);
+    let highlightedText = text;
+    for (const match of sortedMatches) {
+      const before = highlightedText.substring(0, match.start);
+      const after = highlightedText.substring(match.end);
+      const matchText = highlightedText.substring(match.start, match.end);
+      highlightedText = before + `<span class="${options2.highlightClass}">${matchText}</span>` + after;
+    }
+    return highlightedText;
+  }
+  function highlightWithQuery(text, query, options2) {
+    let highlightedText = text;
+    let hasMatches = false;
+    const searchTerms = query.trim().split(/\s+/).filter((term) => term.length > 0);
+    for (const term of searchTerms) {
+      const regex = new RegExp(`\\b(${term.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")})\\b`, "gi");
+      if (regex.test(highlightedText)) {
+        highlightedText = highlightedText.replace(regex, `<span class="${options2.highlightClass}">$1</span>`);
+        hasMatches = true;
+      }
+    }
+    if (!hasMatches) {
+      const fuzzyMatches = findFuzzyMatches(text, query);
+      if (fuzzyMatches.length > 0) {
+        fuzzyMatches.sort((a, b) => b.start - a.start);
+        for (const match of fuzzyMatches) {
+          const before = highlightedText.substring(0, match.start);
+          const after = highlightedText.substring(match.end);
+          const matchText = highlightedText.substring(match.start, match.end);
+          highlightedText = before + `<span class="${options2.highlightClass}">${matchText}</span>` + after;
+        }
+        hasMatches = true;
+      }
+    }
+    return highlightedText;
+  }
   function createHighlightTemplateMiddleware(options2 = {}) {
     const highlightOptions = {
       highlightClass: "sjs-highlight",
       ...options2
     };
-    return function(prop, value, _template, query) {
+    return function(prop, value, _template, query, matchInfo) {
       if ((prop === "content" || prop === "desc") && query && typeof value === "string") {
-        let highlightedText = value;
-        let hasMatches = false;
-        const searchTerms = query.trim().split(/\s+/).filter((term) => term.length > 0);
-        for (const term of searchTerms) {
-          const regex = new RegExp(`\\b(${term.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")})\\b`, "gi");
-          if (regex.test(highlightedText)) {
-            highlightedText = highlightedText.replace(regex, `<span class="${highlightOptions.highlightClass}">$1</span>`);
-            hasMatches = true;
-          }
-        }
-        if (!hasMatches) {
-          const fuzzyMatches = findFuzzyMatches(value, query);
-          if (fuzzyMatches.length > 0) {
-            fuzzyMatches.sort((a, b) => b.start - a.start);
-            for (const match of fuzzyMatches) {
-              const before = highlightedText.substring(0, match.start);
-              const after = highlightedText.substring(match.end);
-              const matchText = highlightedText.substring(match.start, match.end);
-              highlightedText = before + `<span class="${highlightOptions.highlightClass}">${matchText}</span>` + after;
-            }
-            hasMatches = true;
-          }
-        }
-        if (hasMatches) {
-          return highlightedText;
+        if (matchInfo && matchInfo.length > 0) {
+          const highlighted2 = highlightWithMatchInfo(value, matchInfo, highlightOptions);
+          return highlighted2 !== value ? highlighted2 : void 0;
         }
+        const highlighted = highlightWithQuery(value, query, highlightOptions);
+        return highlighted !== value ? highlighted : void 0;
       }
       return void 0;
     };
diff --git a/dest/simple-jekyll-search.min.js b/dest/simple-jekyll-search.min.js
index 84bfcd8..8056511 100644
--- a/dest/simple-jekyll-search.min.js
+++ b/dest/simple-jekyll-search.min.js
@@ -4,4 +4,4 @@
   * Copyright 2025-2025, Sylhare
   * Licensed under the MIT License.
   */
-(function(global,factory){typeof exports==="object"&&typeof module!=="undefined"?factory(exports):typeof define==="function"&&define.amd?define(["exports"],factory):(global=typeof globalThis!=="undefined"?globalThis:global||self,factory(global.SimpleJekyllSearch={}))})(this,(function(exports2){"use strict";function load(location,callback){const xhr=getXHR();xhr.open("GET",location,true);xhr.onreadystatechange=createStateChangeListener(xhr,callback);xhr.send()}function createStateChangeListener(xhr,callback){return function(){if(xhr.readyState===4&&xhr.status===200){try{callback(null,JSON.parse(xhr.responseText))}catch(err){callback(err instanceof Error?err:new Error(String(err)),null)}}}}function getXHR(){return window.XMLHttpRequest?new window.XMLHttpRequest:new window.ActiveXObject("Microsoft.XMLHTTP")}class OptionsValidator{constructor(params){if(!this.validateParams(params)){throw new Error("-- OptionsValidator: required options missing")}this.requiredOptions=params.required}getRequiredOptions(){return this.requiredOptions}validate(parameters){const errors=[];this.requiredOptions.forEach((requiredOptionName=>{if(typeof parameters[requiredOptionName]==="undefined"){errors.push(requiredOptionName)}}));return errors}validateParams(params){if(!params){return false}return typeof params.required!=="undefined"&&Array.isArray(params.required)}}function fuzzySearch(text,pattern){pattern=pattern.trimEnd();if(pattern.length===0)return true;pattern=pattern.toLowerCase();text=text.toLowerCase();let remainingText=text,currentIndex=-1;for(const char of pattern){const nextIndex=remainingText.indexOf(char);if(nextIndex===-1||currentIndex!==-1&&remainingText.slice(0,nextIndex).split(" ").length-1>2){return false}currentIndex=nextIndex;remainingText=remainingText.slice(nextIndex+1)}return true}function findFuzzyMatches$1(text,pattern){if(!text||!pattern)return[];const lowerText=text.toLowerCase();const lowerPattern=pattern.toLowerCase().trim();if(lowerPattern.length===0)return[];const patternWords=lowerPattern.split(/\s+/);const matches=[];for(const word of patternWords){if(word.length===0)continue;const wordMatches=findFuzzyWordMatches$1(lowerText,word);matches.push(...wordMatches)}return matches}function findFuzzyWordMatches$1(text,word){const matches=[];const exactRegex=new RegExp(`\\b${word.replace(/[.*+?^${}()|[\]\\]/g,"\\$&")}\\b`,"gi");let match;while((match=exactRegex.exec(text))!==null){matches.push({start:match.index,end:match.index+match[0].length,text:match[0],type:"exact"})}if(matches.length===0){for(let i=0;i<text.length;i++){const fuzzyMatch=findFuzzySequenceMatch$1(text,word,i);if(fuzzyMatch){matches.push({...fuzzyMatch,type:"fuzzy"});i=fuzzyMatch.end-1}}}return matches}function findFuzzySequenceMatch$1(text,pattern,startPos){let textIndex=startPos;let patternIndex=0;let matchStart=-1;let maxGap=3;const matchedPositions=[];while(textIndex<text.length&&patternIndex<pattern.length){if(text[textIndex]===pattern[patternIndex]){if(matchStart===-1){matchStart=textIndex}matchedPositions.push(textIndex);patternIndex++}else if(matchStart!==-1){if(textIndex-matchStart>maxGap*pattern.length){return null}}textIndex++}if(patternIndex===pattern.length&&matchStart!==-1&&matchedPositions.length>0){const actualStart=matchedPositions[0];const actualEnd=matchedPositions[matchedPositions.length-1]+1;return{start:actualStart,end:actualEnd,text:text.substring(actualStart,actualEnd)}}return null}function literalSearch(text,criteria){text=text.trim().toLowerCase();const pattern=criteria.endsWith(" ")?[criteria.toLowerCase()]:criteria.trim().toLowerCase().split(" ");return pattern.filter((word=>text.indexOf(word)>=0)).length===pattern.length}function findLiteralMatches(text,criteria){if(!text||!criteria)return[];const lowerText=text.toLowerCase();const words=criteria.trim().toLowerCase().split(/\s+/);const matches=[];let textIndex=0;for(const word of words){if(word.length===0)continue;const wordIndex=lowerText.indexOf(word,textIndex);if(wordIndex!==-1){matches.push({start:wordIndex,end:wordIndex+word.length,text:text.substring(wordIndex,wordIndex+word.length),type:"exact"});textIndex=wordIndex+word.length}}return matches}function levenshtein(a,b){const lenA=a.length;const lenB=b.length;const distanceMatrix=Array.from({length:lenA+1},(()=>Array(lenB+1).fill(0)));for(let i=0;i<=lenA;i++)distanceMatrix[i][0]=i;for(let j=0;j<=lenB;j++)distanceMatrix[0][j]=j;for(let i=1;i<=lenA;i++){for(let j=1;j<=lenB;j++){const cost=a[i-1]===b[j-1]?0:1;distanceMatrix[i][j]=Math.min(distanceMatrix[i-1][j]+1,distanceMatrix[i][j-1]+1,distanceMatrix[i-1][j-1]+cost)}}return distanceMatrix[lenA][lenB]}function levenshteinSearch(text,pattern){const distance=levenshtein(pattern,text);const similarity=1-distance/Math.max(pattern.length,text.length);return similarity>=.3}function findLevenshteinMatches(text,pattern){if(!text||!pattern)return[];const matches=[];const words=text.split(/\s+/);for(let i=0;i<words.length;i++){const word=words[i];if(levenshteinSearch(word,pattern)){const start=text.indexOf(word);matches.push({start:start,end:start+word.length,text:word,type:"wildcard"})}}return matches}function wildcardSearch(text,pattern){const regexPattern=pattern.replace(/\*/g,".*");const regex=new RegExp(`^${regexPattern}$`,"i");if(regex.test(text))return true;return levenshteinSearch(text,pattern)}function findWildcardMatches(text,pattern){if(!text||!pattern)return[];const wildcardMatches=findWildcardPatternMatches(text,pattern);if(wildcardMatches.length>0){return wildcardMatches}return findLevenshteinMatches(text,pattern)}function findWildcardPatternMatches(text,pattern){const matches=[];const regexPattern=pattern.replace(/\*/g,".*");const regex=new RegExp(regexPattern,"gi");let match;while((match=regex.exec(text))!==null){matches.push({start:match.index,end:match.index+match[0].length,text:match[0],type:"wildcard"})}return matches}class SearchStrategy{constructor(matchFunction,findMatchesFunction){this.matchFunction=matchFunction;this.findMatchesFunction=findMatchesFunction}matches(text,criteria){if(text===null||text.trim()===""||!criteria){return false}return this.matchFunction(text,criteria)}findMatches(text,criteria){if(text===null||text.trim()===""||!criteria||!this.findMatchesFunction){return[]}return this.findMatchesFunction(text,criteria)}}const LiteralSearchStrategy=new SearchStrategy(literalSearch,findLiteralMatches);const FuzzySearchStrategy=new SearchStrategy(((text,criteria)=>fuzzySearch(text,criteria)||literalSearch(text,criteria)),((text,criteria)=>{const fuzzyMatches=findFuzzyMatches$1(text,criteria);if(fuzzyMatches.length>0){return fuzzyMatches}return findLiteralMatches(text,criteria)}));const WildcardSearchStrategy=new SearchStrategy(((text,criteria)=>wildcardSearch(text,criteria)||literalSearch(text,criteria)),((text,criteria)=>{const wildcardMatches=findWildcardMatches(text,criteria);if(wildcardMatches.length>0){return wildcardMatches}return findLiteralMatches(text,criteria)}));function merge(target,source){return{...target,...source}}function isJSON(json){try{return!!(json instanceof Object&&JSON.parse(JSON.stringify(json)))}catch(_err){return false}}function NoSort(){return 0}function isObject(obj){return Boolean(obj)&&Object.prototype.toString.call(obj)==="[object Object]"}function clone(input){if(input===null||typeof input!=="object"){return input}if(Array.isArray(input)){return input.map((item=>clone(item)))}const output={};for(const key in input){if(Object.prototype.hasOwnProperty.call(input,key)){output[key]=clone(input[key])}}return output}const DEFAULT_OPTIONS={searchInput:null,resultsContainer:null,json:[],success:function(){},searchResultTemplate:'<li><a href="{url}" title="{desc}">{title}</a></li>',templateMiddleware:(_prop,_value,_template,_query)=>void 0,sortMiddleware:NoSort,noResultsText:"No results found",limit:10,fuzzy:false,strategy:"literal",debounceTime:null,exclude:[],onSearch:()=>{}};const REQUIRED_OPTIONS=["searchInput","resultsContainer","json"];const WHITELISTED_KEYS=new Set(["Enter","Shift","CapsLock","ArrowLeft","ArrowUp","ArrowRight","ArrowDown","Meta"]);class Repository{constructor(initialOptions={}){this.data=[];this.setOptions(initialOptions)}put(input){if(isObject(input)){return this.addObject(input)}if(Array.isArray(input)){return this.addArray(input)}return void 0}clear(){this.data.length=0;return this.data}search(criteria){if(!criteria){return[]}return clone(this.findMatches(this.data,criteria).sort(this.options.sortMiddleware))}setOptions(newOptions){this.options={fuzzy:(newOptions==null?void 0:newOptions.fuzzy)||DEFAULT_OPTIONS.fuzzy,limit:(newOptions==null?void 0:newOptions.limit)||DEFAULT_OPTIONS.limit,searchStrategy:this.searchStrategy((newOptions==null?void 0:newOptions.strategy)||newOptions.fuzzy&&"fuzzy"||DEFAULT_OPTIONS.strategy),sortMiddleware:(newOptions==null?void 0:newOptions.sortMiddleware)||DEFAULT_OPTIONS.sortMiddleware,exclude:(newOptions==null?void 0:newOptions.exclude)||DEFAULT_OPTIONS.exclude,strategy:(newOptions==null?void 0:newOptions.strategy)||DEFAULT_OPTIONS.strategy}}addObject(obj){this.data.push(obj);return this.data}addArray(arr){const added=[];this.clear();for(const item of arr){if(isObject(item)){added.push(this.addObject(item)[0])}}return added}findMatches(data,criteria){const matches=[];for(let i=0;i<data.length&&matches.length<this.options.limit;i++){const match=this.findMatchesInObject(data[i],criteria);if(match){matches.push(match)}}return matches}findMatchesInObject(obj,criteria){var _a,_b;for(const key in obj){if(!this.isExcluded(obj[key])&&this.options.searchStrategy.matches(obj[key],criteria)){const matchInfo=(_b=(_a=this.options.searchStrategy).findMatches)==null?void 0:_b.call(_a,obj[key],criteria);const result={...obj};if(matchInfo&&matchInfo.length>0){result._matchInfo={[key]:matchInfo}}return result}}return void 0}isExcluded(term){for(const excludedTerm of this.options.exclude){if(new RegExp(excludedTerm).test(String(term))){return true}}return false}searchStrategy(strategy){switch(strategy){case"fuzzy":return FuzzySearchStrategy;case"wildcard":return WildcardSearchStrategy;default:return LiteralSearchStrategy}}}const options={pattern:/\{(.*?)\}/g,template:"",middleware:function(){return void 0}};function setOptions(_options){if(_options.pattern){options.pattern=_options.pattern}if(_options.template){options.template=_options.template}if(typeof _options.middleware==="function"){options.middleware=_options.middleware}}function compile(data,query){return options.template.replace(options.pattern,(function(match,prop){if(options.middleware.length>=5&&data._matchInfo&&data._matchInfo[prop]){const value2=options.middleware(prop,data[prop],options.template,query,data._matchInfo[prop]);if(typeof value2!=="undefined"){return value2}}const value=options.middleware(prop,data[prop],options.template,query);if(typeof value!=="undefined"){return value}return data[prop]||match}))}let SimpleJekyllSearch$1=class SimpleJekyllSearch{constructor(){this.debounceTimerHandle=null;this.options={...DEFAULT_OPTIONS};this.repository=new Repository;this.optionsValidator=new OptionsValidator({required:REQUIRED_OPTIONS})}debounce(func,delayMillis){if(delayMillis){if(this.debounceTimerHandle){clearTimeout(this.debounceTimerHandle)}this.debounceTimerHandle=setTimeout(func,delayMillis)}else{func()}}throwError(message){throw new Error(`SimpleJekyllSearch --- ${message}`)}emptyResultsContainer(){this.options.resultsContainer.innerHTML=""}initWithJSON(json){this.repository.put(json);this.registerInput()}initWithURL(url){load(url,((err,json)=>{if(err){this.throwError(`Failed to load JSON from ${url}: ${err.message}`)}this.initWithJSON(json)}))}registerInput(){this.options.searchInput.addEventListener("input",(e=>{const inputEvent=e;if(!WHITELISTED_KEYS.has(inputEvent.key)){this.emptyResultsContainer();this.debounce((()=>{this.search(e.target.value)}),this.options.debounceTime??null)}}))}search(query){var _a,_b;if((query==null?void 0:query.trim().length)>0){this.emptyResultsContainer();const results=this.repository.search(query);this.render(results,query);(_b=(_a=this.options).onSearch)==null?void 0:_b.call(_a)}}render(results,query){if(results.length===0){this.options.resultsContainer.insertAdjacentHTML("beforeend",this.options.noResultsText);return}const fragment=document.createDocumentFragment();results.forEach((result=>{result.query=query;const div=document.createElement("div");div.innerHTML=compile(result,query);fragment.appendChild(div)}));this.options.resultsContainer.appendChild(fragment)}init(_options){var _a;const errors=this.optionsValidator.validate(_options);if(errors.length>0){this.throwError(`Missing required options: ${REQUIRED_OPTIONS.join(", ")}`)}this.options=merge(this.options,_options);setOptions({template:this.options.searchResultTemplate,middleware:this.options.templateMiddleware});this.repository.setOptions({fuzzy:this.options.fuzzy,limit:this.options.limit,sortMiddleware:this.options.sortMiddleware,strategy:this.options.strategy,exclude:this.options.exclude});if(isJSON(this.options.json)){this.initWithJSON(this.options.json)}else{this.initWithURL(this.options.json)}const rv={search:this.search.bind(this)};(_a=this.options.success)==null?void 0:_a.call(rv);return rv}};function createHighlightMiddleware(options2={}){const{highlightClass:highlightClass="sjs-highlight",contextBefore:contextBefore=50,contextAfter:contextAfter=50,maxLength:maxLength=250,ellipsis:ellipsis="..."}=options2;return function(result,query){if(!query||!result){return result}const highlightedResult={...result};const textFields=["title","desc","content","excerpt"];for(const field of textFields){if(highlightedResult[field]&&typeof highlightedResult[field]==="string"){const highlighted=highlightText(highlightedResult[field],query,{highlightClass:highlightClass,contextBefore:contextBefore,contextAfter:contextAfter,maxLength:maxLength,ellipsis:ellipsis});if(highlighted.highlightedText!==highlightedResult[field]){highlightedResult[field]=highlighted.highlightedText}}}return highlightedResult}}function highlightText(text,query,options2={}){const{highlightClass:highlightClass="sjs-highlight",contextBefore:contextBefore=50,contextAfter:contextAfter=50,maxLength:maxLength=250,ellipsis:ellipsis="..."}=options2;if(!text||!query){return{highlightedText:text,matchCount:0}}const originalText=text;const searchTerms=query.trim().toLowerCase().split(/\s+/).filter((term=>term.length>0));if(searchTerms.length===0){return{highlightedText:text,matchCount:0}}const matches=[];for(const term of searchTerms){let index=0;while(index<text.length){const found=text.toLowerCase().indexOf(term,index);if(found===-1)break;matches.push({start:found,end:found+term.length,term:text.substring(found,found+term.length)});index=found+1}}if(matches.length===0){return{highlightedText:text,matchCount:0}}matches.sort(((a,b)=>a.start-b.start));const mergedMatches=[];for(const match of matches){if(mergedMatches.length===0||mergedMatches[mergedMatches.length-1].end<match.start){mergedMatches.push(match)}else{const lastMatch=mergedMatches[mergedMatches.length-1];lastMatch.end=Math.max(lastMatch.end,match.end);lastMatch.term=text.substring(lastMatch.start,lastMatch.end)}}if(text.length<=maxLength){let highlightedText2=text;for(let i=mergedMatches.length-1;i>=0;i--){const match=mergedMatches[i];const before=highlightedText2.substring(0,match.start);const after=highlightedText2.substring(match.end);const matchText=highlightedText2.substring(match.start,match.end);highlightedText2=before+`<span class="${highlightClass}">${matchText}</span>`+after}return{highlightedText:highlightedText2,matchCount:mergedMatches.length}}let highlightedText="";let totalLength=0;let lastEnd=0;for(let i=0;i<mergedMatches.length;i++){const match=mergedMatches[i];const contextStart=Math.max(lastEnd,match.start-contextBefore);const contextEnd=Math.min(text.length,match.end+contextAfter);if(contextStart>lastEnd&&lastEnd>0){highlightedText+=ellipsis;totalLength+=ellipsis.length}if(contextStart<match.start){const beforeText=text.substring(contextStart,match.start);highlightedText+=beforeText;totalLength+=beforeText.length}const matchText=text.substring(match.start,match.end);highlightedText+=`<span class="${highlightClass}">${matchText}</span>`;totalLength+=matchText.length;if(match.end<contextEnd){const afterText=text.substring(match.end,contextEnd);highlightedText+=afterText;totalLength+=afterText.length}lastEnd=contextEnd;if(totalLength>=maxLength){if(contextEnd<text.length){highlightedText+=ellipsis}break}}return{highlightedText:highlightedText||originalText,matchCount:mergedMatches.length}}const defaultHighlightMiddleware=createHighlightMiddleware();function findFuzzyMatches(text,pattern){const matches=[];const lowerText=text.toLowerCase();const lowerPattern=pattern.toLowerCase().trim();if(lowerPattern.length===0)return matches;const patternWords=lowerPattern.split(/\s+/);for(const word of patternWords){if(word.length===0)continue;const wordMatches=findFuzzyWordMatches(lowerText,word);matches.push(...wordMatches)}return matches}function findFuzzyWordMatches(text,word){const matches=[];const exactRegex=new RegExp(`\\b${word.replace(/[.*+?^${}()|[\]\\]/g,"\\$&")}\\b`,"gi");let match;while((match=exactRegex.exec(text))!==null){matches.push({start:match.index,end:match.index+match[0].length,text:match[0]})}if(matches.length===0){for(let i=0;i<text.length;i++){const fuzzyMatch=findFuzzySequenceMatch(text,word,i);if(fuzzyMatch){matches.push(fuzzyMatch);i=fuzzyMatch.end-1}}}return matches}function findFuzzySequenceMatch(text,pattern,startPos){let textIndex=startPos;let patternIndex=0;let matchStart=-1;let maxGap=3;const matchedPositions=[];while(textIndex<text.length&&patternIndex<pattern.length){if(text[textIndex]===pattern[patternIndex]){if(matchStart===-1){matchStart=textIndex}matchedPositions.push(textIndex);patternIndex++}else if(matchStart!==-1){if(textIndex-matchStart>maxGap*pattern.length){return null}}textIndex++}if(patternIndex===pattern.length&&matchStart!==-1&&matchedPositions.length>0){const actualStart=matchedPositions[0];const actualEnd=matchedPositions[matchedPositions.length-1]+1;return{start:actualStart,end:actualEnd,text:text.substring(actualStart,actualEnd)}}return null}function createHighlightTemplateMiddleware(options2={}){const highlightOptions={highlightClass:"sjs-highlight",...options2};return function(prop,value,_template,query){if((prop==="content"||prop==="desc")&&query&&typeof value==="string"){let highlightedText=value;let hasMatches=false;const searchTerms=query.trim().split(/\s+/).filter((term=>term.length>0));for(const term of searchTerms){const regex=new RegExp(`\\b(${term.replace(/[.*+?^${}()|[\]\\]/g,"\\$&")})\\b`,"gi");if(regex.test(highlightedText)){highlightedText=highlightedText.replace(regex,`<span class="${highlightOptions.highlightClass}">$1</span>`);hasMatches=true}}if(!hasMatches){const fuzzyMatches=findFuzzyMatches(value,query);if(fuzzyMatches.length>0){fuzzyMatches.sort(((a,b)=>b.start-a.start));for(const match of fuzzyMatches){const before=highlightedText.substring(0,match.start);const after=highlightedText.substring(match.end);const matchText=highlightedText.substring(match.start,match.end);highlightedText=before+`<span class="${highlightOptions.highlightClass}">${matchText}</span>`+after}hasMatches=true}}if(hasMatches){return highlightedText}}return void 0}}const defaultHighlightTemplateMiddleware=createHighlightTemplateMiddleware();function SimpleJekyllSearch(options2){const instance=new SimpleJekyllSearch$1;return instance.init(options2)}if(typeof window!=="undefined"){window.SimpleJekyllSearch=SimpleJekyllSearch;window.SimpleJekyllSearch.createHighlightMiddleware=createHighlightMiddleware;window.SimpleJekyllSearch.createHighlightTemplateMiddleware=createHighlightTemplateMiddleware;window.SimpleJekyllSearch.highlightText=highlightText;window.SimpleJekyllSearch.defaultHighlightMiddleware=defaultHighlightMiddleware;window.SimpleJekyllSearch.defaultHighlightTemplateMiddleware=defaultHighlightTemplateMiddleware}exports2.createHighlightMiddleware=createHighlightMiddleware;exports2.createHighlightTemplateMiddleware=createHighlightTemplateMiddleware;exports2.default=SimpleJekyllSearch;exports2.defaultHighlightMiddleware=defaultHighlightMiddleware;exports2.defaultHighlightTemplateMiddleware=defaultHighlightTemplateMiddleware;exports2.highlightText=highlightText;Object.defineProperties(exports2,{__esModule:{value:true},[Symbol.toStringTag]:{value:"Module"}})}));
\ No newline at end of file
+(function(global,factory){typeof exports==="object"&&typeof module!=="undefined"?factory(exports):typeof define==="function"&&define.amd?define(["exports"],factory):(global=typeof globalThis!=="undefined"?globalThis:global||self,factory(global.SimpleJekyllSearch={}))})(this,(function(exports2){"use strict";function load(location,callback){const xhr=getXHR();xhr.open("GET",location,true);xhr.onreadystatechange=createStateChangeListener(xhr,callback);xhr.send()}function createStateChangeListener(xhr,callback){return function(){if(xhr.readyState===4&&xhr.status===200){try{callback(null,JSON.parse(xhr.responseText))}catch(err){callback(err instanceof Error?err:new Error(String(err)),null)}}}}function getXHR(){return window.XMLHttpRequest?new window.XMLHttpRequest:new window.ActiveXObject("Microsoft.XMLHTTP")}class OptionsValidator{constructor(params){if(!this.validateParams(params)){throw new Error("-- OptionsValidator: required options missing")}this.requiredOptions=params.required}getRequiredOptions(){return this.requiredOptions}validate(parameters){const errors=[];this.requiredOptions.forEach((requiredOptionName=>{if(typeof parameters[requiredOptionName]==="undefined"){errors.push(requiredOptionName)}}));return errors}validateParams(params){if(!params){return false}return typeof params.required!=="undefined"&&Array.isArray(params.required)}}function fuzzySearch(text,pattern){pattern=pattern.trimEnd();if(pattern.length===0)return true;pattern=pattern.toLowerCase();text=text.toLowerCase();let remainingText=text,currentIndex=-1;for(const char of pattern){const nextIndex=remainingText.indexOf(char);if(nextIndex===-1||currentIndex!==-1&&remainingText.slice(0,nextIndex).split(" ").length-1>2){return false}currentIndex=nextIndex;remainingText=remainingText.slice(nextIndex+1)}return true}function findFuzzyMatches$1(text,pattern){if(!text||!pattern)return[];const lowerText=text.toLowerCase();const lowerPattern=pattern.toLowerCase().trim();if(lowerPattern.length===0)return[];const patternWords=lowerPattern.split(/\s+/);const matches=[];for(const word of patternWords){if(word.length===0)continue;const wordMatches=findFuzzyWordMatches$1(lowerText,word);matches.push(...wordMatches)}return mergeAndSortMatches$1(matches)}function findFuzzyWordMatches$1(text,word){const matches=[];const exactRegex=new RegExp(`\\b${word.replace(/[.*+?^${}()|[\]\\]/g,"\\$&")}\\b`,"gi");let match;while((match=exactRegex.exec(text))!==null){matches.push({start:match.index,end:match.index+match[0].length,text:match[0],type:"exact"})}if(matches.length===0){for(let i=0;i<text.length;i++){const fuzzyMatch=findFuzzySequenceMatch$1(text,word,i);if(fuzzyMatch){matches.push({...fuzzyMatch,type:"fuzzy"});i=fuzzyMatch.end-1}}}return matches}function findFuzzySequenceMatch$1(text,pattern,startPos){let textIndex=startPos;let patternIndex=0;let matchStart=-1;let maxGap=3;const matchedPositions=[];while(textIndex<text.length&&patternIndex<pattern.length){if(text[textIndex]===pattern[patternIndex]){if(matchStart===-1){matchStart=textIndex}matchedPositions.push(textIndex);patternIndex++}else if(matchStart!==-1){if(textIndex-matchStart>maxGap*pattern.length){return null}}textIndex++}if(patternIndex===pattern.length&&matchStart!==-1&&matchedPositions.length>0){const actualStart=matchedPositions[0];const actualEnd=matchedPositions[matchedPositions.length-1]+1;return{start:actualStart,end:actualEnd,text:text.substring(actualStart,actualEnd)}}return null}function mergeAndSortMatches$1(matches){if(matches.length===0)return[];const sortedMatches=matches.sort(((a,b)=>a.start-b.start));const merged=[];for(const match of sortedMatches){const lastMerged=merged[merged.length-1];if(lastMerged&&match.start<=lastMerged.end){lastMerged.end=Math.max(lastMerged.end,match.end);lastMerged.text=lastMerged.text+match.text.slice(lastMerged.end-match.start)}else{merged.push({...match})}}return merged}function literalSearch(text,criteria){text=text.trim().toLowerCase();const pattern=criteria.endsWith(" ")?[criteria.toLowerCase()]:criteria.trim().toLowerCase().split(" ");return pattern.filter((word=>text.indexOf(word)>=0)).length===pattern.length}function findLiteralMatches(text,criteria){if(!text||!criteria)return[];const lowerText=text.toLowerCase();const words=criteria.trim().toLowerCase().split(/\s+/);const matches=[];let textIndex=0;for(const word of words){if(word.length===0)continue;const wordIndex=lowerText.indexOf(word,textIndex);if(wordIndex!==-1){matches.push({start:wordIndex,end:wordIndex+word.length,text:text.substring(wordIndex,wordIndex+word.length),type:"exact"});textIndex=wordIndex+word.length}}return matches}function levenshtein(a,b){const lenA=a.length;const lenB=b.length;const distanceMatrix=Array.from({length:lenA+1},(()=>Array(lenB+1).fill(0)));for(let i=0;i<=lenA;i++)distanceMatrix[i][0]=i;for(let j=0;j<=lenB;j++)distanceMatrix[0][j]=j;for(let i=1;i<=lenA;i++){for(let j=1;j<=lenB;j++){const cost=a[i-1]===b[j-1]?0:1;distanceMatrix[i][j]=Math.min(distanceMatrix[i-1][j]+1,distanceMatrix[i][j-1]+1,distanceMatrix[i-1][j-1]+cost)}}return distanceMatrix[lenA][lenB]}function levenshteinSearch(text,pattern){const distance=levenshtein(pattern,text);const similarity=1-distance/Math.max(pattern.length,text.length);return similarity>=.3}function findLevenshteinMatches(text,pattern){if(!text||!pattern)return[];const matches=[];const words=text.split(/\s+/);for(let i=0;i<words.length;i++){const word=words[i];if(levenshteinSearch(word,pattern)){const start=text.indexOf(word);matches.push({start:start,end:start+word.length,text:word,type:"wildcard"})}}return matches}function wildcardSearch(text,pattern){const regexPattern=pattern.replace(/\*/g,".*");const regex=new RegExp(`^${regexPattern}$`,"i");if(regex.test(text))return true;return levenshteinSearch(text,pattern)}function findWildcardMatches(text,pattern){if(!text||!pattern)return[];const wildcardMatches=findWildcardPatternMatches(text,pattern);if(wildcardMatches.length>0){return mergeAndSortMatches(wildcardMatches)}const levenshteinMatches=findLevenshteinMatches(text,pattern);return mergeAndSortMatches(levenshteinMatches)}function findWildcardPatternMatches(text,pattern){const matches=[];const regexPattern=pattern.replace(/\*/g,".*");const regex=new RegExp(regexPattern,"gi");let match;while((match=regex.exec(text))!==null){matches.push({start:match.index,end:match.index+match[0].length,text:match[0],type:"wildcard"})}return matches}function mergeAndSortMatches(matches){if(matches.length===0)return[];const sortedMatches=matches.sort(((a,b)=>a.start-b.start));const merged=[];for(const match of sortedMatches){const lastMerged=merged[merged.length-1];if(lastMerged&&match.start<=lastMerged.end){lastMerged.end=Math.max(lastMerged.end,match.end);lastMerged.text=lastMerged.text+match.text.slice(lastMerged.end-match.start)}else{merged.push({...match})}}return merged}class SearchStrategy{constructor(matchFunction,findMatchesFunction){this.matchFunction=matchFunction;this.findMatchesFunction=findMatchesFunction}matches(text,criteria){if(text===null||text.trim()===""||!criteria){return false}return this.matchFunction(text,criteria)}findMatches(text,criteria){if(text===null||text.trim()===""||!criteria||!this.findMatchesFunction){return[]}return this.findMatchesFunction(text,criteria)}}const LiteralSearchStrategy=new SearchStrategy(literalSearch,findLiteralMatches);const FuzzySearchStrategy=new SearchStrategy(((text,criteria)=>fuzzySearch(text,criteria)||literalSearch(text,criteria)),((text,criteria)=>{const fuzzyMatches=findFuzzyMatches$1(text,criteria);if(fuzzyMatches.length>0){return fuzzyMatches}return findLiteralMatches(text,criteria)}));const WildcardSearchStrategy=new SearchStrategy(((text,criteria)=>wildcardSearch(text,criteria)||literalSearch(text,criteria)),((text,criteria)=>{const wildcardMatches=findWildcardMatches(text,criteria);if(wildcardMatches.length>0){return wildcardMatches}return findLiteralMatches(text,criteria)}));function merge(target,source){return{...target,...source}}function isJSON(json){try{return!!(json instanceof Object&&JSON.parse(JSON.stringify(json)))}catch(_err){return false}}function NoSort(){return 0}function isObject(obj){return Boolean(obj)&&Object.prototype.toString.call(obj)==="[object Object]"}function clone(input){if(input===null||typeof input!=="object"){return input}if(Array.isArray(input)){return input.map((item=>clone(item)))}const output={};for(const key in input){if(Object.prototype.hasOwnProperty.call(input,key)){output[key]=clone(input[key])}}return output}const DEFAULT_OPTIONS={searchInput:null,resultsContainer:null,json:[],success:function(){},searchResultTemplate:'<li><a href="{url}" title="{desc}">{title}</a></li>',templateMiddleware:(_prop,_value,_template,_query)=>void 0,sortMiddleware:NoSort,noResultsText:"No results found",limit:10,fuzzy:false,strategy:"literal",debounceTime:null,exclude:[],onSearch:()=>{}};const REQUIRED_OPTIONS=["searchInput","resultsContainer","json"];const WHITELISTED_KEYS=new Set(["Enter","Shift","CapsLock","ArrowLeft","ArrowUp","ArrowRight","ArrowDown","Meta"]);class Repository{constructor(initialOptions={}){this.data=[];this.setOptions(initialOptions)}put(input){if(isObject(input)){return this.addObject(input)}if(Array.isArray(input)){return this.addArray(input)}return void 0}clear(){this.data.length=0;return this.data}search(criteria){if(!criteria){return[]}return clone(this.findMatches(this.data,criteria).sort(this.options.sortMiddleware))}setOptions(newOptions){this.options={fuzzy:(newOptions==null?void 0:newOptions.fuzzy)||DEFAULT_OPTIONS.fuzzy,limit:(newOptions==null?void 0:newOptions.limit)||DEFAULT_OPTIONS.limit,searchStrategy:this.searchStrategy((newOptions==null?void 0:newOptions.strategy)||newOptions.fuzzy&&"fuzzy"||DEFAULT_OPTIONS.strategy),sortMiddleware:(newOptions==null?void 0:newOptions.sortMiddleware)||DEFAULT_OPTIONS.sortMiddleware,exclude:(newOptions==null?void 0:newOptions.exclude)||DEFAULT_OPTIONS.exclude,strategy:(newOptions==null?void 0:newOptions.strategy)||DEFAULT_OPTIONS.strategy}}addObject(obj){this.data.push(obj);return this.data}addArray(arr){const added=[];this.clear();for(const item of arr){if(isObject(item)){added.push(this.addObject(item)[0])}}return added}findMatches(data,criteria){const matches=[];for(let i=0;i<data.length&&matches.length<this.options.limit;i++){const match=this.findMatchesInObject(data[i],criteria);if(match){matches.push(match)}}return matches}findMatchesInObject(obj,criteria){var _a,_b;for(const key in obj){if(!this.isExcluded(obj[key])&&this.options.searchStrategy.matches(obj[key],criteria)){const matchInfo=(_b=(_a=this.options.searchStrategy).findMatches)==null?void 0:_b.call(_a,obj[key],criteria);const result={...obj};if(matchInfo&&matchInfo.length>0){result._matchInfo={[key]:matchInfo}}return result}}return void 0}isExcluded(term){for(const excludedTerm of this.options.exclude){if(new RegExp(excludedTerm).test(String(term))){return true}}return false}searchStrategy(strategy){switch(strategy){case"fuzzy":return FuzzySearchStrategy;case"wildcard":return WildcardSearchStrategy;default:return LiteralSearchStrategy}}}const options={pattern:/\{(.*?)\}/g,template:"",middleware:function(){return void 0}};function setOptions(_options){if(_options.pattern){options.pattern=_options.pattern}if(_options.template){options.template=_options.template}if(typeof _options.middleware==="function"){options.middleware=_options.middleware}}function compile(data,query){return options.template.replace(options.pattern,(function(match,prop){if(options.middleware.length>=5&&data._matchInfo&&data._matchInfo[prop]){const value2=options.middleware(prop,data[prop],options.template,query,data._matchInfo[prop]);if(typeof value2!=="undefined"){return value2}}const value=options.middleware(prop,data[prop],options.template,query);if(typeof value!=="undefined"){return value}return data[prop]||match}))}let SimpleJekyllSearch$1=class SimpleJekyllSearch{constructor(){this.debounceTimerHandle=null;this.options={...DEFAULT_OPTIONS};this.repository=new Repository;this.optionsValidator=new OptionsValidator({required:REQUIRED_OPTIONS})}debounce(func,delayMillis){if(delayMillis){if(this.debounceTimerHandle){clearTimeout(this.debounceTimerHandle)}this.debounceTimerHandle=setTimeout(func,delayMillis)}else{func()}}throwError(message){throw new Error(`SimpleJekyllSearch --- ${message}`)}emptyResultsContainer(){this.options.resultsContainer.innerHTML=""}initWithJSON(json){this.repository.put(json);this.registerInput()}initWithURL(url){load(url,((err,json)=>{if(err){this.throwError(`Failed to load JSON from ${url}: ${err.message}`)}this.initWithJSON(json)}))}registerInput(){this.options.searchInput.addEventListener("input",(e=>{const inputEvent=e;if(!WHITELISTED_KEYS.has(inputEvent.key)){this.emptyResultsContainer();this.debounce((()=>{this.search(e.target.value)}),this.options.debounceTime??null)}}))}search(query){var _a,_b;if((query==null?void 0:query.trim().length)>0){this.emptyResultsContainer();const results=this.repository.search(query);this.render(results,query);(_b=(_a=this.options).onSearch)==null?void 0:_b.call(_a)}}render(results,query){if(results.length===0){this.options.resultsContainer.insertAdjacentHTML("beforeend",this.options.noResultsText);return}const fragment=document.createDocumentFragment();results.forEach((result=>{result.query=query;const div=document.createElement("div");div.innerHTML=compile(result,query);fragment.appendChild(div)}));this.options.resultsContainer.appendChild(fragment)}init(_options){var _a;const errors=this.optionsValidator.validate(_options);if(errors.length>0){this.throwError(`Missing required options: ${REQUIRED_OPTIONS.join(", ")}`)}this.options=merge(this.options,_options);setOptions({template:this.options.searchResultTemplate,middleware:this.options.templateMiddleware});this.repository.setOptions({fuzzy:this.options.fuzzy,limit:this.options.limit,sortMiddleware:this.options.sortMiddleware,strategy:this.options.strategy,exclude:this.options.exclude});if(isJSON(this.options.json)){this.initWithJSON(this.options.json)}else{this.initWithURL(this.options.json)}const rv={search:this.search.bind(this)};(_a=this.options.success)==null?void 0:_a.call(rv);return rv}};function createHighlightMiddleware(options2={}){const{highlightClass:highlightClass="sjs-highlight",contextBefore:contextBefore=50,contextAfter:contextAfter=50,maxLength:maxLength=250,ellipsis:ellipsis="..."}=options2;return function(result,query){if(!query||!result){return result}const highlightedResult={...result};const textFields=["title","desc","content","excerpt"];for(const field of textFields){if(highlightedResult[field]&&typeof highlightedResult[field]==="string"){const highlighted=highlightText(highlightedResult[field],query,{highlightClass:highlightClass,contextBefore:contextBefore,contextAfter:contextAfter,maxLength:maxLength,ellipsis:ellipsis});if(highlighted.highlightedText!==highlightedResult[field]){highlightedResult[field]=highlighted.highlightedText}}}return highlightedResult}}function highlightText(text,query,options2={}){const{highlightClass:highlightClass="sjs-highlight",contextBefore:contextBefore=50,contextAfter:contextAfter=50,maxLength:maxLength=250,ellipsis:ellipsis="..."}=options2;if(!text||!query){return{highlightedText:text,matchCount:0}}const originalText=text;const searchTerms=query.trim().toLowerCase().split(/\s+/).filter((term=>term.length>0));if(searchTerms.length===0){return{highlightedText:text,matchCount:0}}const matches=[];for(const term of searchTerms){let index=0;while(index<text.length){const found=text.toLowerCase().indexOf(term,index);if(found===-1)break;matches.push({start:found,end:found+term.length,term:text.substring(found,found+term.length)});index=found+1}}if(matches.length===0){return{highlightedText:text,matchCount:0}}matches.sort(((a,b)=>a.start-b.start));const mergedMatches=[];for(const match of matches){if(mergedMatches.length===0||mergedMatches[mergedMatches.length-1].end<match.start){mergedMatches.push(match)}else{const lastMatch=mergedMatches[mergedMatches.length-1];lastMatch.end=Math.max(lastMatch.end,match.end);lastMatch.term=text.substring(lastMatch.start,lastMatch.end)}}if(text.length<=maxLength){let highlightedText2=text;for(let i=mergedMatches.length-1;i>=0;i--){const match=mergedMatches[i];const before=highlightedText2.substring(0,match.start);const after=highlightedText2.substring(match.end);const matchText=highlightedText2.substring(match.start,match.end);highlightedText2=before+`<span class="${highlightClass}">${matchText}</span>`+after}return{highlightedText:highlightedText2,matchCount:mergedMatches.length}}let highlightedText="";let totalLength=0;let lastEnd=0;for(let i=0;i<mergedMatches.length;i++){const match=mergedMatches[i];const contextStart=Math.max(lastEnd,match.start-contextBefore);const contextEnd=Math.min(text.length,match.end+contextAfter);if(contextStart>lastEnd&&lastEnd>0){highlightedText+=ellipsis;totalLength+=ellipsis.length}if(contextStart<match.start){const beforeText=text.substring(contextStart,match.start);highlightedText+=beforeText;totalLength+=beforeText.length}const matchText=text.substring(match.start,match.end);highlightedText+=`<span class="${highlightClass}">${matchText}</span>`;totalLength+=matchText.length;if(match.end<contextEnd){const afterText=text.substring(match.end,contextEnd);highlightedText+=afterText;totalLength+=afterText.length}lastEnd=contextEnd;if(totalLength>=maxLength){if(contextEnd<text.length){highlightedText+=ellipsis}break}}return{highlightedText:highlightedText||originalText,matchCount:mergedMatches.length}}const defaultHighlightMiddleware=createHighlightMiddleware();function findFuzzyMatches(text,pattern){const matches=[];const lowerText=text.toLowerCase();const lowerPattern=pattern.toLowerCase().trim();if(lowerPattern.length===0)return matches;const patternWords=lowerPattern.split(/\s+/);for(const word of patternWords){if(word.length===0)continue;const wordMatches=findFuzzyWordMatches(lowerText,word);matches.push(...wordMatches)}return matches}function findFuzzyWordMatches(text,word){const matches=[];const exactRegex=new RegExp(`\\b${word.replace(/[.*+?^${}()|[\]\\]/g,"\\$&")}\\b`,"gi");let match;while((match=exactRegex.exec(text))!==null){matches.push({start:match.index,end:match.index+match[0].length,text:match[0]})}if(matches.length===0){for(let i=0;i<text.length;i++){const fuzzyMatch=findFuzzySequenceMatch(text,word,i);if(fuzzyMatch){matches.push(fuzzyMatch);i=fuzzyMatch.end-1}}}return matches}function findFuzzySequenceMatch(text,pattern,startPos){let textIndex=startPos;let patternIndex=0;let matchStart=-1;let maxGap=3;const matchedPositions=[];while(textIndex<text.length&&patternIndex<pattern.length){if(text[textIndex]===pattern[patternIndex]){if(matchStart===-1){matchStart=textIndex}matchedPositions.push(textIndex);patternIndex++}else if(matchStart!==-1){if(textIndex-matchStart>maxGap*pattern.length){return null}}textIndex++}if(patternIndex===pattern.length&&matchStart!==-1&&matchedPositions.length>0){const actualStart=matchedPositions[0];const actualEnd=matchedPositions[matchedPositions.length-1]+1;return{start:actualStart,end:actualEnd,text:text.substring(actualStart,actualEnd)}}return null}function highlightWithMatchInfo(text,matchInfo,options2){if(matchInfo.length===0)return text;const sortedMatches=[...matchInfo].sort(((a,b)=>b.start-a.start));let highlightedText=text;for(const match of sortedMatches){const before=highlightedText.substring(0,match.start);const after=highlightedText.substring(match.end);const matchText=highlightedText.substring(match.start,match.end);highlightedText=before+`<span class="${options2.highlightClass}">${matchText}</span>`+after}return highlightedText}function highlightWithQuery(text,query,options2){let highlightedText=text;let hasMatches=false;const searchTerms=query.trim().split(/\s+/).filter((term=>term.length>0));for(const term of searchTerms){const regex=new RegExp(`\\b(${term.replace(/[.*+?^${}()|[\]\\]/g,"\\$&")})\\b`,"gi");if(regex.test(highlightedText)){highlightedText=highlightedText.replace(regex,`<span class="${options2.highlightClass}">$1</span>`);hasMatches=true}}if(!hasMatches){const fuzzyMatches=findFuzzyMatches(text,query);if(fuzzyMatches.length>0){fuzzyMatches.sort(((a,b)=>b.start-a.start));for(const match of fuzzyMatches){const before=highlightedText.substring(0,match.start);const after=highlightedText.substring(match.end);const matchText=highlightedText.substring(match.start,match.end);highlightedText=before+`<span class="${options2.highlightClass}">${matchText}</span>`+after}hasMatches=true}}return highlightedText}function createHighlightTemplateMiddleware(options2={}){const highlightOptions={highlightClass:"sjs-highlight",...options2};return function(prop,value,_template,query,matchInfo){if((prop==="content"||prop==="desc")&&query&&typeof value==="string"){if(matchInfo&&matchInfo.length>0){const highlighted2=highlightWithMatchInfo(value,matchInfo,highlightOptions);return highlighted2!==value?highlighted2:void 0}const highlighted=highlightWithQuery(value,query,highlightOptions);return highlighted!==value?highlighted:void 0}return void 0}}const defaultHighlightTemplateMiddleware=createHighlightTemplateMiddleware();function SimpleJekyllSearch(options2){const instance=new SimpleJekyllSearch$1;return instance.init(options2)}if(typeof window!=="undefined"){window.SimpleJekyllSearch=SimpleJekyllSearch;window.SimpleJekyllSearch.createHighlightMiddleware=createHighlightMiddleware;window.SimpleJekyllSearch.createHighlightTemplateMiddleware=createHighlightTemplateMiddleware;window.SimpleJekyllSearch.highlightText=highlightText;window.SimpleJekyllSearch.defaultHighlightMiddleware=defaultHighlightMiddleware;window.SimpleJekyllSearch.defaultHighlightTemplateMiddleware=defaultHighlightTemplateMiddleware}exports2.createHighlightMiddleware=createHighlightMiddleware;exports2.createHighlightTemplateMiddleware=createHighlightTemplateMiddleware;exports2.default=SimpleJekyllSearch;exports2.defaultHighlightMiddleware=defaultHighlightMiddleware;exports2.defaultHighlightTemplateMiddleware=defaultHighlightTemplateMiddleware;exports2.highlightText=highlightText;Object.defineProperties(exports2,{__esModule:{value:true},[Symbol.toStringTag]:{value:"Module"}})}));
\ No newline at end of file
diff --git a/docs/assets/js/simple-jekyll-search.min.js b/docs/assets/js/simple-jekyll-search.min.js
index 84bfcd8..8056511 100644
--- a/docs/assets/js/simple-jekyll-search.min.js
+++ b/docs/assets/js/simple-jekyll-search.min.js
@@ -4,4 +4,4 @@
   * Copyright 2025-2025, Sylhare
   * Licensed under the MIT License.
   */
-(function(global,factory){typeof exports==="object"&&typeof module!=="undefined"?factory(exports):typeof define==="function"&&define.amd?define(["exports"],factory):(global=typeof globalThis!=="undefined"?globalThis:global||self,factory(global.SimpleJekyllSearch={}))})(this,(function(exports2){"use strict";function load(location,callback){const xhr=getXHR();xhr.open("GET",location,true);xhr.onreadystatechange=createStateChangeListener(xhr,callback);xhr.send()}function createStateChangeListener(xhr,callback){return function(){if(xhr.readyState===4&&xhr.status===200){try{callback(null,JSON.parse(xhr.responseText))}catch(err){callback(err instanceof Error?err:new Error(String(err)),null)}}}}function getXHR(){return window.XMLHttpRequest?new window.XMLHttpRequest:new window.ActiveXObject("Microsoft.XMLHTTP")}class OptionsValidator{constructor(params){if(!this.validateParams(params)){throw new Error("-- OptionsValidator: required options missing")}this.requiredOptions=params.required}getRequiredOptions(){return this.requiredOptions}validate(parameters){const errors=[];this.requiredOptions.forEach((requiredOptionName=>{if(typeof parameters[requiredOptionName]==="undefined"){errors.push(requiredOptionName)}}));return errors}validateParams(params){if(!params){return false}return typeof params.required!=="undefined"&&Array.isArray(params.required)}}function fuzzySearch(text,pattern){pattern=pattern.trimEnd();if(pattern.length===0)return true;pattern=pattern.toLowerCase();text=text.toLowerCase();let remainingText=text,currentIndex=-1;for(const char of pattern){const nextIndex=remainingText.indexOf(char);if(nextIndex===-1||currentIndex!==-1&&remainingText.slice(0,nextIndex).split(" ").length-1>2){return false}currentIndex=nextIndex;remainingText=remainingText.slice(nextIndex+1)}return true}function findFuzzyMatches$1(text,pattern){if(!text||!pattern)return[];const lowerText=text.toLowerCase();const lowerPattern=pattern.toLowerCase().trim();if(lowerPattern.length===0)return[];const patternWords=lowerPattern.split(/\s+/);const matches=[];for(const word of patternWords){if(word.length===0)continue;const wordMatches=findFuzzyWordMatches$1(lowerText,word);matches.push(...wordMatches)}return matches}function findFuzzyWordMatches$1(text,word){const matches=[];const exactRegex=new RegExp(`\\b${word.replace(/[.*+?^${}()|[\]\\]/g,"\\$&")}\\b`,"gi");let match;while((match=exactRegex.exec(text))!==null){matches.push({start:match.index,end:match.index+match[0].length,text:match[0],type:"exact"})}if(matches.length===0){for(let i=0;i<text.length;i++){const fuzzyMatch=findFuzzySequenceMatch$1(text,word,i);if(fuzzyMatch){matches.push({...fuzzyMatch,type:"fuzzy"});i=fuzzyMatch.end-1}}}return matches}function findFuzzySequenceMatch$1(text,pattern,startPos){let textIndex=startPos;let patternIndex=0;let matchStart=-1;let maxGap=3;const matchedPositions=[];while(textIndex<text.length&&patternIndex<pattern.length){if(text[textIndex]===pattern[patternIndex]){if(matchStart===-1){matchStart=textIndex}matchedPositions.push(textIndex);patternIndex++}else if(matchStart!==-1){if(textIndex-matchStart>maxGap*pattern.length){return null}}textIndex++}if(patternIndex===pattern.length&&matchStart!==-1&&matchedPositions.length>0){const actualStart=matchedPositions[0];const actualEnd=matchedPositions[matchedPositions.length-1]+1;return{start:actualStart,end:actualEnd,text:text.substring(actualStart,actualEnd)}}return null}function literalSearch(text,criteria){text=text.trim().toLowerCase();const pattern=criteria.endsWith(" ")?[criteria.toLowerCase()]:criteria.trim().toLowerCase().split(" ");return pattern.filter((word=>text.indexOf(word)>=0)).length===pattern.length}function findLiteralMatches(text,criteria){if(!text||!criteria)return[];const lowerText=text.toLowerCase();const words=criteria.trim().toLowerCase().split(/\s+/);const matches=[];let textIndex=0;for(const word of words){if(word.length===0)continue;const wordIndex=lowerText.indexOf(word,textIndex);if(wordIndex!==-1){matches.push({start:wordIndex,end:wordIndex+word.length,text:text.substring(wordIndex,wordIndex+word.length),type:"exact"});textIndex=wordIndex+word.length}}return matches}function levenshtein(a,b){const lenA=a.length;const lenB=b.length;const distanceMatrix=Array.from({length:lenA+1},(()=>Array(lenB+1).fill(0)));for(let i=0;i<=lenA;i++)distanceMatrix[i][0]=i;for(let j=0;j<=lenB;j++)distanceMatrix[0][j]=j;for(let i=1;i<=lenA;i++){for(let j=1;j<=lenB;j++){const cost=a[i-1]===b[j-1]?0:1;distanceMatrix[i][j]=Math.min(distanceMatrix[i-1][j]+1,distanceMatrix[i][j-1]+1,distanceMatrix[i-1][j-1]+cost)}}return distanceMatrix[lenA][lenB]}function levenshteinSearch(text,pattern){const distance=levenshtein(pattern,text);const similarity=1-distance/Math.max(pattern.length,text.length);return similarity>=.3}function findLevenshteinMatches(text,pattern){if(!text||!pattern)return[];const matches=[];const words=text.split(/\s+/);for(let i=0;i<words.length;i++){const word=words[i];if(levenshteinSearch(word,pattern)){const start=text.indexOf(word);matches.push({start:start,end:start+word.length,text:word,type:"wildcard"})}}return matches}function wildcardSearch(text,pattern){const regexPattern=pattern.replace(/\*/g,".*");const regex=new RegExp(`^${regexPattern}$`,"i");if(regex.test(text))return true;return levenshteinSearch(text,pattern)}function findWildcardMatches(text,pattern){if(!text||!pattern)return[];const wildcardMatches=findWildcardPatternMatches(text,pattern);if(wildcardMatches.length>0){return wildcardMatches}return findLevenshteinMatches(text,pattern)}function findWildcardPatternMatches(text,pattern){const matches=[];const regexPattern=pattern.replace(/\*/g,".*");const regex=new RegExp(regexPattern,"gi");let match;while((match=regex.exec(text))!==null){matches.push({start:match.index,end:match.index+match[0].length,text:match[0],type:"wildcard"})}return matches}class SearchStrategy{constructor(matchFunction,findMatchesFunction){this.matchFunction=matchFunction;this.findMatchesFunction=findMatchesFunction}matches(text,criteria){if(text===null||text.trim()===""||!criteria){return false}return this.matchFunction(text,criteria)}findMatches(text,criteria){if(text===null||text.trim()===""||!criteria||!this.findMatchesFunction){return[]}return this.findMatchesFunction(text,criteria)}}const LiteralSearchStrategy=new SearchStrategy(literalSearch,findLiteralMatches);const FuzzySearchStrategy=new SearchStrategy(((text,criteria)=>fuzzySearch(text,criteria)||literalSearch(text,criteria)),((text,criteria)=>{const fuzzyMatches=findFuzzyMatches$1(text,criteria);if(fuzzyMatches.length>0){return fuzzyMatches}return findLiteralMatches(text,criteria)}));const WildcardSearchStrategy=new SearchStrategy(((text,criteria)=>wildcardSearch(text,criteria)||literalSearch(text,criteria)),((text,criteria)=>{const wildcardMatches=findWildcardMatches(text,criteria);if(wildcardMatches.length>0){return wildcardMatches}return findLiteralMatches(text,criteria)}));function merge(target,source){return{...target,...source}}function isJSON(json){try{return!!(json instanceof Object&&JSON.parse(JSON.stringify(json)))}catch(_err){return false}}function NoSort(){return 0}function isObject(obj){return Boolean(obj)&&Object.prototype.toString.call(obj)==="[object Object]"}function clone(input){if(input===null||typeof input!=="object"){return input}if(Array.isArray(input)){return input.map((item=>clone(item)))}const output={};for(const key in input){if(Object.prototype.hasOwnProperty.call(input,key)){output[key]=clone(input[key])}}return output}const DEFAULT_OPTIONS={searchInput:null,resultsContainer:null,json:[],success:function(){},searchResultTemplate:'<li><a href="{url}" title="{desc}">{title}</a></li>',templateMiddleware:(_prop,_value,_template,_query)=>void 0,sortMiddleware:NoSort,noResultsText:"No results found",limit:10,fuzzy:false,strategy:"literal",debounceTime:null,exclude:[],onSearch:()=>{}};const REQUIRED_OPTIONS=["searchInput","resultsContainer","json"];const WHITELISTED_KEYS=new Set(["Enter","Shift","CapsLock","ArrowLeft","ArrowUp","ArrowRight","ArrowDown","Meta"]);class Repository{constructor(initialOptions={}){this.data=[];this.setOptions(initialOptions)}put(input){if(isObject(input)){return this.addObject(input)}if(Array.isArray(input)){return this.addArray(input)}return void 0}clear(){this.data.length=0;return this.data}search(criteria){if(!criteria){return[]}return clone(this.findMatches(this.data,criteria).sort(this.options.sortMiddleware))}setOptions(newOptions){this.options={fuzzy:(newOptions==null?void 0:newOptions.fuzzy)||DEFAULT_OPTIONS.fuzzy,limit:(newOptions==null?void 0:newOptions.limit)||DEFAULT_OPTIONS.limit,searchStrategy:this.searchStrategy((newOptions==null?void 0:newOptions.strategy)||newOptions.fuzzy&&"fuzzy"||DEFAULT_OPTIONS.strategy),sortMiddleware:(newOptions==null?void 0:newOptions.sortMiddleware)||DEFAULT_OPTIONS.sortMiddleware,exclude:(newOptions==null?void 0:newOptions.exclude)||DEFAULT_OPTIONS.exclude,strategy:(newOptions==null?void 0:newOptions.strategy)||DEFAULT_OPTIONS.strategy}}addObject(obj){this.data.push(obj);return this.data}addArray(arr){const added=[];this.clear();for(const item of arr){if(isObject(item)){added.push(this.addObject(item)[0])}}return added}findMatches(data,criteria){const matches=[];for(let i=0;i<data.length&&matches.length<this.options.limit;i++){const match=this.findMatchesInObject(data[i],criteria);if(match){matches.push(match)}}return matches}findMatchesInObject(obj,criteria){var _a,_b;for(const key in obj){if(!this.isExcluded(obj[key])&&this.options.searchStrategy.matches(obj[key],criteria)){const matchInfo=(_b=(_a=this.options.searchStrategy).findMatches)==null?void 0:_b.call(_a,obj[key],criteria);const result={...obj};if(matchInfo&&matchInfo.length>0){result._matchInfo={[key]:matchInfo}}return result}}return void 0}isExcluded(term){for(const excludedTerm of this.options.exclude){if(new RegExp(excludedTerm).test(String(term))){return true}}return false}searchStrategy(strategy){switch(strategy){case"fuzzy":return FuzzySearchStrategy;case"wildcard":return WildcardSearchStrategy;default:return LiteralSearchStrategy}}}const options={pattern:/\{(.*?)\}/g,template:"",middleware:function(){return void 0}};function setOptions(_options){if(_options.pattern){options.pattern=_options.pattern}if(_options.template){options.template=_options.template}if(typeof _options.middleware==="function"){options.middleware=_options.middleware}}function compile(data,query){return options.template.replace(options.pattern,(function(match,prop){if(options.middleware.length>=5&&data._matchInfo&&data._matchInfo[prop]){const value2=options.middleware(prop,data[prop],options.template,query,data._matchInfo[prop]);if(typeof value2!=="undefined"){return value2}}const value=options.middleware(prop,data[prop],options.template,query);if(typeof value!=="undefined"){return value}return data[prop]||match}))}let SimpleJekyllSearch$1=class SimpleJekyllSearch{constructor(){this.debounceTimerHandle=null;this.options={...DEFAULT_OPTIONS};this.repository=new Repository;this.optionsValidator=new OptionsValidator({required:REQUIRED_OPTIONS})}debounce(func,delayMillis){if(delayMillis){if(this.debounceTimerHandle){clearTimeout(this.debounceTimerHandle)}this.debounceTimerHandle=setTimeout(func,delayMillis)}else{func()}}throwError(message){throw new Error(`SimpleJekyllSearch --- ${message}`)}emptyResultsContainer(){this.options.resultsContainer.innerHTML=""}initWithJSON(json){this.repository.put(json);this.registerInput()}initWithURL(url){load(url,((err,json)=>{if(err){this.throwError(`Failed to load JSON from ${url}: ${err.message}`)}this.initWithJSON(json)}))}registerInput(){this.options.searchInput.addEventListener("input",(e=>{const inputEvent=e;if(!WHITELISTED_KEYS.has(inputEvent.key)){this.emptyResultsContainer();this.debounce((()=>{this.search(e.target.value)}),this.options.debounceTime??null)}}))}search(query){var _a,_b;if((query==null?void 0:query.trim().length)>0){this.emptyResultsContainer();const results=this.repository.search(query);this.render(results,query);(_b=(_a=this.options).onSearch)==null?void 0:_b.call(_a)}}render(results,query){if(results.length===0){this.options.resultsContainer.insertAdjacentHTML("beforeend",this.options.noResultsText);return}const fragment=document.createDocumentFragment();results.forEach((result=>{result.query=query;const div=document.createElement("div");div.innerHTML=compile(result,query);fragment.appendChild(div)}));this.options.resultsContainer.appendChild(fragment)}init(_options){var _a;const errors=this.optionsValidator.validate(_options);if(errors.length>0){this.throwError(`Missing required options: ${REQUIRED_OPTIONS.join(", ")}`)}this.options=merge(this.options,_options);setOptions({template:this.options.searchResultTemplate,middleware:this.options.templateMiddleware});this.repository.setOptions({fuzzy:this.options.fuzzy,limit:this.options.limit,sortMiddleware:this.options.sortMiddleware,strategy:this.options.strategy,exclude:this.options.exclude});if(isJSON(this.options.json)){this.initWithJSON(this.options.json)}else{this.initWithURL(this.options.json)}const rv={search:this.search.bind(this)};(_a=this.options.success)==null?void 0:_a.call(rv);return rv}};function createHighlightMiddleware(options2={}){const{highlightClass:highlightClass="sjs-highlight",contextBefore:contextBefore=50,contextAfter:contextAfter=50,maxLength:maxLength=250,ellipsis:ellipsis="..."}=options2;return function(result,query){if(!query||!result){return result}const highlightedResult={...result};const textFields=["title","desc","content","excerpt"];for(const field of textFields){if(highlightedResult[field]&&typeof highlightedResult[field]==="string"){const highlighted=highlightText(highlightedResult[field],query,{highlightClass:highlightClass,contextBefore:contextBefore,contextAfter:contextAfter,maxLength:maxLength,ellipsis:ellipsis});if(highlighted.highlightedText!==highlightedResult[field]){highlightedResult[field]=highlighted.highlightedText}}}return highlightedResult}}function highlightText(text,query,options2={}){const{highlightClass:highlightClass="sjs-highlight",contextBefore:contextBefore=50,contextAfter:contextAfter=50,maxLength:maxLength=250,ellipsis:ellipsis="..."}=options2;if(!text||!query){return{highlightedText:text,matchCount:0}}const originalText=text;const searchTerms=query.trim().toLowerCase().split(/\s+/).filter((term=>term.length>0));if(searchTerms.length===0){return{highlightedText:text,matchCount:0}}const matches=[];for(const term of searchTerms){let index=0;while(index<text.length){const found=text.toLowerCase().indexOf(term,index);if(found===-1)break;matches.push({start:found,end:found+term.length,term:text.substring(found,found+term.length)});index=found+1}}if(matches.length===0){return{highlightedText:text,matchCount:0}}matches.sort(((a,b)=>a.start-b.start));const mergedMatches=[];for(const match of matches){if(mergedMatches.length===0||mergedMatches[mergedMatches.length-1].end<match.start){mergedMatches.push(match)}else{const lastMatch=mergedMatches[mergedMatches.length-1];lastMatch.end=Math.max(lastMatch.end,match.end);lastMatch.term=text.substring(lastMatch.start,lastMatch.end)}}if(text.length<=maxLength){let highlightedText2=text;for(let i=mergedMatches.length-1;i>=0;i--){const match=mergedMatches[i];const before=highlightedText2.substring(0,match.start);const after=highlightedText2.substring(match.end);const matchText=highlightedText2.substring(match.start,match.end);highlightedText2=before+`<span class="${highlightClass}">${matchText}</span>`+after}return{highlightedText:highlightedText2,matchCount:mergedMatches.length}}let highlightedText="";let totalLength=0;let lastEnd=0;for(let i=0;i<mergedMatches.length;i++){const match=mergedMatches[i];const contextStart=Math.max(lastEnd,match.start-contextBefore);const contextEnd=Math.min(text.length,match.end+contextAfter);if(contextStart>lastEnd&&lastEnd>0){highlightedText+=ellipsis;totalLength+=ellipsis.length}if(contextStart<match.start){const beforeText=text.substring(contextStart,match.start);highlightedText+=beforeText;totalLength+=beforeText.length}const matchText=text.substring(match.start,match.end);highlightedText+=`<span class="${highlightClass}">${matchText}</span>`;totalLength+=matchText.length;if(match.end<contextEnd){const afterText=text.substring(match.end,contextEnd);highlightedText+=afterText;totalLength+=afterText.length}lastEnd=contextEnd;if(totalLength>=maxLength){if(contextEnd<text.length){highlightedText+=ellipsis}break}}return{highlightedText:highlightedText||originalText,matchCount:mergedMatches.length}}const defaultHighlightMiddleware=createHighlightMiddleware();function findFuzzyMatches(text,pattern){const matches=[];const lowerText=text.toLowerCase();const lowerPattern=pattern.toLowerCase().trim();if(lowerPattern.length===0)return matches;const patternWords=lowerPattern.split(/\s+/);for(const word of patternWords){if(word.length===0)continue;const wordMatches=findFuzzyWordMatches(lowerText,word);matches.push(...wordMatches)}return matches}function findFuzzyWordMatches(text,word){const matches=[];const exactRegex=new RegExp(`\\b${word.replace(/[.*+?^${}()|[\]\\]/g,"\\$&")}\\b`,"gi");let match;while((match=exactRegex.exec(text))!==null){matches.push({start:match.index,end:match.index+match[0].length,text:match[0]})}if(matches.length===0){for(let i=0;i<text.length;i++){const fuzzyMatch=findFuzzySequenceMatch(text,word,i);if(fuzzyMatch){matches.push(fuzzyMatch);i=fuzzyMatch.end-1}}}return matches}function findFuzzySequenceMatch(text,pattern,startPos){let textIndex=startPos;let patternIndex=0;let matchStart=-1;let maxGap=3;const matchedPositions=[];while(textIndex<text.length&&patternIndex<pattern.length){if(text[textIndex]===pattern[patternIndex]){if(matchStart===-1){matchStart=textIndex}matchedPositions.push(textIndex);patternIndex++}else if(matchStart!==-1){if(textIndex-matchStart>maxGap*pattern.length){return null}}textIndex++}if(patternIndex===pattern.length&&matchStart!==-1&&matchedPositions.length>0){const actualStart=matchedPositions[0];const actualEnd=matchedPositions[matchedPositions.length-1]+1;return{start:actualStart,end:actualEnd,text:text.substring(actualStart,actualEnd)}}return null}function createHighlightTemplateMiddleware(options2={}){const highlightOptions={highlightClass:"sjs-highlight",...options2};return function(prop,value,_template,query){if((prop==="content"||prop==="desc")&&query&&typeof value==="string"){let highlightedText=value;let hasMatches=false;const searchTerms=query.trim().split(/\s+/).filter((term=>term.length>0));for(const term of searchTerms){const regex=new RegExp(`\\b(${term.replace(/[.*+?^${}()|[\]\\]/g,"\\$&")})\\b`,"gi");if(regex.test(highlightedText)){highlightedText=highlightedText.replace(regex,`<span class="${highlightOptions.highlightClass}">$1</span>`);hasMatches=true}}if(!hasMatches){const fuzzyMatches=findFuzzyMatches(value,query);if(fuzzyMatches.length>0){fuzzyMatches.sort(((a,b)=>b.start-a.start));for(const match of fuzzyMatches){const before=highlightedText.substring(0,match.start);const after=highlightedText.substring(match.end);const matchText=highlightedText.substring(match.start,match.end);highlightedText=before+`<span class="${highlightOptions.highlightClass}">${matchText}</span>`+after}hasMatches=true}}if(hasMatches){return highlightedText}}return void 0}}const defaultHighlightTemplateMiddleware=createHighlightTemplateMiddleware();function SimpleJekyllSearch(options2){const instance=new SimpleJekyllSearch$1;return instance.init(options2)}if(typeof window!=="undefined"){window.SimpleJekyllSearch=SimpleJekyllSearch;window.SimpleJekyllSearch.createHighlightMiddleware=createHighlightMiddleware;window.SimpleJekyllSearch.createHighlightTemplateMiddleware=createHighlightTemplateMiddleware;window.SimpleJekyllSearch.highlightText=highlightText;window.SimpleJekyllSearch.defaultHighlightMiddleware=defaultHighlightMiddleware;window.SimpleJekyllSearch.defaultHighlightTemplateMiddleware=defaultHighlightTemplateMiddleware}exports2.createHighlightMiddleware=createHighlightMiddleware;exports2.createHighlightTemplateMiddleware=createHighlightTemplateMiddleware;exports2.default=SimpleJekyllSearch;exports2.defaultHighlightMiddleware=defaultHighlightMiddleware;exports2.defaultHighlightTemplateMiddleware=defaultHighlightTemplateMiddleware;exports2.highlightText=highlightText;Object.defineProperties(exports2,{__esModule:{value:true},[Symbol.toStringTag]:{value:"Module"}})}));
\ No newline at end of file
+(function(global,factory){typeof exports==="object"&&typeof module!=="undefined"?factory(exports):typeof define==="function"&&define.amd?define(["exports"],factory):(global=typeof globalThis!=="undefined"?globalThis:global||self,factory(global.SimpleJekyllSearch={}))})(this,(function(exports2){"use strict";function load(location,callback){const xhr=getXHR();xhr.open("GET",location,true);xhr.onreadystatechange=createStateChangeListener(xhr,callback);xhr.send()}function createStateChangeListener(xhr,callback){return function(){if(xhr.readyState===4&&xhr.status===200){try{callback(null,JSON.parse(xhr.responseText))}catch(err){callback(err instanceof Error?err:new Error(String(err)),null)}}}}function getXHR(){return window.XMLHttpRequest?new window.XMLHttpRequest:new window.ActiveXObject("Microsoft.XMLHTTP")}class OptionsValidator{constructor(params){if(!this.validateParams(params)){throw new Error("-- OptionsValidator: required options missing")}this.requiredOptions=params.required}getRequiredOptions(){return this.requiredOptions}validate(parameters){const errors=[];this.requiredOptions.forEach((requiredOptionName=>{if(typeof parameters[requiredOptionName]==="undefined"){errors.push(requiredOptionName)}}));return errors}validateParams(params){if(!params){return false}return typeof params.required!=="undefined"&&Array.isArray(params.required)}}function fuzzySearch(text,pattern){pattern=pattern.trimEnd();if(pattern.length===0)return true;pattern=pattern.toLowerCase();text=text.toLowerCase();let remainingText=text,currentIndex=-1;for(const char of pattern){const nextIndex=remainingText.indexOf(char);if(nextIndex===-1||currentIndex!==-1&&remainingText.slice(0,nextIndex).split(" ").length-1>2){return false}currentIndex=nextIndex;remainingText=remainingText.slice(nextIndex+1)}return true}function findFuzzyMatches$1(text,pattern){if(!text||!pattern)return[];const lowerText=text.toLowerCase();const lowerPattern=pattern.toLowerCase().trim();if(lowerPattern.length===0)return[];const patternWords=lowerPattern.split(/\s+/);const matches=[];for(const word of patternWords){if(word.length===0)continue;const wordMatches=findFuzzyWordMatches$1(lowerText,word);matches.push(...wordMatches)}return mergeAndSortMatches$1(matches)}function findFuzzyWordMatches$1(text,word){const matches=[];const exactRegex=new RegExp(`\\b${word.replace(/[.*+?^${}()|[\]\\]/g,"\\$&")}\\b`,"gi");let match;while((match=exactRegex.exec(text))!==null){matches.push({start:match.index,end:match.index+match[0].length,text:match[0],type:"exact"})}if(matches.length===0){for(let i=0;i<text.length;i++){const fuzzyMatch=findFuzzySequenceMatch$1(text,word,i);if(fuzzyMatch){matches.push({...fuzzyMatch,type:"fuzzy"});i=fuzzyMatch.end-1}}}return matches}function findFuzzySequenceMatch$1(text,pattern,startPos){let textIndex=startPos;let patternIndex=0;let matchStart=-1;let maxGap=3;const matchedPositions=[];while(textIndex<text.length&&patternIndex<pattern.length){if(text[textIndex]===pattern[patternIndex]){if(matchStart===-1){matchStart=textIndex}matchedPositions.push(textIndex);patternIndex++}else if(matchStart!==-1){if(textIndex-matchStart>maxGap*pattern.length){return null}}textIndex++}if(patternIndex===pattern.length&&matchStart!==-1&&matchedPositions.length>0){const actualStart=matchedPositions[0];const actualEnd=matchedPositions[matchedPositions.length-1]+1;return{start:actualStart,end:actualEnd,text:text.substring(actualStart,actualEnd)}}return null}function mergeAndSortMatches$1(matches){if(matches.length===0)return[];const sortedMatches=matches.sort(((a,b)=>a.start-b.start));const merged=[];for(const match of sortedMatches){const lastMerged=merged[merged.length-1];if(lastMerged&&match.start<=lastMerged.end){lastMerged.end=Math.max(lastMerged.end,match.end);lastMerged.text=lastMerged.text+match.text.slice(lastMerged.end-match.start)}else{merged.push({...match})}}return merged}function literalSearch(text,criteria){text=text.trim().toLowerCase();const pattern=criteria.endsWith(" ")?[criteria.toLowerCase()]:criteria.trim().toLowerCase().split(" ");return pattern.filter((word=>text.indexOf(word)>=0)).length===pattern.length}function findLiteralMatches(text,criteria){if(!text||!criteria)return[];const lowerText=text.toLowerCase();const words=criteria.trim().toLowerCase().split(/\s+/);const matches=[];let textIndex=0;for(const word of words){if(word.length===0)continue;const wordIndex=lowerText.indexOf(word,textIndex);if(wordIndex!==-1){matches.push({start:wordIndex,end:wordIndex+word.length,text:text.substring(wordIndex,wordIndex+word.length),type:"exact"});textIndex=wordIndex+word.length}}return matches}function levenshtein(a,b){const lenA=a.length;const lenB=b.length;const distanceMatrix=Array.from({length:lenA+1},(()=>Array(lenB+1).fill(0)));for(let i=0;i<=lenA;i++)distanceMatrix[i][0]=i;for(let j=0;j<=lenB;j++)distanceMatrix[0][j]=j;for(let i=1;i<=lenA;i++){for(let j=1;j<=lenB;j++){const cost=a[i-1]===b[j-1]?0:1;distanceMatrix[i][j]=Math.min(distanceMatrix[i-1][j]+1,distanceMatrix[i][j-1]+1,distanceMatrix[i-1][j-1]+cost)}}return distanceMatrix[lenA][lenB]}function levenshteinSearch(text,pattern){const distance=levenshtein(pattern,text);const similarity=1-distance/Math.max(pattern.length,text.length);return similarity>=.3}function findLevenshteinMatches(text,pattern){if(!text||!pattern)return[];const matches=[];const words=text.split(/\s+/);for(let i=0;i<words.length;i++){const word=words[i];if(levenshteinSearch(word,pattern)){const start=text.indexOf(word);matches.push({start:start,end:start+word.length,text:word,type:"wildcard"})}}return matches}function wildcardSearch(text,pattern){const regexPattern=pattern.replace(/\*/g,".*");const regex=new RegExp(`^${regexPattern}$`,"i");if(regex.test(text))return true;return levenshteinSearch(text,pattern)}function findWildcardMatches(text,pattern){if(!text||!pattern)return[];const wildcardMatches=findWildcardPatternMatches(text,pattern);if(wildcardMatches.length>0){return mergeAndSortMatches(wildcardMatches)}const levenshteinMatches=findLevenshteinMatches(text,pattern);return mergeAndSortMatches(levenshteinMatches)}function findWildcardPatternMatches(text,pattern){const matches=[];const regexPattern=pattern.replace(/\*/g,".*");const regex=new RegExp(regexPattern,"gi");let match;while((match=regex.exec(text))!==null){matches.push({start:match.index,end:match.index+match[0].length,text:match[0],type:"wildcard"})}return matches}function mergeAndSortMatches(matches){if(matches.length===0)return[];const sortedMatches=matches.sort(((a,b)=>a.start-b.start));const merged=[];for(const match of sortedMatches){const lastMerged=merged[merged.length-1];if(lastMerged&&match.start<=lastMerged.end){lastMerged.end=Math.max(lastMerged.end,match.end);lastMerged.text=lastMerged.text+match.text.slice(lastMerged.end-match.start)}else{merged.push({...match})}}return merged}class SearchStrategy{constructor(matchFunction,findMatchesFunction){this.matchFunction=matchFunction;this.findMatchesFunction=findMatchesFunction}matches(text,criteria){if(text===null||text.trim()===""||!criteria){return false}return this.matchFunction(text,criteria)}findMatches(text,criteria){if(text===null||text.trim()===""||!criteria||!this.findMatchesFunction){return[]}return this.findMatchesFunction(text,criteria)}}const LiteralSearchStrategy=new SearchStrategy(literalSearch,findLiteralMatches);const FuzzySearchStrategy=new SearchStrategy(((text,criteria)=>fuzzySearch(text,criteria)||literalSearch(text,criteria)),((text,criteria)=>{const fuzzyMatches=findFuzzyMatches$1(text,criteria);if(fuzzyMatches.length>0){return fuzzyMatches}return findLiteralMatches(text,criteria)}));const WildcardSearchStrategy=new SearchStrategy(((text,criteria)=>wildcardSearch(text,criteria)||literalSearch(text,criteria)),((text,criteria)=>{const wildcardMatches=findWildcardMatches(text,criteria);if(wildcardMatches.length>0){return wildcardMatches}return findLiteralMatches(text,criteria)}));function merge(target,source){return{...target,...source}}function isJSON(json){try{return!!(json instanceof Object&&JSON.parse(JSON.stringify(json)))}catch(_err){return false}}function NoSort(){return 0}function isObject(obj){return Boolean(obj)&&Object.prototype.toString.call(obj)==="[object Object]"}function clone(input){if(input===null||typeof input!=="object"){return input}if(Array.isArray(input)){return input.map((item=>clone(item)))}const output={};for(const key in input){if(Object.prototype.hasOwnProperty.call(input,key)){output[key]=clone(input[key])}}return output}const DEFAULT_OPTIONS={searchInput:null,resultsContainer:null,json:[],success:function(){},searchResultTemplate:'<li><a href="{url}" title="{desc}">{title}</a></li>',templateMiddleware:(_prop,_value,_template,_query)=>void 0,sortMiddleware:NoSort,noResultsText:"No results found",limit:10,fuzzy:false,strategy:"literal",debounceTime:null,exclude:[],onSearch:()=>{}};const REQUIRED_OPTIONS=["searchInput","resultsContainer","json"];const WHITELISTED_KEYS=new Set(["Enter","Shift","CapsLock","ArrowLeft","ArrowUp","ArrowRight","ArrowDown","Meta"]);class Repository{constructor(initialOptions={}){this.data=[];this.setOptions(initialOptions)}put(input){if(isObject(input)){return this.addObject(input)}if(Array.isArray(input)){return this.addArray(input)}return void 0}clear(){this.data.length=0;return this.data}search(criteria){if(!criteria){return[]}return clone(this.findMatches(this.data,criteria).sort(this.options.sortMiddleware))}setOptions(newOptions){this.options={fuzzy:(newOptions==null?void 0:newOptions.fuzzy)||DEFAULT_OPTIONS.fuzzy,limit:(newOptions==null?void 0:newOptions.limit)||DEFAULT_OPTIONS.limit,searchStrategy:this.searchStrategy((newOptions==null?void 0:newOptions.strategy)||newOptions.fuzzy&&"fuzzy"||DEFAULT_OPTIONS.strategy),sortMiddleware:(newOptions==null?void 0:newOptions.sortMiddleware)||DEFAULT_OPTIONS.sortMiddleware,exclude:(newOptions==null?void 0:newOptions.exclude)||DEFAULT_OPTIONS.exclude,strategy:(newOptions==null?void 0:newOptions.strategy)||DEFAULT_OPTIONS.strategy}}addObject(obj){this.data.push(obj);return this.data}addArray(arr){const added=[];this.clear();for(const item of arr){if(isObject(item)){added.push(this.addObject(item)[0])}}return added}findMatches(data,criteria){const matches=[];for(let i=0;i<data.length&&matches.length<this.options.limit;i++){const match=this.findMatchesInObject(data[i],criteria);if(match){matches.push(match)}}return matches}findMatchesInObject(obj,criteria){var _a,_b;for(const key in obj){if(!this.isExcluded(obj[key])&&this.options.searchStrategy.matches(obj[key],criteria)){const matchInfo=(_b=(_a=this.options.searchStrategy).findMatches)==null?void 0:_b.call(_a,obj[key],criteria);const result={...obj};if(matchInfo&&matchInfo.length>0){result._matchInfo={[key]:matchInfo}}return result}}return void 0}isExcluded(term){for(const excludedTerm of this.options.exclude){if(new RegExp(excludedTerm).test(String(term))){return true}}return false}searchStrategy(strategy){switch(strategy){case"fuzzy":return FuzzySearchStrategy;case"wildcard":return WildcardSearchStrategy;default:return LiteralSearchStrategy}}}const options={pattern:/\{(.*?)\}/g,template:"",middleware:function(){return void 0}};function setOptions(_options){if(_options.pattern){options.pattern=_options.pattern}if(_options.template){options.template=_options.template}if(typeof _options.middleware==="function"){options.middleware=_options.middleware}}function compile(data,query){return options.template.replace(options.pattern,(function(match,prop){if(options.middleware.length>=5&&data._matchInfo&&data._matchInfo[prop]){const value2=options.middleware(prop,data[prop],options.template,query,data._matchInfo[prop]);if(typeof value2!=="undefined"){return value2}}const value=options.middleware(prop,data[prop],options.template,query);if(typeof value!=="undefined"){return value}return data[prop]||match}))}let SimpleJekyllSearch$1=class SimpleJekyllSearch{constructor(){this.debounceTimerHandle=null;this.options={...DEFAULT_OPTIONS};this.repository=new Repository;this.optionsValidator=new OptionsValidator({required:REQUIRED_OPTIONS})}debounce(func,delayMillis){if(delayMillis){if(this.debounceTimerHandle){clearTimeout(this.debounceTimerHandle)}this.debounceTimerHandle=setTimeout(func,delayMillis)}else{func()}}throwError(message){throw new Error(`SimpleJekyllSearch --- ${message}`)}emptyResultsContainer(){this.options.resultsContainer.innerHTML=""}initWithJSON(json){this.repository.put(json);this.registerInput()}initWithURL(url){load(url,((err,json)=>{if(err){this.throwError(`Failed to load JSON from ${url}: ${err.message}`)}this.initWithJSON(json)}))}registerInput(){this.options.searchInput.addEventListener("input",(e=>{const inputEvent=e;if(!WHITELISTED_KEYS.has(inputEvent.key)){this.emptyResultsContainer();this.debounce((()=>{this.search(e.target.value)}),this.options.debounceTime??null)}}))}search(query){var _a,_b;if((query==null?void 0:query.trim().length)>0){this.emptyResultsContainer();const results=this.repository.search(query);this.render(results,query);(_b=(_a=this.options).onSearch)==null?void 0:_b.call(_a)}}render(results,query){if(results.length===0){this.options.resultsContainer.insertAdjacentHTML("beforeend",this.options.noResultsText);return}const fragment=document.createDocumentFragment();results.forEach((result=>{result.query=query;const div=document.createElement("div");div.innerHTML=compile(result,query);fragment.appendChild(div)}));this.options.resultsContainer.appendChild(fragment)}init(_options){var _a;const errors=this.optionsValidator.validate(_options);if(errors.length>0){this.throwError(`Missing required options: ${REQUIRED_OPTIONS.join(", ")}`)}this.options=merge(this.options,_options);setOptions({template:this.options.searchResultTemplate,middleware:this.options.templateMiddleware});this.repository.setOptions({fuzzy:this.options.fuzzy,limit:this.options.limit,sortMiddleware:this.options.sortMiddleware,strategy:this.options.strategy,exclude:this.options.exclude});if(isJSON(this.options.json)){this.initWithJSON(this.options.json)}else{this.initWithURL(this.options.json)}const rv={search:this.search.bind(this)};(_a=this.options.success)==null?void 0:_a.call(rv);return rv}};function createHighlightMiddleware(options2={}){const{highlightClass:highlightClass="sjs-highlight",contextBefore:contextBefore=50,contextAfter:contextAfter=50,maxLength:maxLength=250,ellipsis:ellipsis="..."}=options2;return function(result,query){if(!query||!result){return result}const highlightedResult={...result};const textFields=["title","desc","content","excerpt"];for(const field of textFields){if(highlightedResult[field]&&typeof highlightedResult[field]==="string"){const highlighted=highlightText(highlightedResult[field],query,{highlightClass:highlightClass,contextBefore:contextBefore,contextAfter:contextAfter,maxLength:maxLength,ellipsis:ellipsis});if(highlighted.highlightedText!==highlightedResult[field]){highlightedResult[field]=highlighted.highlightedText}}}return highlightedResult}}function highlightText(text,query,options2={}){const{highlightClass:highlightClass="sjs-highlight",contextBefore:contextBefore=50,contextAfter:contextAfter=50,maxLength:maxLength=250,ellipsis:ellipsis="..."}=options2;if(!text||!query){return{highlightedText:text,matchCount:0}}const originalText=text;const searchTerms=query.trim().toLowerCase().split(/\s+/).filter((term=>term.length>0));if(searchTerms.length===0){return{highlightedText:text,matchCount:0}}const matches=[];for(const term of searchTerms){let index=0;while(index<text.length){const found=text.toLowerCase().indexOf(term,index);if(found===-1)break;matches.push({start:found,end:found+term.length,term:text.substring(found,found+term.length)});index=found+1}}if(matches.length===0){return{highlightedText:text,matchCount:0}}matches.sort(((a,b)=>a.start-b.start));const mergedMatches=[];for(const match of matches){if(mergedMatches.length===0||mergedMatches[mergedMatches.length-1].end<match.start){mergedMatches.push(match)}else{const lastMatch=mergedMatches[mergedMatches.length-1];lastMatch.end=Math.max(lastMatch.end,match.end);lastMatch.term=text.substring(lastMatch.start,lastMatch.end)}}if(text.length<=maxLength){let highlightedText2=text;for(let i=mergedMatches.length-1;i>=0;i--){const match=mergedMatches[i];const before=highlightedText2.substring(0,match.start);const after=highlightedText2.substring(match.end);const matchText=highlightedText2.substring(match.start,match.end);highlightedText2=before+`<span class="${highlightClass}">${matchText}</span>`+after}return{highlightedText:highlightedText2,matchCount:mergedMatches.length}}let highlightedText="";let totalLength=0;let lastEnd=0;for(let i=0;i<mergedMatches.length;i++){const match=mergedMatches[i];const contextStart=Math.max(lastEnd,match.start-contextBefore);const contextEnd=Math.min(text.length,match.end+contextAfter);if(contextStart>lastEnd&&lastEnd>0){highlightedText+=ellipsis;totalLength+=ellipsis.length}if(contextStart<match.start){const beforeText=text.substring(contextStart,match.start);highlightedText+=beforeText;totalLength+=beforeText.length}const matchText=text.substring(match.start,match.end);highlightedText+=`<span class="${highlightClass}">${matchText}</span>`;totalLength+=matchText.length;if(match.end<contextEnd){const afterText=text.substring(match.end,contextEnd);highlightedText+=afterText;totalLength+=afterText.length}lastEnd=contextEnd;if(totalLength>=maxLength){if(contextEnd<text.length){highlightedText+=ellipsis}break}}return{highlightedText:highlightedText||originalText,matchCount:mergedMatches.length}}const defaultHighlightMiddleware=createHighlightMiddleware();function findFuzzyMatches(text,pattern){const matches=[];const lowerText=text.toLowerCase();const lowerPattern=pattern.toLowerCase().trim();if(lowerPattern.length===0)return matches;const patternWords=lowerPattern.split(/\s+/);for(const word of patternWords){if(word.length===0)continue;const wordMatches=findFuzzyWordMatches(lowerText,word);matches.push(...wordMatches)}return matches}function findFuzzyWordMatches(text,word){const matches=[];const exactRegex=new RegExp(`\\b${word.replace(/[.*+?^${}()|[\]\\]/g,"\\$&")}\\b`,"gi");let match;while((match=exactRegex.exec(text))!==null){matches.push({start:match.index,end:match.index+match[0].length,text:match[0]})}if(matches.length===0){for(let i=0;i<text.length;i++){const fuzzyMatch=findFuzzySequenceMatch(text,word,i);if(fuzzyMatch){matches.push(fuzzyMatch);i=fuzzyMatch.end-1}}}return matches}function findFuzzySequenceMatch(text,pattern,startPos){let textIndex=startPos;let patternIndex=0;let matchStart=-1;let maxGap=3;const matchedPositions=[];while(textIndex<text.length&&patternIndex<pattern.length){if(text[textIndex]===pattern[patternIndex]){if(matchStart===-1){matchStart=textIndex}matchedPositions.push(textIndex);patternIndex++}else if(matchStart!==-1){if(textIndex-matchStart>maxGap*pattern.length){return null}}textIndex++}if(patternIndex===pattern.length&&matchStart!==-1&&matchedPositions.length>0){const actualStart=matchedPositions[0];const actualEnd=matchedPositions[matchedPositions.length-1]+1;return{start:actualStart,end:actualEnd,text:text.substring(actualStart,actualEnd)}}return null}function highlightWithMatchInfo(text,matchInfo,options2){if(matchInfo.length===0)return text;const sortedMatches=[...matchInfo].sort(((a,b)=>b.start-a.start));let highlightedText=text;for(const match of sortedMatches){const before=highlightedText.substring(0,match.start);const after=highlightedText.substring(match.end);const matchText=highlightedText.substring(match.start,match.end);highlightedText=before+`<span class="${options2.highlightClass}">${matchText}</span>`+after}return highlightedText}function highlightWithQuery(text,query,options2){let highlightedText=text;let hasMatches=false;const searchTerms=query.trim().split(/\s+/).filter((term=>term.length>0));for(const term of searchTerms){const regex=new RegExp(`\\b(${term.replace(/[.*+?^${}()|[\]\\]/g,"\\$&")})\\b`,"gi");if(regex.test(highlightedText)){highlightedText=highlightedText.replace(regex,`<span class="${options2.highlightClass}">$1</span>`);hasMatches=true}}if(!hasMatches){const fuzzyMatches=findFuzzyMatches(text,query);if(fuzzyMatches.length>0){fuzzyMatches.sort(((a,b)=>b.start-a.start));for(const match of fuzzyMatches){const before=highlightedText.substring(0,match.start);const after=highlightedText.substring(match.end);const matchText=highlightedText.substring(match.start,match.end);highlightedText=before+`<span class="${options2.highlightClass}">${matchText}</span>`+after}hasMatches=true}}return highlightedText}function createHighlightTemplateMiddleware(options2={}){const highlightOptions={highlightClass:"sjs-highlight",...options2};return function(prop,value,_template,query,matchInfo){if((prop==="content"||prop==="desc")&&query&&typeof value==="string"){if(matchInfo&&matchInfo.length>0){const highlighted2=highlightWithMatchInfo(value,matchInfo,highlightOptions);return highlighted2!==value?highlighted2:void 0}const highlighted=highlightWithQuery(value,query,highlightOptions);return highlighted!==value?highlighted:void 0}return void 0}}const defaultHighlightTemplateMiddleware=createHighlightTemplateMiddleware();function SimpleJekyllSearch(options2){const instance=new SimpleJekyllSearch$1;return instance.init(options2)}if(typeof window!=="undefined"){window.SimpleJekyllSearch=SimpleJekyllSearch;window.SimpleJekyllSearch.createHighlightMiddleware=createHighlightMiddleware;window.SimpleJekyllSearch.createHighlightTemplateMiddleware=createHighlightTemplateMiddleware;window.SimpleJekyllSearch.highlightText=highlightText;window.SimpleJekyllSearch.defaultHighlightMiddleware=defaultHighlightMiddleware;window.SimpleJekyllSearch.defaultHighlightTemplateMiddleware=defaultHighlightTemplateMiddleware}exports2.createHighlightMiddleware=createHighlightMiddleware;exports2.createHighlightTemplateMiddleware=createHighlightTemplateMiddleware;exports2.default=SimpleJekyllSearch;exports2.defaultHighlightMiddleware=defaultHighlightMiddleware;exports2.defaultHighlightTemplateMiddleware=defaultHighlightTemplateMiddleware;exports2.highlightText=highlightText;Object.defineProperties(exports2,{__esModule:{value:true},[Symbol.toStringTag]:{value:"Module"}})}));
\ No newline at end of file
diff --git a/src/SearchStrategies/search/fuzzySearch.ts b/src/SearchStrategies/search/fuzzySearch.ts
index f305c35..145e121 100644
--- a/src/SearchStrategies/search/fuzzySearch.ts
+++ b/src/SearchStrategies/search/fuzzySearch.ts
@@ -60,7 +60,8 @@ export function findFuzzyMatches(text: string, pattern: string): MatchInfo[] {
     matches.push(...wordMatches);
   }
   
-  return matches;
+  // Merge overlapping matches and sort by position
+  return mergeAndSortMatches(matches);
 }
 
 /**
@@ -132,4 +133,29 @@ function findFuzzySequenceMatch(text: string, pattern: string, startPos: number)
   }
   
   return null;
+}
+
+/**
+ * Merges overlapping matches and sorts them by position
+ */
+function mergeAndSortMatches(matches: MatchInfo[]): MatchInfo[] {
+  if (matches.length === 0) return [];
+  
+  // Sort matches by start position
+  const sortedMatches = matches.sort((a, b) => a.start - b.start);
+  const merged: MatchInfo[] = [];
+  
+  for (const match of sortedMatches) {
+    const lastMerged = merged[merged.length - 1];
+    
+    // If this match overlaps with the last merged match, extend it
+    if (lastMerged && match.start <= lastMerged.end) {
+      lastMerged.end = Math.max(lastMerged.end, match.end);
+      lastMerged.text = lastMerged.text + match.text.slice(lastMerged.end - match.start);
+    } else {
+      merged.push({ ...match });
+    }
+  }
+  
+  return merged;
 } 
\ No newline at end of file
diff --git a/src/SearchStrategies/search/wildcardSearch.ts b/src/SearchStrategies/search/wildcardSearch.ts
index 538bd11..24e2c20 100644
--- a/src/SearchStrategies/search/wildcardSearch.ts
+++ b/src/SearchStrategies/search/wildcardSearch.ts
@@ -29,11 +29,12 @@ export function findWildcardMatches(text: string, pattern: string): MatchInfo[]
   // Try wildcard matching first
   const wildcardMatches = findWildcardPatternMatches(text, pattern);
   if (wildcardMatches.length > 0) {
-    return wildcardMatches;
+    return mergeAndSortMatches(wildcardMatches);
   }
   
   // Fall back to levenshtein matching
-  return findLevenshteinMatches(text, pattern);
+  const levenshteinMatches = findLevenshteinMatches(text, pattern);
+  return mergeAndSortMatches(levenshteinMatches);
 }
 
 /**
@@ -56,3 +57,28 @@ function findWildcardPatternMatches(text: string, pattern: string): MatchInfo[]
   
   return matches;
 }
+
+/**
+ * Merges overlapping matches and sorts them by position
+ */
+function mergeAndSortMatches(matches: MatchInfo[]): MatchInfo[] {
+  if (matches.length === 0) return [];
+  
+  // Sort matches by start position
+  const sortedMatches = matches.sort((a, b) => a.start - b.start);
+  const merged: MatchInfo[] = [];
+  
+  for (const match of sortedMatches) {
+    const lastMerged = merged[merged.length - 1];
+    
+    // If this match overlaps with the last merged match, extend it
+    if (lastMerged && match.start <= lastMerged.end) {
+      lastMerged.end = Math.max(lastMerged.end, match.end);
+      lastMerged.text = lastMerged.text + match.text.slice(lastMerged.end - match.start);
+    } else {
+      merged.push({ ...match });
+    }
+  }
+  
+  return merged;
+}
diff --git a/src/Templater.ts b/src/Templater.ts
index 6bcd75e..316af1c 100644
--- a/src/Templater.ts
+++ b/src/Templater.ts
@@ -30,15 +30,20 @@ export function setOptions(_options: TemplaterOptions): void {
 
 export function compile(data: Data, query?: string): string {
   return options.template.replace(options.pattern, function(match: string, prop: string) {
-    // Check if middleware supports matchInfo parameter (5 parameters including matchInfo)
-    if (options.middleware.length >= 5 && data._matchInfo && data._matchInfo[prop]) {
-      const value = (options.middleware as any)(prop, data[prop], options.template, query, data._matchInfo[prop]);
-      if (typeof value !== 'undefined') {
-        return value;
+    // Check if middleware supports matchInfo parameter and we have match info for this property
+    if (data._matchInfo && data._matchInfo[prop] && data._matchInfo[prop].length > 0) {
+      // Try calling with matchInfo parameter first
+      try {
+        const value = (options.middleware as any)(prop, data[prop], options.template, query, data._matchInfo[prop]);
+        if (typeof value !== 'undefined') {
+          return value;
+        }
+      } catch (_e) {
+        // If the middleware doesn't support 5 parameters, fall back to 4
       }
     }
     
-    // Fallback to current behavior
+    // Fallback to current behavior (4 parameters)
     const value = options.middleware(prop, data[prop], options.template, query);
     if (typeof value !== 'undefined') {
       return value;
diff --git a/src/utils/highlightMiddleware.ts b/src/utils/highlightMiddleware.ts
index 239013f..9704a8c 100644
--- a/src/utils/highlightMiddleware.ts
+++ b/src/utils/highlightMiddleware.ts
@@ -1,3 +1,5 @@
+import { MatchInfo } from '../SearchStrategies/types';
+
 /**
  * Highlight middleware that wraps search matches with HTML spans
  * and provides context around matches with a configurable character limit
@@ -288,6 +290,60 @@ function findFuzzySequenceMatch(text: string, pattern: string, startPos: number)
   return null;
 }
 
+/**
+ * Highlights text using provided match information (faster, more accurate)
+ */
+function highlightWithMatchInfo(text: string, matchInfo: MatchInfo[], options: Required<HighlightOptions>): string {
+  if (matchInfo.length === 0) return text;
+  
+  // Sort matches by position (reverse order to avoid index shifting)
+  const sortedMatches = [...matchInfo].sort((a, b) => b.start - a.start);
+  
+  let highlightedText = text;
+  for (const match of sortedMatches) {
+    const before = highlightedText.substring(0, match.start);
+    const after = highlightedText.substring(match.end);
+    const matchText = highlightedText.substring(match.start, match.end);
+    highlightedText = before + `<span class="${options.highlightClass}">${matchText}</span>` + after;
+  }
+  
+  return highlightedText;
+}
+
+/**
+ * Highlights text using query-based search (fallback for backward compatibility)
+ */
+function highlightWithQuery(text: string, query: string, options: Required<HighlightOptions>): string {
+  let highlightedText = text;
+  let hasMatches = false;
+  
+  const searchTerms = query.trim().split(/\s+/).filter(term => term.length > 0);
+  for (const term of searchTerms) {
+    const regex = new RegExp(`\\b(${term.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')})\\b`, 'gi');
+    if (regex.test(highlightedText)) {
+      highlightedText = highlightedText.replace(regex, `<span class="${options.highlightClass}">$1</span>`);
+      hasMatches = true;
+    }
+  }
+  
+  if (!hasMatches) {
+    const fuzzyMatches = findFuzzyMatches(text, query);
+    if (fuzzyMatches.length > 0) {
+      fuzzyMatches.sort((a, b) => b.start - a.start);
+      
+      for (const match of fuzzyMatches) {
+        const before = highlightedText.substring(0, match.start);
+        const after = highlightedText.substring(match.end);
+        const matchText = highlightedText.substring(match.start, match.end);
+        highlightedText = before + `<span class="${options.highlightClass}">${matchText}</span>` + after;
+      }
+      hasMatches = true;
+    }
+  }
+  
+  return highlightedText;
+}
+
 /**
  * Creates a templateMiddleware that includes highlighting functionality
  * @param options - Highlighting options
@@ -303,38 +359,18 @@ export function createHighlightTemplateMiddleware(options: HighlightOptions = {}
     ...options
   };
 
-  return function(prop: string, value: string, _template: string, query?: string): string | undefined {
+  return function(prop: string, value: string, _template: string, query?: string, matchInfo?: MatchInfo[]): string | undefined {
     if ((prop === 'content' || prop === 'desc') && query && typeof value === 'string') {
-      let highlightedText = value;
-      let hasMatches = false;
-      
-      const searchTerms = query.trim().split(/\s+/).filter(term => term.length > 0);
-      for (const term of searchTerms) {
-        const regex = new RegExp(`\\b(${term.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')})\\b`, 'gi');
-        if (regex.test(highlightedText)) {
-          highlightedText = highlightedText.replace(regex, `<span class="${highlightOptions.highlightClass}">$1</span>`);
-          hasMatches = true;
-        }
+      // Use provided match info if available (faster, more accurate - NO DUPLICATE SEARCH)
+      if (matchInfo && matchInfo.length > 0) {
+        const highlighted = highlightWithMatchInfo(value, matchInfo, highlightOptions);
+        return highlighted !== value ? highlighted : undefined;
       }
       
-      if (!hasMatches) {
-        const fuzzyMatches = findFuzzyMatches(value, query);
-        if (fuzzyMatches.length > 0) {
-          fuzzyMatches.sort((a, b) => b.start - a.start);
-          
-          for (const match of fuzzyMatches) {
-            const before = highlightedText.substring(0, match.start);
-            const after = highlightedText.substring(match.end);
-            const matchText = highlightedText.substring(match.start, match.end);
-            highlightedText = before + `<span class="${highlightOptions.highlightClass}">${matchText}</span>` + after;
-          }
-          hasMatches = true;
-        }
-      }
-      
-      if (hasMatches) {
-        return highlightedText;
-      }
+      // Only fallback to query-based search if match info is not available
+      // This should rarely happen in the new architecture
+      const highlighted = highlightWithQuery(value, query, highlightOptions);
+      return highlighted !== value ? highlighted : undefined;
     }
     return undefined;
   };

From 8e086919f6287a1609ae83708c13b27088fc3a2d Mon Sep 17 00:00:00 2001
From: sylhare <sylhare@outlook.com>
Date: Thu, 9 Oct 2025 10:14:43 -0400
Subject: [PATCH 06/10] Remove duplication

---
 dest/simple-jekyll-search.js                  | 21 +++++++++------
 dest/simple-jekyll-search.min.js              |  2 +-
 docs/assets/js/simple-jekyll-search.min.js    |  2 +-
 src/SearchStrategies/search/fuzzySearch.ts    | 26 +------------------
 src/SearchStrategies/search/utils.ts          | 26 +++++++++++++++++++
 src/SearchStrategies/search/wildcardSearch.ts | 25 +-----------------
 6 files changed, 43 insertions(+), 59 deletions(-)
 create mode 100644 src/SearchStrategies/search/utils.ts

diff --git a/dest/simple-jekyll-search.js b/dest/simple-jekyll-search.js
index d165b7b..f3f6ada 100644
--- a/dest/simple-jekyll-search.js
+++ b/dest/simple-jekyll-search.js
@@ -422,17 +422,19 @@
     }
     findMatchesInObject(obj, criteria) {
       var _a, _b;
+      let hasMatch = false;
+      const result = { ...obj };
+      result._matchInfo = {};
       for (const key in obj) {
         if (!this.isExcluded(obj[key]) && this.options.searchStrategy.matches(obj[key], criteria)) {
+          hasMatch = true;
           const matchInfo = (_b = (_a = this.options.searchStrategy).findMatches) == null ? void 0 : _b.call(_a, obj[key], criteria);
-          const result = { ...obj };
           if (matchInfo && matchInfo.length > 0) {
-            result._matchInfo = { [key]: matchInfo };
+            result._matchInfo[key] = matchInfo;
           }
-          return result;
         }
       }
-      return void 0;
+      return hasMatch ? result : void 0;
     }
     isExcluded(term) {
       for (const excludedTerm of this.options.exclude) {
@@ -473,10 +475,13 @@
   }
   function compile(data, query) {
     return options.template.replace(options.pattern, function(match, prop) {
-      if (options.middleware.length >= 5 && data._matchInfo && data._matchInfo[prop]) {
-        const value2 = options.middleware(prop, data[prop], options.template, query, data._matchInfo[prop]);
-        if (typeof value2 !== "undefined") {
-          return value2;
+      if (data._matchInfo && data._matchInfo[prop] && data._matchInfo[prop].length > 0) {
+        try {
+          const value2 = options.middleware(prop, data[prop], options.template, query, data._matchInfo[prop]);
+          if (typeof value2 !== "undefined") {
+            return value2;
+          }
+        } catch (_e) {
         }
       }
       const value = options.middleware(prop, data[prop], options.template, query);
diff --git a/dest/simple-jekyll-search.min.js b/dest/simple-jekyll-search.min.js
index 8056511..7b0ff2d 100644
--- a/dest/simple-jekyll-search.min.js
+++ b/dest/simple-jekyll-search.min.js
@@ -4,4 +4,4 @@
   * Copyright 2025-2025, Sylhare
   * Licensed under the MIT License.
   */
-(function(global,factory){typeof exports==="object"&&typeof module!=="undefined"?factory(exports):typeof define==="function"&&define.amd?define(["exports"],factory):(global=typeof globalThis!=="undefined"?globalThis:global||self,factory(global.SimpleJekyllSearch={}))})(this,(function(exports2){"use strict";function load(location,callback){const xhr=getXHR();xhr.open("GET",location,true);xhr.onreadystatechange=createStateChangeListener(xhr,callback);xhr.send()}function createStateChangeListener(xhr,callback){return function(){if(xhr.readyState===4&&xhr.status===200){try{callback(null,JSON.parse(xhr.responseText))}catch(err){callback(err instanceof Error?err:new Error(String(err)),null)}}}}function getXHR(){return window.XMLHttpRequest?new window.XMLHttpRequest:new window.ActiveXObject("Microsoft.XMLHTTP")}class OptionsValidator{constructor(params){if(!this.validateParams(params)){throw new Error("-- OptionsValidator: required options missing")}this.requiredOptions=params.required}getRequiredOptions(){return this.requiredOptions}validate(parameters){const errors=[];this.requiredOptions.forEach((requiredOptionName=>{if(typeof parameters[requiredOptionName]==="undefined"){errors.push(requiredOptionName)}}));return errors}validateParams(params){if(!params){return false}return typeof params.required!=="undefined"&&Array.isArray(params.required)}}function fuzzySearch(text,pattern){pattern=pattern.trimEnd();if(pattern.length===0)return true;pattern=pattern.toLowerCase();text=text.toLowerCase();let remainingText=text,currentIndex=-1;for(const char of pattern){const nextIndex=remainingText.indexOf(char);if(nextIndex===-1||currentIndex!==-1&&remainingText.slice(0,nextIndex).split(" ").length-1>2){return false}currentIndex=nextIndex;remainingText=remainingText.slice(nextIndex+1)}return true}function findFuzzyMatches$1(text,pattern){if(!text||!pattern)return[];const lowerText=text.toLowerCase();const lowerPattern=pattern.toLowerCase().trim();if(lowerPattern.length===0)return[];const patternWords=lowerPattern.split(/\s+/);const matches=[];for(const word of patternWords){if(word.length===0)continue;const wordMatches=findFuzzyWordMatches$1(lowerText,word);matches.push(...wordMatches)}return mergeAndSortMatches$1(matches)}function findFuzzyWordMatches$1(text,word){const matches=[];const exactRegex=new RegExp(`\\b${word.replace(/[.*+?^${}()|[\]\\]/g,"\\$&")}\\b`,"gi");let match;while((match=exactRegex.exec(text))!==null){matches.push({start:match.index,end:match.index+match[0].length,text:match[0],type:"exact"})}if(matches.length===0){for(let i=0;i<text.length;i++){const fuzzyMatch=findFuzzySequenceMatch$1(text,word,i);if(fuzzyMatch){matches.push({...fuzzyMatch,type:"fuzzy"});i=fuzzyMatch.end-1}}}return matches}function findFuzzySequenceMatch$1(text,pattern,startPos){let textIndex=startPos;let patternIndex=0;let matchStart=-1;let maxGap=3;const matchedPositions=[];while(textIndex<text.length&&patternIndex<pattern.length){if(text[textIndex]===pattern[patternIndex]){if(matchStart===-1){matchStart=textIndex}matchedPositions.push(textIndex);patternIndex++}else if(matchStart!==-1){if(textIndex-matchStart>maxGap*pattern.length){return null}}textIndex++}if(patternIndex===pattern.length&&matchStart!==-1&&matchedPositions.length>0){const actualStart=matchedPositions[0];const actualEnd=matchedPositions[matchedPositions.length-1]+1;return{start:actualStart,end:actualEnd,text:text.substring(actualStart,actualEnd)}}return null}function mergeAndSortMatches$1(matches){if(matches.length===0)return[];const sortedMatches=matches.sort(((a,b)=>a.start-b.start));const merged=[];for(const match of sortedMatches){const lastMerged=merged[merged.length-1];if(lastMerged&&match.start<=lastMerged.end){lastMerged.end=Math.max(lastMerged.end,match.end);lastMerged.text=lastMerged.text+match.text.slice(lastMerged.end-match.start)}else{merged.push({...match})}}return merged}function literalSearch(text,criteria){text=text.trim().toLowerCase();const pattern=criteria.endsWith(" ")?[criteria.toLowerCase()]:criteria.trim().toLowerCase().split(" ");return pattern.filter((word=>text.indexOf(word)>=0)).length===pattern.length}function findLiteralMatches(text,criteria){if(!text||!criteria)return[];const lowerText=text.toLowerCase();const words=criteria.trim().toLowerCase().split(/\s+/);const matches=[];let textIndex=0;for(const word of words){if(word.length===0)continue;const wordIndex=lowerText.indexOf(word,textIndex);if(wordIndex!==-1){matches.push({start:wordIndex,end:wordIndex+word.length,text:text.substring(wordIndex,wordIndex+word.length),type:"exact"});textIndex=wordIndex+word.length}}return matches}function levenshtein(a,b){const lenA=a.length;const lenB=b.length;const distanceMatrix=Array.from({length:lenA+1},(()=>Array(lenB+1).fill(0)));for(let i=0;i<=lenA;i++)distanceMatrix[i][0]=i;for(let j=0;j<=lenB;j++)distanceMatrix[0][j]=j;for(let i=1;i<=lenA;i++){for(let j=1;j<=lenB;j++){const cost=a[i-1]===b[j-1]?0:1;distanceMatrix[i][j]=Math.min(distanceMatrix[i-1][j]+1,distanceMatrix[i][j-1]+1,distanceMatrix[i-1][j-1]+cost)}}return distanceMatrix[lenA][lenB]}function levenshteinSearch(text,pattern){const distance=levenshtein(pattern,text);const similarity=1-distance/Math.max(pattern.length,text.length);return similarity>=.3}function findLevenshteinMatches(text,pattern){if(!text||!pattern)return[];const matches=[];const words=text.split(/\s+/);for(let i=0;i<words.length;i++){const word=words[i];if(levenshteinSearch(word,pattern)){const start=text.indexOf(word);matches.push({start:start,end:start+word.length,text:word,type:"wildcard"})}}return matches}function wildcardSearch(text,pattern){const regexPattern=pattern.replace(/\*/g,".*");const regex=new RegExp(`^${regexPattern}$`,"i");if(regex.test(text))return true;return levenshteinSearch(text,pattern)}function findWildcardMatches(text,pattern){if(!text||!pattern)return[];const wildcardMatches=findWildcardPatternMatches(text,pattern);if(wildcardMatches.length>0){return mergeAndSortMatches(wildcardMatches)}const levenshteinMatches=findLevenshteinMatches(text,pattern);return mergeAndSortMatches(levenshteinMatches)}function findWildcardPatternMatches(text,pattern){const matches=[];const regexPattern=pattern.replace(/\*/g,".*");const regex=new RegExp(regexPattern,"gi");let match;while((match=regex.exec(text))!==null){matches.push({start:match.index,end:match.index+match[0].length,text:match[0],type:"wildcard"})}return matches}function mergeAndSortMatches(matches){if(matches.length===0)return[];const sortedMatches=matches.sort(((a,b)=>a.start-b.start));const merged=[];for(const match of sortedMatches){const lastMerged=merged[merged.length-1];if(lastMerged&&match.start<=lastMerged.end){lastMerged.end=Math.max(lastMerged.end,match.end);lastMerged.text=lastMerged.text+match.text.slice(lastMerged.end-match.start)}else{merged.push({...match})}}return merged}class SearchStrategy{constructor(matchFunction,findMatchesFunction){this.matchFunction=matchFunction;this.findMatchesFunction=findMatchesFunction}matches(text,criteria){if(text===null||text.trim()===""||!criteria){return false}return this.matchFunction(text,criteria)}findMatches(text,criteria){if(text===null||text.trim()===""||!criteria||!this.findMatchesFunction){return[]}return this.findMatchesFunction(text,criteria)}}const LiteralSearchStrategy=new SearchStrategy(literalSearch,findLiteralMatches);const FuzzySearchStrategy=new SearchStrategy(((text,criteria)=>fuzzySearch(text,criteria)||literalSearch(text,criteria)),((text,criteria)=>{const fuzzyMatches=findFuzzyMatches$1(text,criteria);if(fuzzyMatches.length>0){return fuzzyMatches}return findLiteralMatches(text,criteria)}));const WildcardSearchStrategy=new SearchStrategy(((text,criteria)=>wildcardSearch(text,criteria)||literalSearch(text,criteria)),((text,criteria)=>{const wildcardMatches=findWildcardMatches(text,criteria);if(wildcardMatches.length>0){return wildcardMatches}return findLiteralMatches(text,criteria)}));function merge(target,source){return{...target,...source}}function isJSON(json){try{return!!(json instanceof Object&&JSON.parse(JSON.stringify(json)))}catch(_err){return false}}function NoSort(){return 0}function isObject(obj){return Boolean(obj)&&Object.prototype.toString.call(obj)==="[object Object]"}function clone(input){if(input===null||typeof input!=="object"){return input}if(Array.isArray(input)){return input.map((item=>clone(item)))}const output={};for(const key in input){if(Object.prototype.hasOwnProperty.call(input,key)){output[key]=clone(input[key])}}return output}const DEFAULT_OPTIONS={searchInput:null,resultsContainer:null,json:[],success:function(){},searchResultTemplate:'<li><a href="{url}" title="{desc}">{title}</a></li>',templateMiddleware:(_prop,_value,_template,_query)=>void 0,sortMiddleware:NoSort,noResultsText:"No results found",limit:10,fuzzy:false,strategy:"literal",debounceTime:null,exclude:[],onSearch:()=>{}};const REQUIRED_OPTIONS=["searchInput","resultsContainer","json"];const WHITELISTED_KEYS=new Set(["Enter","Shift","CapsLock","ArrowLeft","ArrowUp","ArrowRight","ArrowDown","Meta"]);class Repository{constructor(initialOptions={}){this.data=[];this.setOptions(initialOptions)}put(input){if(isObject(input)){return this.addObject(input)}if(Array.isArray(input)){return this.addArray(input)}return void 0}clear(){this.data.length=0;return this.data}search(criteria){if(!criteria){return[]}return clone(this.findMatches(this.data,criteria).sort(this.options.sortMiddleware))}setOptions(newOptions){this.options={fuzzy:(newOptions==null?void 0:newOptions.fuzzy)||DEFAULT_OPTIONS.fuzzy,limit:(newOptions==null?void 0:newOptions.limit)||DEFAULT_OPTIONS.limit,searchStrategy:this.searchStrategy((newOptions==null?void 0:newOptions.strategy)||newOptions.fuzzy&&"fuzzy"||DEFAULT_OPTIONS.strategy),sortMiddleware:(newOptions==null?void 0:newOptions.sortMiddleware)||DEFAULT_OPTIONS.sortMiddleware,exclude:(newOptions==null?void 0:newOptions.exclude)||DEFAULT_OPTIONS.exclude,strategy:(newOptions==null?void 0:newOptions.strategy)||DEFAULT_OPTIONS.strategy}}addObject(obj){this.data.push(obj);return this.data}addArray(arr){const added=[];this.clear();for(const item of arr){if(isObject(item)){added.push(this.addObject(item)[0])}}return added}findMatches(data,criteria){const matches=[];for(let i=0;i<data.length&&matches.length<this.options.limit;i++){const match=this.findMatchesInObject(data[i],criteria);if(match){matches.push(match)}}return matches}findMatchesInObject(obj,criteria){var _a,_b;for(const key in obj){if(!this.isExcluded(obj[key])&&this.options.searchStrategy.matches(obj[key],criteria)){const matchInfo=(_b=(_a=this.options.searchStrategy).findMatches)==null?void 0:_b.call(_a,obj[key],criteria);const result={...obj};if(matchInfo&&matchInfo.length>0){result._matchInfo={[key]:matchInfo}}return result}}return void 0}isExcluded(term){for(const excludedTerm of this.options.exclude){if(new RegExp(excludedTerm).test(String(term))){return true}}return false}searchStrategy(strategy){switch(strategy){case"fuzzy":return FuzzySearchStrategy;case"wildcard":return WildcardSearchStrategy;default:return LiteralSearchStrategy}}}const options={pattern:/\{(.*?)\}/g,template:"",middleware:function(){return void 0}};function setOptions(_options){if(_options.pattern){options.pattern=_options.pattern}if(_options.template){options.template=_options.template}if(typeof _options.middleware==="function"){options.middleware=_options.middleware}}function compile(data,query){return options.template.replace(options.pattern,(function(match,prop){if(options.middleware.length>=5&&data._matchInfo&&data._matchInfo[prop]){const value2=options.middleware(prop,data[prop],options.template,query,data._matchInfo[prop]);if(typeof value2!=="undefined"){return value2}}const value=options.middleware(prop,data[prop],options.template,query);if(typeof value!=="undefined"){return value}return data[prop]||match}))}let SimpleJekyllSearch$1=class SimpleJekyllSearch{constructor(){this.debounceTimerHandle=null;this.options={...DEFAULT_OPTIONS};this.repository=new Repository;this.optionsValidator=new OptionsValidator({required:REQUIRED_OPTIONS})}debounce(func,delayMillis){if(delayMillis){if(this.debounceTimerHandle){clearTimeout(this.debounceTimerHandle)}this.debounceTimerHandle=setTimeout(func,delayMillis)}else{func()}}throwError(message){throw new Error(`SimpleJekyllSearch --- ${message}`)}emptyResultsContainer(){this.options.resultsContainer.innerHTML=""}initWithJSON(json){this.repository.put(json);this.registerInput()}initWithURL(url){load(url,((err,json)=>{if(err){this.throwError(`Failed to load JSON from ${url}: ${err.message}`)}this.initWithJSON(json)}))}registerInput(){this.options.searchInput.addEventListener("input",(e=>{const inputEvent=e;if(!WHITELISTED_KEYS.has(inputEvent.key)){this.emptyResultsContainer();this.debounce((()=>{this.search(e.target.value)}),this.options.debounceTime??null)}}))}search(query){var _a,_b;if((query==null?void 0:query.trim().length)>0){this.emptyResultsContainer();const results=this.repository.search(query);this.render(results,query);(_b=(_a=this.options).onSearch)==null?void 0:_b.call(_a)}}render(results,query){if(results.length===0){this.options.resultsContainer.insertAdjacentHTML("beforeend",this.options.noResultsText);return}const fragment=document.createDocumentFragment();results.forEach((result=>{result.query=query;const div=document.createElement("div");div.innerHTML=compile(result,query);fragment.appendChild(div)}));this.options.resultsContainer.appendChild(fragment)}init(_options){var _a;const errors=this.optionsValidator.validate(_options);if(errors.length>0){this.throwError(`Missing required options: ${REQUIRED_OPTIONS.join(", ")}`)}this.options=merge(this.options,_options);setOptions({template:this.options.searchResultTemplate,middleware:this.options.templateMiddleware});this.repository.setOptions({fuzzy:this.options.fuzzy,limit:this.options.limit,sortMiddleware:this.options.sortMiddleware,strategy:this.options.strategy,exclude:this.options.exclude});if(isJSON(this.options.json)){this.initWithJSON(this.options.json)}else{this.initWithURL(this.options.json)}const rv={search:this.search.bind(this)};(_a=this.options.success)==null?void 0:_a.call(rv);return rv}};function createHighlightMiddleware(options2={}){const{highlightClass:highlightClass="sjs-highlight",contextBefore:contextBefore=50,contextAfter:contextAfter=50,maxLength:maxLength=250,ellipsis:ellipsis="..."}=options2;return function(result,query){if(!query||!result){return result}const highlightedResult={...result};const textFields=["title","desc","content","excerpt"];for(const field of textFields){if(highlightedResult[field]&&typeof highlightedResult[field]==="string"){const highlighted=highlightText(highlightedResult[field],query,{highlightClass:highlightClass,contextBefore:contextBefore,contextAfter:contextAfter,maxLength:maxLength,ellipsis:ellipsis});if(highlighted.highlightedText!==highlightedResult[field]){highlightedResult[field]=highlighted.highlightedText}}}return highlightedResult}}function highlightText(text,query,options2={}){const{highlightClass:highlightClass="sjs-highlight",contextBefore:contextBefore=50,contextAfter:contextAfter=50,maxLength:maxLength=250,ellipsis:ellipsis="..."}=options2;if(!text||!query){return{highlightedText:text,matchCount:0}}const originalText=text;const searchTerms=query.trim().toLowerCase().split(/\s+/).filter((term=>term.length>0));if(searchTerms.length===0){return{highlightedText:text,matchCount:0}}const matches=[];for(const term of searchTerms){let index=0;while(index<text.length){const found=text.toLowerCase().indexOf(term,index);if(found===-1)break;matches.push({start:found,end:found+term.length,term:text.substring(found,found+term.length)});index=found+1}}if(matches.length===0){return{highlightedText:text,matchCount:0}}matches.sort(((a,b)=>a.start-b.start));const mergedMatches=[];for(const match of matches){if(mergedMatches.length===0||mergedMatches[mergedMatches.length-1].end<match.start){mergedMatches.push(match)}else{const lastMatch=mergedMatches[mergedMatches.length-1];lastMatch.end=Math.max(lastMatch.end,match.end);lastMatch.term=text.substring(lastMatch.start,lastMatch.end)}}if(text.length<=maxLength){let highlightedText2=text;for(let i=mergedMatches.length-1;i>=0;i--){const match=mergedMatches[i];const before=highlightedText2.substring(0,match.start);const after=highlightedText2.substring(match.end);const matchText=highlightedText2.substring(match.start,match.end);highlightedText2=before+`<span class="${highlightClass}">${matchText}</span>`+after}return{highlightedText:highlightedText2,matchCount:mergedMatches.length}}let highlightedText="";let totalLength=0;let lastEnd=0;for(let i=0;i<mergedMatches.length;i++){const match=mergedMatches[i];const contextStart=Math.max(lastEnd,match.start-contextBefore);const contextEnd=Math.min(text.length,match.end+contextAfter);if(contextStart>lastEnd&&lastEnd>0){highlightedText+=ellipsis;totalLength+=ellipsis.length}if(contextStart<match.start){const beforeText=text.substring(contextStart,match.start);highlightedText+=beforeText;totalLength+=beforeText.length}const matchText=text.substring(match.start,match.end);highlightedText+=`<span class="${highlightClass}">${matchText}</span>`;totalLength+=matchText.length;if(match.end<contextEnd){const afterText=text.substring(match.end,contextEnd);highlightedText+=afterText;totalLength+=afterText.length}lastEnd=contextEnd;if(totalLength>=maxLength){if(contextEnd<text.length){highlightedText+=ellipsis}break}}return{highlightedText:highlightedText||originalText,matchCount:mergedMatches.length}}const defaultHighlightMiddleware=createHighlightMiddleware();function findFuzzyMatches(text,pattern){const matches=[];const lowerText=text.toLowerCase();const lowerPattern=pattern.toLowerCase().trim();if(lowerPattern.length===0)return matches;const patternWords=lowerPattern.split(/\s+/);for(const word of patternWords){if(word.length===0)continue;const wordMatches=findFuzzyWordMatches(lowerText,word);matches.push(...wordMatches)}return matches}function findFuzzyWordMatches(text,word){const matches=[];const exactRegex=new RegExp(`\\b${word.replace(/[.*+?^${}()|[\]\\]/g,"\\$&")}\\b`,"gi");let match;while((match=exactRegex.exec(text))!==null){matches.push({start:match.index,end:match.index+match[0].length,text:match[0]})}if(matches.length===0){for(let i=0;i<text.length;i++){const fuzzyMatch=findFuzzySequenceMatch(text,word,i);if(fuzzyMatch){matches.push(fuzzyMatch);i=fuzzyMatch.end-1}}}return matches}function findFuzzySequenceMatch(text,pattern,startPos){let textIndex=startPos;let patternIndex=0;let matchStart=-1;let maxGap=3;const matchedPositions=[];while(textIndex<text.length&&patternIndex<pattern.length){if(text[textIndex]===pattern[patternIndex]){if(matchStart===-1){matchStart=textIndex}matchedPositions.push(textIndex);patternIndex++}else if(matchStart!==-1){if(textIndex-matchStart>maxGap*pattern.length){return null}}textIndex++}if(patternIndex===pattern.length&&matchStart!==-1&&matchedPositions.length>0){const actualStart=matchedPositions[0];const actualEnd=matchedPositions[matchedPositions.length-1]+1;return{start:actualStart,end:actualEnd,text:text.substring(actualStart,actualEnd)}}return null}function highlightWithMatchInfo(text,matchInfo,options2){if(matchInfo.length===0)return text;const sortedMatches=[...matchInfo].sort(((a,b)=>b.start-a.start));let highlightedText=text;for(const match of sortedMatches){const before=highlightedText.substring(0,match.start);const after=highlightedText.substring(match.end);const matchText=highlightedText.substring(match.start,match.end);highlightedText=before+`<span class="${options2.highlightClass}">${matchText}</span>`+after}return highlightedText}function highlightWithQuery(text,query,options2){let highlightedText=text;let hasMatches=false;const searchTerms=query.trim().split(/\s+/).filter((term=>term.length>0));for(const term of searchTerms){const regex=new RegExp(`\\b(${term.replace(/[.*+?^${}()|[\]\\]/g,"\\$&")})\\b`,"gi");if(regex.test(highlightedText)){highlightedText=highlightedText.replace(regex,`<span class="${options2.highlightClass}">$1</span>`);hasMatches=true}}if(!hasMatches){const fuzzyMatches=findFuzzyMatches(text,query);if(fuzzyMatches.length>0){fuzzyMatches.sort(((a,b)=>b.start-a.start));for(const match of fuzzyMatches){const before=highlightedText.substring(0,match.start);const after=highlightedText.substring(match.end);const matchText=highlightedText.substring(match.start,match.end);highlightedText=before+`<span class="${options2.highlightClass}">${matchText}</span>`+after}hasMatches=true}}return highlightedText}function createHighlightTemplateMiddleware(options2={}){const highlightOptions={highlightClass:"sjs-highlight",...options2};return function(prop,value,_template,query,matchInfo){if((prop==="content"||prop==="desc")&&query&&typeof value==="string"){if(matchInfo&&matchInfo.length>0){const highlighted2=highlightWithMatchInfo(value,matchInfo,highlightOptions);return highlighted2!==value?highlighted2:void 0}const highlighted=highlightWithQuery(value,query,highlightOptions);return highlighted!==value?highlighted:void 0}return void 0}}const defaultHighlightTemplateMiddleware=createHighlightTemplateMiddleware();function SimpleJekyllSearch(options2){const instance=new SimpleJekyllSearch$1;return instance.init(options2)}if(typeof window!=="undefined"){window.SimpleJekyllSearch=SimpleJekyllSearch;window.SimpleJekyllSearch.createHighlightMiddleware=createHighlightMiddleware;window.SimpleJekyllSearch.createHighlightTemplateMiddleware=createHighlightTemplateMiddleware;window.SimpleJekyllSearch.highlightText=highlightText;window.SimpleJekyllSearch.defaultHighlightMiddleware=defaultHighlightMiddleware;window.SimpleJekyllSearch.defaultHighlightTemplateMiddleware=defaultHighlightTemplateMiddleware}exports2.createHighlightMiddleware=createHighlightMiddleware;exports2.createHighlightTemplateMiddleware=createHighlightTemplateMiddleware;exports2.default=SimpleJekyllSearch;exports2.defaultHighlightMiddleware=defaultHighlightMiddleware;exports2.defaultHighlightTemplateMiddleware=defaultHighlightTemplateMiddleware;exports2.highlightText=highlightText;Object.defineProperties(exports2,{__esModule:{value:true},[Symbol.toStringTag]:{value:"Module"}})}));
\ No newline at end of file
+(function(global,factory){typeof exports==="object"&&typeof module!=="undefined"?factory(exports):typeof define==="function"&&define.amd?define(["exports"],factory):(global=typeof globalThis!=="undefined"?globalThis:global||self,factory(global.SimpleJekyllSearch={}))})(this,(function(exports2){"use strict";function load(location,callback){const xhr=getXHR();xhr.open("GET",location,true);xhr.onreadystatechange=createStateChangeListener(xhr,callback);xhr.send()}function createStateChangeListener(xhr,callback){return function(){if(xhr.readyState===4&&xhr.status===200){try{callback(null,JSON.parse(xhr.responseText))}catch(err){callback(err instanceof Error?err:new Error(String(err)),null)}}}}function getXHR(){return window.XMLHttpRequest?new window.XMLHttpRequest:new window.ActiveXObject("Microsoft.XMLHTTP")}class OptionsValidator{constructor(params){if(!this.validateParams(params)){throw new Error("-- OptionsValidator: required options missing")}this.requiredOptions=params.required}getRequiredOptions(){return this.requiredOptions}validate(parameters){const errors=[];this.requiredOptions.forEach((requiredOptionName=>{if(typeof parameters[requiredOptionName]==="undefined"){errors.push(requiredOptionName)}}));return errors}validateParams(params){if(!params){return false}return typeof params.required!=="undefined"&&Array.isArray(params.required)}}function fuzzySearch(text,pattern){pattern=pattern.trimEnd();if(pattern.length===0)return true;pattern=pattern.toLowerCase();text=text.toLowerCase();let remainingText=text,currentIndex=-1;for(const char of pattern){const nextIndex=remainingText.indexOf(char);if(nextIndex===-1||currentIndex!==-1&&remainingText.slice(0,nextIndex).split(" ").length-1>2){return false}currentIndex=nextIndex;remainingText=remainingText.slice(nextIndex+1)}return true}function findFuzzyMatches$1(text,pattern){if(!text||!pattern)return[];const lowerText=text.toLowerCase();const lowerPattern=pattern.toLowerCase().trim();if(lowerPattern.length===0)return[];const patternWords=lowerPattern.split(/\s+/);const matches=[];for(const word of patternWords){if(word.length===0)continue;const wordMatches=findFuzzyWordMatches$1(lowerText,word);matches.push(...wordMatches)}return mergeAndSortMatches$1(matches)}function findFuzzyWordMatches$1(text,word){const matches=[];const exactRegex=new RegExp(`\\b${word.replace(/[.*+?^${}()|[\]\\]/g,"\\$&")}\\b`,"gi");let match;while((match=exactRegex.exec(text))!==null){matches.push({start:match.index,end:match.index+match[0].length,text:match[0],type:"exact"})}if(matches.length===0){for(let i=0;i<text.length;i++){const fuzzyMatch=findFuzzySequenceMatch$1(text,word,i);if(fuzzyMatch){matches.push({...fuzzyMatch,type:"fuzzy"});i=fuzzyMatch.end-1}}}return matches}function findFuzzySequenceMatch$1(text,pattern,startPos){let textIndex=startPos;let patternIndex=0;let matchStart=-1;let maxGap=3;const matchedPositions=[];while(textIndex<text.length&&patternIndex<pattern.length){if(text[textIndex]===pattern[patternIndex]){if(matchStart===-1){matchStart=textIndex}matchedPositions.push(textIndex);patternIndex++}else if(matchStart!==-1){if(textIndex-matchStart>maxGap*pattern.length){return null}}textIndex++}if(patternIndex===pattern.length&&matchStart!==-1&&matchedPositions.length>0){const actualStart=matchedPositions[0];const actualEnd=matchedPositions[matchedPositions.length-1]+1;return{start:actualStart,end:actualEnd,text:text.substring(actualStart,actualEnd)}}return null}function mergeAndSortMatches$1(matches){if(matches.length===0)return[];const sortedMatches=matches.sort(((a,b)=>a.start-b.start));const merged=[];for(const match of sortedMatches){const lastMerged=merged[merged.length-1];if(lastMerged&&match.start<=lastMerged.end){lastMerged.end=Math.max(lastMerged.end,match.end);lastMerged.text=lastMerged.text+match.text.slice(lastMerged.end-match.start)}else{merged.push({...match})}}return merged}function literalSearch(text,criteria){text=text.trim().toLowerCase();const pattern=criteria.endsWith(" ")?[criteria.toLowerCase()]:criteria.trim().toLowerCase().split(" ");return pattern.filter((word=>text.indexOf(word)>=0)).length===pattern.length}function findLiteralMatches(text,criteria){if(!text||!criteria)return[];const lowerText=text.toLowerCase();const words=criteria.trim().toLowerCase().split(/\s+/);const matches=[];let textIndex=0;for(const word of words){if(word.length===0)continue;const wordIndex=lowerText.indexOf(word,textIndex);if(wordIndex!==-1){matches.push({start:wordIndex,end:wordIndex+word.length,text:text.substring(wordIndex,wordIndex+word.length),type:"exact"});textIndex=wordIndex+word.length}}return matches}function levenshtein(a,b){const lenA=a.length;const lenB=b.length;const distanceMatrix=Array.from({length:lenA+1},(()=>Array(lenB+1).fill(0)));for(let i=0;i<=lenA;i++)distanceMatrix[i][0]=i;for(let j=0;j<=lenB;j++)distanceMatrix[0][j]=j;for(let i=1;i<=lenA;i++){for(let j=1;j<=lenB;j++){const cost=a[i-1]===b[j-1]?0:1;distanceMatrix[i][j]=Math.min(distanceMatrix[i-1][j]+1,distanceMatrix[i][j-1]+1,distanceMatrix[i-1][j-1]+cost)}}return distanceMatrix[lenA][lenB]}function levenshteinSearch(text,pattern){const distance=levenshtein(pattern,text);const similarity=1-distance/Math.max(pattern.length,text.length);return similarity>=.3}function findLevenshteinMatches(text,pattern){if(!text||!pattern)return[];const matches=[];const words=text.split(/\s+/);for(let i=0;i<words.length;i++){const word=words[i];if(levenshteinSearch(word,pattern)){const start=text.indexOf(word);matches.push({start:start,end:start+word.length,text:word,type:"wildcard"})}}return matches}function wildcardSearch(text,pattern){const regexPattern=pattern.replace(/\*/g,".*");const regex=new RegExp(`^${regexPattern}$`,"i");if(regex.test(text))return true;return levenshteinSearch(text,pattern)}function findWildcardMatches(text,pattern){if(!text||!pattern)return[];const wildcardMatches=findWildcardPatternMatches(text,pattern);if(wildcardMatches.length>0){return mergeAndSortMatches(wildcardMatches)}const levenshteinMatches=findLevenshteinMatches(text,pattern);return mergeAndSortMatches(levenshteinMatches)}function findWildcardPatternMatches(text,pattern){const matches=[];const regexPattern=pattern.replace(/\*/g,".*");const regex=new RegExp(regexPattern,"gi");let match;while((match=regex.exec(text))!==null){matches.push({start:match.index,end:match.index+match[0].length,text:match[0],type:"wildcard"})}return matches}function mergeAndSortMatches(matches){if(matches.length===0)return[];const sortedMatches=matches.sort(((a,b)=>a.start-b.start));const merged=[];for(const match of sortedMatches){const lastMerged=merged[merged.length-1];if(lastMerged&&match.start<=lastMerged.end){lastMerged.end=Math.max(lastMerged.end,match.end);lastMerged.text=lastMerged.text+match.text.slice(lastMerged.end-match.start)}else{merged.push({...match})}}return merged}class SearchStrategy{constructor(matchFunction,findMatchesFunction){this.matchFunction=matchFunction;this.findMatchesFunction=findMatchesFunction}matches(text,criteria){if(text===null||text.trim()===""||!criteria){return false}return this.matchFunction(text,criteria)}findMatches(text,criteria){if(text===null||text.trim()===""||!criteria||!this.findMatchesFunction){return[]}return this.findMatchesFunction(text,criteria)}}const LiteralSearchStrategy=new SearchStrategy(literalSearch,findLiteralMatches);const FuzzySearchStrategy=new SearchStrategy(((text,criteria)=>fuzzySearch(text,criteria)||literalSearch(text,criteria)),((text,criteria)=>{const fuzzyMatches=findFuzzyMatches$1(text,criteria);if(fuzzyMatches.length>0){return fuzzyMatches}return findLiteralMatches(text,criteria)}));const WildcardSearchStrategy=new SearchStrategy(((text,criteria)=>wildcardSearch(text,criteria)||literalSearch(text,criteria)),((text,criteria)=>{const wildcardMatches=findWildcardMatches(text,criteria);if(wildcardMatches.length>0){return wildcardMatches}return findLiteralMatches(text,criteria)}));function merge(target,source){return{...target,...source}}function isJSON(json){try{return!!(json instanceof Object&&JSON.parse(JSON.stringify(json)))}catch(_err){return false}}function NoSort(){return 0}function isObject(obj){return Boolean(obj)&&Object.prototype.toString.call(obj)==="[object Object]"}function clone(input){if(input===null||typeof input!=="object"){return input}if(Array.isArray(input)){return input.map((item=>clone(item)))}const output={};for(const key in input){if(Object.prototype.hasOwnProperty.call(input,key)){output[key]=clone(input[key])}}return output}const DEFAULT_OPTIONS={searchInput:null,resultsContainer:null,json:[],success:function(){},searchResultTemplate:'<li><a href="{url}" title="{desc}">{title}</a></li>',templateMiddleware:(_prop,_value,_template,_query)=>void 0,sortMiddleware:NoSort,noResultsText:"No results found",limit:10,fuzzy:false,strategy:"literal",debounceTime:null,exclude:[],onSearch:()=>{}};const REQUIRED_OPTIONS=["searchInput","resultsContainer","json"];const WHITELISTED_KEYS=new Set(["Enter","Shift","CapsLock","ArrowLeft","ArrowUp","ArrowRight","ArrowDown","Meta"]);class Repository{constructor(initialOptions={}){this.data=[];this.setOptions(initialOptions)}put(input){if(isObject(input)){return this.addObject(input)}if(Array.isArray(input)){return this.addArray(input)}return void 0}clear(){this.data.length=0;return this.data}search(criteria){if(!criteria){return[]}return clone(this.findMatches(this.data,criteria).sort(this.options.sortMiddleware))}setOptions(newOptions){this.options={fuzzy:(newOptions==null?void 0:newOptions.fuzzy)||DEFAULT_OPTIONS.fuzzy,limit:(newOptions==null?void 0:newOptions.limit)||DEFAULT_OPTIONS.limit,searchStrategy:this.searchStrategy((newOptions==null?void 0:newOptions.strategy)||newOptions.fuzzy&&"fuzzy"||DEFAULT_OPTIONS.strategy),sortMiddleware:(newOptions==null?void 0:newOptions.sortMiddleware)||DEFAULT_OPTIONS.sortMiddleware,exclude:(newOptions==null?void 0:newOptions.exclude)||DEFAULT_OPTIONS.exclude,strategy:(newOptions==null?void 0:newOptions.strategy)||DEFAULT_OPTIONS.strategy}}addObject(obj){this.data.push(obj);return this.data}addArray(arr){const added=[];this.clear();for(const item of arr){if(isObject(item)){added.push(this.addObject(item)[0])}}return added}findMatches(data,criteria){const matches=[];for(let i=0;i<data.length&&matches.length<this.options.limit;i++){const match=this.findMatchesInObject(data[i],criteria);if(match){matches.push(match)}}return matches}findMatchesInObject(obj,criteria){var _a,_b;let hasMatch=false;const result={...obj};result._matchInfo={};for(const key in obj){if(!this.isExcluded(obj[key])&&this.options.searchStrategy.matches(obj[key],criteria)){hasMatch=true;const matchInfo=(_b=(_a=this.options.searchStrategy).findMatches)==null?void 0:_b.call(_a,obj[key],criteria);if(matchInfo&&matchInfo.length>0){result._matchInfo[key]=matchInfo}}}return hasMatch?result:void 0}isExcluded(term){for(const excludedTerm of this.options.exclude){if(new RegExp(excludedTerm).test(String(term))){return true}}return false}searchStrategy(strategy){switch(strategy){case"fuzzy":return FuzzySearchStrategy;case"wildcard":return WildcardSearchStrategy;default:return LiteralSearchStrategy}}}const options={pattern:/\{(.*?)\}/g,template:"",middleware:function(){return void 0}};function setOptions(_options){if(_options.pattern){options.pattern=_options.pattern}if(_options.template){options.template=_options.template}if(typeof _options.middleware==="function"){options.middleware=_options.middleware}}function compile(data,query){return options.template.replace(options.pattern,(function(match,prop){if(data._matchInfo&&data._matchInfo[prop]&&data._matchInfo[prop].length>0){try{const value2=options.middleware(prop,data[prop],options.template,query,data._matchInfo[prop]);if(typeof value2!=="undefined"){return value2}}catch(_e){}}const value=options.middleware(prop,data[prop],options.template,query);if(typeof value!=="undefined"){return value}return data[prop]||match}))}let SimpleJekyllSearch$1=class SimpleJekyllSearch{constructor(){this.debounceTimerHandle=null;this.options={...DEFAULT_OPTIONS};this.repository=new Repository;this.optionsValidator=new OptionsValidator({required:REQUIRED_OPTIONS})}debounce(func,delayMillis){if(delayMillis){if(this.debounceTimerHandle){clearTimeout(this.debounceTimerHandle)}this.debounceTimerHandle=setTimeout(func,delayMillis)}else{func()}}throwError(message){throw new Error(`SimpleJekyllSearch --- ${message}`)}emptyResultsContainer(){this.options.resultsContainer.innerHTML=""}initWithJSON(json){this.repository.put(json);this.registerInput()}initWithURL(url){load(url,((err,json)=>{if(err){this.throwError(`Failed to load JSON from ${url}: ${err.message}`)}this.initWithJSON(json)}))}registerInput(){this.options.searchInput.addEventListener("input",(e=>{const inputEvent=e;if(!WHITELISTED_KEYS.has(inputEvent.key)){this.emptyResultsContainer();this.debounce((()=>{this.search(e.target.value)}),this.options.debounceTime??null)}}))}search(query){var _a,_b;if((query==null?void 0:query.trim().length)>0){this.emptyResultsContainer();const results=this.repository.search(query);this.render(results,query);(_b=(_a=this.options).onSearch)==null?void 0:_b.call(_a)}}render(results,query){if(results.length===0){this.options.resultsContainer.insertAdjacentHTML("beforeend",this.options.noResultsText);return}const fragment=document.createDocumentFragment();results.forEach((result=>{result.query=query;const div=document.createElement("div");div.innerHTML=compile(result,query);fragment.appendChild(div)}));this.options.resultsContainer.appendChild(fragment)}init(_options){var _a;const errors=this.optionsValidator.validate(_options);if(errors.length>0){this.throwError(`Missing required options: ${REQUIRED_OPTIONS.join(", ")}`)}this.options=merge(this.options,_options);setOptions({template:this.options.searchResultTemplate,middleware:this.options.templateMiddleware});this.repository.setOptions({fuzzy:this.options.fuzzy,limit:this.options.limit,sortMiddleware:this.options.sortMiddleware,strategy:this.options.strategy,exclude:this.options.exclude});if(isJSON(this.options.json)){this.initWithJSON(this.options.json)}else{this.initWithURL(this.options.json)}const rv={search:this.search.bind(this)};(_a=this.options.success)==null?void 0:_a.call(rv);return rv}};function createHighlightMiddleware(options2={}){const{highlightClass:highlightClass="sjs-highlight",contextBefore:contextBefore=50,contextAfter:contextAfter=50,maxLength:maxLength=250,ellipsis:ellipsis="..."}=options2;return function(result,query){if(!query||!result){return result}const highlightedResult={...result};const textFields=["title","desc","content","excerpt"];for(const field of textFields){if(highlightedResult[field]&&typeof highlightedResult[field]==="string"){const highlighted=highlightText(highlightedResult[field],query,{highlightClass:highlightClass,contextBefore:contextBefore,contextAfter:contextAfter,maxLength:maxLength,ellipsis:ellipsis});if(highlighted.highlightedText!==highlightedResult[field]){highlightedResult[field]=highlighted.highlightedText}}}return highlightedResult}}function highlightText(text,query,options2={}){const{highlightClass:highlightClass="sjs-highlight",contextBefore:contextBefore=50,contextAfter:contextAfter=50,maxLength:maxLength=250,ellipsis:ellipsis="..."}=options2;if(!text||!query){return{highlightedText:text,matchCount:0}}const originalText=text;const searchTerms=query.trim().toLowerCase().split(/\s+/).filter((term=>term.length>0));if(searchTerms.length===0){return{highlightedText:text,matchCount:0}}const matches=[];for(const term of searchTerms){let index=0;while(index<text.length){const found=text.toLowerCase().indexOf(term,index);if(found===-1)break;matches.push({start:found,end:found+term.length,term:text.substring(found,found+term.length)});index=found+1}}if(matches.length===0){return{highlightedText:text,matchCount:0}}matches.sort(((a,b)=>a.start-b.start));const mergedMatches=[];for(const match of matches){if(mergedMatches.length===0||mergedMatches[mergedMatches.length-1].end<match.start){mergedMatches.push(match)}else{const lastMatch=mergedMatches[mergedMatches.length-1];lastMatch.end=Math.max(lastMatch.end,match.end);lastMatch.term=text.substring(lastMatch.start,lastMatch.end)}}if(text.length<=maxLength){let highlightedText2=text;for(let i=mergedMatches.length-1;i>=0;i--){const match=mergedMatches[i];const before=highlightedText2.substring(0,match.start);const after=highlightedText2.substring(match.end);const matchText=highlightedText2.substring(match.start,match.end);highlightedText2=before+`<span class="${highlightClass}">${matchText}</span>`+after}return{highlightedText:highlightedText2,matchCount:mergedMatches.length}}let highlightedText="";let totalLength=0;let lastEnd=0;for(let i=0;i<mergedMatches.length;i++){const match=mergedMatches[i];const contextStart=Math.max(lastEnd,match.start-contextBefore);const contextEnd=Math.min(text.length,match.end+contextAfter);if(contextStart>lastEnd&&lastEnd>0){highlightedText+=ellipsis;totalLength+=ellipsis.length}if(contextStart<match.start){const beforeText=text.substring(contextStart,match.start);highlightedText+=beforeText;totalLength+=beforeText.length}const matchText=text.substring(match.start,match.end);highlightedText+=`<span class="${highlightClass}">${matchText}</span>`;totalLength+=matchText.length;if(match.end<contextEnd){const afterText=text.substring(match.end,contextEnd);highlightedText+=afterText;totalLength+=afterText.length}lastEnd=contextEnd;if(totalLength>=maxLength){if(contextEnd<text.length){highlightedText+=ellipsis}break}}return{highlightedText:highlightedText||originalText,matchCount:mergedMatches.length}}const defaultHighlightMiddleware=createHighlightMiddleware();function findFuzzyMatches(text,pattern){const matches=[];const lowerText=text.toLowerCase();const lowerPattern=pattern.toLowerCase().trim();if(lowerPattern.length===0)return matches;const patternWords=lowerPattern.split(/\s+/);for(const word of patternWords){if(word.length===0)continue;const wordMatches=findFuzzyWordMatches(lowerText,word);matches.push(...wordMatches)}return matches}function findFuzzyWordMatches(text,word){const matches=[];const exactRegex=new RegExp(`\\b${word.replace(/[.*+?^${}()|[\]\\]/g,"\\$&")}\\b`,"gi");let match;while((match=exactRegex.exec(text))!==null){matches.push({start:match.index,end:match.index+match[0].length,text:match[0]})}if(matches.length===0){for(let i=0;i<text.length;i++){const fuzzyMatch=findFuzzySequenceMatch(text,word,i);if(fuzzyMatch){matches.push(fuzzyMatch);i=fuzzyMatch.end-1}}}return matches}function findFuzzySequenceMatch(text,pattern,startPos){let textIndex=startPos;let patternIndex=0;let matchStart=-1;let maxGap=3;const matchedPositions=[];while(textIndex<text.length&&patternIndex<pattern.length){if(text[textIndex]===pattern[patternIndex]){if(matchStart===-1){matchStart=textIndex}matchedPositions.push(textIndex);patternIndex++}else if(matchStart!==-1){if(textIndex-matchStart>maxGap*pattern.length){return null}}textIndex++}if(patternIndex===pattern.length&&matchStart!==-1&&matchedPositions.length>0){const actualStart=matchedPositions[0];const actualEnd=matchedPositions[matchedPositions.length-1]+1;return{start:actualStart,end:actualEnd,text:text.substring(actualStart,actualEnd)}}return null}function highlightWithMatchInfo(text,matchInfo,options2){if(matchInfo.length===0)return text;const sortedMatches=[...matchInfo].sort(((a,b)=>b.start-a.start));let highlightedText=text;for(const match of sortedMatches){const before=highlightedText.substring(0,match.start);const after=highlightedText.substring(match.end);const matchText=highlightedText.substring(match.start,match.end);highlightedText=before+`<span class="${options2.highlightClass}">${matchText}</span>`+after}return highlightedText}function highlightWithQuery(text,query,options2){let highlightedText=text;let hasMatches=false;const searchTerms=query.trim().split(/\s+/).filter((term=>term.length>0));for(const term of searchTerms){const regex=new RegExp(`\\b(${term.replace(/[.*+?^${}()|[\]\\]/g,"\\$&")})\\b`,"gi");if(regex.test(highlightedText)){highlightedText=highlightedText.replace(regex,`<span class="${options2.highlightClass}">$1</span>`);hasMatches=true}}if(!hasMatches){const fuzzyMatches=findFuzzyMatches(text,query);if(fuzzyMatches.length>0){fuzzyMatches.sort(((a,b)=>b.start-a.start));for(const match of fuzzyMatches){const before=highlightedText.substring(0,match.start);const after=highlightedText.substring(match.end);const matchText=highlightedText.substring(match.start,match.end);highlightedText=before+`<span class="${options2.highlightClass}">${matchText}</span>`+after}hasMatches=true}}return highlightedText}function createHighlightTemplateMiddleware(options2={}){const highlightOptions={highlightClass:"sjs-highlight",...options2};return function(prop,value,_template,query,matchInfo){if((prop==="content"||prop==="desc")&&query&&typeof value==="string"){if(matchInfo&&matchInfo.length>0){const highlighted2=highlightWithMatchInfo(value,matchInfo,highlightOptions);return highlighted2!==value?highlighted2:void 0}const highlighted=highlightWithQuery(value,query,highlightOptions);return highlighted!==value?highlighted:void 0}return void 0}}const defaultHighlightTemplateMiddleware=createHighlightTemplateMiddleware();function SimpleJekyllSearch(options2){const instance=new SimpleJekyllSearch$1;return instance.init(options2)}if(typeof window!=="undefined"){window.SimpleJekyllSearch=SimpleJekyllSearch;window.SimpleJekyllSearch.createHighlightMiddleware=createHighlightMiddleware;window.SimpleJekyllSearch.createHighlightTemplateMiddleware=createHighlightTemplateMiddleware;window.SimpleJekyllSearch.highlightText=highlightText;window.SimpleJekyllSearch.defaultHighlightMiddleware=defaultHighlightMiddleware;window.SimpleJekyllSearch.defaultHighlightTemplateMiddleware=defaultHighlightTemplateMiddleware}exports2.createHighlightMiddleware=createHighlightMiddleware;exports2.createHighlightTemplateMiddleware=createHighlightTemplateMiddleware;exports2.default=SimpleJekyllSearch;exports2.defaultHighlightMiddleware=defaultHighlightMiddleware;exports2.defaultHighlightTemplateMiddleware=defaultHighlightTemplateMiddleware;exports2.highlightText=highlightText;Object.defineProperties(exports2,{__esModule:{value:true},[Symbol.toStringTag]:{value:"Module"}})}));
\ No newline at end of file
diff --git a/docs/assets/js/simple-jekyll-search.min.js b/docs/assets/js/simple-jekyll-search.min.js
index 8056511..7b0ff2d 100644
--- a/docs/assets/js/simple-jekyll-search.min.js
+++ b/docs/assets/js/simple-jekyll-search.min.js
@@ -4,4 +4,4 @@
   * Copyright 2025-2025, Sylhare
   * Licensed under the MIT License.
   */
-(function(global,factory){typeof exports==="object"&&typeof module!=="undefined"?factory(exports):typeof define==="function"&&define.amd?define(["exports"],factory):(global=typeof globalThis!=="undefined"?globalThis:global||self,factory(global.SimpleJekyllSearch={}))})(this,(function(exports2){"use strict";function load(location,callback){const xhr=getXHR();xhr.open("GET",location,true);xhr.onreadystatechange=createStateChangeListener(xhr,callback);xhr.send()}function createStateChangeListener(xhr,callback){return function(){if(xhr.readyState===4&&xhr.status===200){try{callback(null,JSON.parse(xhr.responseText))}catch(err){callback(err instanceof Error?err:new Error(String(err)),null)}}}}function getXHR(){return window.XMLHttpRequest?new window.XMLHttpRequest:new window.ActiveXObject("Microsoft.XMLHTTP")}class OptionsValidator{constructor(params){if(!this.validateParams(params)){throw new Error("-- OptionsValidator: required options missing")}this.requiredOptions=params.required}getRequiredOptions(){return this.requiredOptions}validate(parameters){const errors=[];this.requiredOptions.forEach((requiredOptionName=>{if(typeof parameters[requiredOptionName]==="undefined"){errors.push(requiredOptionName)}}));return errors}validateParams(params){if(!params){return false}return typeof params.required!=="undefined"&&Array.isArray(params.required)}}function fuzzySearch(text,pattern){pattern=pattern.trimEnd();if(pattern.length===0)return true;pattern=pattern.toLowerCase();text=text.toLowerCase();let remainingText=text,currentIndex=-1;for(const char of pattern){const nextIndex=remainingText.indexOf(char);if(nextIndex===-1||currentIndex!==-1&&remainingText.slice(0,nextIndex).split(" ").length-1>2){return false}currentIndex=nextIndex;remainingText=remainingText.slice(nextIndex+1)}return true}function findFuzzyMatches$1(text,pattern){if(!text||!pattern)return[];const lowerText=text.toLowerCase();const lowerPattern=pattern.toLowerCase().trim();if(lowerPattern.length===0)return[];const patternWords=lowerPattern.split(/\s+/);const matches=[];for(const word of patternWords){if(word.length===0)continue;const wordMatches=findFuzzyWordMatches$1(lowerText,word);matches.push(...wordMatches)}return mergeAndSortMatches$1(matches)}function findFuzzyWordMatches$1(text,word){const matches=[];const exactRegex=new RegExp(`\\b${word.replace(/[.*+?^${}()|[\]\\]/g,"\\$&")}\\b`,"gi");let match;while((match=exactRegex.exec(text))!==null){matches.push({start:match.index,end:match.index+match[0].length,text:match[0],type:"exact"})}if(matches.length===0){for(let i=0;i<text.length;i++){const fuzzyMatch=findFuzzySequenceMatch$1(text,word,i);if(fuzzyMatch){matches.push({...fuzzyMatch,type:"fuzzy"});i=fuzzyMatch.end-1}}}return matches}function findFuzzySequenceMatch$1(text,pattern,startPos){let textIndex=startPos;let patternIndex=0;let matchStart=-1;let maxGap=3;const matchedPositions=[];while(textIndex<text.length&&patternIndex<pattern.length){if(text[textIndex]===pattern[patternIndex]){if(matchStart===-1){matchStart=textIndex}matchedPositions.push(textIndex);patternIndex++}else if(matchStart!==-1){if(textIndex-matchStart>maxGap*pattern.length){return null}}textIndex++}if(patternIndex===pattern.length&&matchStart!==-1&&matchedPositions.length>0){const actualStart=matchedPositions[0];const actualEnd=matchedPositions[matchedPositions.length-1]+1;return{start:actualStart,end:actualEnd,text:text.substring(actualStart,actualEnd)}}return null}function mergeAndSortMatches$1(matches){if(matches.length===0)return[];const sortedMatches=matches.sort(((a,b)=>a.start-b.start));const merged=[];for(const match of sortedMatches){const lastMerged=merged[merged.length-1];if(lastMerged&&match.start<=lastMerged.end){lastMerged.end=Math.max(lastMerged.end,match.end);lastMerged.text=lastMerged.text+match.text.slice(lastMerged.end-match.start)}else{merged.push({...match})}}return merged}function literalSearch(text,criteria){text=text.trim().toLowerCase();const pattern=criteria.endsWith(" ")?[criteria.toLowerCase()]:criteria.trim().toLowerCase().split(" ");return pattern.filter((word=>text.indexOf(word)>=0)).length===pattern.length}function findLiteralMatches(text,criteria){if(!text||!criteria)return[];const lowerText=text.toLowerCase();const words=criteria.trim().toLowerCase().split(/\s+/);const matches=[];let textIndex=0;for(const word of words){if(word.length===0)continue;const wordIndex=lowerText.indexOf(word,textIndex);if(wordIndex!==-1){matches.push({start:wordIndex,end:wordIndex+word.length,text:text.substring(wordIndex,wordIndex+word.length),type:"exact"});textIndex=wordIndex+word.length}}return matches}function levenshtein(a,b){const lenA=a.length;const lenB=b.length;const distanceMatrix=Array.from({length:lenA+1},(()=>Array(lenB+1).fill(0)));for(let i=0;i<=lenA;i++)distanceMatrix[i][0]=i;for(let j=0;j<=lenB;j++)distanceMatrix[0][j]=j;for(let i=1;i<=lenA;i++){for(let j=1;j<=lenB;j++){const cost=a[i-1]===b[j-1]?0:1;distanceMatrix[i][j]=Math.min(distanceMatrix[i-1][j]+1,distanceMatrix[i][j-1]+1,distanceMatrix[i-1][j-1]+cost)}}return distanceMatrix[lenA][lenB]}function levenshteinSearch(text,pattern){const distance=levenshtein(pattern,text);const similarity=1-distance/Math.max(pattern.length,text.length);return similarity>=.3}function findLevenshteinMatches(text,pattern){if(!text||!pattern)return[];const matches=[];const words=text.split(/\s+/);for(let i=0;i<words.length;i++){const word=words[i];if(levenshteinSearch(word,pattern)){const start=text.indexOf(word);matches.push({start:start,end:start+word.length,text:word,type:"wildcard"})}}return matches}function wildcardSearch(text,pattern){const regexPattern=pattern.replace(/\*/g,".*");const regex=new RegExp(`^${regexPattern}$`,"i");if(regex.test(text))return true;return levenshteinSearch(text,pattern)}function findWildcardMatches(text,pattern){if(!text||!pattern)return[];const wildcardMatches=findWildcardPatternMatches(text,pattern);if(wildcardMatches.length>0){return mergeAndSortMatches(wildcardMatches)}const levenshteinMatches=findLevenshteinMatches(text,pattern);return mergeAndSortMatches(levenshteinMatches)}function findWildcardPatternMatches(text,pattern){const matches=[];const regexPattern=pattern.replace(/\*/g,".*");const regex=new RegExp(regexPattern,"gi");let match;while((match=regex.exec(text))!==null){matches.push({start:match.index,end:match.index+match[0].length,text:match[0],type:"wildcard"})}return matches}function mergeAndSortMatches(matches){if(matches.length===0)return[];const sortedMatches=matches.sort(((a,b)=>a.start-b.start));const merged=[];for(const match of sortedMatches){const lastMerged=merged[merged.length-1];if(lastMerged&&match.start<=lastMerged.end){lastMerged.end=Math.max(lastMerged.end,match.end);lastMerged.text=lastMerged.text+match.text.slice(lastMerged.end-match.start)}else{merged.push({...match})}}return merged}class SearchStrategy{constructor(matchFunction,findMatchesFunction){this.matchFunction=matchFunction;this.findMatchesFunction=findMatchesFunction}matches(text,criteria){if(text===null||text.trim()===""||!criteria){return false}return this.matchFunction(text,criteria)}findMatches(text,criteria){if(text===null||text.trim()===""||!criteria||!this.findMatchesFunction){return[]}return this.findMatchesFunction(text,criteria)}}const LiteralSearchStrategy=new SearchStrategy(literalSearch,findLiteralMatches);const FuzzySearchStrategy=new SearchStrategy(((text,criteria)=>fuzzySearch(text,criteria)||literalSearch(text,criteria)),((text,criteria)=>{const fuzzyMatches=findFuzzyMatches$1(text,criteria);if(fuzzyMatches.length>0){return fuzzyMatches}return findLiteralMatches(text,criteria)}));const WildcardSearchStrategy=new SearchStrategy(((text,criteria)=>wildcardSearch(text,criteria)||literalSearch(text,criteria)),((text,criteria)=>{const wildcardMatches=findWildcardMatches(text,criteria);if(wildcardMatches.length>0){return wildcardMatches}return findLiteralMatches(text,criteria)}));function merge(target,source){return{...target,...source}}function isJSON(json){try{return!!(json instanceof Object&&JSON.parse(JSON.stringify(json)))}catch(_err){return false}}function NoSort(){return 0}function isObject(obj){return Boolean(obj)&&Object.prototype.toString.call(obj)==="[object Object]"}function clone(input){if(input===null||typeof input!=="object"){return input}if(Array.isArray(input)){return input.map((item=>clone(item)))}const output={};for(const key in input){if(Object.prototype.hasOwnProperty.call(input,key)){output[key]=clone(input[key])}}return output}const DEFAULT_OPTIONS={searchInput:null,resultsContainer:null,json:[],success:function(){},searchResultTemplate:'<li><a href="{url}" title="{desc}">{title}</a></li>',templateMiddleware:(_prop,_value,_template,_query)=>void 0,sortMiddleware:NoSort,noResultsText:"No results found",limit:10,fuzzy:false,strategy:"literal",debounceTime:null,exclude:[],onSearch:()=>{}};const REQUIRED_OPTIONS=["searchInput","resultsContainer","json"];const WHITELISTED_KEYS=new Set(["Enter","Shift","CapsLock","ArrowLeft","ArrowUp","ArrowRight","ArrowDown","Meta"]);class Repository{constructor(initialOptions={}){this.data=[];this.setOptions(initialOptions)}put(input){if(isObject(input)){return this.addObject(input)}if(Array.isArray(input)){return this.addArray(input)}return void 0}clear(){this.data.length=0;return this.data}search(criteria){if(!criteria){return[]}return clone(this.findMatches(this.data,criteria).sort(this.options.sortMiddleware))}setOptions(newOptions){this.options={fuzzy:(newOptions==null?void 0:newOptions.fuzzy)||DEFAULT_OPTIONS.fuzzy,limit:(newOptions==null?void 0:newOptions.limit)||DEFAULT_OPTIONS.limit,searchStrategy:this.searchStrategy((newOptions==null?void 0:newOptions.strategy)||newOptions.fuzzy&&"fuzzy"||DEFAULT_OPTIONS.strategy),sortMiddleware:(newOptions==null?void 0:newOptions.sortMiddleware)||DEFAULT_OPTIONS.sortMiddleware,exclude:(newOptions==null?void 0:newOptions.exclude)||DEFAULT_OPTIONS.exclude,strategy:(newOptions==null?void 0:newOptions.strategy)||DEFAULT_OPTIONS.strategy}}addObject(obj){this.data.push(obj);return this.data}addArray(arr){const added=[];this.clear();for(const item of arr){if(isObject(item)){added.push(this.addObject(item)[0])}}return added}findMatches(data,criteria){const matches=[];for(let i=0;i<data.length&&matches.length<this.options.limit;i++){const match=this.findMatchesInObject(data[i],criteria);if(match){matches.push(match)}}return matches}findMatchesInObject(obj,criteria){var _a,_b;for(const key in obj){if(!this.isExcluded(obj[key])&&this.options.searchStrategy.matches(obj[key],criteria)){const matchInfo=(_b=(_a=this.options.searchStrategy).findMatches)==null?void 0:_b.call(_a,obj[key],criteria);const result={...obj};if(matchInfo&&matchInfo.length>0){result._matchInfo={[key]:matchInfo}}return result}}return void 0}isExcluded(term){for(const excludedTerm of this.options.exclude){if(new RegExp(excludedTerm).test(String(term))){return true}}return false}searchStrategy(strategy){switch(strategy){case"fuzzy":return FuzzySearchStrategy;case"wildcard":return WildcardSearchStrategy;default:return LiteralSearchStrategy}}}const options={pattern:/\{(.*?)\}/g,template:"",middleware:function(){return void 0}};function setOptions(_options){if(_options.pattern){options.pattern=_options.pattern}if(_options.template){options.template=_options.template}if(typeof _options.middleware==="function"){options.middleware=_options.middleware}}function compile(data,query){return options.template.replace(options.pattern,(function(match,prop){if(options.middleware.length>=5&&data._matchInfo&&data._matchInfo[prop]){const value2=options.middleware(prop,data[prop],options.template,query,data._matchInfo[prop]);if(typeof value2!=="undefined"){return value2}}const value=options.middleware(prop,data[prop],options.template,query);if(typeof value!=="undefined"){return value}return data[prop]||match}))}let SimpleJekyllSearch$1=class SimpleJekyllSearch{constructor(){this.debounceTimerHandle=null;this.options={...DEFAULT_OPTIONS};this.repository=new Repository;this.optionsValidator=new OptionsValidator({required:REQUIRED_OPTIONS})}debounce(func,delayMillis){if(delayMillis){if(this.debounceTimerHandle){clearTimeout(this.debounceTimerHandle)}this.debounceTimerHandle=setTimeout(func,delayMillis)}else{func()}}throwError(message){throw new Error(`SimpleJekyllSearch --- ${message}`)}emptyResultsContainer(){this.options.resultsContainer.innerHTML=""}initWithJSON(json){this.repository.put(json);this.registerInput()}initWithURL(url){load(url,((err,json)=>{if(err){this.throwError(`Failed to load JSON from ${url}: ${err.message}`)}this.initWithJSON(json)}))}registerInput(){this.options.searchInput.addEventListener("input",(e=>{const inputEvent=e;if(!WHITELISTED_KEYS.has(inputEvent.key)){this.emptyResultsContainer();this.debounce((()=>{this.search(e.target.value)}),this.options.debounceTime??null)}}))}search(query){var _a,_b;if((query==null?void 0:query.trim().length)>0){this.emptyResultsContainer();const results=this.repository.search(query);this.render(results,query);(_b=(_a=this.options).onSearch)==null?void 0:_b.call(_a)}}render(results,query){if(results.length===0){this.options.resultsContainer.insertAdjacentHTML("beforeend",this.options.noResultsText);return}const fragment=document.createDocumentFragment();results.forEach((result=>{result.query=query;const div=document.createElement("div");div.innerHTML=compile(result,query);fragment.appendChild(div)}));this.options.resultsContainer.appendChild(fragment)}init(_options){var _a;const errors=this.optionsValidator.validate(_options);if(errors.length>0){this.throwError(`Missing required options: ${REQUIRED_OPTIONS.join(", ")}`)}this.options=merge(this.options,_options);setOptions({template:this.options.searchResultTemplate,middleware:this.options.templateMiddleware});this.repository.setOptions({fuzzy:this.options.fuzzy,limit:this.options.limit,sortMiddleware:this.options.sortMiddleware,strategy:this.options.strategy,exclude:this.options.exclude});if(isJSON(this.options.json)){this.initWithJSON(this.options.json)}else{this.initWithURL(this.options.json)}const rv={search:this.search.bind(this)};(_a=this.options.success)==null?void 0:_a.call(rv);return rv}};function createHighlightMiddleware(options2={}){const{highlightClass:highlightClass="sjs-highlight",contextBefore:contextBefore=50,contextAfter:contextAfter=50,maxLength:maxLength=250,ellipsis:ellipsis="..."}=options2;return function(result,query){if(!query||!result){return result}const highlightedResult={...result};const textFields=["title","desc","content","excerpt"];for(const field of textFields){if(highlightedResult[field]&&typeof highlightedResult[field]==="string"){const highlighted=highlightText(highlightedResult[field],query,{highlightClass:highlightClass,contextBefore:contextBefore,contextAfter:contextAfter,maxLength:maxLength,ellipsis:ellipsis});if(highlighted.highlightedText!==highlightedResult[field]){highlightedResult[field]=highlighted.highlightedText}}}return highlightedResult}}function highlightText(text,query,options2={}){const{highlightClass:highlightClass="sjs-highlight",contextBefore:contextBefore=50,contextAfter:contextAfter=50,maxLength:maxLength=250,ellipsis:ellipsis="..."}=options2;if(!text||!query){return{highlightedText:text,matchCount:0}}const originalText=text;const searchTerms=query.trim().toLowerCase().split(/\s+/).filter((term=>term.length>0));if(searchTerms.length===0){return{highlightedText:text,matchCount:0}}const matches=[];for(const term of searchTerms){let index=0;while(index<text.length){const found=text.toLowerCase().indexOf(term,index);if(found===-1)break;matches.push({start:found,end:found+term.length,term:text.substring(found,found+term.length)});index=found+1}}if(matches.length===0){return{highlightedText:text,matchCount:0}}matches.sort(((a,b)=>a.start-b.start));const mergedMatches=[];for(const match of matches){if(mergedMatches.length===0||mergedMatches[mergedMatches.length-1].end<match.start){mergedMatches.push(match)}else{const lastMatch=mergedMatches[mergedMatches.length-1];lastMatch.end=Math.max(lastMatch.end,match.end);lastMatch.term=text.substring(lastMatch.start,lastMatch.end)}}if(text.length<=maxLength){let highlightedText2=text;for(let i=mergedMatches.length-1;i>=0;i--){const match=mergedMatches[i];const before=highlightedText2.substring(0,match.start);const after=highlightedText2.substring(match.end);const matchText=highlightedText2.substring(match.start,match.end);highlightedText2=before+`<span class="${highlightClass}">${matchText}</span>`+after}return{highlightedText:highlightedText2,matchCount:mergedMatches.length}}let highlightedText="";let totalLength=0;let lastEnd=0;for(let i=0;i<mergedMatches.length;i++){const match=mergedMatches[i];const contextStart=Math.max(lastEnd,match.start-contextBefore);const contextEnd=Math.min(text.length,match.end+contextAfter);if(contextStart>lastEnd&&lastEnd>0){highlightedText+=ellipsis;totalLength+=ellipsis.length}if(contextStart<match.start){const beforeText=text.substring(contextStart,match.start);highlightedText+=beforeText;totalLength+=beforeText.length}const matchText=text.substring(match.start,match.end);highlightedText+=`<span class="${highlightClass}">${matchText}</span>`;totalLength+=matchText.length;if(match.end<contextEnd){const afterText=text.substring(match.end,contextEnd);highlightedText+=afterText;totalLength+=afterText.length}lastEnd=contextEnd;if(totalLength>=maxLength){if(contextEnd<text.length){highlightedText+=ellipsis}break}}return{highlightedText:highlightedText||originalText,matchCount:mergedMatches.length}}const defaultHighlightMiddleware=createHighlightMiddleware();function findFuzzyMatches(text,pattern){const matches=[];const lowerText=text.toLowerCase();const lowerPattern=pattern.toLowerCase().trim();if(lowerPattern.length===0)return matches;const patternWords=lowerPattern.split(/\s+/);for(const word of patternWords){if(word.length===0)continue;const wordMatches=findFuzzyWordMatches(lowerText,word);matches.push(...wordMatches)}return matches}function findFuzzyWordMatches(text,word){const matches=[];const exactRegex=new RegExp(`\\b${word.replace(/[.*+?^${}()|[\]\\]/g,"\\$&")}\\b`,"gi");let match;while((match=exactRegex.exec(text))!==null){matches.push({start:match.index,end:match.index+match[0].length,text:match[0]})}if(matches.length===0){for(let i=0;i<text.length;i++){const fuzzyMatch=findFuzzySequenceMatch(text,word,i);if(fuzzyMatch){matches.push(fuzzyMatch);i=fuzzyMatch.end-1}}}return matches}function findFuzzySequenceMatch(text,pattern,startPos){let textIndex=startPos;let patternIndex=0;let matchStart=-1;let maxGap=3;const matchedPositions=[];while(textIndex<text.length&&patternIndex<pattern.length){if(text[textIndex]===pattern[patternIndex]){if(matchStart===-1){matchStart=textIndex}matchedPositions.push(textIndex);patternIndex++}else if(matchStart!==-1){if(textIndex-matchStart>maxGap*pattern.length){return null}}textIndex++}if(patternIndex===pattern.length&&matchStart!==-1&&matchedPositions.length>0){const actualStart=matchedPositions[0];const actualEnd=matchedPositions[matchedPositions.length-1]+1;return{start:actualStart,end:actualEnd,text:text.substring(actualStart,actualEnd)}}return null}function highlightWithMatchInfo(text,matchInfo,options2){if(matchInfo.length===0)return text;const sortedMatches=[...matchInfo].sort(((a,b)=>b.start-a.start));let highlightedText=text;for(const match of sortedMatches){const before=highlightedText.substring(0,match.start);const after=highlightedText.substring(match.end);const matchText=highlightedText.substring(match.start,match.end);highlightedText=before+`<span class="${options2.highlightClass}">${matchText}</span>`+after}return highlightedText}function highlightWithQuery(text,query,options2){let highlightedText=text;let hasMatches=false;const searchTerms=query.trim().split(/\s+/).filter((term=>term.length>0));for(const term of searchTerms){const regex=new RegExp(`\\b(${term.replace(/[.*+?^${}()|[\]\\]/g,"\\$&")})\\b`,"gi");if(regex.test(highlightedText)){highlightedText=highlightedText.replace(regex,`<span class="${options2.highlightClass}">$1</span>`);hasMatches=true}}if(!hasMatches){const fuzzyMatches=findFuzzyMatches(text,query);if(fuzzyMatches.length>0){fuzzyMatches.sort(((a,b)=>b.start-a.start));for(const match of fuzzyMatches){const before=highlightedText.substring(0,match.start);const after=highlightedText.substring(match.end);const matchText=highlightedText.substring(match.start,match.end);highlightedText=before+`<span class="${options2.highlightClass}">${matchText}</span>`+after}hasMatches=true}}return highlightedText}function createHighlightTemplateMiddleware(options2={}){const highlightOptions={highlightClass:"sjs-highlight",...options2};return function(prop,value,_template,query,matchInfo){if((prop==="content"||prop==="desc")&&query&&typeof value==="string"){if(matchInfo&&matchInfo.length>0){const highlighted2=highlightWithMatchInfo(value,matchInfo,highlightOptions);return highlighted2!==value?highlighted2:void 0}const highlighted=highlightWithQuery(value,query,highlightOptions);return highlighted!==value?highlighted:void 0}return void 0}}const defaultHighlightTemplateMiddleware=createHighlightTemplateMiddleware();function SimpleJekyllSearch(options2){const instance=new SimpleJekyllSearch$1;return instance.init(options2)}if(typeof window!=="undefined"){window.SimpleJekyllSearch=SimpleJekyllSearch;window.SimpleJekyllSearch.createHighlightMiddleware=createHighlightMiddleware;window.SimpleJekyllSearch.createHighlightTemplateMiddleware=createHighlightTemplateMiddleware;window.SimpleJekyllSearch.highlightText=highlightText;window.SimpleJekyllSearch.defaultHighlightMiddleware=defaultHighlightMiddleware;window.SimpleJekyllSearch.defaultHighlightTemplateMiddleware=defaultHighlightTemplateMiddleware}exports2.createHighlightMiddleware=createHighlightMiddleware;exports2.createHighlightTemplateMiddleware=createHighlightTemplateMiddleware;exports2.default=SimpleJekyllSearch;exports2.defaultHighlightMiddleware=defaultHighlightMiddleware;exports2.defaultHighlightTemplateMiddleware=defaultHighlightTemplateMiddleware;exports2.highlightText=highlightText;Object.defineProperties(exports2,{__esModule:{value:true},[Symbol.toStringTag]:{value:"Module"}})}));
\ No newline at end of file
+(function(global,factory){typeof exports==="object"&&typeof module!=="undefined"?factory(exports):typeof define==="function"&&define.amd?define(["exports"],factory):(global=typeof globalThis!=="undefined"?globalThis:global||self,factory(global.SimpleJekyllSearch={}))})(this,(function(exports2){"use strict";function load(location,callback){const xhr=getXHR();xhr.open("GET",location,true);xhr.onreadystatechange=createStateChangeListener(xhr,callback);xhr.send()}function createStateChangeListener(xhr,callback){return function(){if(xhr.readyState===4&&xhr.status===200){try{callback(null,JSON.parse(xhr.responseText))}catch(err){callback(err instanceof Error?err:new Error(String(err)),null)}}}}function getXHR(){return window.XMLHttpRequest?new window.XMLHttpRequest:new window.ActiveXObject("Microsoft.XMLHTTP")}class OptionsValidator{constructor(params){if(!this.validateParams(params)){throw new Error("-- OptionsValidator: required options missing")}this.requiredOptions=params.required}getRequiredOptions(){return this.requiredOptions}validate(parameters){const errors=[];this.requiredOptions.forEach((requiredOptionName=>{if(typeof parameters[requiredOptionName]==="undefined"){errors.push(requiredOptionName)}}));return errors}validateParams(params){if(!params){return false}return typeof params.required!=="undefined"&&Array.isArray(params.required)}}function fuzzySearch(text,pattern){pattern=pattern.trimEnd();if(pattern.length===0)return true;pattern=pattern.toLowerCase();text=text.toLowerCase();let remainingText=text,currentIndex=-1;for(const char of pattern){const nextIndex=remainingText.indexOf(char);if(nextIndex===-1||currentIndex!==-1&&remainingText.slice(0,nextIndex).split(" ").length-1>2){return false}currentIndex=nextIndex;remainingText=remainingText.slice(nextIndex+1)}return true}function findFuzzyMatches$1(text,pattern){if(!text||!pattern)return[];const lowerText=text.toLowerCase();const lowerPattern=pattern.toLowerCase().trim();if(lowerPattern.length===0)return[];const patternWords=lowerPattern.split(/\s+/);const matches=[];for(const word of patternWords){if(word.length===0)continue;const wordMatches=findFuzzyWordMatches$1(lowerText,word);matches.push(...wordMatches)}return mergeAndSortMatches$1(matches)}function findFuzzyWordMatches$1(text,word){const matches=[];const exactRegex=new RegExp(`\\b${word.replace(/[.*+?^${}()|[\]\\]/g,"\\$&")}\\b`,"gi");let match;while((match=exactRegex.exec(text))!==null){matches.push({start:match.index,end:match.index+match[0].length,text:match[0],type:"exact"})}if(matches.length===0){for(let i=0;i<text.length;i++){const fuzzyMatch=findFuzzySequenceMatch$1(text,word,i);if(fuzzyMatch){matches.push({...fuzzyMatch,type:"fuzzy"});i=fuzzyMatch.end-1}}}return matches}function findFuzzySequenceMatch$1(text,pattern,startPos){let textIndex=startPos;let patternIndex=0;let matchStart=-1;let maxGap=3;const matchedPositions=[];while(textIndex<text.length&&patternIndex<pattern.length){if(text[textIndex]===pattern[patternIndex]){if(matchStart===-1){matchStart=textIndex}matchedPositions.push(textIndex);patternIndex++}else if(matchStart!==-1){if(textIndex-matchStart>maxGap*pattern.length){return null}}textIndex++}if(patternIndex===pattern.length&&matchStart!==-1&&matchedPositions.length>0){const actualStart=matchedPositions[0];const actualEnd=matchedPositions[matchedPositions.length-1]+1;return{start:actualStart,end:actualEnd,text:text.substring(actualStart,actualEnd)}}return null}function mergeAndSortMatches$1(matches){if(matches.length===0)return[];const sortedMatches=matches.sort(((a,b)=>a.start-b.start));const merged=[];for(const match of sortedMatches){const lastMerged=merged[merged.length-1];if(lastMerged&&match.start<=lastMerged.end){lastMerged.end=Math.max(lastMerged.end,match.end);lastMerged.text=lastMerged.text+match.text.slice(lastMerged.end-match.start)}else{merged.push({...match})}}return merged}function literalSearch(text,criteria){text=text.trim().toLowerCase();const pattern=criteria.endsWith(" ")?[criteria.toLowerCase()]:criteria.trim().toLowerCase().split(" ");return pattern.filter((word=>text.indexOf(word)>=0)).length===pattern.length}function findLiteralMatches(text,criteria){if(!text||!criteria)return[];const lowerText=text.toLowerCase();const words=criteria.trim().toLowerCase().split(/\s+/);const matches=[];let textIndex=0;for(const word of words){if(word.length===0)continue;const wordIndex=lowerText.indexOf(word,textIndex);if(wordIndex!==-1){matches.push({start:wordIndex,end:wordIndex+word.length,text:text.substring(wordIndex,wordIndex+word.length),type:"exact"});textIndex=wordIndex+word.length}}return matches}function levenshtein(a,b){const lenA=a.length;const lenB=b.length;const distanceMatrix=Array.from({length:lenA+1},(()=>Array(lenB+1).fill(0)));for(let i=0;i<=lenA;i++)distanceMatrix[i][0]=i;for(let j=0;j<=lenB;j++)distanceMatrix[0][j]=j;for(let i=1;i<=lenA;i++){for(let j=1;j<=lenB;j++){const cost=a[i-1]===b[j-1]?0:1;distanceMatrix[i][j]=Math.min(distanceMatrix[i-1][j]+1,distanceMatrix[i][j-1]+1,distanceMatrix[i-1][j-1]+cost)}}return distanceMatrix[lenA][lenB]}function levenshteinSearch(text,pattern){const distance=levenshtein(pattern,text);const similarity=1-distance/Math.max(pattern.length,text.length);return similarity>=.3}function findLevenshteinMatches(text,pattern){if(!text||!pattern)return[];const matches=[];const words=text.split(/\s+/);for(let i=0;i<words.length;i++){const word=words[i];if(levenshteinSearch(word,pattern)){const start=text.indexOf(word);matches.push({start:start,end:start+word.length,text:word,type:"wildcard"})}}return matches}function wildcardSearch(text,pattern){const regexPattern=pattern.replace(/\*/g,".*");const regex=new RegExp(`^${regexPattern}$`,"i");if(regex.test(text))return true;return levenshteinSearch(text,pattern)}function findWildcardMatches(text,pattern){if(!text||!pattern)return[];const wildcardMatches=findWildcardPatternMatches(text,pattern);if(wildcardMatches.length>0){return mergeAndSortMatches(wildcardMatches)}const levenshteinMatches=findLevenshteinMatches(text,pattern);return mergeAndSortMatches(levenshteinMatches)}function findWildcardPatternMatches(text,pattern){const matches=[];const regexPattern=pattern.replace(/\*/g,".*");const regex=new RegExp(regexPattern,"gi");let match;while((match=regex.exec(text))!==null){matches.push({start:match.index,end:match.index+match[0].length,text:match[0],type:"wildcard"})}return matches}function mergeAndSortMatches(matches){if(matches.length===0)return[];const sortedMatches=matches.sort(((a,b)=>a.start-b.start));const merged=[];for(const match of sortedMatches){const lastMerged=merged[merged.length-1];if(lastMerged&&match.start<=lastMerged.end){lastMerged.end=Math.max(lastMerged.end,match.end);lastMerged.text=lastMerged.text+match.text.slice(lastMerged.end-match.start)}else{merged.push({...match})}}return merged}class SearchStrategy{constructor(matchFunction,findMatchesFunction){this.matchFunction=matchFunction;this.findMatchesFunction=findMatchesFunction}matches(text,criteria){if(text===null||text.trim()===""||!criteria){return false}return this.matchFunction(text,criteria)}findMatches(text,criteria){if(text===null||text.trim()===""||!criteria||!this.findMatchesFunction){return[]}return this.findMatchesFunction(text,criteria)}}const LiteralSearchStrategy=new SearchStrategy(literalSearch,findLiteralMatches);const FuzzySearchStrategy=new SearchStrategy(((text,criteria)=>fuzzySearch(text,criteria)||literalSearch(text,criteria)),((text,criteria)=>{const fuzzyMatches=findFuzzyMatches$1(text,criteria);if(fuzzyMatches.length>0){return fuzzyMatches}return findLiteralMatches(text,criteria)}));const WildcardSearchStrategy=new SearchStrategy(((text,criteria)=>wildcardSearch(text,criteria)||literalSearch(text,criteria)),((text,criteria)=>{const wildcardMatches=findWildcardMatches(text,criteria);if(wildcardMatches.length>0){return wildcardMatches}return findLiteralMatches(text,criteria)}));function merge(target,source){return{...target,...source}}function isJSON(json){try{return!!(json instanceof Object&&JSON.parse(JSON.stringify(json)))}catch(_err){return false}}function NoSort(){return 0}function isObject(obj){return Boolean(obj)&&Object.prototype.toString.call(obj)==="[object Object]"}function clone(input){if(input===null||typeof input!=="object"){return input}if(Array.isArray(input)){return input.map((item=>clone(item)))}const output={};for(const key in input){if(Object.prototype.hasOwnProperty.call(input,key)){output[key]=clone(input[key])}}return output}const DEFAULT_OPTIONS={searchInput:null,resultsContainer:null,json:[],success:function(){},searchResultTemplate:'<li><a href="{url}" title="{desc}">{title}</a></li>',templateMiddleware:(_prop,_value,_template,_query)=>void 0,sortMiddleware:NoSort,noResultsText:"No results found",limit:10,fuzzy:false,strategy:"literal",debounceTime:null,exclude:[],onSearch:()=>{}};const REQUIRED_OPTIONS=["searchInput","resultsContainer","json"];const WHITELISTED_KEYS=new Set(["Enter","Shift","CapsLock","ArrowLeft","ArrowUp","ArrowRight","ArrowDown","Meta"]);class Repository{constructor(initialOptions={}){this.data=[];this.setOptions(initialOptions)}put(input){if(isObject(input)){return this.addObject(input)}if(Array.isArray(input)){return this.addArray(input)}return void 0}clear(){this.data.length=0;return this.data}search(criteria){if(!criteria){return[]}return clone(this.findMatches(this.data,criteria).sort(this.options.sortMiddleware))}setOptions(newOptions){this.options={fuzzy:(newOptions==null?void 0:newOptions.fuzzy)||DEFAULT_OPTIONS.fuzzy,limit:(newOptions==null?void 0:newOptions.limit)||DEFAULT_OPTIONS.limit,searchStrategy:this.searchStrategy((newOptions==null?void 0:newOptions.strategy)||newOptions.fuzzy&&"fuzzy"||DEFAULT_OPTIONS.strategy),sortMiddleware:(newOptions==null?void 0:newOptions.sortMiddleware)||DEFAULT_OPTIONS.sortMiddleware,exclude:(newOptions==null?void 0:newOptions.exclude)||DEFAULT_OPTIONS.exclude,strategy:(newOptions==null?void 0:newOptions.strategy)||DEFAULT_OPTIONS.strategy}}addObject(obj){this.data.push(obj);return this.data}addArray(arr){const added=[];this.clear();for(const item of arr){if(isObject(item)){added.push(this.addObject(item)[0])}}return added}findMatches(data,criteria){const matches=[];for(let i=0;i<data.length&&matches.length<this.options.limit;i++){const match=this.findMatchesInObject(data[i],criteria);if(match){matches.push(match)}}return matches}findMatchesInObject(obj,criteria){var _a,_b;let hasMatch=false;const result={...obj};result._matchInfo={};for(const key in obj){if(!this.isExcluded(obj[key])&&this.options.searchStrategy.matches(obj[key],criteria)){hasMatch=true;const matchInfo=(_b=(_a=this.options.searchStrategy).findMatches)==null?void 0:_b.call(_a,obj[key],criteria);if(matchInfo&&matchInfo.length>0){result._matchInfo[key]=matchInfo}}}return hasMatch?result:void 0}isExcluded(term){for(const excludedTerm of this.options.exclude){if(new RegExp(excludedTerm).test(String(term))){return true}}return false}searchStrategy(strategy){switch(strategy){case"fuzzy":return FuzzySearchStrategy;case"wildcard":return WildcardSearchStrategy;default:return LiteralSearchStrategy}}}const options={pattern:/\{(.*?)\}/g,template:"",middleware:function(){return void 0}};function setOptions(_options){if(_options.pattern){options.pattern=_options.pattern}if(_options.template){options.template=_options.template}if(typeof _options.middleware==="function"){options.middleware=_options.middleware}}function compile(data,query){return options.template.replace(options.pattern,(function(match,prop){if(data._matchInfo&&data._matchInfo[prop]&&data._matchInfo[prop].length>0){try{const value2=options.middleware(prop,data[prop],options.template,query,data._matchInfo[prop]);if(typeof value2!=="undefined"){return value2}}catch(_e){}}const value=options.middleware(prop,data[prop],options.template,query);if(typeof value!=="undefined"){return value}return data[prop]||match}))}let SimpleJekyllSearch$1=class SimpleJekyllSearch{constructor(){this.debounceTimerHandle=null;this.options={...DEFAULT_OPTIONS};this.repository=new Repository;this.optionsValidator=new OptionsValidator({required:REQUIRED_OPTIONS})}debounce(func,delayMillis){if(delayMillis){if(this.debounceTimerHandle){clearTimeout(this.debounceTimerHandle)}this.debounceTimerHandle=setTimeout(func,delayMillis)}else{func()}}throwError(message){throw new Error(`SimpleJekyllSearch --- ${message}`)}emptyResultsContainer(){this.options.resultsContainer.innerHTML=""}initWithJSON(json){this.repository.put(json);this.registerInput()}initWithURL(url){load(url,((err,json)=>{if(err){this.throwError(`Failed to load JSON from ${url}: ${err.message}`)}this.initWithJSON(json)}))}registerInput(){this.options.searchInput.addEventListener("input",(e=>{const inputEvent=e;if(!WHITELISTED_KEYS.has(inputEvent.key)){this.emptyResultsContainer();this.debounce((()=>{this.search(e.target.value)}),this.options.debounceTime??null)}}))}search(query){var _a,_b;if((query==null?void 0:query.trim().length)>0){this.emptyResultsContainer();const results=this.repository.search(query);this.render(results,query);(_b=(_a=this.options).onSearch)==null?void 0:_b.call(_a)}}render(results,query){if(results.length===0){this.options.resultsContainer.insertAdjacentHTML("beforeend",this.options.noResultsText);return}const fragment=document.createDocumentFragment();results.forEach((result=>{result.query=query;const div=document.createElement("div");div.innerHTML=compile(result,query);fragment.appendChild(div)}));this.options.resultsContainer.appendChild(fragment)}init(_options){var _a;const errors=this.optionsValidator.validate(_options);if(errors.length>0){this.throwError(`Missing required options: ${REQUIRED_OPTIONS.join(", ")}`)}this.options=merge(this.options,_options);setOptions({template:this.options.searchResultTemplate,middleware:this.options.templateMiddleware});this.repository.setOptions({fuzzy:this.options.fuzzy,limit:this.options.limit,sortMiddleware:this.options.sortMiddleware,strategy:this.options.strategy,exclude:this.options.exclude});if(isJSON(this.options.json)){this.initWithJSON(this.options.json)}else{this.initWithURL(this.options.json)}const rv={search:this.search.bind(this)};(_a=this.options.success)==null?void 0:_a.call(rv);return rv}};function createHighlightMiddleware(options2={}){const{highlightClass:highlightClass="sjs-highlight",contextBefore:contextBefore=50,contextAfter:contextAfter=50,maxLength:maxLength=250,ellipsis:ellipsis="..."}=options2;return function(result,query){if(!query||!result){return result}const highlightedResult={...result};const textFields=["title","desc","content","excerpt"];for(const field of textFields){if(highlightedResult[field]&&typeof highlightedResult[field]==="string"){const highlighted=highlightText(highlightedResult[field],query,{highlightClass:highlightClass,contextBefore:contextBefore,contextAfter:contextAfter,maxLength:maxLength,ellipsis:ellipsis});if(highlighted.highlightedText!==highlightedResult[field]){highlightedResult[field]=highlighted.highlightedText}}}return highlightedResult}}function highlightText(text,query,options2={}){const{highlightClass:highlightClass="sjs-highlight",contextBefore:contextBefore=50,contextAfter:contextAfter=50,maxLength:maxLength=250,ellipsis:ellipsis="..."}=options2;if(!text||!query){return{highlightedText:text,matchCount:0}}const originalText=text;const searchTerms=query.trim().toLowerCase().split(/\s+/).filter((term=>term.length>0));if(searchTerms.length===0){return{highlightedText:text,matchCount:0}}const matches=[];for(const term of searchTerms){let index=0;while(index<text.length){const found=text.toLowerCase().indexOf(term,index);if(found===-1)break;matches.push({start:found,end:found+term.length,term:text.substring(found,found+term.length)});index=found+1}}if(matches.length===0){return{highlightedText:text,matchCount:0}}matches.sort(((a,b)=>a.start-b.start));const mergedMatches=[];for(const match of matches){if(mergedMatches.length===0||mergedMatches[mergedMatches.length-1].end<match.start){mergedMatches.push(match)}else{const lastMatch=mergedMatches[mergedMatches.length-1];lastMatch.end=Math.max(lastMatch.end,match.end);lastMatch.term=text.substring(lastMatch.start,lastMatch.end)}}if(text.length<=maxLength){let highlightedText2=text;for(let i=mergedMatches.length-1;i>=0;i--){const match=mergedMatches[i];const before=highlightedText2.substring(0,match.start);const after=highlightedText2.substring(match.end);const matchText=highlightedText2.substring(match.start,match.end);highlightedText2=before+`<span class="${highlightClass}">${matchText}</span>`+after}return{highlightedText:highlightedText2,matchCount:mergedMatches.length}}let highlightedText="";let totalLength=0;let lastEnd=0;for(let i=0;i<mergedMatches.length;i++){const match=mergedMatches[i];const contextStart=Math.max(lastEnd,match.start-contextBefore);const contextEnd=Math.min(text.length,match.end+contextAfter);if(contextStart>lastEnd&&lastEnd>0){highlightedText+=ellipsis;totalLength+=ellipsis.length}if(contextStart<match.start){const beforeText=text.substring(contextStart,match.start);highlightedText+=beforeText;totalLength+=beforeText.length}const matchText=text.substring(match.start,match.end);highlightedText+=`<span class="${highlightClass}">${matchText}</span>`;totalLength+=matchText.length;if(match.end<contextEnd){const afterText=text.substring(match.end,contextEnd);highlightedText+=afterText;totalLength+=afterText.length}lastEnd=contextEnd;if(totalLength>=maxLength){if(contextEnd<text.length){highlightedText+=ellipsis}break}}return{highlightedText:highlightedText||originalText,matchCount:mergedMatches.length}}const defaultHighlightMiddleware=createHighlightMiddleware();function findFuzzyMatches(text,pattern){const matches=[];const lowerText=text.toLowerCase();const lowerPattern=pattern.toLowerCase().trim();if(lowerPattern.length===0)return matches;const patternWords=lowerPattern.split(/\s+/);for(const word of patternWords){if(word.length===0)continue;const wordMatches=findFuzzyWordMatches(lowerText,word);matches.push(...wordMatches)}return matches}function findFuzzyWordMatches(text,word){const matches=[];const exactRegex=new RegExp(`\\b${word.replace(/[.*+?^${}()|[\]\\]/g,"\\$&")}\\b`,"gi");let match;while((match=exactRegex.exec(text))!==null){matches.push({start:match.index,end:match.index+match[0].length,text:match[0]})}if(matches.length===0){for(let i=0;i<text.length;i++){const fuzzyMatch=findFuzzySequenceMatch(text,word,i);if(fuzzyMatch){matches.push(fuzzyMatch);i=fuzzyMatch.end-1}}}return matches}function findFuzzySequenceMatch(text,pattern,startPos){let textIndex=startPos;let patternIndex=0;let matchStart=-1;let maxGap=3;const matchedPositions=[];while(textIndex<text.length&&patternIndex<pattern.length){if(text[textIndex]===pattern[patternIndex]){if(matchStart===-1){matchStart=textIndex}matchedPositions.push(textIndex);patternIndex++}else if(matchStart!==-1){if(textIndex-matchStart>maxGap*pattern.length){return null}}textIndex++}if(patternIndex===pattern.length&&matchStart!==-1&&matchedPositions.length>0){const actualStart=matchedPositions[0];const actualEnd=matchedPositions[matchedPositions.length-1]+1;return{start:actualStart,end:actualEnd,text:text.substring(actualStart,actualEnd)}}return null}function highlightWithMatchInfo(text,matchInfo,options2){if(matchInfo.length===0)return text;const sortedMatches=[...matchInfo].sort(((a,b)=>b.start-a.start));let highlightedText=text;for(const match of sortedMatches){const before=highlightedText.substring(0,match.start);const after=highlightedText.substring(match.end);const matchText=highlightedText.substring(match.start,match.end);highlightedText=before+`<span class="${options2.highlightClass}">${matchText}</span>`+after}return highlightedText}function highlightWithQuery(text,query,options2){let highlightedText=text;let hasMatches=false;const searchTerms=query.trim().split(/\s+/).filter((term=>term.length>0));for(const term of searchTerms){const regex=new RegExp(`\\b(${term.replace(/[.*+?^${}()|[\]\\]/g,"\\$&")})\\b`,"gi");if(regex.test(highlightedText)){highlightedText=highlightedText.replace(regex,`<span class="${options2.highlightClass}">$1</span>`);hasMatches=true}}if(!hasMatches){const fuzzyMatches=findFuzzyMatches(text,query);if(fuzzyMatches.length>0){fuzzyMatches.sort(((a,b)=>b.start-a.start));for(const match of fuzzyMatches){const before=highlightedText.substring(0,match.start);const after=highlightedText.substring(match.end);const matchText=highlightedText.substring(match.start,match.end);highlightedText=before+`<span class="${options2.highlightClass}">${matchText}</span>`+after}hasMatches=true}}return highlightedText}function createHighlightTemplateMiddleware(options2={}){const highlightOptions={highlightClass:"sjs-highlight",...options2};return function(prop,value,_template,query,matchInfo){if((prop==="content"||prop==="desc")&&query&&typeof value==="string"){if(matchInfo&&matchInfo.length>0){const highlighted2=highlightWithMatchInfo(value,matchInfo,highlightOptions);return highlighted2!==value?highlighted2:void 0}const highlighted=highlightWithQuery(value,query,highlightOptions);return highlighted!==value?highlighted:void 0}return void 0}}const defaultHighlightTemplateMiddleware=createHighlightTemplateMiddleware();function SimpleJekyllSearch(options2){const instance=new SimpleJekyllSearch$1;return instance.init(options2)}if(typeof window!=="undefined"){window.SimpleJekyllSearch=SimpleJekyllSearch;window.SimpleJekyllSearch.createHighlightMiddleware=createHighlightMiddleware;window.SimpleJekyllSearch.createHighlightTemplateMiddleware=createHighlightTemplateMiddleware;window.SimpleJekyllSearch.highlightText=highlightText;window.SimpleJekyllSearch.defaultHighlightMiddleware=defaultHighlightMiddleware;window.SimpleJekyllSearch.defaultHighlightTemplateMiddleware=defaultHighlightTemplateMiddleware}exports2.createHighlightMiddleware=createHighlightMiddleware;exports2.createHighlightTemplateMiddleware=createHighlightTemplateMiddleware;exports2.default=SimpleJekyllSearch;exports2.defaultHighlightMiddleware=defaultHighlightMiddleware;exports2.defaultHighlightTemplateMiddleware=defaultHighlightTemplateMiddleware;exports2.highlightText=highlightText;Object.defineProperties(exports2,{__esModule:{value:true},[Symbol.toStringTag]:{value:"Module"}})}));
\ No newline at end of file
diff --git a/src/SearchStrategies/search/fuzzySearch.ts b/src/SearchStrategies/search/fuzzySearch.ts
index 145e121..b96a642 100644
--- a/src/SearchStrategies/search/fuzzySearch.ts
+++ b/src/SearchStrategies/search/fuzzySearch.ts
@@ -1,4 +1,5 @@
 import { MatchInfo } from '../types';
+import { mergeAndSortMatches } from './utils';
 
 /**
  * A simple fuzzy search implementation that checks if characters in the pattern appear
@@ -134,28 +135,3 @@ function findFuzzySequenceMatch(text: string, pattern: string, startPos: number)
   
   return null;
 }
-
-/**
- * Merges overlapping matches and sorts them by position
- */
-function mergeAndSortMatches(matches: MatchInfo[]): MatchInfo[] {
-  if (matches.length === 0) return [];
-  
-  // Sort matches by start position
-  const sortedMatches = matches.sort((a, b) => a.start - b.start);
-  const merged: MatchInfo[] = [];
-  
-  for (const match of sortedMatches) {
-    const lastMerged = merged[merged.length - 1];
-    
-    // If this match overlaps with the last merged match, extend it
-    if (lastMerged && match.start <= lastMerged.end) {
-      lastMerged.end = Math.max(lastMerged.end, match.end);
-      lastMerged.text = lastMerged.text + match.text.slice(lastMerged.end - match.start);
-    } else {
-      merged.push({ ...match });
-    }
-  }
-  
-  return merged;
-} 
\ No newline at end of file
diff --git a/src/SearchStrategies/search/utils.ts b/src/SearchStrategies/search/utils.ts
new file mode 100644
index 0000000..37d8e1f
--- /dev/null
+++ b/src/SearchStrategies/search/utils.ts
@@ -0,0 +1,26 @@
+import { MatchInfo } from '../types';
+
+/**
+ * Merges overlapping matches and sorts them by position
+ */
+export function mergeAndSortMatches(matches: MatchInfo[]): MatchInfo[] {
+  if (matches.length === 0) return [];
+  
+  // Sort matches by start position
+  const sortedMatches = matches.sort((a, b) => a.start - b.start);
+  const merged: MatchInfo[] = [];
+  
+  for (const match of sortedMatches) {
+    const lastMerged = merged[merged.length - 1];
+    
+    // If this match overlaps with the last merged match, extend it
+    if (lastMerged && match.start <= lastMerged.end) {
+      lastMerged.end = Math.max(lastMerged.end, match.end);
+      lastMerged.text = lastMerged.text + match.text.slice(lastMerged.end - match.start);
+    } else {
+      merged.push({ ...match });
+    }
+  }
+  
+  return merged;
+}
diff --git a/src/SearchStrategies/search/wildcardSearch.ts b/src/SearchStrategies/search/wildcardSearch.ts
index 24e2c20..6c70720 100644
--- a/src/SearchStrategies/search/wildcardSearch.ts
+++ b/src/SearchStrategies/search/wildcardSearch.ts
@@ -1,5 +1,6 @@
 import { levenshteinSearch, findLevenshteinMatches } from './levenshtein';
 import { MatchInfo } from '../types';
+import { mergeAndSortMatches } from './utils';
 
 /**
  * Matches a pattern with wildcards (*) against a text.
@@ -58,27 +59,3 @@ function findWildcardPatternMatches(text: string, pattern: string): MatchInfo[]
   return matches;
 }
 
-/**
- * Merges overlapping matches and sorts them by position
- */
-function mergeAndSortMatches(matches: MatchInfo[]): MatchInfo[] {
-  if (matches.length === 0) return [];
-  
-  // Sort matches by start position
-  const sortedMatches = matches.sort((a, b) => a.start - b.start);
-  const merged: MatchInfo[] = [];
-  
-  for (const match of sortedMatches) {
-    const lastMerged = merged[merged.length - 1];
-    
-    // If this match overlaps with the last merged match, extend it
-    if (lastMerged && match.start <= lastMerged.end) {
-      lastMerged.end = Math.max(lastMerged.end, match.end);
-      lastMerged.text = lastMerged.text + match.text.slice(lastMerged.end - match.start);
-    } else {
-      merged.push({ ...match });
-    }
-  }
-  
-  return merged;
-}

From 4761ff39a9894728e5054c7e37d24372eacd817a Mon Sep 17 00:00:00 2001
From: sylhare <sylhare@outlook.com>
Date: Fri, 10 Oct 2025 11:35:22 -0400
Subject: [PATCH 07/10] Update search function

---
 cypress/e2e/highlight-middleware.cy.ts        |  82 ++++++++
 src/Repository.ts                             |  14 +-
 src/SearchStrategies/SearchStrategy.ts        |  45 ++++-
 src/SearchStrategies/search/fuzzySearch.ts    | 111 +++--------
 src/SearchStrategies/search/literalSearch.ts  |  29 +--
 src/SearchStrategies/search/wildcardSearch.ts |  44 +++--
 tests/SearchStrategies/fuzzySearch.test.ts    | 105 +++++-----
 tests/SearchStrategies/levenshtein.test.ts    | 180 +++++++++++++++++-
 tests/SearchStrategies/literalSearch.test.ts  |   7 +-
 tests/SearchStrategies/wildcardSearch.test.ts |  88 ++++++---
 tests/highlightMiddleware.test.ts             |  61 ++++++
 11 files changed, 559 insertions(+), 207 deletions(-)
 create mode 100644 cypress/e2e/highlight-middleware.cy.ts

diff --git a/cypress/e2e/highlight-middleware.cy.ts b/cypress/e2e/highlight-middleware.cy.ts
new file mode 100644
index 0000000..27d146e
--- /dev/null
+++ b/cypress/e2e/highlight-middleware.cy.ts
@@ -0,0 +1,82 @@
+describe('Highlight Middleware', () => {
+  beforeEach(() => {
+    cy.visit('/');
+  });
+
+  it('should highlight search terms with default middleware', () => {
+    cy.window().should('have.property', 'SimpleJekyllSearch');
+    
+    cy.get('#search-input').type('search');
+    
+    cy.get('#results-container', { timeout: 10000 }).should('not.be.empty');
+    
+    cy.get('#results-container')
+      .find('.sjs-highlight')
+      .should('exist')
+      .and('contain', 'search');
+    
+    cy.get('#results-container')
+      .find('.sjs-highlight')
+      .should('have.length.at.least', 1);
+  });
+
+  it('should handle case insensitive search', () => {
+    cy.get('#search-input').type('SEARCH');
+    
+    cy.get('#results-container').should('not.be.empty');
+    
+    cy.get('#results-container')
+      .find('.sjs-highlight')
+      .should('exist')
+      .and('contain', 'search');
+  });
+
+  it('should highlight multiple search terms', () => {
+    cy.get('#search-input').type('search test');
+    
+    cy.get('#results-container').should('not.be.empty');
+    
+    cy.get('#results-container')
+      .find('.sjs-highlight')
+      .should('exist');
+  });
+
+  it('should show context around matches', () => {
+    cy.get('#search-input').type('test');
+    
+    cy.get('#results-container').should('not.be.empty');
+    
+    cy.get('#results-container')
+      .find('.sjs-highlight')
+      .should('exist')
+      .and('contain', 'test');
+    
+    cy.get('#results-container')
+      .find('.search-snippet')
+      .should('contain.text', 'test')
+      .and('not.have.text', 'test');
+  });
+
+  it('should clear results when search is cleared', () => {
+    cy.get('#search-input').type('test');
+    
+    cy.get('#results-container').should('not.be.empty');
+    
+    cy.get('#search-input').clear();
+    
+    cy.get('#results-container').should('be.empty');
+  });
+
+  it('should handle empty search gracefully', () => {
+    cy.get('#search-input').focus();
+    
+    cy.get('#results-container').should('be.empty');
+  });
+
+  it('should show no results for non-matching terms', () => {
+    cy.get('#search-input').type('nonexistentterm');
+    
+    cy.get('#results-container')
+      .should('contain', 'No results found');
+  });
+});
diff --git a/src/Repository.ts b/src/Repository.ts
index 32afea3..9b9d87c 100644
--- a/src/Repository.ts
+++ b/src/Repository.ts
@@ -73,18 +73,22 @@ export class Repository {
   }
 
   private findMatchesInObject(obj: RepositoryData, criteria: string): RepositoryData | undefined {
+    let hasMatch = false;
+    const result = { ...obj };
+    result._matchInfo = {};
+    
     for (const key in obj) {
       if (!this.isExcluded(obj[key]) && this.options.searchStrategy.matches(obj[key], criteria)) {
-        // Get match information if available
+        hasMatch = true;
+        // Get match information for all matching fields
         const matchInfo = this.options.searchStrategy.findMatches?.(obj[key], criteria);
-        const result = { ...obj };
         if (matchInfo && matchInfo.length > 0) {
-          result._matchInfo = { [key]: matchInfo };
+          result._matchInfo[key] = matchInfo;
         }
-        return result;
       }
     }
-    return undefined;
+    
+    return hasMatch ? result : undefined;
   }
 
   private isExcluded(term: any): boolean {
diff --git a/src/SearchStrategies/SearchStrategy.ts b/src/SearchStrategies/SearchStrategy.ts
index e68e70e..1d129fc 100644
--- a/src/SearchStrategies/SearchStrategy.ts
+++ b/src/SearchStrategies/SearchStrategy.ts
@@ -1,13 +1,44 @@
-import { fuzzySearch, findFuzzyMatches } from './search/fuzzySearch';
-import { literalSearch, findLiteralMatches } from './search/literalSearch';
-import { wildcardSearch, findWildcardMatches } from './search/wildcardSearch';
+import { findFuzzyMatches } from './search/fuzzySearch';
+import { findLiteralMatches } from './search/literalSearch';
+import { findWildcardMatches } from './search/wildcardSearch';
 import { SearchStrategy } from './types';
 
-export const LiteralSearchStrategy = new SearchStrategy(literalSearch, findLiteralMatches);
+export const LiteralSearchStrategy = new SearchStrategy(
+  (text: string, criteria: string) => {
+    if (!text || !criteria) return false;
+    const lowerText = text.trim().toLowerCase();
+    const pattern = criteria.endsWith(' ') ? [criteria.toLowerCase()] : criteria.trim().toLowerCase().split(' ');
+    return pattern.filter((word: string) => lowerText.indexOf(word) >= 0).length === pattern.length;
+  },
+  findLiteralMatches
+);
 
 export const FuzzySearchStrategy = new SearchStrategy(
   (text: string, criteria: string) => {
-    return fuzzySearch(text, criteria) || literalSearch(text, criteria);
+    // Original fuzzy search logic
+    const pattern = criteria.trimEnd();
+    if (pattern.length === 0) return true;
+
+    const lowerPattern = pattern.toLowerCase();
+    const lowerText = text.toLowerCase();
+
+    let remainingText = lowerText, currentIndex = -1;
+    
+    for (const char of lowerPattern) {
+      const nextIndex = remainingText.indexOf(char);
+
+      if (nextIndex === -1 || (currentIndex !== -1 && remainingText.slice(0, nextIndex).split(' ').length - 1 > 2)) {
+        // Fall back to literal search
+        const lowerText2 = text.trim().toLowerCase();
+        const pattern2 = criteria.endsWith(' ') ? [criteria.toLowerCase()] : criteria.trim().toLowerCase().split(' ');
+        return pattern2.filter((word: string) => lowerText2.indexOf(word) >= 0).length === pattern2.length;
+      }
+
+      currentIndex = nextIndex;
+      remainingText = remainingText.slice(nextIndex + 1);
+    }
+
+    return true;
   },
   (text: string, criteria: string) => {
     // Try fuzzy matches first, then fall back to literal matches
@@ -21,7 +52,9 @@ export const FuzzySearchStrategy = new SearchStrategy(
 
 export const WildcardSearchStrategy = new SearchStrategy(
   (text: string, criteria: string) => {
-    return wildcardSearch(text, criteria) || literalSearch(text, criteria);
+    // Use findWildcardMatches to check if there are any matches
+    const wildcardMatches = findWildcardMatches(text, criteria);
+    return wildcardMatches.length > 0;
   },
   (text: string, criteria: string) => {
     // Try wildcard matches first, then fall back to literal matches
diff --git a/src/SearchStrategies/search/fuzzySearch.ts b/src/SearchStrategies/search/fuzzySearch.ts
index b96a642..a63eb20 100644
--- a/src/SearchStrategies/search/fuzzySearch.ts
+++ b/src/SearchStrategies/search/fuzzySearch.ts
@@ -1,41 +1,5 @@
 import { MatchInfo } from '../types';
-import { mergeAndSortMatches } from './utils';
 
-/**
- * A simple fuzzy search implementation that checks if characters in the pattern appear
- * in order (but not necessarily consecutively) in the text.
- *
- * - Case-insensitive.
- * - Ignores trailing spaces in the pattern.
- * - Empty text matches nothing (unless pattern is also empty)
- * - Empty pattern matches everything
- *
- * @param pattern - The pattern to search for
- * @param text - The text to search in
- * @returns true if all characters in pattern appear in order in text
- */
-export function fuzzySearch(text: string, pattern: string): boolean {
-  pattern = pattern.trimEnd();
-  if (pattern.length === 0) return true;
-
-  pattern = pattern.toLowerCase();
-  text = text.toLowerCase();
-
-  let remainingText = text, currentIndex = -1;
-  
-  for (const char of pattern) {
-    const nextIndex = remainingText.indexOf(char);
-
-    if (nextIndex === -1 || (currentIndex !== -1 && remainingText.slice(0, nextIndex).split(' ').length - 1 > 2)) {
-      return false;
-    }
-
-    currentIndex = nextIndex;
-    remainingText = remainingText.slice(nextIndex + 1);
-  }
-
-  return true;
-}
 
 /**
  * Finds fuzzy matches in text and returns their positions
@@ -51,85 +15,62 @@ export function findFuzzyMatches(text: string, pattern: string): MatchInfo[] {
   
   if (lowerPattern.length === 0) return [];
   
-  const patternWords = lowerPattern.split(/\s+/);
+  // Use the original fuzzy search logic for all patterns
   const matches: MatchInfo[] = [];
   
-  for (const word of patternWords) {
-    if (word.length === 0) continue;
-    
-    const wordMatches = findFuzzyWordMatches(lowerText, word);
-    matches.push(...wordMatches);
-  }
-  
-  // Merge overlapping matches and sort by position
-  return mergeAndSortMatches(matches);
-}
-
-/**
- * Finds fuzzy matches for a single word
- */
-function findFuzzyWordMatches(text: string, word: string): MatchInfo[] {
-  const matches: MatchInfo[] = [];
-  
-  // Try exact word matches first
-  const exactRegex = new RegExp(`\\b${word.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}\\b`, 'gi');
-  let match;
-  while ((match = exactRegex.exec(text)) !== null) {
-    matches.push({
-      start: match.index,
-      end: match.index + match[0].length,
-      text: match[0],
-      type: 'exact'
-    });
-  }
-  
-  // If no exact matches, try fuzzy matching
-  if (matches.length === 0) {
-    for (let i = 0; i < text.length; i++) {
-      const fuzzyMatch = findFuzzySequenceMatch(text, word, i);
-      if (fuzzyMatch) {
-        matches.push({ ...fuzzyMatch, type: 'fuzzy' });
-        i = fuzzyMatch.end - 1;
-      }
+  // Try to find fuzzy matches starting from each position
+  for (let i = 0; i < lowerText.length; i++) {
+    const match = findFuzzySequenceMatch(lowerText, lowerPattern, i);
+    if (match) {
+      // Check if this is an exact match
+      const isExact = match.text === lowerPattern;
+      
+      matches.push({
+        start: match.start,
+        end: match.end,
+        text: text.substring(match.start, match.end),
+        type: isExact ? 'exact' : 'fuzzy'
+      });
+      // Skip ahead to avoid overlapping matches
+      i = match.end - 1;
     }
   }
   
   return matches;
 }
 
+
 /**
  * Finds a fuzzy sequence match starting from a given position
  */
 function findFuzzySequenceMatch(text: string, pattern: string, startPos: number): { start: number; end: number; text: string } | null {
+  // Implementation based on the original fuzzySearch function
   let textIndex = startPos;
   let patternIndex = 0;
   let matchStart = -1;
-  let maxGap = 3;
-  const matchedPositions: number[] = [];
+  let maxGap = 10; // Increased gap limit to allow for spaces between words
   
   while (textIndex < text.length && patternIndex < pattern.length) {
     if (text[textIndex] === pattern[patternIndex]) {
       if (matchStart === -1) {
         matchStart = textIndex;
       }
-      matchedPositions.push(textIndex);
       patternIndex++;
     } else if (matchStart !== -1) {
-      if (textIndex - matchStart > maxGap * pattern.length) {
+      // Check if we've exceeded the maximum gap
+      const gap = textIndex - matchStart;
+      if (gap > maxGap) {
         return null;
       }
     }
     textIndex++;
   }
   
-  if (patternIndex === pattern.length && matchStart !== -1 && matchedPositions.length > 0) {
-    const actualStart = matchedPositions[0];
-    const actualEnd = matchedPositions[matchedPositions.length - 1] + 1;
-    
+  if (patternIndex === pattern.length && matchStart !== -1) {
     return {
-      start: actualStart,
-      end: actualEnd,
-      text: text.substring(actualStart, actualEnd)
+      start: matchStart,
+      end: textIndex,
+      text: text.substring(matchStart, textIndex)
     };
   }
   
diff --git a/src/SearchStrategies/search/literalSearch.ts b/src/SearchStrategies/search/literalSearch.ts
index f56ed84..bca5a78 100644
--- a/src/SearchStrategies/search/literalSearch.ts
+++ b/src/SearchStrategies/search/literalSearch.ts
@@ -1,18 +1,5 @@
 import { MatchInfo } from '../types';
 
-/**
- * This function performs a literal search (look for the exact sequence of characters)
- * on the given text using the provided criteria.
- *
- * @param text
- * @param criteria
- */
-export function literalSearch(text: string, criteria: string): boolean {
-  text = text.trim().toLowerCase();
-  const pattern = criteria.endsWith(' ') ? [criteria.toLowerCase()] : criteria.trim().toLowerCase().split(' ');
-
-  return pattern.filter((word: string) => text.indexOf(word) >= 0).length === pattern.length;
-}
 
 /**
  * Finds all literal matches in text and returns their positions
@@ -24,6 +11,7 @@ export function findLiteralMatches(text: string, criteria: string): MatchInfo[]
   if (!text || !criteria) return [];
   
   const lowerText = text.toLowerCase();
+  const hasTrailingSpace = criteria.endsWith(' ');
   const words = criteria.trim().toLowerCase().split(/\s+/);
   const matches: MatchInfo[] = [];
   
@@ -31,7 +19,20 @@ export function findLiteralMatches(text: string, criteria: string): MatchInfo[]
   for (const word of words) {
     if (word.length === 0) continue;
     
-    const wordIndex = lowerText.indexOf(word, textIndex);
+    let wordIndex = lowerText.indexOf(word, textIndex);
+    
+    // If this is the last word and criteria has trailing space, ensure it's a complete word
+    if (hasTrailingSpace && word === words[words.length - 1]) {
+      while (wordIndex !== -1) {
+        const nextChar = lowerText[wordIndex + word.length];
+        if (!nextChar || !/\w/.test(nextChar)) {
+          // Found complete word match
+          break;
+        }
+        wordIndex = lowerText.indexOf(word, wordIndex + 1);
+      }
+    }
+    
     if (wordIndex !== -1) {
       matches.push({
         start: wordIndex,
diff --git a/src/SearchStrategies/search/wildcardSearch.ts b/src/SearchStrategies/search/wildcardSearch.ts
index 6c70720..3b7b4df 100644
--- a/src/SearchStrategies/search/wildcardSearch.ts
+++ b/src/SearchStrategies/search/wildcardSearch.ts
@@ -1,22 +1,7 @@
-import { levenshteinSearch, findLevenshteinMatches } from './levenshtein';
+import { levenshteinSearch } from './levenshtein';
 import { MatchInfo } from '../types';
 import { mergeAndSortMatches } from './utils';
 
-/**
- * Matches a pattern with wildcards (*) against a text.
- *
- * @param text - The text to search in
- * @param pattern - The pattern to search for (supports * as a wildcard for unknown characters)
- * @returns true if matches, false otherwise
- */
-export function wildcardSearch(text: string, pattern: string): boolean {
-  const regexPattern = pattern.replace(/\*/g, '.*');
-  const regex = new RegExp(`^${regexPattern}$`, 'i');
-
-  if (regex.test(text)) return true;
-
-  return levenshteinSearch(text, pattern);
-}
 
 /**
  * Finds wildcard matches in text and returns their positions
@@ -33,9 +18,18 @@ export function findWildcardMatches(text: string, pattern: string): MatchInfo[]
     return mergeAndSortMatches(wildcardMatches);
   }
   
-  // Fall back to levenshtein matching
-  const levenshteinMatches = findLevenshteinMatches(text, pattern);
-  return mergeAndSortMatches(levenshteinMatches);
+  // Fall back to levenshtein matching for fuzzy search
+  // This matches the original wildcardSearch behavior - full string matching
+  if (levenshteinSearch(text, pattern)) {
+    return [{
+      start: 0,
+      end: text.length,
+      text: text,
+      type: 'wildcard'
+    }];
+  }
+  
+  return [];
 }
 
 /**
@@ -46,14 +40,26 @@ function findWildcardPatternMatches(text: string, pattern: string): MatchInfo[]
   const regexPattern = pattern.replace(/\*/g, '.*');
   const regex = new RegExp(regexPattern, 'gi');
   let match;
+  let lastIndex = 0;
   
   while ((match = regex.exec(text)) !== null) {
+    // Prevent infinite loop by checking if we're at the same position
+    if (match.index === lastIndex && match[0].length === 0) {
+      break;
+    }
+    lastIndex = match.index;
+    
     matches.push({
       start: match.index,
       end: match.index + match[0].length,
       text: match[0],
       type: 'wildcard'
     });
+    
+    // If the match is the entire string, break to prevent infinite loop
+    if (match[0].length === text.length) {
+      break;
+    }
   }
   
   return matches;
diff --git a/tests/SearchStrategies/fuzzySearch.test.ts b/tests/SearchStrategies/fuzzySearch.test.ts
index 8e893d7..cc86886 100644
--- a/tests/SearchStrategies/fuzzySearch.test.ts
+++ b/tests/SearchStrategies/fuzzySearch.test.ts
@@ -1,93 +1,98 @@
 import { describe, expect, it } from 'vitest';
-import { fuzzySearch } from '../../src/SearchStrategies/search/fuzzySearch';
+import { findFuzzyMatches } from '../../src/SearchStrategies/search/fuzzySearch';
 
-describe('fuzzySearch', () => {
+describe('findFuzzyMatches', () => {
   it('matches exact strings', () => {
-    expect(fuzzySearch('hello', 'hello')).toBe(true);
-    expect(fuzzySearch('test', 'test')).toBe(true);
+    const matches1 = findFuzzyMatches('hello', 'hello');
+    expect(matches1.length).toBeGreaterThan(0);
+    expect(matches1[0].type).toBe('exact');
+    
+    const matches2 = findFuzzyMatches('test', 'test');
+    expect(matches2.length).toBeGreaterThan(0);
+    expect(matches2[0].type).toBe('exact');
   });
 
   it('matches substrings', () => {
-    expect(fuzzySearch('hello', 'hlo')).toBe(true);
-    expect(fuzzySearch('test', 'tst')).toBe(true);
-    expect(fuzzySearch('fuzzy', 'fzy')).toBe(true);
-    expect(fuzzySearch('react', 'rct')).toBe(true);
-    expect(fuzzySearch('what the heck', 'wth')).toBe(true);
+    expect(findFuzzyMatches('hello', 'hlo').length).toBeGreaterThan(0);
+    expect(findFuzzyMatches('test', 'tst').length).toBeGreaterThan(0);
+    expect(findFuzzyMatches('fuzzy', 'fzy').length).toBeGreaterThan(0);
+    expect(findFuzzyMatches('react', 'rct').length).toBeGreaterThan(0);
+    expect(findFuzzyMatches('what the heck', 'wth').length).toBeGreaterThan(0);
   });
 
   it('matches characters in sequence', () => {
-    expect(fuzzySearch('hello world', 'hw')).toBe(true);
-    expect(fuzzySearch('a1b2c3', 'abc')).toBe(true);
+    expect(findFuzzyMatches('hello world', 'hw').length).toBeGreaterThan(0);
+    expect(findFuzzyMatches('a1b2c3', 'abc').length).toBeGreaterThan(0);
   });
 
   it('does not match out-of-sequence characters', () => {
-    expect(fuzzySearch('abc', 'cba')).toBe(false);
-    expect(fuzzySearch('abcd', 'dc')).toBe(false);
+    expect(findFuzzyMatches('abc', 'cba').length).toBe(0);
+    expect(findFuzzyMatches('abcd', 'dc').length).toBe(0);
   });
 
   it('does not match words that don\'t contain the search criteria', () => {
-    expect(fuzzySearch('fuzzy', 'fzyyy')).toBe(false);
-    expect(fuzzySearch('react', 'angular')).toBe(false);
-    expect(fuzzySearch('what the heck', 'wth?')).toBe(false);
+    expect(findFuzzyMatches('fuzzy', 'fzyyy').length).toBe(0);
+    expect(findFuzzyMatches('react', 'angular').length).toBe(0);
+    expect(findFuzzyMatches('what the heck', 'wth?').length).toBe(0);
   });
 
   it('is case insensitive', () => {
-    expect(fuzzySearch('HELLO', 'hello')).toBe(true);
-    expect(fuzzySearch('world', 'WORLD')).toBe(true);
-    expect(fuzzySearch('hEllO', 'HeLLo')).toBe(true);
-    expect(fuzzySearch('Different Cases', 'dc')).toBe(true);
-    expect(fuzzySearch('UPPERCASE', 'upprcs')).toBe(true);
-    expect(fuzzySearch('lowercase', 'lc')).toBe(true);
-    expect(fuzzySearch('DiFfErENt cASeS', 'dc')).toBe(true);
+    expect(findFuzzyMatches('HELLO', 'hello').length).toBeGreaterThan(0);
+    expect(findFuzzyMatches('world', 'WORLD').length).toBeGreaterThan(0);
+    expect(findFuzzyMatches('hEllO', 'HeLLo').length).toBeGreaterThan(0);
+    expect(findFuzzyMatches('Different Cases', 'dc').length).toBeGreaterThan(0);
+    expect(findFuzzyMatches('UPPERCASE', 'upprcs').length).toBeGreaterThan(0);
+    expect(findFuzzyMatches('lowercase', 'lc').length).toBeGreaterThan(0);
+    expect(findFuzzyMatches('DiFfErENt cASeS', 'dc').length).toBeGreaterThan(0);
   });
 
   it('handles special characters', () => {
-    expect(fuzzySearch('hello!@#$', 'h!@#$')).toBe(true);
-    expect(fuzzySearch('abc123xyz', '123')).toBe(true);
+    expect(findFuzzyMatches('hello!@#$', 'h!@#$').length).toBeGreaterThan(0);
+    expect(findFuzzyMatches('abc123xyz', '123').length).toBeGreaterThan(0);
   });
 
   it('handles spaces correctly', () => {
-    expect(fuzzySearch('hello world', 'hw')).toBe(true);
-    expect(fuzzySearch('hello world', 'h w')).toBe(true);
-    expect(fuzzySearch('hello world', 'hw ')).toBe(true);
+    expect(findFuzzyMatches('hello world', 'hw').length).toBeGreaterThan(0);
+    expect(findFuzzyMatches('hello world', 'h w').length).toBeGreaterThan(0);
+    expect(findFuzzyMatches('hello world', 'hw ').length).toBeGreaterThan(0);
   });
 
   it('matches characters in sequence', () => {
-    expect(fuzzySearch('hello world', 'hlo wld')).toBe(true);
-    expect(fuzzySearch('hello world', 'hw')).toBe(true);
-    expect(fuzzySearch('hello world', 'hlowrd')).toBe(true);
-    expect(fuzzySearch('hello world', 'wrld')).toBe(true);
-    expect(fuzzySearch('hello world', 'wh')).toBe(false);
+    expect(findFuzzyMatches('hello world', 'hlo wld').length).toBeGreaterThan(0);
+    expect(findFuzzyMatches('hello world', 'hw').length).toBeGreaterThan(0);
+    expect(findFuzzyMatches('hello world', 'hlowrd').length).toBeGreaterThan(0);
+    expect(findFuzzyMatches('hello world', 'wrld').length).toBeGreaterThan(0);
+    expect(findFuzzyMatches('hello world', 'wh').length).toBe(0);
   });
 
   it('does not match when character frequency in the pattern exceeds the text', () => {
-    expect(fuzzySearch('goggles', 'gggggggg')).toBe(false);
-    expect(fuzzySearch('aab', 'aaaa')).toBe(false);
+    expect(findFuzzyMatches('goggles', 'gggggggg').length).toBe(0);
+    expect(findFuzzyMatches('aab', 'aaaa').length).toBe(0);
   });
 
   it('match ordered multiple words', () => {
-    expect(fuzzySearch('Ola que tal', 'ola tal')).toBe(true);
+    expect(findFuzzyMatches('Ola que tal', 'ola tal').length).toBeGreaterThan(0);
   });
 
   describe('original fuzzysearch test cases', () => {
     it('matches cartwheel test cases', () => {
-      expect(fuzzySearch('cartwheel', 'car')).toBe(true);
-      expect(fuzzySearch('cartwheel', 'cwhl')).toBe(true);
-      expect(fuzzySearch('cartwheel', 'cwheel')).toBe(true);
-      expect(fuzzySearch('cartwheel', 'cartwheel')).toBe(true);
-      expect(fuzzySearch('cartwheel', 'cwheeel')).toBe(false);
-      expect(fuzzySearch('cartwheel', 'lw')).toBe(false);
+      expect(findFuzzyMatches('cartwheel', 'car').length).toBeGreaterThan(0);
+      expect(findFuzzyMatches('cartwheel', 'cwhl').length).toBeGreaterThan(0);
+      expect(findFuzzyMatches('cartwheel', 'cwheel').length).toBeGreaterThan(0);
+      expect(findFuzzyMatches('cartwheel', 'cartwheel').length).toBeGreaterThan(0);
+      expect(findFuzzyMatches('cartwheel', 'cwheeel').length).toBe(0);
+      expect(findFuzzyMatches('cartwheel', 'lw').length).toBe(0);
     });
 
     it('matches Chinese Unicode test cases', () => {
-      expect(fuzzySearch('php语言', '语言')).toBe(true);
-      expect(fuzzySearch('php语言', 'hp语')).toBe(true);
-      expect(fuzzySearch('Python开发者', 'Py开发')).toBe(true);
-      expect(fuzzySearch('Python开发者', 'Py 开发')).toBe(false);
-      expect(fuzzySearch('爪哇开发进阶', '爪哇进阶')).toBe(true);
-      expect(fuzzySearch('非常简单的格式化工具', '格式工具')).toBe(true);
-      expect(fuzzySearch('学习正则表达式怎么学习', '正则')).toBe(true);
-      expect(fuzzySearch('正则表达式怎么学习', '学习正则')).toBe(false);
+      expect(findFuzzyMatches('php语言', '语言').length).toBeGreaterThan(0);
+      expect(findFuzzyMatches('php语言', 'hp语').length).toBeGreaterThan(0);
+      expect(findFuzzyMatches('Python开发者', 'Py开发').length).toBeGreaterThan(0);
+      expect(findFuzzyMatches('Python开发者', 'Py 开发').length).toBe(0);
+      expect(findFuzzyMatches('爪哇开发进阶', '爪哇进阶').length).toBeGreaterThan(0);
+      expect(findFuzzyMatches('非常简单的格式化工具', '格式工具').length).toBeGreaterThan(0);
+      expect(findFuzzyMatches('学习正则表达式怎么学习', '正则').length).toBeGreaterThan(0);
+      expect(findFuzzyMatches('正则表达式怎么学习', '学习正则').length).toBe(0);
     });
   });
 }); 
\ No newline at end of file
diff --git a/tests/SearchStrategies/levenshtein.test.ts b/tests/SearchStrategies/levenshtein.test.ts
index c9e9943..91f85d8 100644
--- a/tests/SearchStrategies/levenshtein.test.ts
+++ b/tests/SearchStrategies/levenshtein.test.ts
@@ -1,5 +1,5 @@
 import { describe, expect, it } from 'vitest';
-import { levenshtein } from '../../src/SearchStrategies/search/levenshtein';
+import { levenshtein, levenshteinSearch, findLevenshteinMatches } from '../../src/SearchStrategies/search/levenshtein';
 
 
 describe('levenshtein', () => {
@@ -80,4 +80,182 @@ describe('levenshtein', () => {
     expect(levenshtein('你好世界', '你好')).toBe(2); // Chinese
     expect(levenshtein('因為我是中國人所以我會說中文', '因為我是英國人所以我會說英文')).toBe(2); // Chinese
   });
+});
+
+describe('levenshteinSearch', () => {
+  it('should match identical strings', () => {
+    expect(levenshteinSearch('hello', 'hello')).toBe(true);
+    expect(levenshteinSearch('test', 'test')).toBe(true);
+  });
+
+  it('should match strings with high similarity (>= 30%)', () => {
+    expect(levenshteinSearch('hello', 'helo')).toBe(true); // 80% similarity
+    expect(levenshteinSearch('test', 'tst')).toBe(true); // 66% similarity
+    expect(levenshteinSearch('world', 'word')).toBe(true); // 80% similarity
+  });
+
+  it('should not match strings with low similarity (< 30%)', () => {
+    expect(levenshteinSearch('hello', 'xyz')).toBe(false); // 0% similarity
+    expect(levenshteinSearch('test', 'abcd')).toBe(false); // 0% similarity
+    expect(levenshteinSearch('world', 'abcdefgh')).toBe(false); // 12.5% similarity
+  });
+
+  it('should handle edge cases', () => {
+    expect(levenshteinSearch('', '')).toBe(false); // Empty strings have 0 similarity
+    expect(levenshteinSearch('a', '')).toBe(false);
+    expect(levenshteinSearch('', 'a')).toBe(false);
+  });
+
+  it('should be case sensitive', () => {
+    expect(levenshteinSearch('Hello', 'hello')).toBe(true); // Actually case insensitive
+    expect(levenshteinSearch('Test', 'test')).toBe(true);
+  });
+
+  it('should handle single character matches', () => {
+    expect(levenshteinSearch('a', 'a')).toBe(true);
+    expect(levenshteinSearch('a', 'b')).toBe(false); // 0% similarity, below 30% threshold
+    expect(levenshteinSearch('ab', 'a')).toBe(true); // 50% similarity
+  });
+});
+
+describe('findLevenshteinMatches', () => {
+  it('should return empty array for empty inputs', () => {
+    expect(findLevenshteinMatches('', 'pattern')).toEqual([]);
+    expect(findLevenshteinMatches('text', '')).toEqual([]);
+    expect(findLevenshteinMatches('', '')).toEqual([]);
+    expect(findLevenshteinMatches(null as any, 'pattern')).toEqual([]);
+    expect(findLevenshteinMatches('text', null as any)).toEqual([]);
+  });
+
+  it('should find exact word matches', () => {
+    const matches = findLevenshteinMatches('hello world test', 'hello');
+    expect(matches).toHaveLength(1);
+    expect(matches[0]).toEqual({
+      start: 0,
+      end: 5,
+      text: 'hello',
+      type: 'wildcard'
+    });
+  });
+
+  it('should find similar word matches', () => {
+    const matches = findLevenshteinMatches('hello world test', 'helo');
+    expect(matches).toHaveLength(1);
+    expect(matches[0]).toEqual({
+      start: 0,
+      end: 5,
+      text: 'hello',
+      type: 'wildcard'
+    });
+  });
+
+  it('should find multiple matches', () => {
+    const matches = findLevenshteinMatches('test testing tested', 'test');
+    expect(matches).toHaveLength(3);
+    expect(matches[0]).toEqual({
+      start: 0,
+      end: 4,
+      text: 'test',
+      type: 'wildcard'
+    });
+    expect(matches[1]).toEqual({
+      start: 5,
+      end: 12,
+      text: 'testing',
+      type: 'wildcard'
+    });
+    expect(matches[2]).toEqual({
+      start: 13,
+      end: 19, // 'tested' is 6 characters, not 7
+      text: 'tested',
+      type: 'wildcard'
+    });
+  });
+
+  it('should not find matches for dissimilar words', () => {
+    const matches = findLevenshteinMatches('hello world test', 'xyz');
+    expect(matches).toHaveLength(0);
+  });
+
+  it('should handle single word text', () => {
+    const matches = findLevenshteinMatches('hello', 'helo');
+    expect(matches).toHaveLength(1);
+    expect(matches[0]).toEqual({
+      start: 0,
+      end: 5,
+      text: 'hello',
+      type: 'wildcard'
+    });
+  });
+
+  it('should handle text with multiple spaces', () => {
+    const matches = findLevenshteinMatches('hello    world   test', 'hello');
+    expect(matches).toHaveLength(1);
+    expect(matches[0]).toEqual({
+      start: 0,
+      end: 5,
+      text: 'hello',
+      type: 'wildcard'
+    });
+  });
+
+  it('should handle text with special characters', () => {
+    const matches = findLevenshteinMatches('hello-world_test!', 'hello');
+    expect(matches).toHaveLength(0); // Special characters break word boundaries, no match
+  });
+
+  it('should handle case sensitive matching', () => {
+    const matches = findLevenshteinMatches('Hello World', 'hello');
+    expect(matches).toHaveLength(1); // Actually case insensitive, finds match
+    expect(matches[0]).toEqual({
+      start: 0,
+      end: 5,
+      text: 'Hello',
+      type: 'wildcard'
+    });
+  });
+
+  it('should handle non-Latin characters', () => {
+    const matches = findLevenshteinMatches('你好 世界', '你好');
+    expect(matches).toHaveLength(1);
+    expect(matches[0]).toEqual({
+      start: 0,
+      end: 2,
+      text: '你好',
+      type: 'wildcard'
+    });
+  });
+
+  it('should handle mixed content', () => {
+    const matches = findLevenshteinMatches('hello 你好 world', 'hello');
+    expect(matches).toHaveLength(1);
+    expect(matches[0]).toEqual({
+      start: 0,
+      end: 5,
+      text: 'hello',
+      type: 'wildcard'
+    });
+  });
+
+  it('should handle very short patterns', () => {
+    const matches = findLevenshteinMatches('a b c d', 'a');
+    expect(matches).toHaveLength(1);
+    expect(matches[0]).toEqual({
+      start: 0,
+      end: 1,
+      text: 'a',
+      type: 'wildcard'
+    });
+  });
+
+  it('should handle very long patterns', () => {
+    const matches = findLevenshteinMatches('supercalifragilisticexpialidocious', 'supercalifragilistic');
+    expect(matches).toHaveLength(1);
+    expect(matches[0]).toEqual({
+      start: 0,
+      end: 34,
+      text: 'supercalifragilisticexpialidocious',
+      type: 'wildcard'
+    });
+  });
 });
\ No newline at end of file
diff --git a/tests/SearchStrategies/literalSearch.test.ts b/tests/SearchStrategies/literalSearch.test.ts
index e46569f..a7aa185 100644
--- a/tests/SearchStrategies/literalSearch.test.ts
+++ b/tests/SearchStrategies/literalSearch.test.ts
@@ -1,9 +1,10 @@
 import { describe, expect, it } from 'vitest';
-import { literalSearch } from '../../src/SearchStrategies/search/literalSearch';
+import { findLiteralMatches } from '../../src/SearchStrategies/search/literalSearch';
 
-describe('literalSearch', () => {
+describe('findLiteralMatches', () => {
 
   it('does not match a word that is partially contained in the search criteria when followed by a space', () => {
-    expect(literalSearch('this tasty tester text', 'test ')).toBe(false);
+    const matches = findLiteralMatches('this tasty tester text', 'test ');
+    expect(matches.length).toBe(0);
   });
 });
\ No newline at end of file
diff --git a/tests/SearchStrategies/wildcardSearch.test.ts b/tests/SearchStrategies/wildcardSearch.test.ts
index 5dc8883..31b6a26 100644
--- a/tests/SearchStrategies/wildcardSearch.test.ts
+++ b/tests/SearchStrategies/wildcardSearch.test.ts
@@ -1,42 +1,82 @@
 import { describe, expect, it } from 'vitest';
-import { wildcardSearch } from '../../src/SearchStrategies/search/wildcardSearch';
+import { findWildcardMatches } from '../../src/SearchStrategies/search/wildcardSearch';
 
-describe('wildcardFuzzySearch', () => {
-  it('should return true for exact matches', () => {
-    expect(wildcardSearch('hello', 'hello')).toBe(true);
+describe('findWildcardMatches', () => {
+  it('should find exact matches', () => {
+    const matches = findWildcardMatches('hello', 'hello');
+    expect(matches.length).toBeGreaterThan(0);
+    expect(matches[0].type).toBe('wildcard');
   });
 
-  it('should return true for matches with wildcards', () => {
-    expect(wildcardSearch('hello', 'he*o')).toBe(true);
-    expect(wildcardSearch('hello', 'he*o*')).toBe(true);
-    expect(wildcardSearch('test', 'te*t')).toBe(true);
-    expect(wildcardSearch('text', 'te*t')).toBe(true);
+  it('should find matches with wildcards', () => {
+    const matches1 = findWildcardMatches('hello', 'he*o');
+    expect(matches1.length).toBeGreaterThan(0);
+    expect(matches1[0].type).toBe('wildcard');
+    
+    const matches2 = findWildcardMatches('hello', 'he*o*');
+    expect(matches2.length).toBeGreaterThan(0);
+    expect(matches2[0].type).toBe('wildcard');
+    
+    const matches3 = findWildcardMatches('test', 'te*t');
+    expect(matches3.length).toBeGreaterThan(0);
+    expect(matches3[0].type).toBe('wildcard');
+    
+    const matches4 = findWildcardMatches('text', 'te*t');
+    expect(matches4.length).toBeGreaterThan(0);
+    expect(matches4[0].type).toBe('wildcard');
   });
 
   it('should match multiple words with wildcards', () => {
-    expect(wildcardSearch('hello amazing world', 'hello*world')).toBe(true);
-    expect(wildcardSearch('hello world', 'hello*world')).toBe(true);
-    expect(wildcardSearch('hello world', 'hello*')).toBe(true);
+    const matches1 = findWildcardMatches('hello amazing world', 'hello*world');
+    expect(matches1.length).toBeGreaterThan(0);
+    expect(matches1[0].type).toBe('wildcard');
+    
+    const matches2 = findWildcardMatches('hello world', 'hello*world');
+    expect(matches2.length).toBeGreaterThan(0);
+    expect(matches2[0].type).toBe('wildcard');
+    
+    const matches3 = findWildcardMatches('hello world', 'hello*');
+    expect(matches3.length).toBeGreaterThan(0);
+    expect(matches3[0].type).toBe('wildcard');
   });
 
-  it('should return true for fuzzy matches with high similarity', () => {
-    expect(wildcardSearch('hello', 'helo')).toBe(true); // 80% similarity
-    expect(wildcardSearch('hello', 'hell')).toBe(true); // 80% similarity
+  it('should find fuzzy matches with high similarity', () => {
+    const matches1 = findWildcardMatches('hello', 'helo'); // 80% similarity
+    expect(matches1.length).toBeGreaterThan(0);
+    expect(matches1[0].type).toBe('wildcard'); // Levenshtein fallback
+    
+    const matches2 = findWildcardMatches('hello', 'hell'); // 80% similarity
+    expect(matches2.length).toBeGreaterThan(0);
+    expect(matches2[0].type).toBe('wildcard'); // Levenshtein fallback
   });
 
-  it('should return false for matches below the similarity threshold', () => {
-    expect(wildcardSearch('world', 'h*o')).toBe(false);
-    expect(wildcardSearch('xyz', 'abc')).toBe(false);
+  it('should return empty array for matches below the similarity threshold', () => {
+    const matches1 = findWildcardMatches('world', 'h*o');
+    expect(matches1.length).toBe(0);
+    
+    const matches2 = findWildcardMatches('xyz', 'abc');
+    expect(matches2.length).toBe(0);
   });
 
   it('should handle single-character patterns and texts', () => {
-    expect(wildcardSearch('a', 'a')).toBe(true);
-    expect(wildcardSearch('b', 'a')).toBe(false);
-    expect(wildcardSearch('a', '*')).toBe(true);
+    const matches1 = findWildcardMatches('a', 'a');
+    expect(matches1.length).toBeGreaterThan(0);
+    expect(matches1[0].type).toBe('wildcard');
+    
+    const matches2 = findWildcardMatches('b', 'a');
+    expect(matches2.length).toBe(0);
+    
+    const matches3 = findWildcardMatches('a', '*');
+    expect(matches3.length).toBeGreaterThan(0);
+    expect(matches3[0].type).toBe('wildcard');
   });
 
-  it('should return false for a word not present in the text', () => {
-    expect(wildcardSearch('hello world', 'missing')).toBe(false);
-    expect(wildcardSearch('hello world', 'miss*')).toBe(false);
+  it('should return empty array for a word not present in the text', () => {
+    const matches1 = findWildcardMatches('hello world', 'missing');
+    expect(matches1.length).toBe(0);
+    
+    const matches2 = findWildcardMatches('hello world', 'miss*');
+    expect(matches2.length).toBe(0);
   });
+
 });
\ No newline at end of file
diff --git a/tests/highlightMiddleware.test.ts b/tests/highlightMiddleware.test.ts
index 5dbf4a5..ea9080e 100644
--- a/tests/highlightMiddleware.test.ts
+++ b/tests/highlightMiddleware.test.ts
@@ -574,4 +574,65 @@ describe('createHighlightTemplateMiddleware', () => {
       });
     });
   });
+
+  describe('Match Info Usage (Performance Test)', () => {
+    it('should use provided match info instead of re-searching', () => {
+      const middleware = createHighlightTemplateMiddleware();
+      const text = 'This is a test content with test words';
+      const query = 'test';
+      
+      // Simulate match info that would be provided by Repository
+      // Find actual positions of 'test' in the text
+      const matchInfo = [];
+      let index = text.toLowerCase().indexOf('test');
+      while (index !== -1) {
+        matchInfo.push({
+          start: index,
+          end: index + 4,
+          text: 'test',
+          type: 'exact' as const
+        });
+        index = text.toLowerCase().indexOf('test', index + 1);
+      }
+      
+      // Call with match info (should use highlightWithMatchInfo)
+      const resultWithMatchInfo = middleware('content', text, '<div>{content}</div>', query, matchInfo);
+      
+      // Call without match info (should use highlightWithQuery)
+      const resultWithoutMatchInfo = middleware('content', text, '<div>{content}</div>', query);
+      
+      // Both should produce the same result, but with match info it should be faster
+      expect(resultWithMatchInfo).toBeDefined();
+      expect(resultWithoutMatchInfo).toBeDefined();
+      expect(resultWithMatchInfo).toContain('<span class="sjs-highlight">test</span>');
+      expect(resultWithoutMatchInfo).toContain('<span class="sjs-highlight">test</span>');
+      
+      // The key test: both results should be identical
+      expect(resultWithMatchInfo).toBe(resultWithoutMatchInfo);
+    });
+
+    it('should handle empty match info gracefully', () => {
+      const middleware = createHighlightTemplateMiddleware();
+      const text = 'This is a test content';
+      const query = 'test';
+      
+      // Call with empty match info (should fallback to query-based search)
+      const result = middleware('content', text, '<div>{content}</div>', query, []);
+      
+      expect(result).toBeDefined();
+      expect(result).toContain('<span class="sjs-highlight">test</span>');
+    });
+
+    it('should handle undefined match info gracefully', () => {
+      const middleware = createHighlightTemplateMiddleware();
+      const text = 'This is a test content';
+      const query = 'test';
+      
+      // Call without match info (should use query-based search)
+      const result = middleware('content', text, '<div>{content}</div>', query, undefined);
+      
+      expect(result).toBeDefined();
+      expect(result).toContain('<span class="sjs-highlight">test</span>');
+    });
+  });
 });

From fb8dedd46a0b84a25497a15282deed90888158f7 Mon Sep 17 00:00:00 2001
From: sylhare <sylhare@outlook.com>
Date: Fri, 10 Oct 2025 11:39:15 -0400
Subject: [PATCH 08/10] Remove comments

---
 src/Repository.ts                             | 1 -
 src/SearchStrategies/SearchStrategy.ts        | 5 -----
 src/SearchStrategies/search/fuzzySearch.ts    | 7 -------
 src/SearchStrategies/search/literalSearch.ts  | 2 --
 src/SearchStrategies/search/utils.ts          | 3 ---
 src/SearchStrategies/search/wildcardSearch.ts | 6 ------
 src/Templater.ts                              | 5 -----
 src/utils/highlightMiddleware.ts              | 5 -----
 tests/Repository.test.ts                      | 1 -
 tests/highlightMiddleware.test.ts             | 8 --------
 10 files changed, 43 deletions(-)

diff --git a/src/Repository.ts b/src/Repository.ts
index 9b9d87c..847d3de 100644
--- a/src/Repository.ts
+++ b/src/Repository.ts
@@ -80,7 +80,6 @@ export class Repository {
     for (const key in obj) {
       if (!this.isExcluded(obj[key]) && this.options.searchStrategy.matches(obj[key], criteria)) {
         hasMatch = true;
-        // Get match information for all matching fields
         const matchInfo = this.options.searchStrategy.findMatches?.(obj[key], criteria);
         if (matchInfo && matchInfo.length > 0) {
           result._matchInfo[key] = matchInfo;
diff --git a/src/SearchStrategies/SearchStrategy.ts b/src/SearchStrategies/SearchStrategy.ts
index 1d129fc..6de7224 100644
--- a/src/SearchStrategies/SearchStrategy.ts
+++ b/src/SearchStrategies/SearchStrategy.ts
@@ -15,7 +15,6 @@ export const LiteralSearchStrategy = new SearchStrategy(
 
 export const FuzzySearchStrategy = new SearchStrategy(
   (text: string, criteria: string) => {
-    // Original fuzzy search logic
     const pattern = criteria.trimEnd();
     if (pattern.length === 0) return true;
 
@@ -28,7 +27,6 @@ export const FuzzySearchStrategy = new SearchStrategy(
       const nextIndex = remainingText.indexOf(char);
 
       if (nextIndex === -1 || (currentIndex !== -1 && remainingText.slice(0, nextIndex).split(' ').length - 1 > 2)) {
-        // Fall back to literal search
         const lowerText2 = text.trim().toLowerCase();
         const pattern2 = criteria.endsWith(' ') ? [criteria.toLowerCase()] : criteria.trim().toLowerCase().split(' ');
         return pattern2.filter((word: string) => lowerText2.indexOf(word) >= 0).length === pattern2.length;
@@ -41,7 +39,6 @@ export const FuzzySearchStrategy = new SearchStrategy(
     return true;
   },
   (text: string, criteria: string) => {
-    // Try fuzzy matches first, then fall back to literal matches
     const fuzzyMatches = findFuzzyMatches(text, criteria);
     if (fuzzyMatches.length > 0) {
       return fuzzyMatches;
@@ -52,12 +49,10 @@ export const FuzzySearchStrategy = new SearchStrategy(
 
 export const WildcardSearchStrategy = new SearchStrategy(
   (text: string, criteria: string) => {
-    // Use findWildcardMatches to check if there are any matches
     const wildcardMatches = findWildcardMatches(text, criteria);
     return wildcardMatches.length > 0;
   },
   (text: string, criteria: string) => {
-    // Try wildcard matches first, then fall back to literal matches
     const wildcardMatches = findWildcardMatches(text, criteria);
     if (wildcardMatches.length > 0) {
       return wildcardMatches;
diff --git a/src/SearchStrategies/search/fuzzySearch.ts b/src/SearchStrategies/search/fuzzySearch.ts
index a63eb20..b4ea960 100644
--- a/src/SearchStrategies/search/fuzzySearch.ts
+++ b/src/SearchStrategies/search/fuzzySearch.ts
@@ -15,14 +15,10 @@ export function findFuzzyMatches(text: string, pattern: string): MatchInfo[] {
   
   if (lowerPattern.length === 0) return [];
   
-  // Use the original fuzzy search logic for all patterns
   const matches: MatchInfo[] = [];
-  
-  // Try to find fuzzy matches starting from each position
   for (let i = 0; i < lowerText.length; i++) {
     const match = findFuzzySequenceMatch(lowerText, lowerPattern, i);
     if (match) {
-      // Check if this is an exact match
       const isExact = match.text === lowerPattern;
       
       matches.push({
@@ -31,7 +27,6 @@ export function findFuzzyMatches(text: string, pattern: string): MatchInfo[] {
         text: text.substring(match.start, match.end),
         type: isExact ? 'exact' : 'fuzzy'
       });
-      // Skip ahead to avoid overlapping matches
       i = match.end - 1;
     }
   }
@@ -44,7 +39,6 @@ export function findFuzzyMatches(text: string, pattern: string): MatchInfo[] {
  * Finds a fuzzy sequence match starting from a given position
  */
 function findFuzzySequenceMatch(text: string, pattern: string, startPos: number): { start: number; end: number; text: string } | null {
-  // Implementation based on the original fuzzySearch function
   let textIndex = startPos;
   let patternIndex = 0;
   let matchStart = -1;
@@ -57,7 +51,6 @@ function findFuzzySequenceMatch(text: string, pattern: string, startPos: number)
       }
       patternIndex++;
     } else if (matchStart !== -1) {
-      // Check if we've exceeded the maximum gap
       const gap = textIndex - matchStart;
       if (gap > maxGap) {
         return null;
diff --git a/src/SearchStrategies/search/literalSearch.ts b/src/SearchStrategies/search/literalSearch.ts
index bca5a78..f3cd76c 100644
--- a/src/SearchStrategies/search/literalSearch.ts
+++ b/src/SearchStrategies/search/literalSearch.ts
@@ -21,12 +21,10 @@ export function findLiteralMatches(text: string, criteria: string): MatchInfo[]
     
     let wordIndex = lowerText.indexOf(word, textIndex);
     
-    // If this is the last word and criteria has trailing space, ensure it's a complete word
     if (hasTrailingSpace && word === words[words.length - 1]) {
       while (wordIndex !== -1) {
         const nextChar = lowerText[wordIndex + word.length];
         if (!nextChar || !/\w/.test(nextChar)) {
-          // Found complete word match
           break;
         }
         wordIndex = lowerText.indexOf(word, wordIndex + 1);
diff --git a/src/SearchStrategies/search/utils.ts b/src/SearchStrategies/search/utils.ts
index 37d8e1f..f04fffb 100644
--- a/src/SearchStrategies/search/utils.ts
+++ b/src/SearchStrategies/search/utils.ts
@@ -6,14 +6,11 @@ import { MatchInfo } from '../types';
 export function mergeAndSortMatches(matches: MatchInfo[]): MatchInfo[] {
   if (matches.length === 0) return [];
   
-  // Sort matches by start position
   const sortedMatches = matches.sort((a, b) => a.start - b.start);
   const merged: MatchInfo[] = [];
   
   for (const match of sortedMatches) {
     const lastMerged = merged[merged.length - 1];
-    
-    // If this match overlaps with the last merged match, extend it
     if (lastMerged && match.start <= lastMerged.end) {
       lastMerged.end = Math.max(lastMerged.end, match.end);
       lastMerged.text = lastMerged.text + match.text.slice(lastMerged.end - match.start);
diff --git a/src/SearchStrategies/search/wildcardSearch.ts b/src/SearchStrategies/search/wildcardSearch.ts
index 3b7b4df..fed5ede 100644
--- a/src/SearchStrategies/search/wildcardSearch.ts
+++ b/src/SearchStrategies/search/wildcardSearch.ts
@@ -12,14 +12,10 @@ import { mergeAndSortMatches } from './utils';
 export function findWildcardMatches(text: string, pattern: string): MatchInfo[] {
   if (!text || !pattern) return [];
   
-  // Try wildcard matching first
   const wildcardMatches = findWildcardPatternMatches(text, pattern);
   if (wildcardMatches.length > 0) {
     return mergeAndSortMatches(wildcardMatches);
   }
-  
-  // Fall back to levenshtein matching for fuzzy search
-  // This matches the original wildcardSearch behavior - full string matching
   if (levenshteinSearch(text, pattern)) {
     return [{
       start: 0,
@@ -43,7 +39,6 @@ function findWildcardPatternMatches(text: string, pattern: string): MatchInfo[]
   let lastIndex = 0;
   
   while ((match = regex.exec(text)) !== null) {
-    // Prevent infinite loop by checking if we're at the same position
     if (match.index === lastIndex && match[0].length === 0) {
       break;
     }
@@ -56,7 +51,6 @@ function findWildcardPatternMatches(text: string, pattern: string): MatchInfo[]
       type: 'wildcard'
     });
     
-    // If the match is the entire string, break to prevent infinite loop
     if (match[0].length === text.length) {
       break;
     }
diff --git a/src/Templater.ts b/src/Templater.ts
index 316af1c..fadbe02 100644
--- a/src/Templater.ts
+++ b/src/Templater.ts
@@ -30,20 +30,15 @@ export function setOptions(_options: TemplaterOptions): void {
 
 export function compile(data: Data, query?: string): string {
   return options.template.replace(options.pattern, function(match: string, prop: string) {
-    // Check if middleware supports matchInfo parameter and we have match info for this property
     if (data._matchInfo && data._matchInfo[prop] && data._matchInfo[prop].length > 0) {
-      // Try calling with matchInfo parameter first
       try {
         const value = (options.middleware as any)(prop, data[prop], options.template, query, data._matchInfo[prop]);
         if (typeof value !== 'undefined') {
           return value;
         }
       } catch (_e) {
-        // If the middleware doesn't support 5 parameters, fall back to 4
       }
     }
-    
-    // Fallback to current behavior (4 parameters)
     const value = options.middleware(prop, data[prop], options.template, query);
     if (typeof value !== 'undefined') {
       return value;
diff --git a/src/utils/highlightMiddleware.ts b/src/utils/highlightMiddleware.ts
index 9704a8c..2679a2c 100644
--- a/src/utils/highlightMiddleware.ts
+++ b/src/utils/highlightMiddleware.ts
@@ -296,7 +296,6 @@ function findFuzzySequenceMatch(text: string, pattern: string, startPos: number)
 function highlightWithMatchInfo(text: string, matchInfo: MatchInfo[], options: Required<HighlightOptions>): string {
   if (matchInfo.length === 0) return text;
   
-  // Sort matches by position (reverse order to avoid index shifting)
   const sortedMatches = [...matchInfo].sort((a, b) => b.start - a.start);
   
   let highlightedText = text;
@@ -361,14 +360,10 @@ export function createHighlightTemplateMiddleware(options: HighlightOptions = {}
 
   return function(prop: string, value: string, _template: string, query?: string, matchInfo?: MatchInfo[]): string | undefined {
     if ((prop === 'content' || prop === 'desc') && query && typeof value === 'string') {
-      // Use provided match info if available (faster, more accurate - NO DUPLICATE SEARCH)
       if (matchInfo && matchInfo.length > 0) {
         const highlighted = highlightWithMatchInfo(value, matchInfo, highlightOptions);
         return highlighted !== value ? highlighted : undefined;
       }
-      
-      // Only fallback to query-based search if match info is not available
-      // This should rarely happen in the new architecture
       const highlighted = highlightWithQuery(value, query, highlightOptions);
       return highlighted !== value ? highlighted : undefined;
     }
diff --git a/tests/Repository.test.ts b/tests/Repository.test.ts
index 7807094..8d48010 100644
--- a/tests/Repository.test.ts
+++ b/tests/Repository.test.ts
@@ -17,7 +17,6 @@ const loremElement: TestElement = { title: 'lorem', content: 'lorem ipsum' };
 
 const data: TestElement[] = [barElement, almostBarElement, loremElement];
 
-// Helper function to strip _matchInfo for backward compatibility testing
 function stripMatchInfo(results: any[]): any[] {
   return results.map(result => {
     const { _matchInfo, ...cleanResult } = result;
diff --git a/tests/highlightMiddleware.test.ts b/tests/highlightMiddleware.test.ts
index ea9080e..b5ea99a 100644
--- a/tests/highlightMiddleware.test.ts
+++ b/tests/highlightMiddleware.test.ts
@@ -581,8 +581,6 @@ describe('createHighlightTemplateMiddleware', () => {
       const text = 'This is a test content with test words';
       const query = 'test';
       
-      // Simulate match info that would be provided by Repository
-      // Find actual positions of 'test' in the text
       const matchInfo = [];
       let index = text.toLowerCase().indexOf('test');
       while (index !== -1) {
@@ -595,19 +593,15 @@ describe('createHighlightTemplateMiddleware', () => {
         index = text.toLowerCase().indexOf('test', index + 1);
       }
       
-      // Call with match info (should use highlightWithMatchInfo)
       const resultWithMatchInfo = middleware('content', text, '<div>{content}</div>', query, matchInfo);
       
-      // Call without match info (should use highlightWithQuery)
       const resultWithoutMatchInfo = middleware('content', text, '<div>{content}</div>', query);
       
-      // Both should produce the same result, but with match info it should be faster
       expect(resultWithMatchInfo).toBeDefined();
       expect(resultWithoutMatchInfo).toBeDefined();
       expect(resultWithMatchInfo).toContain('<span class="sjs-highlight">test</span>');
       expect(resultWithoutMatchInfo).toContain('<span class="sjs-highlight">test</span>');
       
-      // The key test: both results should be identical
       expect(resultWithMatchInfo).toBe(resultWithoutMatchInfo);
     });
 
@@ -616,7 +610,6 @@ describe('createHighlightTemplateMiddleware', () => {
       const text = 'This is a test content';
       const query = 'test';
       
-      // Call with empty match info (should fallback to query-based search)
       const result = middleware('content', text, '<div>{content}</div>', query, []);
       
       expect(result).toBeDefined();
@@ -628,7 +621,6 @@ describe('createHighlightTemplateMiddleware', () => {
       const text = 'This is a test content';
       const query = 'test';
       
-      // Call without match info (should use query-based search)
       const result = middleware('content', text, '<div>{content}</div>', query, undefined);
       
       expect(result).toBeDefined();

From 24329236322f234b8fbb6a23f8cb24d945b2e7b5 Mon Sep 17 00:00:00 2001
From: sylhare <sylhare@outlook.com>
Date: Fri, 10 Oct 2025 11:58:51 -0400
Subject: [PATCH 09/10] Remove fallback

---
 README.md                              |  63 +---
 dest/simple-jekyll-search.js           | 333 ++++++-------------
 dest/simple-jekyll-search.min.js       |   2 +-
 src/Repository.ts                      |   2 +-
 src/SearchStrategies/SearchStrategy.ts |  16 +-
 src/SearchStrategies/types.ts          |  10 +-
 src/Templater.ts                       |  14 +-
 src/utils/highlightMiddleware.ts       | 127 -------
 tests/highlightMiddleware.test.ts      | 439 +++++++------------------
 9 files changed, 230 insertions(+), 776 deletions(-)

diff --git a/README.md b/README.md
index 50b0e3b..5e419a5 100644
--- a/README.md
+++ b/README.md
@@ -97,24 +97,24 @@ Here is a table for the available options, usage questions, troubleshooting & gu
 | `success`              | Function       | No       | A function called once the data has been loaded.                                                                                                                                   |
 | `debounceTime`         | Number         | No       | Limit how many times the search function can be executed over the given time window. If no `debounceTime` (milliseconds) is provided a search will be triggered on each keystroke. |
 | `searchResultTemplate` | String         | No       | The template of a single rendered search result. (match liquid value eg: `'<li><a href="{{ site.url }}{url}">{title}</a></li>'`                                                    |
-| `templateMiddleware`   | Function       | No       | A function that processes template placeholders and can include highlighting functionality. The function receives (prop, value, template, query) parameters. |
+| `templateMiddleware`   | Function       | No       | A function that processes template placeholders and can include highlighting functionality. The function receives (prop, value, template, query, matchInfo) parameters. |
 
 ## Middleware
 
 ### templateMiddleware (Function) [optional]
 
 A function that will be called whenever a match in the template is found.
-It gets passed the current property name, property value, and the template.
+It gets passed the current property name, property value, template, query, and matchInfo.
 If the function returns a non-undefined value, it gets replaced in the template.
 
-This can be potentially useful for manipulating URLs etc.
+This can be potentially useful for manipulating URLs or adding highlighting.
 
 Example:
 
 ```js
 SimpleJekyllSearch({
   // ...other config
-  templateMiddleware: function(prop, value, template) {
+  templateMiddleware: function(prop, value, template, query, matchInfo) {
     if (prop === 'bar') {
       return value.replace(/^\//, '')
     }
@@ -141,17 +141,9 @@ SimpleJekyllSearch({
 })
 ```
 
-### templateMiddleware with Highlighting (Function) [optional]
+### Highlighting Search Results
 
-The `templateMiddleware` function now supports highlighting functionality. It processes template placeholders and can add HTML highlighting to search results.
-
-The function receives four parameters:
-- `prop`: The property name being processed (e.g., 'title', 'content', 'desc')
-- `value`: The value of the property
-- `template`: The full template string
-- `query`: The search query (optional)
-
-Example with built-in highlight template middleware:
+The library includes built-in highlighting functionality through the `createHighlightTemplateMiddleware` function.
 
 ```js
 import { createHighlightTemplateMiddleware } from 'simple-jekyll-search';
@@ -159,7 +151,7 @@ import { createHighlightTemplateMiddleware } from 'simple-jekyll-search';
 SimpleJekyllSearch({
   // ...other config
   templateMiddleware: createHighlightTemplateMiddleware({
-    highlightClass: 'my-highlight',  // Custom CSS class
+    highlightClass: 'highlight',     // CSS class for highlighted text
     contextBefore: 30,               // Characters before match
     contextAfter: 30,                // Characters after match
     maxLength: 200,                  // Maximum total length
@@ -168,43 +160,4 @@ SimpleJekyllSearch({
 })
 ```
 
-You can also create a custom template middleware with highlighting:
-
-```js
-SimpleJekyllSearch({
-  // ...other config
-  templateMiddleware: function(prop, value, template, query) {
-    // Only highlight content and desc fields
-    if ((prop === 'content' || prop === 'desc') && query && typeof value === 'string') {
-      return value.replace(
-        new RegExp(`(${query})`, 'gi'),
-        '<span class="highlight">$1</span>'
-      );
-    }
-    return undefined; // Use default value for other properties
-  },
-})
-```
-
-The template middleware should return a string to replace the placeholder, or `undefined` to use the default value.
-
-#### Search Strategy Compatibility
-
-The highlight template middleware works with all search strategies:
-
-- **Literal Search**: Highlights exact word matches
-- **Wildcard Search**: Highlights exact matches (supports regex patterns)
-- **Fuzzy Search**: Highlights both exact matches and fuzzy matches (e.g., "test" matches "tst", "testing")
-
-The middleware intelligently handles different search types:
-1. First tries exact word matching (for literal and wildcard searches)
-2. Falls back to fuzzy matching if no exact matches found
-3. Prefers exact matches over fuzzy matches when both are available
-
-Example with fuzzy search:
-```js
-// Searching for "test" will highlight:
-// - "test" (exact match)
-// - "testing" (fuzzy match - highlights "test" part)
-// - "tst" (fuzzy match - highlights "tst")
-```
+The highlight middleware works with all search strategies and uses match information provided by the search engine for accurate highlighting.
diff --git a/dest/simple-jekyll-search.js b/dest/simple-jekyll-search.js
index f3f6ada..aa03367 100644
--- a/dest/simple-jekyll-search.js
+++ b/dest/simple-jekyll-search.js
@@ -48,119 +48,74 @@
       return typeof params.required !== "undefined" && Array.isArray(params.required);
     }
   }
-  function fuzzySearch(text, pattern) {
-    pattern = pattern.trimEnd();
-    if (pattern.length === 0) return true;
-    pattern = pattern.toLowerCase();
-    text = text.toLowerCase();
-    let remainingText = text, currentIndex = -1;
-    for (const char of pattern) {
-      const nextIndex = remainingText.indexOf(char);
-      if (nextIndex === -1 || currentIndex !== -1 && remainingText.slice(0, nextIndex).split(" ").length - 1 > 2) {
-        return false;
-      }
-      currentIndex = nextIndex;
-      remainingText = remainingText.slice(nextIndex + 1);
-    }
-    return true;
-  }
-  function findFuzzyMatches$1(text, pattern) {
+  function findFuzzyMatches(text, pattern) {
     if (!text || !pattern) return [];
     const lowerText = text.toLowerCase();
     const lowerPattern = pattern.toLowerCase().trim();
     if (lowerPattern.length === 0) return [];
-    const patternWords = lowerPattern.split(/\s+/);
     const matches = [];
-    for (const word of patternWords) {
-      if (word.length === 0) continue;
-      const wordMatches = findFuzzyWordMatches$1(lowerText, word);
-      matches.push(...wordMatches);
-    }
-    return mergeAndSortMatches$1(matches);
-  }
-  function findFuzzyWordMatches$1(text, word) {
-    const matches = [];
-    const exactRegex = new RegExp(`\\b${word.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}\\b`, "gi");
-    let match;
-    while ((match = exactRegex.exec(text)) !== null) {
-      matches.push({
-        start: match.index,
-        end: match.index + match[0].length,
-        text: match[0],
-        type: "exact"
-      });
-    }
-    if (matches.length === 0) {
-      for (let i = 0; i < text.length; i++) {
-        const fuzzyMatch = findFuzzySequenceMatch$1(text, word, i);
-        if (fuzzyMatch) {
-          matches.push({ ...fuzzyMatch, type: "fuzzy" });
-          i = fuzzyMatch.end - 1;
-        }
+    for (let i = 0; i < lowerText.length; i++) {
+      const match = findFuzzySequenceMatch(lowerText, lowerPattern, i);
+      if (match) {
+        const isExact = match.text === lowerPattern;
+        matches.push({
+          start: match.start,
+          end: match.end,
+          text: text.substring(match.start, match.end),
+          type: isExact ? "exact" : "fuzzy"
+        });
+        i = match.end - 1;
       }
     }
     return matches;
   }
-  function findFuzzySequenceMatch$1(text, pattern, startPos) {
+  function findFuzzySequenceMatch(text, pattern, startPos) {
     let textIndex = startPos;
     let patternIndex = 0;
     let matchStart = -1;
-    let maxGap = 3;
-    const matchedPositions = [];
+    let maxGap = 10;
     while (textIndex < text.length && patternIndex < pattern.length) {
       if (text[textIndex] === pattern[patternIndex]) {
         if (matchStart === -1) {
           matchStart = textIndex;
         }
-        matchedPositions.push(textIndex);
         patternIndex++;
       } else if (matchStart !== -1) {
-        if (textIndex - matchStart > maxGap * pattern.length) {
+        const gap = textIndex - matchStart;
+        if (gap > maxGap) {
           return null;
         }
       }
       textIndex++;
     }
-    if (patternIndex === pattern.length && matchStart !== -1 && matchedPositions.length > 0) {
-      const actualStart = matchedPositions[0];
-      const actualEnd = matchedPositions[matchedPositions.length - 1] + 1;
+    if (patternIndex === pattern.length && matchStart !== -1) {
       return {
-        start: actualStart,
-        end: actualEnd,
-        text: text.substring(actualStart, actualEnd)
+        start: matchStart,
+        end: textIndex,
+        text: text.substring(matchStart, textIndex)
       };
     }
     return null;
   }
-  function mergeAndSortMatches$1(matches) {
-    if (matches.length === 0) return [];
-    const sortedMatches = matches.sort((a, b) => a.start - b.start);
-    const merged = [];
-    for (const match of sortedMatches) {
-      const lastMerged = merged[merged.length - 1];
-      if (lastMerged && match.start <= lastMerged.end) {
-        lastMerged.end = Math.max(lastMerged.end, match.end);
-        lastMerged.text = lastMerged.text + match.text.slice(lastMerged.end - match.start);
-      } else {
-        merged.push({ ...match });
-      }
-    }
-    return merged;
-  }
-  function literalSearch(text, criteria) {
-    text = text.trim().toLowerCase();
-    const pattern = criteria.endsWith(" ") ? [criteria.toLowerCase()] : criteria.trim().toLowerCase().split(" ");
-    return pattern.filter((word) => text.indexOf(word) >= 0).length === pattern.length;
-  }
   function findLiteralMatches(text, criteria) {
     if (!text || !criteria) return [];
     const lowerText = text.toLowerCase();
+    const hasTrailingSpace = criteria.endsWith(" ");
     const words = criteria.trim().toLowerCase().split(/\s+/);
     const matches = [];
     let textIndex = 0;
     for (const word of words) {
       if (word.length === 0) continue;
-      const wordIndex = lowerText.indexOf(word, textIndex);
+      let wordIndex = lowerText.indexOf(word, textIndex);
+      if (hasTrailingSpace && word === words[words.length - 1]) {
+        while (wordIndex !== -1) {
+          const nextChar = lowerText[wordIndex + word.length];
+          if (!nextChar || !/\w/.test(nextChar)) {
+            break;
+          }
+          wordIndex = lowerText.indexOf(word, wordIndex + 1);
+        }
+      }
       if (wordIndex !== -1) {
         matches.push({
           start: wordIndex,
@@ -196,29 +151,20 @@
     const similarity = 1 - distance / Math.max(pattern.length, text.length);
     return similarity >= 0.3;
   }
-  function findLevenshteinMatches(text, pattern) {
-    if (!text || !pattern) return [];
-    const matches = [];
-    const words = text.split(/\s+/);
-    for (let i = 0; i < words.length; i++) {
-      const word = words[i];
-      if (levenshteinSearch(word, pattern)) {
-        const start = text.indexOf(word);
-        matches.push({
-          start,
-          end: start + word.length,
-          text: word,
-          type: "wildcard"
-        });
+  function mergeAndSortMatches(matches) {
+    if (matches.length === 0) return [];
+    const sortedMatches = matches.sort((a, b) => a.start - b.start);
+    const merged = [];
+    for (const match of sortedMatches) {
+      const lastMerged = merged[merged.length - 1];
+      if (lastMerged && match.start <= lastMerged.end) {
+        lastMerged.end = Math.max(lastMerged.end, match.end);
+        lastMerged.text = lastMerged.text + match.text.slice(lastMerged.end - match.start);
+      } else {
+        merged.push({ ...match });
       }
     }
-    return matches;
-  }
-  function wildcardSearch(text, pattern) {
-    const regexPattern = pattern.replace(/\*/g, ".*");
-    const regex = new RegExp(`^${regexPattern}$`, "i");
-    if (regex.test(text)) return true;
-    return levenshteinSearch(text, pattern);
+    return merged;
   }
   function findWildcardMatches(text, pattern) {
     if (!text || !pattern) return [];
@@ -226,38 +172,38 @@
     if (wildcardMatches.length > 0) {
       return mergeAndSortMatches(wildcardMatches);
     }
-    const levenshteinMatches = findLevenshteinMatches(text, pattern);
-    return mergeAndSortMatches(levenshteinMatches);
+    if (levenshteinSearch(text, pattern)) {
+      return [{
+        start: 0,
+        end: text.length,
+        text,
+        type: "wildcard"
+      }];
+    }
+    return [];
   }
   function findWildcardPatternMatches(text, pattern) {
     const matches = [];
     const regexPattern = pattern.replace(/\*/g, ".*");
     const regex = new RegExp(regexPattern, "gi");
     let match;
+    let lastIndex = 0;
     while ((match = regex.exec(text)) !== null) {
+      if (match.index === lastIndex && match[0].length === 0) {
+        break;
+      }
+      lastIndex = match.index;
       matches.push({
         start: match.index,
         end: match.index + match[0].length,
         text: match[0],
         type: "wildcard"
       });
-    }
-    return matches;
-  }
-  function mergeAndSortMatches(matches) {
-    if (matches.length === 0) return [];
-    const sortedMatches = matches.sort((a, b) => a.start - b.start);
-    const merged = [];
-    for (const match of sortedMatches) {
-      const lastMerged = merged[merged.length - 1];
-      if (lastMerged && match.start <= lastMerged.end) {
-        lastMerged.end = Math.max(lastMerged.end, match.end);
-        lastMerged.text = lastMerged.text + match.text.slice(lastMerged.end - match.start);
-      } else {
-        merged.push({ ...match });
+      if (match[0].length === text.length) {
+        break;
       }
     }
-    return merged;
+    return matches;
   }
   class SearchStrategy {
     constructor(matchFunction, findMatchesFunction) {
@@ -271,36 +217,48 @@
       return this.matchFunction(text, criteria);
     }
     findMatches(text, criteria) {
-      if (text === null || text.trim() === "" || !criteria || !this.findMatchesFunction) {
+      if (text === null || text.trim() === "" || !criteria) {
         return [];
       }
       return this.findMatchesFunction(text, criteria);
     }
   }
-  const LiteralSearchStrategy = new SearchStrategy(literalSearch, findLiteralMatches);
-  const FuzzySearchStrategy = new SearchStrategy(
+  const LiteralSearchStrategy = new SearchStrategy(
     (text, criteria) => {
-      return fuzzySearch(text, criteria) || literalSearch(text, criteria);
+      if (!text || !criteria) return false;
+      const lowerText = text.trim().toLowerCase();
+      const pattern = criteria.endsWith(" ") ? [criteria.toLowerCase()] : criteria.trim().toLowerCase().split(" ");
+      return pattern.filter((word) => lowerText.indexOf(word) >= 0).length === pattern.length;
     },
+    findLiteralMatches
+  );
+  const FuzzySearchStrategy = new SearchStrategy(
     (text, criteria) => {
-      const fuzzyMatches = findFuzzyMatches$1(text, criteria);
-      if (fuzzyMatches.length > 0) {
-        return fuzzyMatches;
+      const pattern = criteria.trimEnd();
+      if (pattern.length === 0) return true;
+      const lowerPattern = pattern.toLowerCase();
+      const lowerText = text.toLowerCase();
+      let remainingText = lowerText, currentIndex = -1;
+      for (const char of lowerPattern) {
+        const nextIndex = remainingText.indexOf(char);
+        if (nextIndex === -1 || currentIndex !== -1 && remainingText.slice(0, nextIndex).split(" ").length - 1 > 2) {
+          const lowerText2 = text.trim().toLowerCase();
+          const pattern2 = criteria.endsWith(" ") ? [criteria.toLowerCase()] : criteria.trim().toLowerCase().split(" ");
+          return pattern2.filter((word) => lowerText2.indexOf(word) >= 0).length === pattern2.length;
+        }
+        currentIndex = nextIndex;
+        remainingText = remainingText.slice(nextIndex + 1);
       }
-      return findLiteralMatches(text, criteria);
-    }
+      return true;
+    },
+    findFuzzyMatches
   );
   const WildcardSearchStrategy = new SearchStrategy(
-    (text, criteria) => {
-      return wildcardSearch(text, criteria) || literalSearch(text, criteria);
-    },
     (text, criteria) => {
       const wildcardMatches = findWildcardMatches(text, criteria);
-      if (wildcardMatches.length > 0) {
-        return wildcardMatches;
-      }
-      return findLiteralMatches(text, criteria);
-    }
+      return wildcardMatches.length > 0;
+    },
+    findWildcardMatches
   );
   function merge(target, source) {
     return { ...target, ...source };
@@ -421,14 +379,13 @@
       return matches;
     }
     findMatchesInObject(obj, criteria) {
-      var _a, _b;
       let hasMatch = false;
       const result = { ...obj };
       result._matchInfo = {};
       for (const key in obj) {
         if (!this.isExcluded(obj[key]) && this.options.searchStrategy.matches(obj[key], criteria)) {
           hasMatch = true;
-          const matchInfo = (_b = (_a = this.options.searchStrategy).findMatches) == null ? void 0 : _b.call(_a, obj[key], criteria);
+          const matchInfo = this.options.searchStrategy.findMatches(obj[key], criteria);
           if (matchInfo && matchInfo.length > 0) {
             result._matchInfo[key] = matchInfo;
           }
@@ -475,16 +432,8 @@
   }
   function compile(data, query) {
     return options.template.replace(options.pattern, function(match, prop) {
-      if (data._matchInfo && data._matchInfo[prop] && data._matchInfo[prop].length > 0) {
-        try {
-          const value2 = options.middleware(prop, data[prop], options.template, query, data._matchInfo[prop]);
-          if (typeof value2 !== "undefined") {
-            return value2;
-          }
-        } catch (_e) {
-        }
-      }
-      const value = options.middleware(prop, data[prop], options.template, query);
+      const matchInfo = data._matchInfo && data._matchInfo[prop] ? data._matchInfo[prop] : void 0;
+      const value = options.middleware(prop, data[prop], options.template, query, matchInfo);
       if (typeof value !== "undefined") {
         return value;
       }
@@ -714,72 +663,6 @@
     };
   }
   const defaultHighlightMiddleware = createHighlightMiddleware();
-  function findFuzzyMatches(text, pattern) {
-    const matches = [];
-    const lowerText = text.toLowerCase();
-    const lowerPattern = pattern.toLowerCase().trim();
-    if (lowerPattern.length === 0) return matches;
-    const patternWords = lowerPattern.split(/\s+/);
-    for (const word of patternWords) {
-      if (word.length === 0) continue;
-      const wordMatches = findFuzzyWordMatches(lowerText, word);
-      matches.push(...wordMatches);
-    }
-    return matches;
-  }
-  function findFuzzyWordMatches(text, word) {
-    const matches = [];
-    const exactRegex = new RegExp(`\\b${word.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}\\b`, "gi");
-    let match;
-    while ((match = exactRegex.exec(text)) !== null) {
-      matches.push({
-        start: match.index,
-        end: match.index + match[0].length,
-        text: match[0]
-      });
-    }
-    if (matches.length === 0) {
-      for (let i = 0; i < text.length; i++) {
-        const fuzzyMatch = findFuzzySequenceMatch(text, word, i);
-        if (fuzzyMatch) {
-          matches.push(fuzzyMatch);
-          i = fuzzyMatch.end - 1;
-        }
-      }
-    }
-    return matches;
-  }
-  function findFuzzySequenceMatch(text, pattern, startPos) {
-    let textIndex = startPos;
-    let patternIndex = 0;
-    let matchStart = -1;
-    let maxGap = 3;
-    const matchedPositions = [];
-    while (textIndex < text.length && patternIndex < pattern.length) {
-      if (text[textIndex] === pattern[patternIndex]) {
-        if (matchStart === -1) {
-          matchStart = textIndex;
-        }
-        matchedPositions.push(textIndex);
-        patternIndex++;
-      } else if (matchStart !== -1) {
-        if (textIndex - matchStart > maxGap * pattern.length) {
-          return null;
-        }
-      }
-      textIndex++;
-    }
-    if (patternIndex === pattern.length && matchStart !== -1 && matchedPositions.length > 0) {
-      const actualStart = matchedPositions[0];
-      const actualEnd = matchedPositions[matchedPositions.length - 1] + 1;
-      return {
-        start: actualStart,
-        end: actualEnd,
-        text: text.substring(actualStart, actualEnd)
-      };
-    }
-    return null;
-  }
   function highlightWithMatchInfo(text, matchInfo, options2) {
     if (matchInfo.length === 0) return text;
     const sortedMatches = [...matchInfo].sort((a, b) => b.start - a.start);
@@ -792,32 +675,6 @@
     }
     return highlightedText;
   }
-  function highlightWithQuery(text, query, options2) {
-    let highlightedText = text;
-    let hasMatches = false;
-    const searchTerms = query.trim().split(/\s+/).filter((term) => term.length > 0);
-    for (const term of searchTerms) {
-      const regex = new RegExp(`\\b(${term.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")})\\b`, "gi");
-      if (regex.test(highlightedText)) {
-        highlightedText = highlightedText.replace(regex, `<span class="${options2.highlightClass}">$1</span>`);
-        hasMatches = true;
-      }
-    }
-    if (!hasMatches) {
-      const fuzzyMatches = findFuzzyMatches(text, query);
-      if (fuzzyMatches.length > 0) {
-        fuzzyMatches.sort((a, b) => b.start - a.start);
-        for (const match of fuzzyMatches) {
-          const before = highlightedText.substring(0, match.start);
-          const after = highlightedText.substring(match.end);
-          const matchText = highlightedText.substring(match.start, match.end);
-          highlightedText = before + `<span class="${options2.highlightClass}">${matchText}</span>` + after;
-        }
-        hasMatches = true;
-      }
-    }
-    return highlightedText;
-  }
   function createHighlightTemplateMiddleware(options2 = {}) {
     const highlightOptions = {
       highlightClass: "sjs-highlight",
@@ -826,11 +683,9 @@
     return function(prop, value, _template, query, matchInfo) {
       if ((prop === "content" || prop === "desc") && query && typeof value === "string") {
         if (matchInfo && matchInfo.length > 0) {
-          const highlighted2 = highlightWithMatchInfo(value, matchInfo, highlightOptions);
-          return highlighted2 !== value ? highlighted2 : void 0;
+          const highlighted = highlightWithMatchInfo(value, matchInfo, highlightOptions);
+          return highlighted !== value ? highlighted : void 0;
         }
-        const highlighted = highlightWithQuery(value, query, highlightOptions);
-        return highlighted !== value ? highlighted : void 0;
       }
       return void 0;
     };
diff --git a/dest/simple-jekyll-search.min.js b/dest/simple-jekyll-search.min.js
index 7b0ff2d..5856dbb 100644
--- a/dest/simple-jekyll-search.min.js
+++ b/dest/simple-jekyll-search.min.js
@@ -4,4 +4,4 @@
   * Copyright 2025-2025, Sylhare
   * Licensed under the MIT License.
   */
-(function(global,factory){typeof exports==="object"&&typeof module!=="undefined"?factory(exports):typeof define==="function"&&define.amd?define(["exports"],factory):(global=typeof globalThis!=="undefined"?globalThis:global||self,factory(global.SimpleJekyllSearch={}))})(this,(function(exports2){"use strict";function load(location,callback){const xhr=getXHR();xhr.open("GET",location,true);xhr.onreadystatechange=createStateChangeListener(xhr,callback);xhr.send()}function createStateChangeListener(xhr,callback){return function(){if(xhr.readyState===4&&xhr.status===200){try{callback(null,JSON.parse(xhr.responseText))}catch(err){callback(err instanceof Error?err:new Error(String(err)),null)}}}}function getXHR(){return window.XMLHttpRequest?new window.XMLHttpRequest:new window.ActiveXObject("Microsoft.XMLHTTP")}class OptionsValidator{constructor(params){if(!this.validateParams(params)){throw new Error("-- OptionsValidator: required options missing")}this.requiredOptions=params.required}getRequiredOptions(){return this.requiredOptions}validate(parameters){const errors=[];this.requiredOptions.forEach((requiredOptionName=>{if(typeof parameters[requiredOptionName]==="undefined"){errors.push(requiredOptionName)}}));return errors}validateParams(params){if(!params){return false}return typeof params.required!=="undefined"&&Array.isArray(params.required)}}function fuzzySearch(text,pattern){pattern=pattern.trimEnd();if(pattern.length===0)return true;pattern=pattern.toLowerCase();text=text.toLowerCase();let remainingText=text,currentIndex=-1;for(const char of pattern){const nextIndex=remainingText.indexOf(char);if(nextIndex===-1||currentIndex!==-1&&remainingText.slice(0,nextIndex).split(" ").length-1>2){return false}currentIndex=nextIndex;remainingText=remainingText.slice(nextIndex+1)}return true}function findFuzzyMatches$1(text,pattern){if(!text||!pattern)return[];const lowerText=text.toLowerCase();const lowerPattern=pattern.toLowerCase().trim();if(lowerPattern.length===0)return[];const patternWords=lowerPattern.split(/\s+/);const matches=[];for(const word of patternWords){if(word.length===0)continue;const wordMatches=findFuzzyWordMatches$1(lowerText,word);matches.push(...wordMatches)}return mergeAndSortMatches$1(matches)}function findFuzzyWordMatches$1(text,word){const matches=[];const exactRegex=new RegExp(`\\b${word.replace(/[.*+?^${}()|[\]\\]/g,"\\$&")}\\b`,"gi");let match;while((match=exactRegex.exec(text))!==null){matches.push({start:match.index,end:match.index+match[0].length,text:match[0],type:"exact"})}if(matches.length===0){for(let i=0;i<text.length;i++){const fuzzyMatch=findFuzzySequenceMatch$1(text,word,i);if(fuzzyMatch){matches.push({...fuzzyMatch,type:"fuzzy"});i=fuzzyMatch.end-1}}}return matches}function findFuzzySequenceMatch$1(text,pattern,startPos){let textIndex=startPos;let patternIndex=0;let matchStart=-1;let maxGap=3;const matchedPositions=[];while(textIndex<text.length&&patternIndex<pattern.length){if(text[textIndex]===pattern[patternIndex]){if(matchStart===-1){matchStart=textIndex}matchedPositions.push(textIndex);patternIndex++}else if(matchStart!==-1){if(textIndex-matchStart>maxGap*pattern.length){return null}}textIndex++}if(patternIndex===pattern.length&&matchStart!==-1&&matchedPositions.length>0){const actualStart=matchedPositions[0];const actualEnd=matchedPositions[matchedPositions.length-1]+1;return{start:actualStart,end:actualEnd,text:text.substring(actualStart,actualEnd)}}return null}function mergeAndSortMatches$1(matches){if(matches.length===0)return[];const sortedMatches=matches.sort(((a,b)=>a.start-b.start));const merged=[];for(const match of sortedMatches){const lastMerged=merged[merged.length-1];if(lastMerged&&match.start<=lastMerged.end){lastMerged.end=Math.max(lastMerged.end,match.end);lastMerged.text=lastMerged.text+match.text.slice(lastMerged.end-match.start)}else{merged.push({...match})}}return merged}function literalSearch(text,criteria){text=text.trim().toLowerCase();const pattern=criteria.endsWith(" ")?[criteria.toLowerCase()]:criteria.trim().toLowerCase().split(" ");return pattern.filter((word=>text.indexOf(word)>=0)).length===pattern.length}function findLiteralMatches(text,criteria){if(!text||!criteria)return[];const lowerText=text.toLowerCase();const words=criteria.trim().toLowerCase().split(/\s+/);const matches=[];let textIndex=0;for(const word of words){if(word.length===0)continue;const wordIndex=lowerText.indexOf(word,textIndex);if(wordIndex!==-1){matches.push({start:wordIndex,end:wordIndex+word.length,text:text.substring(wordIndex,wordIndex+word.length),type:"exact"});textIndex=wordIndex+word.length}}return matches}function levenshtein(a,b){const lenA=a.length;const lenB=b.length;const distanceMatrix=Array.from({length:lenA+1},(()=>Array(lenB+1).fill(0)));for(let i=0;i<=lenA;i++)distanceMatrix[i][0]=i;for(let j=0;j<=lenB;j++)distanceMatrix[0][j]=j;for(let i=1;i<=lenA;i++){for(let j=1;j<=lenB;j++){const cost=a[i-1]===b[j-1]?0:1;distanceMatrix[i][j]=Math.min(distanceMatrix[i-1][j]+1,distanceMatrix[i][j-1]+1,distanceMatrix[i-1][j-1]+cost)}}return distanceMatrix[lenA][lenB]}function levenshteinSearch(text,pattern){const distance=levenshtein(pattern,text);const similarity=1-distance/Math.max(pattern.length,text.length);return similarity>=.3}function findLevenshteinMatches(text,pattern){if(!text||!pattern)return[];const matches=[];const words=text.split(/\s+/);for(let i=0;i<words.length;i++){const word=words[i];if(levenshteinSearch(word,pattern)){const start=text.indexOf(word);matches.push({start:start,end:start+word.length,text:word,type:"wildcard"})}}return matches}function wildcardSearch(text,pattern){const regexPattern=pattern.replace(/\*/g,".*");const regex=new RegExp(`^${regexPattern}$`,"i");if(regex.test(text))return true;return levenshteinSearch(text,pattern)}function findWildcardMatches(text,pattern){if(!text||!pattern)return[];const wildcardMatches=findWildcardPatternMatches(text,pattern);if(wildcardMatches.length>0){return mergeAndSortMatches(wildcardMatches)}const levenshteinMatches=findLevenshteinMatches(text,pattern);return mergeAndSortMatches(levenshteinMatches)}function findWildcardPatternMatches(text,pattern){const matches=[];const regexPattern=pattern.replace(/\*/g,".*");const regex=new RegExp(regexPattern,"gi");let match;while((match=regex.exec(text))!==null){matches.push({start:match.index,end:match.index+match[0].length,text:match[0],type:"wildcard"})}return matches}function mergeAndSortMatches(matches){if(matches.length===0)return[];const sortedMatches=matches.sort(((a,b)=>a.start-b.start));const merged=[];for(const match of sortedMatches){const lastMerged=merged[merged.length-1];if(lastMerged&&match.start<=lastMerged.end){lastMerged.end=Math.max(lastMerged.end,match.end);lastMerged.text=lastMerged.text+match.text.slice(lastMerged.end-match.start)}else{merged.push({...match})}}return merged}class SearchStrategy{constructor(matchFunction,findMatchesFunction){this.matchFunction=matchFunction;this.findMatchesFunction=findMatchesFunction}matches(text,criteria){if(text===null||text.trim()===""||!criteria){return false}return this.matchFunction(text,criteria)}findMatches(text,criteria){if(text===null||text.trim()===""||!criteria||!this.findMatchesFunction){return[]}return this.findMatchesFunction(text,criteria)}}const LiteralSearchStrategy=new SearchStrategy(literalSearch,findLiteralMatches);const FuzzySearchStrategy=new SearchStrategy(((text,criteria)=>fuzzySearch(text,criteria)||literalSearch(text,criteria)),((text,criteria)=>{const fuzzyMatches=findFuzzyMatches$1(text,criteria);if(fuzzyMatches.length>0){return fuzzyMatches}return findLiteralMatches(text,criteria)}));const WildcardSearchStrategy=new SearchStrategy(((text,criteria)=>wildcardSearch(text,criteria)||literalSearch(text,criteria)),((text,criteria)=>{const wildcardMatches=findWildcardMatches(text,criteria);if(wildcardMatches.length>0){return wildcardMatches}return findLiteralMatches(text,criteria)}));function merge(target,source){return{...target,...source}}function isJSON(json){try{return!!(json instanceof Object&&JSON.parse(JSON.stringify(json)))}catch(_err){return false}}function NoSort(){return 0}function isObject(obj){return Boolean(obj)&&Object.prototype.toString.call(obj)==="[object Object]"}function clone(input){if(input===null||typeof input!=="object"){return input}if(Array.isArray(input)){return input.map((item=>clone(item)))}const output={};for(const key in input){if(Object.prototype.hasOwnProperty.call(input,key)){output[key]=clone(input[key])}}return output}const DEFAULT_OPTIONS={searchInput:null,resultsContainer:null,json:[],success:function(){},searchResultTemplate:'<li><a href="{url}" title="{desc}">{title}</a></li>',templateMiddleware:(_prop,_value,_template,_query)=>void 0,sortMiddleware:NoSort,noResultsText:"No results found",limit:10,fuzzy:false,strategy:"literal",debounceTime:null,exclude:[],onSearch:()=>{}};const REQUIRED_OPTIONS=["searchInput","resultsContainer","json"];const WHITELISTED_KEYS=new Set(["Enter","Shift","CapsLock","ArrowLeft","ArrowUp","ArrowRight","ArrowDown","Meta"]);class Repository{constructor(initialOptions={}){this.data=[];this.setOptions(initialOptions)}put(input){if(isObject(input)){return this.addObject(input)}if(Array.isArray(input)){return this.addArray(input)}return void 0}clear(){this.data.length=0;return this.data}search(criteria){if(!criteria){return[]}return clone(this.findMatches(this.data,criteria).sort(this.options.sortMiddleware))}setOptions(newOptions){this.options={fuzzy:(newOptions==null?void 0:newOptions.fuzzy)||DEFAULT_OPTIONS.fuzzy,limit:(newOptions==null?void 0:newOptions.limit)||DEFAULT_OPTIONS.limit,searchStrategy:this.searchStrategy((newOptions==null?void 0:newOptions.strategy)||newOptions.fuzzy&&"fuzzy"||DEFAULT_OPTIONS.strategy),sortMiddleware:(newOptions==null?void 0:newOptions.sortMiddleware)||DEFAULT_OPTIONS.sortMiddleware,exclude:(newOptions==null?void 0:newOptions.exclude)||DEFAULT_OPTIONS.exclude,strategy:(newOptions==null?void 0:newOptions.strategy)||DEFAULT_OPTIONS.strategy}}addObject(obj){this.data.push(obj);return this.data}addArray(arr){const added=[];this.clear();for(const item of arr){if(isObject(item)){added.push(this.addObject(item)[0])}}return added}findMatches(data,criteria){const matches=[];for(let i=0;i<data.length&&matches.length<this.options.limit;i++){const match=this.findMatchesInObject(data[i],criteria);if(match){matches.push(match)}}return matches}findMatchesInObject(obj,criteria){var _a,_b;let hasMatch=false;const result={...obj};result._matchInfo={};for(const key in obj){if(!this.isExcluded(obj[key])&&this.options.searchStrategy.matches(obj[key],criteria)){hasMatch=true;const matchInfo=(_b=(_a=this.options.searchStrategy).findMatches)==null?void 0:_b.call(_a,obj[key],criteria);if(matchInfo&&matchInfo.length>0){result._matchInfo[key]=matchInfo}}}return hasMatch?result:void 0}isExcluded(term){for(const excludedTerm of this.options.exclude){if(new RegExp(excludedTerm).test(String(term))){return true}}return false}searchStrategy(strategy){switch(strategy){case"fuzzy":return FuzzySearchStrategy;case"wildcard":return WildcardSearchStrategy;default:return LiteralSearchStrategy}}}const options={pattern:/\{(.*?)\}/g,template:"",middleware:function(){return void 0}};function setOptions(_options){if(_options.pattern){options.pattern=_options.pattern}if(_options.template){options.template=_options.template}if(typeof _options.middleware==="function"){options.middleware=_options.middleware}}function compile(data,query){return options.template.replace(options.pattern,(function(match,prop){if(data._matchInfo&&data._matchInfo[prop]&&data._matchInfo[prop].length>0){try{const value2=options.middleware(prop,data[prop],options.template,query,data._matchInfo[prop]);if(typeof value2!=="undefined"){return value2}}catch(_e){}}const value=options.middleware(prop,data[prop],options.template,query);if(typeof value!=="undefined"){return value}return data[prop]||match}))}let SimpleJekyllSearch$1=class SimpleJekyllSearch{constructor(){this.debounceTimerHandle=null;this.options={...DEFAULT_OPTIONS};this.repository=new Repository;this.optionsValidator=new OptionsValidator({required:REQUIRED_OPTIONS})}debounce(func,delayMillis){if(delayMillis){if(this.debounceTimerHandle){clearTimeout(this.debounceTimerHandle)}this.debounceTimerHandle=setTimeout(func,delayMillis)}else{func()}}throwError(message){throw new Error(`SimpleJekyllSearch --- ${message}`)}emptyResultsContainer(){this.options.resultsContainer.innerHTML=""}initWithJSON(json){this.repository.put(json);this.registerInput()}initWithURL(url){load(url,((err,json)=>{if(err){this.throwError(`Failed to load JSON from ${url}: ${err.message}`)}this.initWithJSON(json)}))}registerInput(){this.options.searchInput.addEventListener("input",(e=>{const inputEvent=e;if(!WHITELISTED_KEYS.has(inputEvent.key)){this.emptyResultsContainer();this.debounce((()=>{this.search(e.target.value)}),this.options.debounceTime??null)}}))}search(query){var _a,_b;if((query==null?void 0:query.trim().length)>0){this.emptyResultsContainer();const results=this.repository.search(query);this.render(results,query);(_b=(_a=this.options).onSearch)==null?void 0:_b.call(_a)}}render(results,query){if(results.length===0){this.options.resultsContainer.insertAdjacentHTML("beforeend",this.options.noResultsText);return}const fragment=document.createDocumentFragment();results.forEach((result=>{result.query=query;const div=document.createElement("div");div.innerHTML=compile(result,query);fragment.appendChild(div)}));this.options.resultsContainer.appendChild(fragment)}init(_options){var _a;const errors=this.optionsValidator.validate(_options);if(errors.length>0){this.throwError(`Missing required options: ${REQUIRED_OPTIONS.join(", ")}`)}this.options=merge(this.options,_options);setOptions({template:this.options.searchResultTemplate,middleware:this.options.templateMiddleware});this.repository.setOptions({fuzzy:this.options.fuzzy,limit:this.options.limit,sortMiddleware:this.options.sortMiddleware,strategy:this.options.strategy,exclude:this.options.exclude});if(isJSON(this.options.json)){this.initWithJSON(this.options.json)}else{this.initWithURL(this.options.json)}const rv={search:this.search.bind(this)};(_a=this.options.success)==null?void 0:_a.call(rv);return rv}};function createHighlightMiddleware(options2={}){const{highlightClass:highlightClass="sjs-highlight",contextBefore:contextBefore=50,contextAfter:contextAfter=50,maxLength:maxLength=250,ellipsis:ellipsis="..."}=options2;return function(result,query){if(!query||!result){return result}const highlightedResult={...result};const textFields=["title","desc","content","excerpt"];for(const field of textFields){if(highlightedResult[field]&&typeof highlightedResult[field]==="string"){const highlighted=highlightText(highlightedResult[field],query,{highlightClass:highlightClass,contextBefore:contextBefore,contextAfter:contextAfter,maxLength:maxLength,ellipsis:ellipsis});if(highlighted.highlightedText!==highlightedResult[field]){highlightedResult[field]=highlighted.highlightedText}}}return highlightedResult}}function highlightText(text,query,options2={}){const{highlightClass:highlightClass="sjs-highlight",contextBefore:contextBefore=50,contextAfter:contextAfter=50,maxLength:maxLength=250,ellipsis:ellipsis="..."}=options2;if(!text||!query){return{highlightedText:text,matchCount:0}}const originalText=text;const searchTerms=query.trim().toLowerCase().split(/\s+/).filter((term=>term.length>0));if(searchTerms.length===0){return{highlightedText:text,matchCount:0}}const matches=[];for(const term of searchTerms){let index=0;while(index<text.length){const found=text.toLowerCase().indexOf(term,index);if(found===-1)break;matches.push({start:found,end:found+term.length,term:text.substring(found,found+term.length)});index=found+1}}if(matches.length===0){return{highlightedText:text,matchCount:0}}matches.sort(((a,b)=>a.start-b.start));const mergedMatches=[];for(const match of matches){if(mergedMatches.length===0||mergedMatches[mergedMatches.length-1].end<match.start){mergedMatches.push(match)}else{const lastMatch=mergedMatches[mergedMatches.length-1];lastMatch.end=Math.max(lastMatch.end,match.end);lastMatch.term=text.substring(lastMatch.start,lastMatch.end)}}if(text.length<=maxLength){let highlightedText2=text;for(let i=mergedMatches.length-1;i>=0;i--){const match=mergedMatches[i];const before=highlightedText2.substring(0,match.start);const after=highlightedText2.substring(match.end);const matchText=highlightedText2.substring(match.start,match.end);highlightedText2=before+`<span class="${highlightClass}">${matchText}</span>`+after}return{highlightedText:highlightedText2,matchCount:mergedMatches.length}}let highlightedText="";let totalLength=0;let lastEnd=0;for(let i=0;i<mergedMatches.length;i++){const match=mergedMatches[i];const contextStart=Math.max(lastEnd,match.start-contextBefore);const contextEnd=Math.min(text.length,match.end+contextAfter);if(contextStart>lastEnd&&lastEnd>0){highlightedText+=ellipsis;totalLength+=ellipsis.length}if(contextStart<match.start){const beforeText=text.substring(contextStart,match.start);highlightedText+=beforeText;totalLength+=beforeText.length}const matchText=text.substring(match.start,match.end);highlightedText+=`<span class="${highlightClass}">${matchText}</span>`;totalLength+=matchText.length;if(match.end<contextEnd){const afterText=text.substring(match.end,contextEnd);highlightedText+=afterText;totalLength+=afterText.length}lastEnd=contextEnd;if(totalLength>=maxLength){if(contextEnd<text.length){highlightedText+=ellipsis}break}}return{highlightedText:highlightedText||originalText,matchCount:mergedMatches.length}}const defaultHighlightMiddleware=createHighlightMiddleware();function findFuzzyMatches(text,pattern){const matches=[];const lowerText=text.toLowerCase();const lowerPattern=pattern.toLowerCase().trim();if(lowerPattern.length===0)return matches;const patternWords=lowerPattern.split(/\s+/);for(const word of patternWords){if(word.length===0)continue;const wordMatches=findFuzzyWordMatches(lowerText,word);matches.push(...wordMatches)}return matches}function findFuzzyWordMatches(text,word){const matches=[];const exactRegex=new RegExp(`\\b${word.replace(/[.*+?^${}()|[\]\\]/g,"\\$&")}\\b`,"gi");let match;while((match=exactRegex.exec(text))!==null){matches.push({start:match.index,end:match.index+match[0].length,text:match[0]})}if(matches.length===0){for(let i=0;i<text.length;i++){const fuzzyMatch=findFuzzySequenceMatch(text,word,i);if(fuzzyMatch){matches.push(fuzzyMatch);i=fuzzyMatch.end-1}}}return matches}function findFuzzySequenceMatch(text,pattern,startPos){let textIndex=startPos;let patternIndex=0;let matchStart=-1;let maxGap=3;const matchedPositions=[];while(textIndex<text.length&&patternIndex<pattern.length){if(text[textIndex]===pattern[patternIndex]){if(matchStart===-1){matchStart=textIndex}matchedPositions.push(textIndex);patternIndex++}else if(matchStart!==-1){if(textIndex-matchStart>maxGap*pattern.length){return null}}textIndex++}if(patternIndex===pattern.length&&matchStart!==-1&&matchedPositions.length>0){const actualStart=matchedPositions[0];const actualEnd=matchedPositions[matchedPositions.length-1]+1;return{start:actualStart,end:actualEnd,text:text.substring(actualStart,actualEnd)}}return null}function highlightWithMatchInfo(text,matchInfo,options2){if(matchInfo.length===0)return text;const sortedMatches=[...matchInfo].sort(((a,b)=>b.start-a.start));let highlightedText=text;for(const match of sortedMatches){const before=highlightedText.substring(0,match.start);const after=highlightedText.substring(match.end);const matchText=highlightedText.substring(match.start,match.end);highlightedText=before+`<span class="${options2.highlightClass}">${matchText}</span>`+after}return highlightedText}function highlightWithQuery(text,query,options2){let highlightedText=text;let hasMatches=false;const searchTerms=query.trim().split(/\s+/).filter((term=>term.length>0));for(const term of searchTerms){const regex=new RegExp(`\\b(${term.replace(/[.*+?^${}()|[\]\\]/g,"\\$&")})\\b`,"gi");if(regex.test(highlightedText)){highlightedText=highlightedText.replace(regex,`<span class="${options2.highlightClass}">$1</span>`);hasMatches=true}}if(!hasMatches){const fuzzyMatches=findFuzzyMatches(text,query);if(fuzzyMatches.length>0){fuzzyMatches.sort(((a,b)=>b.start-a.start));for(const match of fuzzyMatches){const before=highlightedText.substring(0,match.start);const after=highlightedText.substring(match.end);const matchText=highlightedText.substring(match.start,match.end);highlightedText=before+`<span class="${options2.highlightClass}">${matchText}</span>`+after}hasMatches=true}}return highlightedText}function createHighlightTemplateMiddleware(options2={}){const highlightOptions={highlightClass:"sjs-highlight",...options2};return function(prop,value,_template,query,matchInfo){if((prop==="content"||prop==="desc")&&query&&typeof value==="string"){if(matchInfo&&matchInfo.length>0){const highlighted2=highlightWithMatchInfo(value,matchInfo,highlightOptions);return highlighted2!==value?highlighted2:void 0}const highlighted=highlightWithQuery(value,query,highlightOptions);return highlighted!==value?highlighted:void 0}return void 0}}const defaultHighlightTemplateMiddleware=createHighlightTemplateMiddleware();function SimpleJekyllSearch(options2){const instance=new SimpleJekyllSearch$1;return instance.init(options2)}if(typeof window!=="undefined"){window.SimpleJekyllSearch=SimpleJekyllSearch;window.SimpleJekyllSearch.createHighlightMiddleware=createHighlightMiddleware;window.SimpleJekyllSearch.createHighlightTemplateMiddleware=createHighlightTemplateMiddleware;window.SimpleJekyllSearch.highlightText=highlightText;window.SimpleJekyllSearch.defaultHighlightMiddleware=defaultHighlightMiddleware;window.SimpleJekyllSearch.defaultHighlightTemplateMiddleware=defaultHighlightTemplateMiddleware}exports2.createHighlightMiddleware=createHighlightMiddleware;exports2.createHighlightTemplateMiddleware=createHighlightTemplateMiddleware;exports2.default=SimpleJekyllSearch;exports2.defaultHighlightMiddleware=defaultHighlightMiddleware;exports2.defaultHighlightTemplateMiddleware=defaultHighlightTemplateMiddleware;exports2.highlightText=highlightText;Object.defineProperties(exports2,{__esModule:{value:true},[Symbol.toStringTag]:{value:"Module"}})}));
\ No newline at end of file
+(function(global,factory){typeof exports==="object"&&typeof module!=="undefined"?factory(exports):typeof define==="function"&&define.amd?define(["exports"],factory):(global=typeof globalThis!=="undefined"?globalThis:global||self,factory(global.SimpleJekyllSearch={}))})(this,(function(exports2){"use strict";function load(location,callback){const xhr=getXHR();xhr.open("GET",location,true);xhr.onreadystatechange=createStateChangeListener(xhr,callback);xhr.send()}function createStateChangeListener(xhr,callback){return function(){if(xhr.readyState===4&&xhr.status===200){try{callback(null,JSON.parse(xhr.responseText))}catch(err){callback(err instanceof Error?err:new Error(String(err)),null)}}}}function getXHR(){return window.XMLHttpRequest?new window.XMLHttpRequest:new window.ActiveXObject("Microsoft.XMLHTTP")}class OptionsValidator{constructor(params){if(!this.validateParams(params)){throw new Error("-- OptionsValidator: required options missing")}this.requiredOptions=params.required}getRequiredOptions(){return this.requiredOptions}validate(parameters){const errors=[];this.requiredOptions.forEach((requiredOptionName=>{if(typeof parameters[requiredOptionName]==="undefined"){errors.push(requiredOptionName)}}));return errors}validateParams(params){if(!params){return false}return typeof params.required!=="undefined"&&Array.isArray(params.required)}}function findFuzzyMatches(text,pattern){if(!text||!pattern)return[];const lowerText=text.toLowerCase();const lowerPattern=pattern.toLowerCase().trim();if(lowerPattern.length===0)return[];const matches=[];for(let i=0;i<lowerText.length;i++){const match=findFuzzySequenceMatch(lowerText,lowerPattern,i);if(match){const isExact=match.text===lowerPattern;matches.push({start:match.start,end:match.end,text:text.substring(match.start,match.end),type:isExact?"exact":"fuzzy"});i=match.end-1}}return matches}function findFuzzySequenceMatch(text,pattern,startPos){let textIndex=startPos;let patternIndex=0;let matchStart=-1;let maxGap=10;while(textIndex<text.length&&patternIndex<pattern.length){if(text[textIndex]===pattern[patternIndex]){if(matchStart===-1){matchStart=textIndex}patternIndex++}else if(matchStart!==-1){const gap=textIndex-matchStart;if(gap>maxGap){return null}}textIndex++}if(patternIndex===pattern.length&&matchStart!==-1){return{start:matchStart,end:textIndex,text:text.substring(matchStart,textIndex)}}return null}function findLiteralMatches(text,criteria){if(!text||!criteria)return[];const lowerText=text.toLowerCase();const hasTrailingSpace=criteria.endsWith(" ");const words=criteria.trim().toLowerCase().split(/\s+/);const matches=[];let textIndex=0;for(const word of words){if(word.length===0)continue;let wordIndex=lowerText.indexOf(word,textIndex);if(hasTrailingSpace&&word===words[words.length-1]){while(wordIndex!==-1){const nextChar=lowerText[wordIndex+word.length];if(!nextChar||!/\w/.test(nextChar)){break}wordIndex=lowerText.indexOf(word,wordIndex+1)}}if(wordIndex!==-1){matches.push({start:wordIndex,end:wordIndex+word.length,text:text.substring(wordIndex,wordIndex+word.length),type:"exact"});textIndex=wordIndex+word.length}}return matches}function levenshtein(a,b){const lenA=a.length;const lenB=b.length;const distanceMatrix=Array.from({length:lenA+1},(()=>Array(lenB+1).fill(0)));for(let i=0;i<=lenA;i++)distanceMatrix[i][0]=i;for(let j=0;j<=lenB;j++)distanceMatrix[0][j]=j;for(let i=1;i<=lenA;i++){for(let j=1;j<=lenB;j++){const cost=a[i-1]===b[j-1]?0:1;distanceMatrix[i][j]=Math.min(distanceMatrix[i-1][j]+1,distanceMatrix[i][j-1]+1,distanceMatrix[i-1][j-1]+cost)}}return distanceMatrix[lenA][lenB]}function levenshteinSearch(text,pattern){const distance=levenshtein(pattern,text);const similarity=1-distance/Math.max(pattern.length,text.length);return similarity>=.3}function mergeAndSortMatches(matches){if(matches.length===0)return[];const sortedMatches=matches.sort(((a,b)=>a.start-b.start));const merged=[];for(const match of sortedMatches){const lastMerged=merged[merged.length-1];if(lastMerged&&match.start<=lastMerged.end){lastMerged.end=Math.max(lastMerged.end,match.end);lastMerged.text=lastMerged.text+match.text.slice(lastMerged.end-match.start)}else{merged.push({...match})}}return merged}function findWildcardMatches(text,pattern){if(!text||!pattern)return[];const wildcardMatches=findWildcardPatternMatches(text,pattern);if(wildcardMatches.length>0){return mergeAndSortMatches(wildcardMatches)}if(levenshteinSearch(text,pattern)){return[{start:0,end:text.length,text:text,type:"wildcard"}]}return[]}function findWildcardPatternMatches(text,pattern){const matches=[];const regexPattern=pattern.replace(/\*/g,".*");const regex=new RegExp(regexPattern,"gi");let match;let lastIndex=0;while((match=regex.exec(text))!==null){if(match.index===lastIndex&&match[0].length===0){break}lastIndex=match.index;matches.push({start:match.index,end:match.index+match[0].length,text:match[0],type:"wildcard"});if(match[0].length===text.length){break}}return matches}class SearchStrategy{constructor(matchFunction,findMatchesFunction){this.matchFunction=matchFunction;this.findMatchesFunction=findMatchesFunction}matches(text,criteria){if(text===null||text.trim()===""||!criteria){return false}return this.matchFunction(text,criteria)}findMatches(text,criteria){if(text===null||text.trim()===""||!criteria){return[]}return this.findMatchesFunction(text,criteria)}}const LiteralSearchStrategy=new SearchStrategy(((text,criteria)=>{if(!text||!criteria)return false;const lowerText=text.trim().toLowerCase();const pattern=criteria.endsWith(" ")?[criteria.toLowerCase()]:criteria.trim().toLowerCase().split(" ");return pattern.filter((word=>lowerText.indexOf(word)>=0)).length===pattern.length}),findLiteralMatches);const FuzzySearchStrategy=new SearchStrategy(((text,criteria)=>{const pattern=criteria.trimEnd();if(pattern.length===0)return true;const lowerPattern=pattern.toLowerCase();const lowerText=text.toLowerCase();let remainingText=lowerText,currentIndex=-1;for(const char of lowerPattern){const nextIndex=remainingText.indexOf(char);if(nextIndex===-1||currentIndex!==-1&&remainingText.slice(0,nextIndex).split(" ").length-1>2){const lowerText2=text.trim().toLowerCase();const pattern2=criteria.endsWith(" ")?[criteria.toLowerCase()]:criteria.trim().toLowerCase().split(" ");return pattern2.filter((word=>lowerText2.indexOf(word)>=0)).length===pattern2.length}currentIndex=nextIndex;remainingText=remainingText.slice(nextIndex+1)}return true}),findFuzzyMatches);const WildcardSearchStrategy=new SearchStrategy(((text,criteria)=>{const wildcardMatches=findWildcardMatches(text,criteria);return wildcardMatches.length>0}),findWildcardMatches);function merge(target,source){return{...target,...source}}function isJSON(json){try{return!!(json instanceof Object&&JSON.parse(JSON.stringify(json)))}catch(_err){return false}}function NoSort(){return 0}function isObject(obj){return Boolean(obj)&&Object.prototype.toString.call(obj)==="[object Object]"}function clone(input){if(input===null||typeof input!=="object"){return input}if(Array.isArray(input)){return input.map((item=>clone(item)))}const output={};for(const key in input){if(Object.prototype.hasOwnProperty.call(input,key)){output[key]=clone(input[key])}}return output}const DEFAULT_OPTIONS={searchInput:null,resultsContainer:null,json:[],success:function(){},searchResultTemplate:'<li><a href="{url}" title="{desc}">{title}</a></li>',templateMiddleware:(_prop,_value,_template,_query)=>void 0,sortMiddleware:NoSort,noResultsText:"No results found",limit:10,fuzzy:false,strategy:"literal",debounceTime:null,exclude:[],onSearch:()=>{}};const REQUIRED_OPTIONS=["searchInput","resultsContainer","json"];const WHITELISTED_KEYS=new Set(["Enter","Shift","CapsLock","ArrowLeft","ArrowUp","ArrowRight","ArrowDown","Meta"]);class Repository{constructor(initialOptions={}){this.data=[];this.setOptions(initialOptions)}put(input){if(isObject(input)){return this.addObject(input)}if(Array.isArray(input)){return this.addArray(input)}return void 0}clear(){this.data.length=0;return this.data}search(criteria){if(!criteria){return[]}return clone(this.findMatches(this.data,criteria).sort(this.options.sortMiddleware))}setOptions(newOptions){this.options={fuzzy:(newOptions==null?void 0:newOptions.fuzzy)||DEFAULT_OPTIONS.fuzzy,limit:(newOptions==null?void 0:newOptions.limit)||DEFAULT_OPTIONS.limit,searchStrategy:this.searchStrategy((newOptions==null?void 0:newOptions.strategy)||newOptions.fuzzy&&"fuzzy"||DEFAULT_OPTIONS.strategy),sortMiddleware:(newOptions==null?void 0:newOptions.sortMiddleware)||DEFAULT_OPTIONS.sortMiddleware,exclude:(newOptions==null?void 0:newOptions.exclude)||DEFAULT_OPTIONS.exclude,strategy:(newOptions==null?void 0:newOptions.strategy)||DEFAULT_OPTIONS.strategy}}addObject(obj){this.data.push(obj);return this.data}addArray(arr){const added=[];this.clear();for(const item of arr){if(isObject(item)){added.push(this.addObject(item)[0])}}return added}findMatches(data,criteria){const matches=[];for(let i=0;i<data.length&&matches.length<this.options.limit;i++){const match=this.findMatchesInObject(data[i],criteria);if(match){matches.push(match)}}return matches}findMatchesInObject(obj,criteria){let hasMatch=false;const result={...obj};result._matchInfo={};for(const key in obj){if(!this.isExcluded(obj[key])&&this.options.searchStrategy.matches(obj[key],criteria)){hasMatch=true;const matchInfo=this.options.searchStrategy.findMatches(obj[key],criteria);if(matchInfo&&matchInfo.length>0){result._matchInfo[key]=matchInfo}}}return hasMatch?result:void 0}isExcluded(term){for(const excludedTerm of this.options.exclude){if(new RegExp(excludedTerm).test(String(term))){return true}}return false}searchStrategy(strategy){switch(strategy){case"fuzzy":return FuzzySearchStrategy;case"wildcard":return WildcardSearchStrategy;default:return LiteralSearchStrategy}}}const options={pattern:/\{(.*?)\}/g,template:"",middleware:function(){return void 0}};function setOptions(_options){if(_options.pattern){options.pattern=_options.pattern}if(_options.template){options.template=_options.template}if(typeof _options.middleware==="function"){options.middleware=_options.middleware}}function compile(data,query){return options.template.replace(options.pattern,(function(match,prop){const matchInfo=data._matchInfo&&data._matchInfo[prop]?data._matchInfo[prop]:void 0;const value=options.middleware(prop,data[prop],options.template,query,matchInfo);if(typeof value!=="undefined"){return value}return data[prop]||match}))}let SimpleJekyllSearch$1=class SimpleJekyllSearch{constructor(){this.debounceTimerHandle=null;this.options={...DEFAULT_OPTIONS};this.repository=new Repository;this.optionsValidator=new OptionsValidator({required:REQUIRED_OPTIONS})}debounce(func,delayMillis){if(delayMillis){if(this.debounceTimerHandle){clearTimeout(this.debounceTimerHandle)}this.debounceTimerHandle=setTimeout(func,delayMillis)}else{func()}}throwError(message){throw new Error(`SimpleJekyllSearch --- ${message}`)}emptyResultsContainer(){this.options.resultsContainer.innerHTML=""}initWithJSON(json){this.repository.put(json);this.registerInput()}initWithURL(url){load(url,((err,json)=>{if(err){this.throwError(`Failed to load JSON from ${url}: ${err.message}`)}this.initWithJSON(json)}))}registerInput(){this.options.searchInput.addEventListener("input",(e=>{const inputEvent=e;if(!WHITELISTED_KEYS.has(inputEvent.key)){this.emptyResultsContainer();this.debounce((()=>{this.search(e.target.value)}),this.options.debounceTime??null)}}))}search(query){var _a,_b;if((query==null?void 0:query.trim().length)>0){this.emptyResultsContainer();const results=this.repository.search(query);this.render(results,query);(_b=(_a=this.options).onSearch)==null?void 0:_b.call(_a)}}render(results,query){if(results.length===0){this.options.resultsContainer.insertAdjacentHTML("beforeend",this.options.noResultsText);return}const fragment=document.createDocumentFragment();results.forEach((result=>{result.query=query;const div=document.createElement("div");div.innerHTML=compile(result,query);fragment.appendChild(div)}));this.options.resultsContainer.appendChild(fragment)}init(_options){var _a;const errors=this.optionsValidator.validate(_options);if(errors.length>0){this.throwError(`Missing required options: ${REQUIRED_OPTIONS.join(", ")}`)}this.options=merge(this.options,_options);setOptions({template:this.options.searchResultTemplate,middleware:this.options.templateMiddleware});this.repository.setOptions({fuzzy:this.options.fuzzy,limit:this.options.limit,sortMiddleware:this.options.sortMiddleware,strategy:this.options.strategy,exclude:this.options.exclude});if(isJSON(this.options.json)){this.initWithJSON(this.options.json)}else{this.initWithURL(this.options.json)}const rv={search:this.search.bind(this)};(_a=this.options.success)==null?void 0:_a.call(rv);return rv}};function createHighlightMiddleware(options2={}){const{highlightClass:highlightClass="sjs-highlight",contextBefore:contextBefore=50,contextAfter:contextAfter=50,maxLength:maxLength=250,ellipsis:ellipsis="..."}=options2;return function(result,query){if(!query||!result){return result}const highlightedResult={...result};const textFields=["title","desc","content","excerpt"];for(const field of textFields){if(highlightedResult[field]&&typeof highlightedResult[field]==="string"){const highlighted=highlightText(highlightedResult[field],query,{highlightClass:highlightClass,contextBefore:contextBefore,contextAfter:contextAfter,maxLength:maxLength,ellipsis:ellipsis});if(highlighted.highlightedText!==highlightedResult[field]){highlightedResult[field]=highlighted.highlightedText}}}return highlightedResult}}function highlightText(text,query,options2={}){const{highlightClass:highlightClass="sjs-highlight",contextBefore:contextBefore=50,contextAfter:contextAfter=50,maxLength:maxLength=250,ellipsis:ellipsis="..."}=options2;if(!text||!query){return{highlightedText:text,matchCount:0}}const originalText=text;const searchTerms=query.trim().toLowerCase().split(/\s+/).filter((term=>term.length>0));if(searchTerms.length===0){return{highlightedText:text,matchCount:0}}const matches=[];for(const term of searchTerms){let index=0;while(index<text.length){const found=text.toLowerCase().indexOf(term,index);if(found===-1)break;matches.push({start:found,end:found+term.length,term:text.substring(found,found+term.length)});index=found+1}}if(matches.length===0){return{highlightedText:text,matchCount:0}}matches.sort(((a,b)=>a.start-b.start));const mergedMatches=[];for(const match of matches){if(mergedMatches.length===0||mergedMatches[mergedMatches.length-1].end<match.start){mergedMatches.push(match)}else{const lastMatch=mergedMatches[mergedMatches.length-1];lastMatch.end=Math.max(lastMatch.end,match.end);lastMatch.term=text.substring(lastMatch.start,lastMatch.end)}}if(text.length<=maxLength){let highlightedText2=text;for(let i=mergedMatches.length-1;i>=0;i--){const match=mergedMatches[i];const before=highlightedText2.substring(0,match.start);const after=highlightedText2.substring(match.end);const matchText=highlightedText2.substring(match.start,match.end);highlightedText2=before+`<span class="${highlightClass}">${matchText}</span>`+after}return{highlightedText:highlightedText2,matchCount:mergedMatches.length}}let highlightedText="";let totalLength=0;let lastEnd=0;for(let i=0;i<mergedMatches.length;i++){const match=mergedMatches[i];const contextStart=Math.max(lastEnd,match.start-contextBefore);const contextEnd=Math.min(text.length,match.end+contextAfter);if(contextStart>lastEnd&&lastEnd>0){highlightedText+=ellipsis;totalLength+=ellipsis.length}if(contextStart<match.start){const beforeText=text.substring(contextStart,match.start);highlightedText+=beforeText;totalLength+=beforeText.length}const matchText=text.substring(match.start,match.end);highlightedText+=`<span class="${highlightClass}">${matchText}</span>`;totalLength+=matchText.length;if(match.end<contextEnd){const afterText=text.substring(match.end,contextEnd);highlightedText+=afterText;totalLength+=afterText.length}lastEnd=contextEnd;if(totalLength>=maxLength){if(contextEnd<text.length){highlightedText+=ellipsis}break}}return{highlightedText:highlightedText||originalText,matchCount:mergedMatches.length}}const defaultHighlightMiddleware=createHighlightMiddleware();function highlightWithMatchInfo(text,matchInfo,options2){if(matchInfo.length===0)return text;const sortedMatches=[...matchInfo].sort(((a,b)=>b.start-a.start));let highlightedText=text;for(const match of sortedMatches){const before=highlightedText.substring(0,match.start);const after=highlightedText.substring(match.end);const matchText=highlightedText.substring(match.start,match.end);highlightedText=before+`<span class="${options2.highlightClass}">${matchText}</span>`+after}return highlightedText}function createHighlightTemplateMiddleware(options2={}){const highlightOptions={highlightClass:"sjs-highlight",...options2};return function(prop,value,_template,query,matchInfo){if((prop==="content"||prop==="desc")&&query&&typeof value==="string"){if(matchInfo&&matchInfo.length>0){const highlighted=highlightWithMatchInfo(value,matchInfo,highlightOptions);return highlighted!==value?highlighted:void 0}}return void 0}}const defaultHighlightTemplateMiddleware=createHighlightTemplateMiddleware();function SimpleJekyllSearch(options2){const instance=new SimpleJekyllSearch$1;return instance.init(options2)}if(typeof window!=="undefined"){window.SimpleJekyllSearch=SimpleJekyllSearch;window.SimpleJekyllSearch.createHighlightMiddleware=createHighlightMiddleware;window.SimpleJekyllSearch.createHighlightTemplateMiddleware=createHighlightTemplateMiddleware;window.SimpleJekyllSearch.highlightText=highlightText;window.SimpleJekyllSearch.defaultHighlightMiddleware=defaultHighlightMiddleware;window.SimpleJekyllSearch.defaultHighlightTemplateMiddleware=defaultHighlightTemplateMiddleware}exports2.createHighlightMiddleware=createHighlightMiddleware;exports2.createHighlightTemplateMiddleware=createHighlightTemplateMiddleware;exports2.default=SimpleJekyllSearch;exports2.defaultHighlightMiddleware=defaultHighlightMiddleware;exports2.defaultHighlightTemplateMiddleware=defaultHighlightTemplateMiddleware;exports2.highlightText=highlightText;Object.defineProperties(exports2,{__esModule:{value:true},[Symbol.toStringTag]:{value:"Module"}})}));
\ No newline at end of file
diff --git a/src/Repository.ts b/src/Repository.ts
index 847d3de..a7dc0d1 100644
--- a/src/Repository.ts
+++ b/src/Repository.ts
@@ -80,7 +80,7 @@ export class Repository {
     for (const key in obj) {
       if (!this.isExcluded(obj[key]) && this.options.searchStrategy.matches(obj[key], criteria)) {
         hasMatch = true;
-        const matchInfo = this.options.searchStrategy.findMatches?.(obj[key], criteria);
+        const matchInfo = this.options.searchStrategy.findMatches(obj[key], criteria);
         if (matchInfo && matchInfo.length > 0) {
           result._matchInfo[key] = matchInfo;
         }
diff --git a/src/SearchStrategies/SearchStrategy.ts b/src/SearchStrategies/SearchStrategy.ts
index 6de7224..4b00591 100644
--- a/src/SearchStrategies/SearchStrategy.ts
+++ b/src/SearchStrategies/SearchStrategy.ts
@@ -38,13 +38,7 @@ export const FuzzySearchStrategy = new SearchStrategy(
 
     return true;
   },
-  (text: string, criteria: string) => {
-    const fuzzyMatches = findFuzzyMatches(text, criteria);
-    if (fuzzyMatches.length > 0) {
-      return fuzzyMatches;
-    }
-    return findLiteralMatches(text, criteria);
-  }
+  findFuzzyMatches
 );
 
 export const WildcardSearchStrategy = new SearchStrategy(
@@ -52,11 +46,5 @@ export const WildcardSearchStrategy = new SearchStrategy(
     const wildcardMatches = findWildcardMatches(text, criteria);
     return wildcardMatches.length > 0;
   },
-  (text: string, criteria: string) => {
-    const wildcardMatches = findWildcardMatches(text, criteria);
-    if (wildcardMatches.length > 0) {
-      return wildcardMatches;
-    }
-    return findLiteralMatches(text, criteria);
-  }
+  findWildcardMatches
 );
\ No newline at end of file
diff --git a/src/SearchStrategies/types.ts b/src/SearchStrategies/types.ts
index 80108e2..7edc93d 100644
--- a/src/SearchStrategies/types.ts
+++ b/src/SearchStrategies/types.ts
@@ -7,14 +7,14 @@ export interface MatchInfo {
 
 export interface Matcher {
   matches(text: string | null, criteria: string): boolean;
-  findMatches?(text: string | null, criteria: string): MatchInfo[];
+  findMatches(text: string | null, criteria: string): MatchInfo[];
 }
 
 export class SearchStrategy implements Matcher {
   private readonly matchFunction: (text: string, criteria: string) => boolean;
-  private readonly findMatchesFunction?: (text: string, criteria: string) => MatchInfo[];
+  private readonly findMatchesFunction: (text: string, criteria: string) => MatchInfo[];
 
-  constructor(matchFunction: (text: string, criteria: string) => boolean, findMatchesFunction?: (text: string, criteria: string) => MatchInfo[]) {
+  constructor(matchFunction: (text: string, criteria: string) => boolean, findMatchesFunction: (text: string, criteria: string) => MatchInfo[]) {
     this.matchFunction = matchFunction;
     this.findMatchesFunction = findMatchesFunction;
   }
@@ -27,8 +27,8 @@ export class SearchStrategy implements Matcher {
     return this.matchFunction(text, criteria);
   }
 
-  findMatches?(text: string | null, criteria: string): MatchInfo[] {
-    if (text === null || text.trim() === '' || !criteria || !this.findMatchesFunction) {
+  findMatches(text: string | null, criteria: string): MatchInfo[] {
+    if (text === null || text.trim() === '' || !criteria) {
       return [];
     }
 
diff --git a/src/Templater.ts b/src/Templater.ts
index fadbe02..d0047d1 100644
--- a/src/Templater.ts
+++ b/src/Templater.ts
@@ -1,4 +1,4 @@
-type MiddlewareFunction = (prop: string, value: any, template: string, query?: string) => any;
+type MiddlewareFunction = (prop: string, value: any, template: string, query?: string, matchInfo?: any[]) => any;
 
 interface TemplaterOptions {
   pattern?: RegExp;
@@ -30,16 +30,8 @@ export function setOptions(_options: TemplaterOptions): void {
 
 export function compile(data: Data, query?: string): string {
   return options.template.replace(options.pattern, function(match: string, prop: string) {
-    if (data._matchInfo && data._matchInfo[prop] && data._matchInfo[prop].length > 0) {
-      try {
-        const value = (options.middleware as any)(prop, data[prop], options.template, query, data._matchInfo[prop]);
-        if (typeof value !== 'undefined') {
-          return value;
-        }
-      } catch (_e) {
-      }
-    }
-    const value = options.middleware(prop, data[prop], options.template, query);
+    const matchInfo = data._matchInfo && data._matchInfo[prop] ? data._matchInfo[prop] : undefined;
+    const value = options.middleware(prop, data[prop], options.template, query, matchInfo);
     if (typeof value !== 'undefined') {
       return value;
     }
diff --git a/src/utils/highlightMiddleware.ts b/src/utils/highlightMiddleware.ts
index 2679a2c..6638444 100644
--- a/src/utils/highlightMiddleware.ts
+++ b/src/utils/highlightMiddleware.ts
@@ -197,98 +197,6 @@ export function highlightText(
  */
 export const defaultHighlightMiddleware = createHighlightMiddleware();
 
-/**
- * Finds fuzzy match positions in text for highlighting
- * @param text - The text to search in
- * @param pattern - The search pattern
- * @returns Array of match positions
- */
-function findFuzzyMatches(text: string, pattern: string): Array<{ start: number; end: number; text: string }> {
-  const matches: Array<{ start: number; end: number; text: string }> = [];
-  const lowerText = text.toLowerCase();
-  const lowerPattern = pattern.toLowerCase().trim();
-  
-  if (lowerPattern.length === 0) return matches;
-  
-  const patternWords = lowerPattern.split(/\s+/);
-  
-  for (const word of patternWords) {
-    if (word.length === 0) continue;
-    
-    const wordMatches = findFuzzyWordMatches(lowerText, word);
-    matches.push(...wordMatches);
-  }
-  
-  return matches;
-}
-
-/**
- * Finds fuzzy matches for a single word
- */
-function findFuzzyWordMatches(text: string, word: string): Array<{ start: number; end: number; text: string }> {
-  const matches: Array<{ start: number; end: number; text: string }> = [];
-  
-  const exactRegex = new RegExp(`\\b${word.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}\\b`, 'gi');
-  let match;
-  while ((match = exactRegex.exec(text)) !== null) {
-    matches.push({
-      start: match.index,
-      end: match.index + match[0].length,
-      text: match[0]
-    });
-  }
-  
-  if (matches.length === 0) {
-    for (let i = 0; i < text.length; i++) {
-      const fuzzyMatch = findFuzzySequenceMatch(text, word, i);
-      if (fuzzyMatch) {
-        matches.push(fuzzyMatch);
-        i = fuzzyMatch.end - 1; // Skip to end of match
-      }
-    }
-  }
-  
-  return matches;
-}
-
-/**
- * Finds a fuzzy sequence match starting from a given position
- */
-function findFuzzySequenceMatch(text: string, pattern: string, startPos: number): { start: number; end: number; text: string } | null {
-  let textIndex = startPos;
-  let patternIndex = 0;
-  let matchStart = -1;
-  let maxGap = 3;
-  const matchedPositions: number[] = [];
-  
-  while (textIndex < text.length && patternIndex < pattern.length) {
-    if (text[textIndex] === pattern[patternIndex]) {
-      if (matchStart === -1) {
-        matchStart = textIndex;
-      }
-      matchedPositions.push(textIndex);
-      patternIndex++;
-    } else if (matchStart !== -1) {
-      if (textIndex - matchStart > maxGap * pattern.length) {
-        return null;
-      }
-    }
-    textIndex++;
-  }
-  
-  if (patternIndex === pattern.length && matchStart !== -1 && matchedPositions.length > 0) {
-    const actualStart = matchedPositions[0];
-    const actualEnd = matchedPositions[matchedPositions.length - 1] + 1;
-    
-    return {
-      start: actualStart,
-      end: actualEnd,
-      text: text.substring(actualStart, actualEnd)
-    };
-  }
-  
-  return null;
-}
 
 /**
  * Highlights text using provided match information (faster, more accurate)
@@ -309,39 +217,6 @@ function highlightWithMatchInfo(text: string, matchInfo: MatchInfo[], options: R
   return highlightedText;
 }
 
-/**
- * Highlights text using query-based search (fallback for backward compatibility)
- */
-function highlightWithQuery(text: string, query: string, options: Required<HighlightOptions>): string {
-  let highlightedText = text;
-  let hasMatches = false;
-  
-  const searchTerms = query.trim().split(/\s+/).filter(term => term.length > 0);
-  for (const term of searchTerms) {
-    const regex = new RegExp(`\\b(${term.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')})\\b`, 'gi');
-    if (regex.test(highlightedText)) {
-      highlightedText = highlightedText.replace(regex, `<span class="${options.highlightClass}">$1</span>`);
-      hasMatches = true;
-    }
-  }
-  
-  if (!hasMatches) {
-    const fuzzyMatches = findFuzzyMatches(text, query);
-    if (fuzzyMatches.length > 0) {
-      fuzzyMatches.sort((a, b) => b.start - a.start);
-      
-      for (const match of fuzzyMatches) {
-        const before = highlightedText.substring(0, match.start);
-        const after = highlightedText.substring(match.end);
-        const matchText = highlightedText.substring(match.start, match.end);
-        highlightedText = before + `<span class="${options.highlightClass}">${matchText}</span>` + after;
-      }
-      hasMatches = true;
-    }
-  }
-  
-  return highlightedText;
-}
 
 /**
  * Creates a templateMiddleware that includes highlighting functionality
@@ -364,8 +239,6 @@ export function createHighlightTemplateMiddleware(options: HighlightOptions = {}
         const highlighted = highlightWithMatchInfo(value, matchInfo, highlightOptions);
         return highlighted !== value ? highlighted : undefined;
       }
-      const highlighted = highlightWithQuery(value, query, highlightOptions);
-      return highlighted !== value ? highlighted : undefined;
     }
     return undefined;
   };
diff --git a/tests/highlightMiddleware.test.ts b/tests/highlightMiddleware.test.ts
index b5ea99a..c6ae407 100644
--- a/tests/highlightMiddleware.test.ts
+++ b/tests/highlightMiddleware.test.ts
@@ -182,16 +182,18 @@ describe('createHighlightMiddleware', () => {
 });
 
 describe('createHighlightTemplateMiddleware', () => {
-  it('should create a template middleware that highlights content field', () => {
+  it('should create a template middleware that highlights content field with matchInfo', () => {
     const middleware = createHighlightTemplateMiddleware();
-    const result = middleware('content', 'This is a test search result', '<div>{content}</div>', 'search');
+    const matchInfo = [{ start: 15, end: 21, text: 'search', type: 'exact' as const }];
+    const result = middleware('content', 'This is a test search result', '<div>{content}</div>', 'search', matchInfo);
     
     expect(result).toContain('<span class="sjs-highlight">search</span>');
   });
 
-  it('should create a template middleware that highlights desc field', () => {
+  it('should create a template middleware that highlights desc field with matchInfo', () => {
     const middleware = createHighlightTemplateMiddleware();
-    const result = middleware('desc', 'This is a test search result', '<div>{desc}</div>', 'search');
+    const matchInfo = [{ start: 15, end: 21, text: 'search', type: 'exact' as const }];
+    const result = middleware('desc', 'This is a test search result', '<div>{desc}</div>', 'search', matchInfo);
     
     expect(result).toContain('<span class="sjs-highlight">search</span>');
   });
@@ -210,24 +212,30 @@ describe('createHighlightTemplateMiddleware', () => {
     expect(result).toBeUndefined();
   });
 
-  it('should use custom highlight class', () => {
+  it('should use custom highlight class with matchInfo', () => {
     const middleware = createHighlightTemplateMiddleware({ highlightClass: 'custom-highlight' });
-    const result = middleware('content', 'This is a test search result', '<div>{content}</div>', 'search');
+    const matchInfo = [{ start: 15, end: 21, text: 'search', type: 'exact' as const }];
+    const result = middleware('content', 'This is a test search result', '<div>{content}</div>', 'search', matchInfo);
     
     expect(result).toContain('<span class="custom-highlight">search</span>');
   });
 
-  it('should handle multiple search terms', () => {
+  it('should handle multiple search terms with matchInfo', () => {
     const middleware = createHighlightTemplateMiddleware();
-    const result = middleware('content', 'This is a test search result with multiple terms', '<div>{content}</div>', 'test search');
+    const matchInfo = [
+      { start: 10, end: 14, text: 'test', type: 'exact' as const },
+      { start: 15, end: 21, text: 'search', type: 'exact' as const }
+    ];
+    const result = middleware('content', 'This is a test search result with multiple terms', '<div>{content}</div>', 'test search', matchInfo);
     
     expect(result).toContain('<span class="sjs-highlight">test</span>');
     expect(result).toContain('<span class="sjs-highlight">search</span>');
   });
 
-  it('should handle case insensitive matching', () => {
+  it('should handle case insensitive matching with matchInfo', () => {
     const middleware = createHighlightTemplateMiddleware();
-    const result = middleware('content', 'This is a TEST search result', '<div>{content}</div>', 'test');
+    const matchInfo = [{ start: 10, end: 14, text: 'TEST', type: 'exact' as const }];
+    const result = middleware('content', 'This is a TEST search result', '<div>{content}</div>', 'test', matchInfo);
     
     expect(result).toContain('<span class="sjs-highlight">TEST</span>');
   });
@@ -240,348 +248,130 @@ describe('createHighlightTemplateMiddleware', () => {
     expect(result).toBeUndefined();
   });
 
-  it('should handle fuzzy search highlighting', () => {
+  it('should not highlight without matchInfo (no fallback)', () => {
     const middleware = createHighlightTemplateMiddleware();
     const result = middleware('content', 'This is a testing result', '<div>{content}</div>', 'test');
     
-    expect(result).toContain('<span class="sjs-highlight">');
-    expect(result).toContain('test');
+    expect(result).toBeUndefined();
   });
 
-  it('should handle fuzzy search with partial matches', () => {
+  it('should not highlight partial matches without matchInfo', () => {
     const middleware = createHighlightTemplateMiddleware();
     const result = middleware('content', 'This is a tst result', '<div>{content}</div>', 'test');
     
-    expect(result).toContain('<span class="sjs-highlight">');
-    expect(result).toContain('tst');
+    expect(result).toBeUndefined();
   });
 
-  it('should prefer exact matches over fuzzy matches', () => {
+  it('should only highlight when matchInfo is provided', () => {
     const middleware = createHighlightTemplateMiddleware();
-    const result = middleware('content', 'This is a test and testing result', '<div>{content}</div>', 'test');
+    const matchInfo = [{
+      start: 10,
+      end: 14,
+      text: 'test',
+      type: 'exact' as const
+    }];
+    const result = middleware('content', 'This is a test and testing result', '<div>{content}</div>', 'test', matchInfo);
     
     expect(result).toContain('<span class="sjs-highlight">test</span>');
-    expect(result).not.toContain('<span class="sjs-highlight">testing</span>');
   });
 
-  it('should handle fuzzy search with multiple words', () => {
+  it('should not highlight multiple words without matchInfo', () => {
     const middleware = createHighlightTemplateMiddleware();
     const result = middleware('content', 'This is a tst srch result', '<div>{content}</div>', 'test search');
     
-    expect(result).toContain('<span class="sjs-highlight">');
+    expect(result).toBeUndefined();
   });
 
-  describe('Search Strategy Compatibility', () => {
-    const testCases = [
-      {
-        strategy: 'literal',
-        description: 'should highlight exact word matches for literal search',
-        content: 'This is a test search result with exact matches',
-        query: 'test search',
-        expectedHighlights: ['<span class="sjs-highlight">test</span>', '<span class="sjs-highlight">search</span>'],
-        shouldNotContain: []
-      },
-      {
-        strategy: 'literal',
-        description: 'should not highlight partial word matches for literal search',
-        content: 'This is a testing searching result',
-        query: 'test search',
-        expectedHighlights: ['<span class="sjs-highlight">'],
-        shouldNotContain: ['<span class="sjs-highlight">testing</span>', '<span class="sjs-highlight">searching</span>']
-      },
-      {
-        strategy: 'literal',
-        description: 'should handle case insensitive literal search',
-        content: 'This is a TEST SEARCH result',
-        query: 'test search',
-        expectedHighlights: ['<span class="sjs-highlight">TEST</span>', '<span class="sjs-highlight">SEARCH</span>'],
-        shouldNotContain: []
-      },
-      {
-        strategy: 'literal',
-        description: 'should highlight all words in multi-word literal search',
-        content: 'This is a test search result with multiple words',
-        query: 'test search result',
-        expectedHighlights: ['<span class="sjs-highlight">test</span>', '<span class="sjs-highlight">search</span>', '<span class="sjs-highlight">result</span>'],
-        shouldNotContain: []
-      },
-      
-      {
-        strategy: 'fuzzy',
-        description: 'should highlight exact matches when available for fuzzy search',
-        content: 'This is a test search result with exact matches',
-        query: 'test search',
-        expectedHighlights: ['<span class="sjs-highlight">test</span>', '<span class="sjs-highlight">search</span>'],
-        shouldNotContain: []
-      },
-      {
-        strategy: 'fuzzy',
-        description: 'should highlight fuzzy character sequence matches',
-        content: 'This is a tst srch result with fuzzy matches',
-        query: 'test search',
-        expectedHighlights: ['<span class="sjs-highlight">'],
-        shouldNotContain: []
-      },
-      {
-        strategy: 'fuzzy',
-        description: 'should prefer exact matches over fuzzy matches',
-        content: 'This is a test and tst result with both exact and fuzzy',
-        query: 'test',
-        expectedHighlights: ['<span class="sjs-highlight">test</span>'],
-        shouldNotContain: ['<span class="sjs-highlight">tst</span>']
-      },
-      {
-        strategy: 'fuzzy',
-        description: 'should handle partial word matches in fuzzy search',
-        content: 'This is a testing result with partial matches',
-        query: 'test',
-        expectedHighlights: ['<span class="sjs-highlight">'],
-        shouldNotContain: []
-      },
-      {
-        strategy: 'fuzzy',
-        description: 'should handle case insensitive fuzzy matching',
-        content: 'This is a TEST result with different case',
-        query: 'test',
-        expectedHighlights: ['<span class="sjs-highlight">TEST</span>'],
-        shouldNotContain: []
-      },
-      {
-        strategy: 'fuzzy',
-        description: 'should handle mixed exact and fuzzy matches',
-        content: 'This is a test srch result with mixed matches',
-        query: 'test search result',
-        expectedHighlights: ['<span class="sjs-highlight">'],
-        shouldNotContain: []
-      },
+  describe('MatchInfo-based Highlighting', () => {
+    it('should highlight with provided matchInfo for exact matches', () => {
+      const middleware = createHighlightTemplateMiddleware();
+      const matchInfo = [
+        { start: 10, end: 14, text: 'test', type: 'exact' as const },
+        { start: 15, end: 21, text: 'search', type: 'exact' as const }
+      ];
+      const result = middleware('content', 'This is a test search result', '<div>{content}</div>', 'test search', matchInfo);
       
-      {
-        strategy: 'wildcard',
-        description: 'should highlight exact matches for wildcard search',
-        content: 'This is a test search result with wildcard patterns',
-        query: 'test search',
-        expectedHighlights: ['<span class="sjs-highlight">test</span>', '<span class="sjs-highlight">search</span>'],
-        shouldNotContain: []
-      },
-      {
-        strategy: 'wildcard',
-        description: 'should handle wildcard patterns in highlighting',
-        content: 'This is a test* search? result with wildcards',
-        query: 'test* search?',
-        expectedHighlights: ['<span class="sjs-highlight">'],
-        shouldNotContain: []
-      },
-      {
-        strategy: 'wildcard',
-        description: 'should fallback to levenshtein for wildcard search',
-        content: 'This is a tst srch result with similar words',
-        query: 'test search',
-        expectedHighlights: ['<span class="sjs-highlight">'],
-        shouldNotContain: []
-      },
-      {
-        strategy: 'wildcard',
-        description: 'should handle case insensitive wildcard search',
-        content: 'This is a TEST SEARCH result',
-        query: 'test search',
-        expectedHighlights: ['<span class="sjs-highlight">TEST</span>', '<span class="sjs-highlight">SEARCH</span>'],
-        shouldNotContain: []
-      },
+      expect(result).toContain('<span class="sjs-highlight">test</span>');
+      expect(result).toContain('<span class="sjs-highlight">search</span>');
+    });
+
+    it('should highlight with fuzzy matchInfo', () => {
+      const middleware = createHighlightTemplateMiddleware();
+      const matchInfo = [
+        { start: 10, end: 13, text: 'tst', type: 'fuzzy' as const },
+        { start: 14, end: 18, text: 'srch', type: 'fuzzy' as const }
+      ];
+      const result = middleware('content', 'This is a tst srch result', '<div>{content}</div>', 'test search', matchInfo);
       
-      {
-        strategy: 'levenshtein',
-        description: 'should highlight similar words using levenshtein distance',
-        content: 'This is a tst srch result with similar words',
-        query: 'test search',
-        expectedHighlights: ['<span class="sjs-highlight">'],
-        shouldNotContain: []
-      },
-      {
-        strategy: 'levenshtein',
-        description: 'should handle single character differences',
-        content: 'This is a tesr srch result with typos',
-        query: 'test search',
-        expectedHighlights: [],
-        shouldNotContain: []
-      },
-      {
-        strategy: 'levenshtein',
-        description: 'should handle case insensitive levenshtein matching',
-        content: 'This is a TST SRCH result with different case',
-        query: 'test search',
-        expectedHighlights: ['<span class="sjs-highlight">'],
-        shouldNotContain: []
-      },
+      expect(result).toContain('<span class="sjs-highlight">tst</span>');
+      expect(result).toContain('<span class="sjs-highlight">srch</span>');
+    });
+
+    it('should highlight with wildcard matchInfo', () => {
+      const middleware = createHighlightTemplateMiddleware();
+      const matchInfo = [
+        { start: 10, end: 14, text: 'test', type: 'wildcard' as const }
+      ];
+      const result = middleware('content', 'This is a test result', '<div>{content}</div>', 'test*', matchInfo);
       
-      {
-        strategy: 'all',
-        description: 'should handle empty query',
-        content: 'This is a test result',
-        query: '',
-        expectedHighlights: [],
-        shouldNotContain: ['<span class="sjs-highlight">']
-      },
-      {
-        strategy: 'all',
-        description: 'should handle query with only spaces',
-        content: 'This is a test result',
-        query: '   ',
-        expectedHighlights: [],
-        shouldNotContain: ['<span class="sjs-highlight">']
-      },
-      {
-        strategy: 'all',
-        description: 'should handle special characters in query',
-        content: 'This is a test-result with special chars',
-        query: 'test-result',
-        expectedHighlights: ['<span class="sjs-highlight">test-result</span>'],
-        shouldNotContain: []
-      },
-      {
-        strategy: 'all',
-        description: 'should handle regex special characters safely',
-        content: 'This is a test.result with regex chars',
-        query: 'test.result',
-        expectedHighlights: ['<span class="sjs-highlight">test.result</span>'],
-        shouldNotContain: []
-      },
-      {
-        strategy: 'all',
-        description: 'should handle punctuation in search terms',
-        content: 'This is a test, search! result with punctuation',
-        query: 'test, search!',
-        expectedHighlights: ['<span class="sjs-highlight">'],
-        shouldNotContain: []
-      },
-      {
-        strategy: 'all',
-        description: 'should handle numbers in search terms',
-        content: 'This is a test123 search456 result with numbers',
-        query: 'test123 search456',
-        expectedHighlights: ['<span class="sjs-highlight">test123</span>', '<span class="sjs-highlight">search456</span>'],
-        shouldNotContain: []
-      }
-    ];
+      expect(result).toContain('<span class="sjs-highlight">test</span>');
+    });
 
-    it.each(testCases)('$strategy: $description', ({ content, query, expectedHighlights, shouldNotContain }) => {
+    it('should not highlight without matchInfo', () => {
       const middleware = createHighlightTemplateMiddleware();
-      const result = middleware('content', content, '<div>{content}</div>', query);
+      const result = middleware('content', 'This is a test search result', '<div>{content}</div>', 'test search');
       
-      if (expectedHighlights.length > 0) {
-        expectedHighlights.forEach(highlight => {
-          expect(result).toContain(highlight);
-        });
-      } else {
-        expect(result).toBeUndefined();
-      }
+      expect(result).toBeUndefined();
+    });
+
+    it('should not highlight with empty matchInfo', () => {
+      const middleware = createHighlightTemplateMiddleware();
+      const result = middleware('content', 'This is a test search result', '<div>{content}</div>', 'test search', []);
       
-      shouldNotContain.forEach(notExpected => {
-        if (result) {
-          expect(result).not.toContain(notExpected);
-        }
-      });
+      expect(result).toBeUndefined();
     });
-  });
 
-  describe('Multi-word Search Strategy Tests', () => {
-    const multiWordTestCases = [
-      {
-        strategy: 'literal',
-        description: 'should highlight all exact words for literal search',
-        content: 'This is a test search result with multiple words',
-        query: 'test search result',
-        expectedWords: ['test', 'search', 'result'],
-        shouldNotHighlight: ['testing', 'searching', 'results']
-      },
-      {
-        strategy: 'literal',
-        description: 'should handle partial word matches in literal search',
-        content: 'This is a testing searching results with partial words',
-        query: 'test search result',
-        expectedWords: [],
-        shouldNotHighlight: ['testing', 'searching', 'results']
-      },
-      {
-        strategy: 'fuzzy',
-        description: 'should highlight all fuzzy matches for fuzzy search',
-        content: 'This is a tst srch rslt with fuzzy matches',
-        query: 'test search result',
-        expectedWords: [],
-        shouldNotHighlight: []
-      },
-      {
-        strategy: 'fuzzy',
-        description: 'should mix exact and fuzzy matches for fuzzy search',
-        content: 'This is a test srch result with mixed matches',
-        query: 'test search result',
-        expectedWords: ['test', 'result'],
-        shouldNotHighlight: ['search']
-      },
-      {
-        strategy: 'fuzzy',
-        description: 'should handle case insensitive multi-word fuzzy search',
-        content: 'This is a TEST SRCH RESULT with different case',
-        query: 'test search result',
-        expectedWords: ['TEST', 'RESULT'],
-        shouldNotHighlight: []
-      },
-      {
-        strategy: 'wildcard',
-        description: 'should highlight exact matches for wildcard search',
-        content: 'This is a test search result with wildcard patterns',
-        query: 'test search result',
-        expectedWords: ['test', 'search', 'result'],
-        shouldNotHighlight: []
-      },
-      {
-        strategy: 'wildcard',
-        description: 'should fallback to levenshtein for wildcard search',
-        content: 'This is a tst srch rslt with similar words',
-        query: 'test search result',
-        expectedWords: [],
-        shouldNotHighlight: []
-      },
-      {
-        strategy: 'levenshtein',
-        description: 'should highlight similar words using levenshtein distance',
-        content: 'This is a tesr srch rslt with typos',
-        query: 'test search result',
-        expectedWords: [],
-        shouldNotHighlight: []
-      },
-      {
-        strategy: 'levenshtein',
-        description: 'should handle mixed exact and similar words',
-        content: 'This is a test srch result with mixed accuracy',
-        query: 'test search result',
-        expectedWords: ['test', 'result'],
-        shouldNotHighlight: ['search']
-      }
-    ];
+    it('should handle case insensitive matchInfo', () => {
+      const middleware = createHighlightTemplateMiddleware();
+      const matchInfo = [
+        { start: 10, end: 14, text: 'TEST', type: 'exact' as const }
+      ];
+      const result = middleware('content', 'This is a TEST result', '<div>{content}</div>', 'test', matchInfo);
+      
+      expect(result).toContain('<span class="sjs-highlight">TEST</span>');
+    });
 
-    it.each(multiWordTestCases)('$strategy: $description', ({ content, query, expectedWords, shouldNotHighlight }) => {
+    it('should handle special characters in matchInfo', () => {
       const middleware = createHighlightTemplateMiddleware();
-      const result = middleware('content', content, '<div>{content}</div>', query);
+      const matchInfo = [
+        { start: 10, end: 21, text: 'test-result', type: 'exact' as const }
+      ];
+      const result = middleware('content', 'This is a test-result with special chars', '<div>{content}</div>', 'test-result', matchInfo);
       
-      expectedWords.forEach(word => {
-        expect(result).toContain(`<span class="sjs-highlight">${word}</span>`);
-      });
+      expect(result).toContain('<span class="sjs-highlight">test-result</span>');
+    });
+
+    it('should handle numbers in matchInfo', () => {
+      const middleware = createHighlightTemplateMiddleware();
+      const matchInfo = [
+        { start: 10, end: 17, text: 'test123', type: 'exact' as const },
+        { start: 18, end: 27, text: 'search456', type: 'exact' as const }
+      ];
+      const result = middleware('content', 'This is a test123 search456 result', '<div>{content}</div>', 'test123 search456', matchInfo);
       
-      shouldNotHighlight.forEach(word => {
-        if (result) {
-          expect(result).not.toContain(`<span class="sjs-highlight">${word}</span>`);
-        }
-      });
+      expect(result).toContain('<span class="sjs-highlight">test123</span>');
+      expect(result).toContain('<span class="sjs-highlight">search456</span>');
     });
   });
 
+
   describe('Match Info Usage (Performance Test)', () => {
-    it('should use provided match info instead of re-searching', () => {
+    it('should use provided match info for highlighting', () => {
       const middleware = createHighlightTemplateMiddleware();
       const text = 'This is a test content with test words';
       const query = 'test';
       
-      const matchInfo = [];
+      const matchInfo: Array<{ start: number; end: number; text: string; type: 'exact' }> = [];
       let index = text.toLowerCase().indexOf('test');
       while (index !== -1) {
         matchInfo.push({
@@ -595,36 +385,39 @@ describe('createHighlightTemplateMiddleware', () => {
       
       const resultWithMatchInfo = middleware('content', text, '<div>{content}</div>', query, matchInfo);
       
-      const resultWithoutMatchInfo = middleware('content', text, '<div>{content}</div>', query);
-      
       expect(resultWithMatchInfo).toBeDefined();
-      expect(resultWithoutMatchInfo).toBeDefined();
       expect(resultWithMatchInfo).toContain('<span class="sjs-highlight">test</span>');
-      expect(resultWithoutMatchInfo).toContain('<span class="sjs-highlight">test</span>');
-      
-      expect(resultWithMatchInfo).toBe(resultWithoutMatchInfo);
+      expect(resultWithMatchInfo).toContain('<span class="sjs-highlight">test</span>');
     });
 
-    it('should handle empty match info gracefully', () => {
+    it('should not highlight with empty match info', () => {
       const middleware = createHighlightTemplateMiddleware();
       const text = 'This is a test content';
       const query = 'test';
       
       const result = middleware('content', text, '<div>{content}</div>', query, []);
       
-      expect(result).toBeDefined();
-      expect(result).toContain('<span class="sjs-highlight">test</span>');
+      expect(result).toBeUndefined();
     });
 
-    it('should handle undefined match info gracefully', () => {
+    it('should not highlight with undefined match info', () => {
       const middleware = createHighlightTemplateMiddleware();
       const text = 'This is a test content';
       const query = 'test';
       
       const result = middleware('content', text, '<div>{content}</div>', query, undefined);
       
-      expect(result).toBeDefined();
-      expect(result).toContain('<span class="sjs-highlight">test</span>');
+      expect(result).toBeUndefined();
+    });
+
+    it('should not highlight without match info parameter', () => {
+      const middleware = createHighlightTemplateMiddleware();
+      const text = 'This is a test content';
+      const query = 'test';
+      
+      const result = middleware('content', text, '<div>{content}</div>', query);
+      
+      expect(result).toBeUndefined();
     });
   });
 });

From cfe19325f66ff94f6e2c080d56d2e2fe3ca3eb62 Mon Sep 17 00:00:00 2001
From: sylhare <sylhare@outlook.com>
Date: Sat, 11 Oct 2025 10:24:35 -0400
Subject: [PATCH 10/10] Update strategy

---
 dest/simple-jekyll-search.js                  |  25 +++-
 dest/simple-jekyll-search.min.js              |   2 +-
 docs/assets/js/simple-jekyll-search.min.js    |   2 +-
 src/SearchStrategies/SearchStrategy.ts        |  30 +----
 src/SearchStrategies/search/fuzzySearch.ts    |  24 ++++
 src/SearchStrategies/search/literalSearch.ts  |   7 +-
 src/SearchStrategies/search/wildcardSearch.ts |  16 ++-
 tests/SearchStrategies/wildcardSearch.test.ts |  20 ++-
 tests/highlightMiddleware.test.ts             | 126 ++++++++++++++++++
 9 files changed, 214 insertions(+), 38 deletions(-)

diff --git a/dest/simple-jekyll-search.js b/dest/simple-jekyll-search.js
index aa03367..5f27ce9 100644
--- a/dest/simple-jekyll-search.js
+++ b/dest/simple-jekyll-search.js
@@ -168,9 +168,18 @@
   }
   function findWildcardMatches(text, pattern) {
     if (!text || !pattern) return [];
-    const wildcardMatches = findWildcardPatternMatches(text, pattern);
-    if (wildcardMatches.length > 0) {
-      return mergeAndSortMatches(wildcardMatches);
+    if (pattern.includes("*") || pattern.includes("?")) {
+      const wildcardMatches = findWildcardPatternMatches(text, pattern);
+      if (wildcardMatches.length > 0) {
+        return mergeAndSortMatches(wildcardMatches);
+      }
+    }
+    const literalMatches = findLiteralMatches(text, pattern);
+    if (literalMatches.length > 0) {
+      return literalMatches.map((match) => ({
+        ...match,
+        type: "wildcard"
+      }));
     }
     if (levenshteinSearch(text, pattern)) {
       return [{
@@ -255,8 +264,14 @@
   );
   const WildcardSearchStrategy = new SearchStrategy(
     (text, criteria) => {
-      const wildcardMatches = findWildcardMatches(text, criteria);
-      return wildcardMatches.length > 0;
+      if (criteria.includes("*") || criteria.includes("?")) {
+        const wildcardMatches = findWildcardMatches(text, criteria);
+        return wildcardMatches.length > 0;
+      }
+      if (!text || !criteria) return false;
+      const lowerText = text.trim().toLowerCase();
+      const pattern = criteria.endsWith(" ") ? [criteria.toLowerCase()] : criteria.trim().toLowerCase().split(" ");
+      return pattern.filter((word) => lowerText.indexOf(word) >= 0).length === pattern.length;
     },
     findWildcardMatches
   );
diff --git a/dest/simple-jekyll-search.min.js b/dest/simple-jekyll-search.min.js
index 5856dbb..63a5daf 100644
--- a/dest/simple-jekyll-search.min.js
+++ b/dest/simple-jekyll-search.min.js
@@ -4,4 +4,4 @@
   * Copyright 2025-2025, Sylhare
   * Licensed under the MIT License.
   */
-(function(global,factory){typeof exports==="object"&&typeof module!=="undefined"?factory(exports):typeof define==="function"&&define.amd?define(["exports"],factory):(global=typeof globalThis!=="undefined"?globalThis:global||self,factory(global.SimpleJekyllSearch={}))})(this,(function(exports2){"use strict";function load(location,callback){const xhr=getXHR();xhr.open("GET",location,true);xhr.onreadystatechange=createStateChangeListener(xhr,callback);xhr.send()}function createStateChangeListener(xhr,callback){return function(){if(xhr.readyState===4&&xhr.status===200){try{callback(null,JSON.parse(xhr.responseText))}catch(err){callback(err instanceof Error?err:new Error(String(err)),null)}}}}function getXHR(){return window.XMLHttpRequest?new window.XMLHttpRequest:new window.ActiveXObject("Microsoft.XMLHTTP")}class OptionsValidator{constructor(params){if(!this.validateParams(params)){throw new Error("-- OptionsValidator: required options missing")}this.requiredOptions=params.required}getRequiredOptions(){return this.requiredOptions}validate(parameters){const errors=[];this.requiredOptions.forEach((requiredOptionName=>{if(typeof parameters[requiredOptionName]==="undefined"){errors.push(requiredOptionName)}}));return errors}validateParams(params){if(!params){return false}return typeof params.required!=="undefined"&&Array.isArray(params.required)}}function findFuzzyMatches(text,pattern){if(!text||!pattern)return[];const lowerText=text.toLowerCase();const lowerPattern=pattern.toLowerCase().trim();if(lowerPattern.length===0)return[];const matches=[];for(let i=0;i<lowerText.length;i++){const match=findFuzzySequenceMatch(lowerText,lowerPattern,i);if(match){const isExact=match.text===lowerPattern;matches.push({start:match.start,end:match.end,text:text.substring(match.start,match.end),type:isExact?"exact":"fuzzy"});i=match.end-1}}return matches}function findFuzzySequenceMatch(text,pattern,startPos){let textIndex=startPos;let patternIndex=0;let matchStart=-1;let maxGap=10;while(textIndex<text.length&&patternIndex<pattern.length){if(text[textIndex]===pattern[patternIndex]){if(matchStart===-1){matchStart=textIndex}patternIndex++}else if(matchStart!==-1){const gap=textIndex-matchStart;if(gap>maxGap){return null}}textIndex++}if(patternIndex===pattern.length&&matchStart!==-1){return{start:matchStart,end:textIndex,text:text.substring(matchStart,textIndex)}}return null}function findLiteralMatches(text,criteria){if(!text||!criteria)return[];const lowerText=text.toLowerCase();const hasTrailingSpace=criteria.endsWith(" ");const words=criteria.trim().toLowerCase().split(/\s+/);const matches=[];let textIndex=0;for(const word of words){if(word.length===0)continue;let wordIndex=lowerText.indexOf(word,textIndex);if(hasTrailingSpace&&word===words[words.length-1]){while(wordIndex!==-1){const nextChar=lowerText[wordIndex+word.length];if(!nextChar||!/\w/.test(nextChar)){break}wordIndex=lowerText.indexOf(word,wordIndex+1)}}if(wordIndex!==-1){matches.push({start:wordIndex,end:wordIndex+word.length,text:text.substring(wordIndex,wordIndex+word.length),type:"exact"});textIndex=wordIndex+word.length}}return matches}function levenshtein(a,b){const lenA=a.length;const lenB=b.length;const distanceMatrix=Array.from({length:lenA+1},(()=>Array(lenB+1).fill(0)));for(let i=0;i<=lenA;i++)distanceMatrix[i][0]=i;for(let j=0;j<=lenB;j++)distanceMatrix[0][j]=j;for(let i=1;i<=lenA;i++){for(let j=1;j<=lenB;j++){const cost=a[i-1]===b[j-1]?0:1;distanceMatrix[i][j]=Math.min(distanceMatrix[i-1][j]+1,distanceMatrix[i][j-1]+1,distanceMatrix[i-1][j-1]+cost)}}return distanceMatrix[lenA][lenB]}function levenshteinSearch(text,pattern){const distance=levenshtein(pattern,text);const similarity=1-distance/Math.max(pattern.length,text.length);return similarity>=.3}function mergeAndSortMatches(matches){if(matches.length===0)return[];const sortedMatches=matches.sort(((a,b)=>a.start-b.start));const merged=[];for(const match of sortedMatches){const lastMerged=merged[merged.length-1];if(lastMerged&&match.start<=lastMerged.end){lastMerged.end=Math.max(lastMerged.end,match.end);lastMerged.text=lastMerged.text+match.text.slice(lastMerged.end-match.start)}else{merged.push({...match})}}return merged}function findWildcardMatches(text,pattern){if(!text||!pattern)return[];const wildcardMatches=findWildcardPatternMatches(text,pattern);if(wildcardMatches.length>0){return mergeAndSortMatches(wildcardMatches)}if(levenshteinSearch(text,pattern)){return[{start:0,end:text.length,text:text,type:"wildcard"}]}return[]}function findWildcardPatternMatches(text,pattern){const matches=[];const regexPattern=pattern.replace(/\*/g,".*");const regex=new RegExp(regexPattern,"gi");let match;let lastIndex=0;while((match=regex.exec(text))!==null){if(match.index===lastIndex&&match[0].length===0){break}lastIndex=match.index;matches.push({start:match.index,end:match.index+match[0].length,text:match[0],type:"wildcard"});if(match[0].length===text.length){break}}return matches}class SearchStrategy{constructor(matchFunction,findMatchesFunction){this.matchFunction=matchFunction;this.findMatchesFunction=findMatchesFunction}matches(text,criteria){if(text===null||text.trim()===""||!criteria){return false}return this.matchFunction(text,criteria)}findMatches(text,criteria){if(text===null||text.trim()===""||!criteria){return[]}return this.findMatchesFunction(text,criteria)}}const LiteralSearchStrategy=new SearchStrategy(((text,criteria)=>{if(!text||!criteria)return false;const lowerText=text.trim().toLowerCase();const pattern=criteria.endsWith(" ")?[criteria.toLowerCase()]:criteria.trim().toLowerCase().split(" ");return pattern.filter((word=>lowerText.indexOf(word)>=0)).length===pattern.length}),findLiteralMatches);const FuzzySearchStrategy=new SearchStrategy(((text,criteria)=>{const pattern=criteria.trimEnd();if(pattern.length===0)return true;const lowerPattern=pattern.toLowerCase();const lowerText=text.toLowerCase();let remainingText=lowerText,currentIndex=-1;for(const char of lowerPattern){const nextIndex=remainingText.indexOf(char);if(nextIndex===-1||currentIndex!==-1&&remainingText.slice(0,nextIndex).split(" ").length-1>2){const lowerText2=text.trim().toLowerCase();const pattern2=criteria.endsWith(" ")?[criteria.toLowerCase()]:criteria.trim().toLowerCase().split(" ");return pattern2.filter((word=>lowerText2.indexOf(word)>=0)).length===pattern2.length}currentIndex=nextIndex;remainingText=remainingText.slice(nextIndex+1)}return true}),findFuzzyMatches);const WildcardSearchStrategy=new SearchStrategy(((text,criteria)=>{const wildcardMatches=findWildcardMatches(text,criteria);return wildcardMatches.length>0}),findWildcardMatches);function merge(target,source){return{...target,...source}}function isJSON(json){try{return!!(json instanceof Object&&JSON.parse(JSON.stringify(json)))}catch(_err){return false}}function NoSort(){return 0}function isObject(obj){return Boolean(obj)&&Object.prototype.toString.call(obj)==="[object Object]"}function clone(input){if(input===null||typeof input!=="object"){return input}if(Array.isArray(input)){return input.map((item=>clone(item)))}const output={};for(const key in input){if(Object.prototype.hasOwnProperty.call(input,key)){output[key]=clone(input[key])}}return output}const DEFAULT_OPTIONS={searchInput:null,resultsContainer:null,json:[],success:function(){},searchResultTemplate:'<li><a href="{url}" title="{desc}">{title}</a></li>',templateMiddleware:(_prop,_value,_template,_query)=>void 0,sortMiddleware:NoSort,noResultsText:"No results found",limit:10,fuzzy:false,strategy:"literal",debounceTime:null,exclude:[],onSearch:()=>{}};const REQUIRED_OPTIONS=["searchInput","resultsContainer","json"];const WHITELISTED_KEYS=new Set(["Enter","Shift","CapsLock","ArrowLeft","ArrowUp","ArrowRight","ArrowDown","Meta"]);class Repository{constructor(initialOptions={}){this.data=[];this.setOptions(initialOptions)}put(input){if(isObject(input)){return this.addObject(input)}if(Array.isArray(input)){return this.addArray(input)}return void 0}clear(){this.data.length=0;return this.data}search(criteria){if(!criteria){return[]}return clone(this.findMatches(this.data,criteria).sort(this.options.sortMiddleware))}setOptions(newOptions){this.options={fuzzy:(newOptions==null?void 0:newOptions.fuzzy)||DEFAULT_OPTIONS.fuzzy,limit:(newOptions==null?void 0:newOptions.limit)||DEFAULT_OPTIONS.limit,searchStrategy:this.searchStrategy((newOptions==null?void 0:newOptions.strategy)||newOptions.fuzzy&&"fuzzy"||DEFAULT_OPTIONS.strategy),sortMiddleware:(newOptions==null?void 0:newOptions.sortMiddleware)||DEFAULT_OPTIONS.sortMiddleware,exclude:(newOptions==null?void 0:newOptions.exclude)||DEFAULT_OPTIONS.exclude,strategy:(newOptions==null?void 0:newOptions.strategy)||DEFAULT_OPTIONS.strategy}}addObject(obj){this.data.push(obj);return this.data}addArray(arr){const added=[];this.clear();for(const item of arr){if(isObject(item)){added.push(this.addObject(item)[0])}}return added}findMatches(data,criteria){const matches=[];for(let i=0;i<data.length&&matches.length<this.options.limit;i++){const match=this.findMatchesInObject(data[i],criteria);if(match){matches.push(match)}}return matches}findMatchesInObject(obj,criteria){let hasMatch=false;const result={...obj};result._matchInfo={};for(const key in obj){if(!this.isExcluded(obj[key])&&this.options.searchStrategy.matches(obj[key],criteria)){hasMatch=true;const matchInfo=this.options.searchStrategy.findMatches(obj[key],criteria);if(matchInfo&&matchInfo.length>0){result._matchInfo[key]=matchInfo}}}return hasMatch?result:void 0}isExcluded(term){for(const excludedTerm of this.options.exclude){if(new RegExp(excludedTerm).test(String(term))){return true}}return false}searchStrategy(strategy){switch(strategy){case"fuzzy":return FuzzySearchStrategy;case"wildcard":return WildcardSearchStrategy;default:return LiteralSearchStrategy}}}const options={pattern:/\{(.*?)\}/g,template:"",middleware:function(){return void 0}};function setOptions(_options){if(_options.pattern){options.pattern=_options.pattern}if(_options.template){options.template=_options.template}if(typeof _options.middleware==="function"){options.middleware=_options.middleware}}function compile(data,query){return options.template.replace(options.pattern,(function(match,prop){const matchInfo=data._matchInfo&&data._matchInfo[prop]?data._matchInfo[prop]:void 0;const value=options.middleware(prop,data[prop],options.template,query,matchInfo);if(typeof value!=="undefined"){return value}return data[prop]||match}))}let SimpleJekyllSearch$1=class SimpleJekyllSearch{constructor(){this.debounceTimerHandle=null;this.options={...DEFAULT_OPTIONS};this.repository=new Repository;this.optionsValidator=new OptionsValidator({required:REQUIRED_OPTIONS})}debounce(func,delayMillis){if(delayMillis){if(this.debounceTimerHandle){clearTimeout(this.debounceTimerHandle)}this.debounceTimerHandle=setTimeout(func,delayMillis)}else{func()}}throwError(message){throw new Error(`SimpleJekyllSearch --- ${message}`)}emptyResultsContainer(){this.options.resultsContainer.innerHTML=""}initWithJSON(json){this.repository.put(json);this.registerInput()}initWithURL(url){load(url,((err,json)=>{if(err){this.throwError(`Failed to load JSON from ${url}: ${err.message}`)}this.initWithJSON(json)}))}registerInput(){this.options.searchInput.addEventListener("input",(e=>{const inputEvent=e;if(!WHITELISTED_KEYS.has(inputEvent.key)){this.emptyResultsContainer();this.debounce((()=>{this.search(e.target.value)}),this.options.debounceTime??null)}}))}search(query){var _a,_b;if((query==null?void 0:query.trim().length)>0){this.emptyResultsContainer();const results=this.repository.search(query);this.render(results,query);(_b=(_a=this.options).onSearch)==null?void 0:_b.call(_a)}}render(results,query){if(results.length===0){this.options.resultsContainer.insertAdjacentHTML("beforeend",this.options.noResultsText);return}const fragment=document.createDocumentFragment();results.forEach((result=>{result.query=query;const div=document.createElement("div");div.innerHTML=compile(result,query);fragment.appendChild(div)}));this.options.resultsContainer.appendChild(fragment)}init(_options){var _a;const errors=this.optionsValidator.validate(_options);if(errors.length>0){this.throwError(`Missing required options: ${REQUIRED_OPTIONS.join(", ")}`)}this.options=merge(this.options,_options);setOptions({template:this.options.searchResultTemplate,middleware:this.options.templateMiddleware});this.repository.setOptions({fuzzy:this.options.fuzzy,limit:this.options.limit,sortMiddleware:this.options.sortMiddleware,strategy:this.options.strategy,exclude:this.options.exclude});if(isJSON(this.options.json)){this.initWithJSON(this.options.json)}else{this.initWithURL(this.options.json)}const rv={search:this.search.bind(this)};(_a=this.options.success)==null?void 0:_a.call(rv);return rv}};function createHighlightMiddleware(options2={}){const{highlightClass:highlightClass="sjs-highlight",contextBefore:contextBefore=50,contextAfter:contextAfter=50,maxLength:maxLength=250,ellipsis:ellipsis="..."}=options2;return function(result,query){if(!query||!result){return result}const highlightedResult={...result};const textFields=["title","desc","content","excerpt"];for(const field of textFields){if(highlightedResult[field]&&typeof highlightedResult[field]==="string"){const highlighted=highlightText(highlightedResult[field],query,{highlightClass:highlightClass,contextBefore:contextBefore,contextAfter:contextAfter,maxLength:maxLength,ellipsis:ellipsis});if(highlighted.highlightedText!==highlightedResult[field]){highlightedResult[field]=highlighted.highlightedText}}}return highlightedResult}}function highlightText(text,query,options2={}){const{highlightClass:highlightClass="sjs-highlight",contextBefore:contextBefore=50,contextAfter:contextAfter=50,maxLength:maxLength=250,ellipsis:ellipsis="..."}=options2;if(!text||!query){return{highlightedText:text,matchCount:0}}const originalText=text;const searchTerms=query.trim().toLowerCase().split(/\s+/).filter((term=>term.length>0));if(searchTerms.length===0){return{highlightedText:text,matchCount:0}}const matches=[];for(const term of searchTerms){let index=0;while(index<text.length){const found=text.toLowerCase().indexOf(term,index);if(found===-1)break;matches.push({start:found,end:found+term.length,term:text.substring(found,found+term.length)});index=found+1}}if(matches.length===0){return{highlightedText:text,matchCount:0}}matches.sort(((a,b)=>a.start-b.start));const mergedMatches=[];for(const match of matches){if(mergedMatches.length===0||mergedMatches[mergedMatches.length-1].end<match.start){mergedMatches.push(match)}else{const lastMatch=mergedMatches[mergedMatches.length-1];lastMatch.end=Math.max(lastMatch.end,match.end);lastMatch.term=text.substring(lastMatch.start,lastMatch.end)}}if(text.length<=maxLength){let highlightedText2=text;for(let i=mergedMatches.length-1;i>=0;i--){const match=mergedMatches[i];const before=highlightedText2.substring(0,match.start);const after=highlightedText2.substring(match.end);const matchText=highlightedText2.substring(match.start,match.end);highlightedText2=before+`<span class="${highlightClass}">${matchText}</span>`+after}return{highlightedText:highlightedText2,matchCount:mergedMatches.length}}let highlightedText="";let totalLength=0;let lastEnd=0;for(let i=0;i<mergedMatches.length;i++){const match=mergedMatches[i];const contextStart=Math.max(lastEnd,match.start-contextBefore);const contextEnd=Math.min(text.length,match.end+contextAfter);if(contextStart>lastEnd&&lastEnd>0){highlightedText+=ellipsis;totalLength+=ellipsis.length}if(contextStart<match.start){const beforeText=text.substring(contextStart,match.start);highlightedText+=beforeText;totalLength+=beforeText.length}const matchText=text.substring(match.start,match.end);highlightedText+=`<span class="${highlightClass}">${matchText}</span>`;totalLength+=matchText.length;if(match.end<contextEnd){const afterText=text.substring(match.end,contextEnd);highlightedText+=afterText;totalLength+=afterText.length}lastEnd=contextEnd;if(totalLength>=maxLength){if(contextEnd<text.length){highlightedText+=ellipsis}break}}return{highlightedText:highlightedText||originalText,matchCount:mergedMatches.length}}const defaultHighlightMiddleware=createHighlightMiddleware();function highlightWithMatchInfo(text,matchInfo,options2){if(matchInfo.length===0)return text;const sortedMatches=[...matchInfo].sort(((a,b)=>b.start-a.start));let highlightedText=text;for(const match of sortedMatches){const before=highlightedText.substring(0,match.start);const after=highlightedText.substring(match.end);const matchText=highlightedText.substring(match.start,match.end);highlightedText=before+`<span class="${options2.highlightClass}">${matchText}</span>`+after}return highlightedText}function createHighlightTemplateMiddleware(options2={}){const highlightOptions={highlightClass:"sjs-highlight",...options2};return function(prop,value,_template,query,matchInfo){if((prop==="content"||prop==="desc")&&query&&typeof value==="string"){if(matchInfo&&matchInfo.length>0){const highlighted=highlightWithMatchInfo(value,matchInfo,highlightOptions);return highlighted!==value?highlighted:void 0}}return void 0}}const defaultHighlightTemplateMiddleware=createHighlightTemplateMiddleware();function SimpleJekyllSearch(options2){const instance=new SimpleJekyllSearch$1;return instance.init(options2)}if(typeof window!=="undefined"){window.SimpleJekyllSearch=SimpleJekyllSearch;window.SimpleJekyllSearch.createHighlightMiddleware=createHighlightMiddleware;window.SimpleJekyllSearch.createHighlightTemplateMiddleware=createHighlightTemplateMiddleware;window.SimpleJekyllSearch.highlightText=highlightText;window.SimpleJekyllSearch.defaultHighlightMiddleware=defaultHighlightMiddleware;window.SimpleJekyllSearch.defaultHighlightTemplateMiddleware=defaultHighlightTemplateMiddleware}exports2.createHighlightMiddleware=createHighlightMiddleware;exports2.createHighlightTemplateMiddleware=createHighlightTemplateMiddleware;exports2.default=SimpleJekyllSearch;exports2.defaultHighlightMiddleware=defaultHighlightMiddleware;exports2.defaultHighlightTemplateMiddleware=defaultHighlightTemplateMiddleware;exports2.highlightText=highlightText;Object.defineProperties(exports2,{__esModule:{value:true},[Symbol.toStringTag]:{value:"Module"}})}));
\ No newline at end of file
+(function(global,factory){typeof exports==="object"&&typeof module!=="undefined"?factory(exports):typeof define==="function"&&define.amd?define(["exports"],factory):(global=typeof globalThis!=="undefined"?globalThis:global||self,factory(global.SimpleJekyllSearch={}))})(this,(function(exports2){"use strict";function load(location,callback){const xhr=getXHR();xhr.open("GET",location,true);xhr.onreadystatechange=createStateChangeListener(xhr,callback);xhr.send()}function createStateChangeListener(xhr,callback){return function(){if(xhr.readyState===4&&xhr.status===200){try{callback(null,JSON.parse(xhr.responseText))}catch(err){callback(err instanceof Error?err:new Error(String(err)),null)}}}}function getXHR(){return window.XMLHttpRequest?new window.XMLHttpRequest:new window.ActiveXObject("Microsoft.XMLHTTP")}class OptionsValidator{constructor(params){if(!this.validateParams(params)){throw new Error("-- OptionsValidator: required options missing")}this.requiredOptions=params.required}getRequiredOptions(){return this.requiredOptions}validate(parameters){const errors=[];this.requiredOptions.forEach((requiredOptionName=>{if(typeof parameters[requiredOptionName]==="undefined"){errors.push(requiredOptionName)}}));return errors}validateParams(params){if(!params){return false}return typeof params.required!=="undefined"&&Array.isArray(params.required)}}function findFuzzyMatches(text,pattern){if(!text||!pattern)return[];const lowerText=text.toLowerCase();const lowerPattern=pattern.toLowerCase().trim();if(lowerPattern.length===0)return[];const matches=[];for(let i=0;i<lowerText.length;i++){const match=findFuzzySequenceMatch(lowerText,lowerPattern,i);if(match){const isExact=match.text===lowerPattern;matches.push({start:match.start,end:match.end,text:text.substring(match.start,match.end),type:isExact?"exact":"fuzzy"});i=match.end-1}}return matches}function findFuzzySequenceMatch(text,pattern,startPos){let textIndex=startPos;let patternIndex=0;let matchStart=-1;let maxGap=10;while(textIndex<text.length&&patternIndex<pattern.length){if(text[textIndex]===pattern[patternIndex]){if(matchStart===-1){matchStart=textIndex}patternIndex++}else if(matchStart!==-1){const gap=textIndex-matchStart;if(gap>maxGap){return null}}textIndex++}if(patternIndex===pattern.length&&matchStart!==-1){return{start:matchStart,end:textIndex,text:text.substring(matchStart,textIndex)}}return null}function findLiteralMatches(text,criteria){if(!text||!criteria)return[];const lowerText=text.toLowerCase();const hasTrailingSpace=criteria.endsWith(" ");const words=criteria.trim().toLowerCase().split(/\s+/);const matches=[];let textIndex=0;for(const word of words){if(word.length===0)continue;let wordIndex=lowerText.indexOf(word,textIndex);if(hasTrailingSpace&&word===words[words.length-1]){while(wordIndex!==-1){const nextChar=lowerText[wordIndex+word.length];if(!nextChar||!/\w/.test(nextChar)){break}wordIndex=lowerText.indexOf(word,wordIndex+1)}}if(wordIndex!==-1){matches.push({start:wordIndex,end:wordIndex+word.length,text:text.substring(wordIndex,wordIndex+word.length),type:"exact"});textIndex=wordIndex+word.length}}return matches}function levenshtein(a,b){const lenA=a.length;const lenB=b.length;const distanceMatrix=Array.from({length:lenA+1},(()=>Array(lenB+1).fill(0)));for(let i=0;i<=lenA;i++)distanceMatrix[i][0]=i;for(let j=0;j<=lenB;j++)distanceMatrix[0][j]=j;for(let i=1;i<=lenA;i++){for(let j=1;j<=lenB;j++){const cost=a[i-1]===b[j-1]?0:1;distanceMatrix[i][j]=Math.min(distanceMatrix[i-1][j]+1,distanceMatrix[i][j-1]+1,distanceMatrix[i-1][j-1]+cost)}}return distanceMatrix[lenA][lenB]}function levenshteinSearch(text,pattern){const distance=levenshtein(pattern,text);const similarity=1-distance/Math.max(pattern.length,text.length);return similarity>=.3}function mergeAndSortMatches(matches){if(matches.length===0)return[];const sortedMatches=matches.sort(((a,b)=>a.start-b.start));const merged=[];for(const match of sortedMatches){const lastMerged=merged[merged.length-1];if(lastMerged&&match.start<=lastMerged.end){lastMerged.end=Math.max(lastMerged.end,match.end);lastMerged.text=lastMerged.text+match.text.slice(lastMerged.end-match.start)}else{merged.push({...match})}}return merged}function findWildcardMatches(text,pattern){if(!text||!pattern)return[];if(pattern.includes("*")||pattern.includes("?")){const wildcardMatches=findWildcardPatternMatches(text,pattern);if(wildcardMatches.length>0){return mergeAndSortMatches(wildcardMatches)}}const literalMatches=findLiteralMatches(text,pattern);if(literalMatches.length>0){return literalMatches.map((match=>({...match,type:"wildcard"})))}if(levenshteinSearch(text,pattern)){return[{start:0,end:text.length,text:text,type:"wildcard"}]}return[]}function findWildcardPatternMatches(text,pattern){const matches=[];const regexPattern=pattern.replace(/\*/g,".*");const regex=new RegExp(regexPattern,"gi");let match;let lastIndex=0;while((match=regex.exec(text))!==null){if(match.index===lastIndex&&match[0].length===0){break}lastIndex=match.index;matches.push({start:match.index,end:match.index+match[0].length,text:match[0],type:"wildcard"});if(match[0].length===text.length){break}}return matches}class SearchStrategy{constructor(matchFunction,findMatchesFunction){this.matchFunction=matchFunction;this.findMatchesFunction=findMatchesFunction}matches(text,criteria){if(text===null||text.trim()===""||!criteria){return false}return this.matchFunction(text,criteria)}findMatches(text,criteria){if(text===null||text.trim()===""||!criteria){return[]}return this.findMatchesFunction(text,criteria)}}const LiteralSearchStrategy=new SearchStrategy(((text,criteria)=>{if(!text||!criteria)return false;const lowerText=text.trim().toLowerCase();const pattern=criteria.endsWith(" ")?[criteria.toLowerCase()]:criteria.trim().toLowerCase().split(" ");return pattern.filter((word=>lowerText.indexOf(word)>=0)).length===pattern.length}),findLiteralMatches);const FuzzySearchStrategy=new SearchStrategy(((text,criteria)=>{const pattern=criteria.trimEnd();if(pattern.length===0)return true;const lowerPattern=pattern.toLowerCase();const lowerText=text.toLowerCase();let remainingText=lowerText,currentIndex=-1;for(const char of lowerPattern){const nextIndex=remainingText.indexOf(char);if(nextIndex===-1||currentIndex!==-1&&remainingText.slice(0,nextIndex).split(" ").length-1>2){const lowerText2=text.trim().toLowerCase();const pattern2=criteria.endsWith(" ")?[criteria.toLowerCase()]:criteria.trim().toLowerCase().split(" ");return pattern2.filter((word=>lowerText2.indexOf(word)>=0)).length===pattern2.length}currentIndex=nextIndex;remainingText=remainingText.slice(nextIndex+1)}return true}),findFuzzyMatches);const WildcardSearchStrategy=new SearchStrategy(((text,criteria)=>{if(criteria.includes("*")||criteria.includes("?")){const wildcardMatches=findWildcardMatches(text,criteria);return wildcardMatches.length>0}if(!text||!criteria)return false;const lowerText=text.trim().toLowerCase();const pattern=criteria.endsWith(" ")?[criteria.toLowerCase()]:criteria.trim().toLowerCase().split(" ");return pattern.filter((word=>lowerText.indexOf(word)>=0)).length===pattern.length}),findWildcardMatches);function merge(target,source){return{...target,...source}}function isJSON(json){try{return!!(json instanceof Object&&JSON.parse(JSON.stringify(json)))}catch(_err){return false}}function NoSort(){return 0}function isObject(obj){return Boolean(obj)&&Object.prototype.toString.call(obj)==="[object Object]"}function clone(input){if(input===null||typeof input!=="object"){return input}if(Array.isArray(input)){return input.map((item=>clone(item)))}const output={};for(const key in input){if(Object.prototype.hasOwnProperty.call(input,key)){output[key]=clone(input[key])}}return output}const DEFAULT_OPTIONS={searchInput:null,resultsContainer:null,json:[],success:function(){},searchResultTemplate:'<li><a href="{url}" title="{desc}">{title}</a></li>',templateMiddleware:(_prop,_value,_template,_query)=>void 0,sortMiddleware:NoSort,noResultsText:"No results found",limit:10,fuzzy:false,strategy:"literal",debounceTime:null,exclude:[],onSearch:()=>{}};const REQUIRED_OPTIONS=["searchInput","resultsContainer","json"];const WHITELISTED_KEYS=new Set(["Enter","Shift","CapsLock","ArrowLeft","ArrowUp","ArrowRight","ArrowDown","Meta"]);class Repository{constructor(initialOptions={}){this.data=[];this.setOptions(initialOptions)}put(input){if(isObject(input)){return this.addObject(input)}if(Array.isArray(input)){return this.addArray(input)}return void 0}clear(){this.data.length=0;return this.data}search(criteria){if(!criteria){return[]}return clone(this.findMatches(this.data,criteria).sort(this.options.sortMiddleware))}setOptions(newOptions){this.options={fuzzy:(newOptions==null?void 0:newOptions.fuzzy)||DEFAULT_OPTIONS.fuzzy,limit:(newOptions==null?void 0:newOptions.limit)||DEFAULT_OPTIONS.limit,searchStrategy:this.searchStrategy((newOptions==null?void 0:newOptions.strategy)||newOptions.fuzzy&&"fuzzy"||DEFAULT_OPTIONS.strategy),sortMiddleware:(newOptions==null?void 0:newOptions.sortMiddleware)||DEFAULT_OPTIONS.sortMiddleware,exclude:(newOptions==null?void 0:newOptions.exclude)||DEFAULT_OPTIONS.exclude,strategy:(newOptions==null?void 0:newOptions.strategy)||DEFAULT_OPTIONS.strategy}}addObject(obj){this.data.push(obj);return this.data}addArray(arr){const added=[];this.clear();for(const item of arr){if(isObject(item)){added.push(this.addObject(item)[0])}}return added}findMatches(data,criteria){const matches=[];for(let i=0;i<data.length&&matches.length<this.options.limit;i++){const match=this.findMatchesInObject(data[i],criteria);if(match){matches.push(match)}}return matches}findMatchesInObject(obj,criteria){let hasMatch=false;const result={...obj};result._matchInfo={};for(const key in obj){if(!this.isExcluded(obj[key])&&this.options.searchStrategy.matches(obj[key],criteria)){hasMatch=true;const matchInfo=this.options.searchStrategy.findMatches(obj[key],criteria);if(matchInfo&&matchInfo.length>0){result._matchInfo[key]=matchInfo}}}return hasMatch?result:void 0}isExcluded(term){for(const excludedTerm of this.options.exclude){if(new RegExp(excludedTerm).test(String(term))){return true}}return false}searchStrategy(strategy){switch(strategy){case"fuzzy":return FuzzySearchStrategy;case"wildcard":return WildcardSearchStrategy;default:return LiteralSearchStrategy}}}const options={pattern:/\{(.*?)\}/g,template:"",middleware:function(){return void 0}};function setOptions(_options){if(_options.pattern){options.pattern=_options.pattern}if(_options.template){options.template=_options.template}if(typeof _options.middleware==="function"){options.middleware=_options.middleware}}function compile(data,query){return options.template.replace(options.pattern,(function(match,prop){const matchInfo=data._matchInfo&&data._matchInfo[prop]?data._matchInfo[prop]:void 0;const value=options.middleware(prop,data[prop],options.template,query,matchInfo);if(typeof value!=="undefined"){return value}return data[prop]||match}))}let SimpleJekyllSearch$1=class SimpleJekyllSearch{constructor(){this.debounceTimerHandle=null;this.options={...DEFAULT_OPTIONS};this.repository=new Repository;this.optionsValidator=new OptionsValidator({required:REQUIRED_OPTIONS})}debounce(func,delayMillis){if(delayMillis){if(this.debounceTimerHandle){clearTimeout(this.debounceTimerHandle)}this.debounceTimerHandle=setTimeout(func,delayMillis)}else{func()}}throwError(message){throw new Error(`SimpleJekyllSearch --- ${message}`)}emptyResultsContainer(){this.options.resultsContainer.innerHTML=""}initWithJSON(json){this.repository.put(json);this.registerInput()}initWithURL(url){load(url,((err,json)=>{if(err){this.throwError(`Failed to load JSON from ${url}: ${err.message}`)}this.initWithJSON(json)}))}registerInput(){this.options.searchInput.addEventListener("input",(e=>{const inputEvent=e;if(!WHITELISTED_KEYS.has(inputEvent.key)){this.emptyResultsContainer();this.debounce((()=>{this.search(e.target.value)}),this.options.debounceTime??null)}}))}search(query){var _a,_b;if((query==null?void 0:query.trim().length)>0){this.emptyResultsContainer();const results=this.repository.search(query);this.render(results,query);(_b=(_a=this.options).onSearch)==null?void 0:_b.call(_a)}}render(results,query){if(results.length===0){this.options.resultsContainer.insertAdjacentHTML("beforeend",this.options.noResultsText);return}const fragment=document.createDocumentFragment();results.forEach((result=>{result.query=query;const div=document.createElement("div");div.innerHTML=compile(result,query);fragment.appendChild(div)}));this.options.resultsContainer.appendChild(fragment)}init(_options){var _a;const errors=this.optionsValidator.validate(_options);if(errors.length>0){this.throwError(`Missing required options: ${REQUIRED_OPTIONS.join(", ")}`)}this.options=merge(this.options,_options);setOptions({template:this.options.searchResultTemplate,middleware:this.options.templateMiddleware});this.repository.setOptions({fuzzy:this.options.fuzzy,limit:this.options.limit,sortMiddleware:this.options.sortMiddleware,strategy:this.options.strategy,exclude:this.options.exclude});if(isJSON(this.options.json)){this.initWithJSON(this.options.json)}else{this.initWithURL(this.options.json)}const rv={search:this.search.bind(this)};(_a=this.options.success)==null?void 0:_a.call(rv);return rv}};function createHighlightMiddleware(options2={}){const{highlightClass:highlightClass="sjs-highlight",contextBefore:contextBefore=50,contextAfter:contextAfter=50,maxLength:maxLength=250,ellipsis:ellipsis="..."}=options2;return function(result,query){if(!query||!result){return result}const highlightedResult={...result};const textFields=["title","desc","content","excerpt"];for(const field of textFields){if(highlightedResult[field]&&typeof highlightedResult[field]==="string"){const highlighted=highlightText(highlightedResult[field],query,{highlightClass:highlightClass,contextBefore:contextBefore,contextAfter:contextAfter,maxLength:maxLength,ellipsis:ellipsis});if(highlighted.highlightedText!==highlightedResult[field]){highlightedResult[field]=highlighted.highlightedText}}}return highlightedResult}}function highlightText(text,query,options2={}){const{highlightClass:highlightClass="sjs-highlight",contextBefore:contextBefore=50,contextAfter:contextAfter=50,maxLength:maxLength=250,ellipsis:ellipsis="..."}=options2;if(!text||!query){return{highlightedText:text,matchCount:0}}const originalText=text;const searchTerms=query.trim().toLowerCase().split(/\s+/).filter((term=>term.length>0));if(searchTerms.length===0){return{highlightedText:text,matchCount:0}}const matches=[];for(const term of searchTerms){let index=0;while(index<text.length){const found=text.toLowerCase().indexOf(term,index);if(found===-1)break;matches.push({start:found,end:found+term.length,term:text.substring(found,found+term.length)});index=found+1}}if(matches.length===0){return{highlightedText:text,matchCount:0}}matches.sort(((a,b)=>a.start-b.start));const mergedMatches=[];for(const match of matches){if(mergedMatches.length===0||mergedMatches[mergedMatches.length-1].end<match.start){mergedMatches.push(match)}else{const lastMatch=mergedMatches[mergedMatches.length-1];lastMatch.end=Math.max(lastMatch.end,match.end);lastMatch.term=text.substring(lastMatch.start,lastMatch.end)}}if(text.length<=maxLength){let highlightedText2=text;for(let i=mergedMatches.length-1;i>=0;i--){const match=mergedMatches[i];const before=highlightedText2.substring(0,match.start);const after=highlightedText2.substring(match.end);const matchText=highlightedText2.substring(match.start,match.end);highlightedText2=before+`<span class="${highlightClass}">${matchText}</span>`+after}return{highlightedText:highlightedText2,matchCount:mergedMatches.length}}let highlightedText="";let totalLength=0;let lastEnd=0;for(let i=0;i<mergedMatches.length;i++){const match=mergedMatches[i];const contextStart=Math.max(lastEnd,match.start-contextBefore);const contextEnd=Math.min(text.length,match.end+contextAfter);if(contextStart>lastEnd&&lastEnd>0){highlightedText+=ellipsis;totalLength+=ellipsis.length}if(contextStart<match.start){const beforeText=text.substring(contextStart,match.start);highlightedText+=beforeText;totalLength+=beforeText.length}const matchText=text.substring(match.start,match.end);highlightedText+=`<span class="${highlightClass}">${matchText}</span>`;totalLength+=matchText.length;if(match.end<contextEnd){const afterText=text.substring(match.end,contextEnd);highlightedText+=afterText;totalLength+=afterText.length}lastEnd=contextEnd;if(totalLength>=maxLength){if(contextEnd<text.length){highlightedText+=ellipsis}break}}return{highlightedText:highlightedText||originalText,matchCount:mergedMatches.length}}const defaultHighlightMiddleware=createHighlightMiddleware();function highlightWithMatchInfo(text,matchInfo,options2){if(matchInfo.length===0)return text;const sortedMatches=[...matchInfo].sort(((a,b)=>b.start-a.start));let highlightedText=text;for(const match of sortedMatches){const before=highlightedText.substring(0,match.start);const after=highlightedText.substring(match.end);const matchText=highlightedText.substring(match.start,match.end);highlightedText=before+`<span class="${options2.highlightClass}">${matchText}</span>`+after}return highlightedText}function createHighlightTemplateMiddleware(options2={}){const highlightOptions={highlightClass:"sjs-highlight",...options2};return function(prop,value,_template,query,matchInfo){if((prop==="content"||prop==="desc")&&query&&typeof value==="string"){if(matchInfo&&matchInfo.length>0){const highlighted=highlightWithMatchInfo(value,matchInfo,highlightOptions);return highlighted!==value?highlighted:void 0}}return void 0}}const defaultHighlightTemplateMiddleware=createHighlightTemplateMiddleware();function SimpleJekyllSearch(options2){const instance=new SimpleJekyllSearch$1;return instance.init(options2)}if(typeof window!=="undefined"){window.SimpleJekyllSearch=SimpleJekyllSearch;window.SimpleJekyllSearch.createHighlightMiddleware=createHighlightMiddleware;window.SimpleJekyllSearch.createHighlightTemplateMiddleware=createHighlightTemplateMiddleware;window.SimpleJekyllSearch.highlightText=highlightText;window.SimpleJekyllSearch.defaultHighlightMiddleware=defaultHighlightMiddleware;window.SimpleJekyllSearch.defaultHighlightTemplateMiddleware=defaultHighlightTemplateMiddleware}exports2.createHighlightMiddleware=createHighlightMiddleware;exports2.createHighlightTemplateMiddleware=createHighlightTemplateMiddleware;exports2.default=SimpleJekyllSearch;exports2.defaultHighlightMiddleware=defaultHighlightMiddleware;exports2.defaultHighlightTemplateMiddleware=defaultHighlightTemplateMiddleware;exports2.highlightText=highlightText;Object.defineProperties(exports2,{__esModule:{value:true},[Symbol.toStringTag]:{value:"Module"}})}));
\ No newline at end of file
diff --git a/docs/assets/js/simple-jekyll-search.min.js b/docs/assets/js/simple-jekyll-search.min.js
index 7b0ff2d..63a5daf 100644
--- a/docs/assets/js/simple-jekyll-search.min.js
+++ b/docs/assets/js/simple-jekyll-search.min.js
@@ -4,4 +4,4 @@
   * Copyright 2025-2025, Sylhare
   * Licensed under the MIT License.
   */
-(function(global,factory){typeof exports==="object"&&typeof module!=="undefined"?factory(exports):typeof define==="function"&&define.amd?define(["exports"],factory):(global=typeof globalThis!=="undefined"?globalThis:global||self,factory(global.SimpleJekyllSearch={}))})(this,(function(exports2){"use strict";function load(location,callback){const xhr=getXHR();xhr.open("GET",location,true);xhr.onreadystatechange=createStateChangeListener(xhr,callback);xhr.send()}function createStateChangeListener(xhr,callback){return function(){if(xhr.readyState===4&&xhr.status===200){try{callback(null,JSON.parse(xhr.responseText))}catch(err){callback(err instanceof Error?err:new Error(String(err)),null)}}}}function getXHR(){return window.XMLHttpRequest?new window.XMLHttpRequest:new window.ActiveXObject("Microsoft.XMLHTTP")}class OptionsValidator{constructor(params){if(!this.validateParams(params)){throw new Error("-- OptionsValidator: required options missing")}this.requiredOptions=params.required}getRequiredOptions(){return this.requiredOptions}validate(parameters){const errors=[];this.requiredOptions.forEach((requiredOptionName=>{if(typeof parameters[requiredOptionName]==="undefined"){errors.push(requiredOptionName)}}));return errors}validateParams(params){if(!params){return false}return typeof params.required!=="undefined"&&Array.isArray(params.required)}}function fuzzySearch(text,pattern){pattern=pattern.trimEnd();if(pattern.length===0)return true;pattern=pattern.toLowerCase();text=text.toLowerCase();let remainingText=text,currentIndex=-1;for(const char of pattern){const nextIndex=remainingText.indexOf(char);if(nextIndex===-1||currentIndex!==-1&&remainingText.slice(0,nextIndex).split(" ").length-1>2){return false}currentIndex=nextIndex;remainingText=remainingText.slice(nextIndex+1)}return true}function findFuzzyMatches$1(text,pattern){if(!text||!pattern)return[];const lowerText=text.toLowerCase();const lowerPattern=pattern.toLowerCase().trim();if(lowerPattern.length===0)return[];const patternWords=lowerPattern.split(/\s+/);const matches=[];for(const word of patternWords){if(word.length===0)continue;const wordMatches=findFuzzyWordMatches$1(lowerText,word);matches.push(...wordMatches)}return mergeAndSortMatches$1(matches)}function findFuzzyWordMatches$1(text,word){const matches=[];const exactRegex=new RegExp(`\\b${word.replace(/[.*+?^${}()|[\]\\]/g,"\\$&")}\\b`,"gi");let match;while((match=exactRegex.exec(text))!==null){matches.push({start:match.index,end:match.index+match[0].length,text:match[0],type:"exact"})}if(matches.length===0){for(let i=0;i<text.length;i++){const fuzzyMatch=findFuzzySequenceMatch$1(text,word,i);if(fuzzyMatch){matches.push({...fuzzyMatch,type:"fuzzy"});i=fuzzyMatch.end-1}}}return matches}function findFuzzySequenceMatch$1(text,pattern,startPos){let textIndex=startPos;let patternIndex=0;let matchStart=-1;let maxGap=3;const matchedPositions=[];while(textIndex<text.length&&patternIndex<pattern.length){if(text[textIndex]===pattern[patternIndex]){if(matchStart===-1){matchStart=textIndex}matchedPositions.push(textIndex);patternIndex++}else if(matchStart!==-1){if(textIndex-matchStart>maxGap*pattern.length){return null}}textIndex++}if(patternIndex===pattern.length&&matchStart!==-1&&matchedPositions.length>0){const actualStart=matchedPositions[0];const actualEnd=matchedPositions[matchedPositions.length-1]+1;return{start:actualStart,end:actualEnd,text:text.substring(actualStart,actualEnd)}}return null}function mergeAndSortMatches$1(matches){if(matches.length===0)return[];const sortedMatches=matches.sort(((a,b)=>a.start-b.start));const merged=[];for(const match of sortedMatches){const lastMerged=merged[merged.length-1];if(lastMerged&&match.start<=lastMerged.end){lastMerged.end=Math.max(lastMerged.end,match.end);lastMerged.text=lastMerged.text+match.text.slice(lastMerged.end-match.start)}else{merged.push({...match})}}return merged}function literalSearch(text,criteria){text=text.trim().toLowerCase();const pattern=criteria.endsWith(" ")?[criteria.toLowerCase()]:criteria.trim().toLowerCase().split(" ");return pattern.filter((word=>text.indexOf(word)>=0)).length===pattern.length}function findLiteralMatches(text,criteria){if(!text||!criteria)return[];const lowerText=text.toLowerCase();const words=criteria.trim().toLowerCase().split(/\s+/);const matches=[];let textIndex=0;for(const word of words){if(word.length===0)continue;const wordIndex=lowerText.indexOf(word,textIndex);if(wordIndex!==-1){matches.push({start:wordIndex,end:wordIndex+word.length,text:text.substring(wordIndex,wordIndex+word.length),type:"exact"});textIndex=wordIndex+word.length}}return matches}function levenshtein(a,b){const lenA=a.length;const lenB=b.length;const distanceMatrix=Array.from({length:lenA+1},(()=>Array(lenB+1).fill(0)));for(let i=0;i<=lenA;i++)distanceMatrix[i][0]=i;for(let j=0;j<=lenB;j++)distanceMatrix[0][j]=j;for(let i=1;i<=lenA;i++){for(let j=1;j<=lenB;j++){const cost=a[i-1]===b[j-1]?0:1;distanceMatrix[i][j]=Math.min(distanceMatrix[i-1][j]+1,distanceMatrix[i][j-1]+1,distanceMatrix[i-1][j-1]+cost)}}return distanceMatrix[lenA][lenB]}function levenshteinSearch(text,pattern){const distance=levenshtein(pattern,text);const similarity=1-distance/Math.max(pattern.length,text.length);return similarity>=.3}function findLevenshteinMatches(text,pattern){if(!text||!pattern)return[];const matches=[];const words=text.split(/\s+/);for(let i=0;i<words.length;i++){const word=words[i];if(levenshteinSearch(word,pattern)){const start=text.indexOf(word);matches.push({start:start,end:start+word.length,text:word,type:"wildcard"})}}return matches}function wildcardSearch(text,pattern){const regexPattern=pattern.replace(/\*/g,".*");const regex=new RegExp(`^${regexPattern}$`,"i");if(regex.test(text))return true;return levenshteinSearch(text,pattern)}function findWildcardMatches(text,pattern){if(!text||!pattern)return[];const wildcardMatches=findWildcardPatternMatches(text,pattern);if(wildcardMatches.length>0){return mergeAndSortMatches(wildcardMatches)}const levenshteinMatches=findLevenshteinMatches(text,pattern);return mergeAndSortMatches(levenshteinMatches)}function findWildcardPatternMatches(text,pattern){const matches=[];const regexPattern=pattern.replace(/\*/g,".*");const regex=new RegExp(regexPattern,"gi");let match;while((match=regex.exec(text))!==null){matches.push({start:match.index,end:match.index+match[0].length,text:match[0],type:"wildcard"})}return matches}function mergeAndSortMatches(matches){if(matches.length===0)return[];const sortedMatches=matches.sort(((a,b)=>a.start-b.start));const merged=[];for(const match of sortedMatches){const lastMerged=merged[merged.length-1];if(lastMerged&&match.start<=lastMerged.end){lastMerged.end=Math.max(lastMerged.end,match.end);lastMerged.text=lastMerged.text+match.text.slice(lastMerged.end-match.start)}else{merged.push({...match})}}return merged}class SearchStrategy{constructor(matchFunction,findMatchesFunction){this.matchFunction=matchFunction;this.findMatchesFunction=findMatchesFunction}matches(text,criteria){if(text===null||text.trim()===""||!criteria){return false}return this.matchFunction(text,criteria)}findMatches(text,criteria){if(text===null||text.trim()===""||!criteria||!this.findMatchesFunction){return[]}return this.findMatchesFunction(text,criteria)}}const LiteralSearchStrategy=new SearchStrategy(literalSearch,findLiteralMatches);const FuzzySearchStrategy=new SearchStrategy(((text,criteria)=>fuzzySearch(text,criteria)||literalSearch(text,criteria)),((text,criteria)=>{const fuzzyMatches=findFuzzyMatches$1(text,criteria);if(fuzzyMatches.length>0){return fuzzyMatches}return findLiteralMatches(text,criteria)}));const WildcardSearchStrategy=new SearchStrategy(((text,criteria)=>wildcardSearch(text,criteria)||literalSearch(text,criteria)),((text,criteria)=>{const wildcardMatches=findWildcardMatches(text,criteria);if(wildcardMatches.length>0){return wildcardMatches}return findLiteralMatches(text,criteria)}));function merge(target,source){return{...target,...source}}function isJSON(json){try{return!!(json instanceof Object&&JSON.parse(JSON.stringify(json)))}catch(_err){return false}}function NoSort(){return 0}function isObject(obj){return Boolean(obj)&&Object.prototype.toString.call(obj)==="[object Object]"}function clone(input){if(input===null||typeof input!=="object"){return input}if(Array.isArray(input)){return input.map((item=>clone(item)))}const output={};for(const key in input){if(Object.prototype.hasOwnProperty.call(input,key)){output[key]=clone(input[key])}}return output}const DEFAULT_OPTIONS={searchInput:null,resultsContainer:null,json:[],success:function(){},searchResultTemplate:'<li><a href="{url}" title="{desc}">{title}</a></li>',templateMiddleware:(_prop,_value,_template,_query)=>void 0,sortMiddleware:NoSort,noResultsText:"No results found",limit:10,fuzzy:false,strategy:"literal",debounceTime:null,exclude:[],onSearch:()=>{}};const REQUIRED_OPTIONS=["searchInput","resultsContainer","json"];const WHITELISTED_KEYS=new Set(["Enter","Shift","CapsLock","ArrowLeft","ArrowUp","ArrowRight","ArrowDown","Meta"]);class Repository{constructor(initialOptions={}){this.data=[];this.setOptions(initialOptions)}put(input){if(isObject(input)){return this.addObject(input)}if(Array.isArray(input)){return this.addArray(input)}return void 0}clear(){this.data.length=0;return this.data}search(criteria){if(!criteria){return[]}return clone(this.findMatches(this.data,criteria).sort(this.options.sortMiddleware))}setOptions(newOptions){this.options={fuzzy:(newOptions==null?void 0:newOptions.fuzzy)||DEFAULT_OPTIONS.fuzzy,limit:(newOptions==null?void 0:newOptions.limit)||DEFAULT_OPTIONS.limit,searchStrategy:this.searchStrategy((newOptions==null?void 0:newOptions.strategy)||newOptions.fuzzy&&"fuzzy"||DEFAULT_OPTIONS.strategy),sortMiddleware:(newOptions==null?void 0:newOptions.sortMiddleware)||DEFAULT_OPTIONS.sortMiddleware,exclude:(newOptions==null?void 0:newOptions.exclude)||DEFAULT_OPTIONS.exclude,strategy:(newOptions==null?void 0:newOptions.strategy)||DEFAULT_OPTIONS.strategy}}addObject(obj){this.data.push(obj);return this.data}addArray(arr){const added=[];this.clear();for(const item of arr){if(isObject(item)){added.push(this.addObject(item)[0])}}return added}findMatches(data,criteria){const matches=[];for(let i=0;i<data.length&&matches.length<this.options.limit;i++){const match=this.findMatchesInObject(data[i],criteria);if(match){matches.push(match)}}return matches}findMatchesInObject(obj,criteria){var _a,_b;let hasMatch=false;const result={...obj};result._matchInfo={};for(const key in obj){if(!this.isExcluded(obj[key])&&this.options.searchStrategy.matches(obj[key],criteria)){hasMatch=true;const matchInfo=(_b=(_a=this.options.searchStrategy).findMatches)==null?void 0:_b.call(_a,obj[key],criteria);if(matchInfo&&matchInfo.length>0){result._matchInfo[key]=matchInfo}}}return hasMatch?result:void 0}isExcluded(term){for(const excludedTerm of this.options.exclude){if(new RegExp(excludedTerm).test(String(term))){return true}}return false}searchStrategy(strategy){switch(strategy){case"fuzzy":return FuzzySearchStrategy;case"wildcard":return WildcardSearchStrategy;default:return LiteralSearchStrategy}}}const options={pattern:/\{(.*?)\}/g,template:"",middleware:function(){return void 0}};function setOptions(_options){if(_options.pattern){options.pattern=_options.pattern}if(_options.template){options.template=_options.template}if(typeof _options.middleware==="function"){options.middleware=_options.middleware}}function compile(data,query){return options.template.replace(options.pattern,(function(match,prop){if(data._matchInfo&&data._matchInfo[prop]&&data._matchInfo[prop].length>0){try{const value2=options.middleware(prop,data[prop],options.template,query,data._matchInfo[prop]);if(typeof value2!=="undefined"){return value2}}catch(_e){}}const value=options.middleware(prop,data[prop],options.template,query);if(typeof value!=="undefined"){return value}return data[prop]||match}))}let SimpleJekyllSearch$1=class SimpleJekyllSearch{constructor(){this.debounceTimerHandle=null;this.options={...DEFAULT_OPTIONS};this.repository=new Repository;this.optionsValidator=new OptionsValidator({required:REQUIRED_OPTIONS})}debounce(func,delayMillis){if(delayMillis){if(this.debounceTimerHandle){clearTimeout(this.debounceTimerHandle)}this.debounceTimerHandle=setTimeout(func,delayMillis)}else{func()}}throwError(message){throw new Error(`SimpleJekyllSearch --- ${message}`)}emptyResultsContainer(){this.options.resultsContainer.innerHTML=""}initWithJSON(json){this.repository.put(json);this.registerInput()}initWithURL(url){load(url,((err,json)=>{if(err){this.throwError(`Failed to load JSON from ${url}: ${err.message}`)}this.initWithJSON(json)}))}registerInput(){this.options.searchInput.addEventListener("input",(e=>{const inputEvent=e;if(!WHITELISTED_KEYS.has(inputEvent.key)){this.emptyResultsContainer();this.debounce((()=>{this.search(e.target.value)}),this.options.debounceTime??null)}}))}search(query){var _a,_b;if((query==null?void 0:query.trim().length)>0){this.emptyResultsContainer();const results=this.repository.search(query);this.render(results,query);(_b=(_a=this.options).onSearch)==null?void 0:_b.call(_a)}}render(results,query){if(results.length===0){this.options.resultsContainer.insertAdjacentHTML("beforeend",this.options.noResultsText);return}const fragment=document.createDocumentFragment();results.forEach((result=>{result.query=query;const div=document.createElement("div");div.innerHTML=compile(result,query);fragment.appendChild(div)}));this.options.resultsContainer.appendChild(fragment)}init(_options){var _a;const errors=this.optionsValidator.validate(_options);if(errors.length>0){this.throwError(`Missing required options: ${REQUIRED_OPTIONS.join(", ")}`)}this.options=merge(this.options,_options);setOptions({template:this.options.searchResultTemplate,middleware:this.options.templateMiddleware});this.repository.setOptions({fuzzy:this.options.fuzzy,limit:this.options.limit,sortMiddleware:this.options.sortMiddleware,strategy:this.options.strategy,exclude:this.options.exclude});if(isJSON(this.options.json)){this.initWithJSON(this.options.json)}else{this.initWithURL(this.options.json)}const rv={search:this.search.bind(this)};(_a=this.options.success)==null?void 0:_a.call(rv);return rv}};function createHighlightMiddleware(options2={}){const{highlightClass:highlightClass="sjs-highlight",contextBefore:contextBefore=50,contextAfter:contextAfter=50,maxLength:maxLength=250,ellipsis:ellipsis="..."}=options2;return function(result,query){if(!query||!result){return result}const highlightedResult={...result};const textFields=["title","desc","content","excerpt"];for(const field of textFields){if(highlightedResult[field]&&typeof highlightedResult[field]==="string"){const highlighted=highlightText(highlightedResult[field],query,{highlightClass:highlightClass,contextBefore:contextBefore,contextAfter:contextAfter,maxLength:maxLength,ellipsis:ellipsis});if(highlighted.highlightedText!==highlightedResult[field]){highlightedResult[field]=highlighted.highlightedText}}}return highlightedResult}}function highlightText(text,query,options2={}){const{highlightClass:highlightClass="sjs-highlight",contextBefore:contextBefore=50,contextAfter:contextAfter=50,maxLength:maxLength=250,ellipsis:ellipsis="..."}=options2;if(!text||!query){return{highlightedText:text,matchCount:0}}const originalText=text;const searchTerms=query.trim().toLowerCase().split(/\s+/).filter((term=>term.length>0));if(searchTerms.length===0){return{highlightedText:text,matchCount:0}}const matches=[];for(const term of searchTerms){let index=0;while(index<text.length){const found=text.toLowerCase().indexOf(term,index);if(found===-1)break;matches.push({start:found,end:found+term.length,term:text.substring(found,found+term.length)});index=found+1}}if(matches.length===0){return{highlightedText:text,matchCount:0}}matches.sort(((a,b)=>a.start-b.start));const mergedMatches=[];for(const match of matches){if(mergedMatches.length===0||mergedMatches[mergedMatches.length-1].end<match.start){mergedMatches.push(match)}else{const lastMatch=mergedMatches[mergedMatches.length-1];lastMatch.end=Math.max(lastMatch.end,match.end);lastMatch.term=text.substring(lastMatch.start,lastMatch.end)}}if(text.length<=maxLength){let highlightedText2=text;for(let i=mergedMatches.length-1;i>=0;i--){const match=mergedMatches[i];const before=highlightedText2.substring(0,match.start);const after=highlightedText2.substring(match.end);const matchText=highlightedText2.substring(match.start,match.end);highlightedText2=before+`<span class="${highlightClass}">${matchText}</span>`+after}return{highlightedText:highlightedText2,matchCount:mergedMatches.length}}let highlightedText="";let totalLength=0;let lastEnd=0;for(let i=0;i<mergedMatches.length;i++){const match=mergedMatches[i];const contextStart=Math.max(lastEnd,match.start-contextBefore);const contextEnd=Math.min(text.length,match.end+contextAfter);if(contextStart>lastEnd&&lastEnd>0){highlightedText+=ellipsis;totalLength+=ellipsis.length}if(contextStart<match.start){const beforeText=text.substring(contextStart,match.start);highlightedText+=beforeText;totalLength+=beforeText.length}const matchText=text.substring(match.start,match.end);highlightedText+=`<span class="${highlightClass}">${matchText}</span>`;totalLength+=matchText.length;if(match.end<contextEnd){const afterText=text.substring(match.end,contextEnd);highlightedText+=afterText;totalLength+=afterText.length}lastEnd=contextEnd;if(totalLength>=maxLength){if(contextEnd<text.length){highlightedText+=ellipsis}break}}return{highlightedText:highlightedText||originalText,matchCount:mergedMatches.length}}const defaultHighlightMiddleware=createHighlightMiddleware();function findFuzzyMatches(text,pattern){const matches=[];const lowerText=text.toLowerCase();const lowerPattern=pattern.toLowerCase().trim();if(lowerPattern.length===0)return matches;const patternWords=lowerPattern.split(/\s+/);for(const word of patternWords){if(word.length===0)continue;const wordMatches=findFuzzyWordMatches(lowerText,word);matches.push(...wordMatches)}return matches}function findFuzzyWordMatches(text,word){const matches=[];const exactRegex=new RegExp(`\\b${word.replace(/[.*+?^${}()|[\]\\]/g,"\\$&")}\\b`,"gi");let match;while((match=exactRegex.exec(text))!==null){matches.push({start:match.index,end:match.index+match[0].length,text:match[0]})}if(matches.length===0){for(let i=0;i<text.length;i++){const fuzzyMatch=findFuzzySequenceMatch(text,word,i);if(fuzzyMatch){matches.push(fuzzyMatch);i=fuzzyMatch.end-1}}}return matches}function findFuzzySequenceMatch(text,pattern,startPos){let textIndex=startPos;let patternIndex=0;let matchStart=-1;let maxGap=3;const matchedPositions=[];while(textIndex<text.length&&patternIndex<pattern.length){if(text[textIndex]===pattern[patternIndex]){if(matchStart===-1){matchStart=textIndex}matchedPositions.push(textIndex);patternIndex++}else if(matchStart!==-1){if(textIndex-matchStart>maxGap*pattern.length){return null}}textIndex++}if(patternIndex===pattern.length&&matchStart!==-1&&matchedPositions.length>0){const actualStart=matchedPositions[0];const actualEnd=matchedPositions[matchedPositions.length-1]+1;return{start:actualStart,end:actualEnd,text:text.substring(actualStart,actualEnd)}}return null}function highlightWithMatchInfo(text,matchInfo,options2){if(matchInfo.length===0)return text;const sortedMatches=[...matchInfo].sort(((a,b)=>b.start-a.start));let highlightedText=text;for(const match of sortedMatches){const before=highlightedText.substring(0,match.start);const after=highlightedText.substring(match.end);const matchText=highlightedText.substring(match.start,match.end);highlightedText=before+`<span class="${options2.highlightClass}">${matchText}</span>`+after}return highlightedText}function highlightWithQuery(text,query,options2){let highlightedText=text;let hasMatches=false;const searchTerms=query.trim().split(/\s+/).filter((term=>term.length>0));for(const term of searchTerms){const regex=new RegExp(`\\b(${term.replace(/[.*+?^${}()|[\]\\]/g,"\\$&")})\\b`,"gi");if(regex.test(highlightedText)){highlightedText=highlightedText.replace(regex,`<span class="${options2.highlightClass}">$1</span>`);hasMatches=true}}if(!hasMatches){const fuzzyMatches=findFuzzyMatches(text,query);if(fuzzyMatches.length>0){fuzzyMatches.sort(((a,b)=>b.start-a.start));for(const match of fuzzyMatches){const before=highlightedText.substring(0,match.start);const after=highlightedText.substring(match.end);const matchText=highlightedText.substring(match.start,match.end);highlightedText=before+`<span class="${options2.highlightClass}">${matchText}</span>`+after}hasMatches=true}}return highlightedText}function createHighlightTemplateMiddleware(options2={}){const highlightOptions={highlightClass:"sjs-highlight",...options2};return function(prop,value,_template,query,matchInfo){if((prop==="content"||prop==="desc")&&query&&typeof value==="string"){if(matchInfo&&matchInfo.length>0){const highlighted2=highlightWithMatchInfo(value,matchInfo,highlightOptions);return highlighted2!==value?highlighted2:void 0}const highlighted=highlightWithQuery(value,query,highlightOptions);return highlighted!==value?highlighted:void 0}return void 0}}const defaultHighlightTemplateMiddleware=createHighlightTemplateMiddleware();function SimpleJekyllSearch(options2){const instance=new SimpleJekyllSearch$1;return instance.init(options2)}if(typeof window!=="undefined"){window.SimpleJekyllSearch=SimpleJekyllSearch;window.SimpleJekyllSearch.createHighlightMiddleware=createHighlightMiddleware;window.SimpleJekyllSearch.createHighlightTemplateMiddleware=createHighlightTemplateMiddleware;window.SimpleJekyllSearch.highlightText=highlightText;window.SimpleJekyllSearch.defaultHighlightMiddleware=defaultHighlightMiddleware;window.SimpleJekyllSearch.defaultHighlightTemplateMiddleware=defaultHighlightTemplateMiddleware}exports2.createHighlightMiddleware=createHighlightMiddleware;exports2.createHighlightTemplateMiddleware=createHighlightTemplateMiddleware;exports2.default=SimpleJekyllSearch;exports2.defaultHighlightMiddleware=defaultHighlightMiddleware;exports2.defaultHighlightTemplateMiddleware=defaultHighlightTemplateMiddleware;exports2.highlightText=highlightText;Object.defineProperties(exports2,{__esModule:{value:true},[Symbol.toStringTag]:{value:"Module"}})}));
\ No newline at end of file
+(function(global,factory){typeof exports==="object"&&typeof module!=="undefined"?factory(exports):typeof define==="function"&&define.amd?define(["exports"],factory):(global=typeof globalThis!=="undefined"?globalThis:global||self,factory(global.SimpleJekyllSearch={}))})(this,(function(exports2){"use strict";function load(location,callback){const xhr=getXHR();xhr.open("GET",location,true);xhr.onreadystatechange=createStateChangeListener(xhr,callback);xhr.send()}function createStateChangeListener(xhr,callback){return function(){if(xhr.readyState===4&&xhr.status===200){try{callback(null,JSON.parse(xhr.responseText))}catch(err){callback(err instanceof Error?err:new Error(String(err)),null)}}}}function getXHR(){return window.XMLHttpRequest?new window.XMLHttpRequest:new window.ActiveXObject("Microsoft.XMLHTTP")}class OptionsValidator{constructor(params){if(!this.validateParams(params)){throw new Error("-- OptionsValidator: required options missing")}this.requiredOptions=params.required}getRequiredOptions(){return this.requiredOptions}validate(parameters){const errors=[];this.requiredOptions.forEach((requiredOptionName=>{if(typeof parameters[requiredOptionName]==="undefined"){errors.push(requiredOptionName)}}));return errors}validateParams(params){if(!params){return false}return typeof params.required!=="undefined"&&Array.isArray(params.required)}}function findFuzzyMatches(text,pattern){if(!text||!pattern)return[];const lowerText=text.toLowerCase();const lowerPattern=pattern.toLowerCase().trim();if(lowerPattern.length===0)return[];const matches=[];for(let i=0;i<lowerText.length;i++){const match=findFuzzySequenceMatch(lowerText,lowerPattern,i);if(match){const isExact=match.text===lowerPattern;matches.push({start:match.start,end:match.end,text:text.substring(match.start,match.end),type:isExact?"exact":"fuzzy"});i=match.end-1}}return matches}function findFuzzySequenceMatch(text,pattern,startPos){let textIndex=startPos;let patternIndex=0;let matchStart=-1;let maxGap=10;while(textIndex<text.length&&patternIndex<pattern.length){if(text[textIndex]===pattern[patternIndex]){if(matchStart===-1){matchStart=textIndex}patternIndex++}else if(matchStart!==-1){const gap=textIndex-matchStart;if(gap>maxGap){return null}}textIndex++}if(patternIndex===pattern.length&&matchStart!==-1){return{start:matchStart,end:textIndex,text:text.substring(matchStart,textIndex)}}return null}function findLiteralMatches(text,criteria){if(!text||!criteria)return[];const lowerText=text.toLowerCase();const hasTrailingSpace=criteria.endsWith(" ");const words=criteria.trim().toLowerCase().split(/\s+/);const matches=[];let textIndex=0;for(const word of words){if(word.length===0)continue;let wordIndex=lowerText.indexOf(word,textIndex);if(hasTrailingSpace&&word===words[words.length-1]){while(wordIndex!==-1){const nextChar=lowerText[wordIndex+word.length];if(!nextChar||!/\w/.test(nextChar)){break}wordIndex=lowerText.indexOf(word,wordIndex+1)}}if(wordIndex!==-1){matches.push({start:wordIndex,end:wordIndex+word.length,text:text.substring(wordIndex,wordIndex+word.length),type:"exact"});textIndex=wordIndex+word.length}}return matches}function levenshtein(a,b){const lenA=a.length;const lenB=b.length;const distanceMatrix=Array.from({length:lenA+1},(()=>Array(lenB+1).fill(0)));for(let i=0;i<=lenA;i++)distanceMatrix[i][0]=i;for(let j=0;j<=lenB;j++)distanceMatrix[0][j]=j;for(let i=1;i<=lenA;i++){for(let j=1;j<=lenB;j++){const cost=a[i-1]===b[j-1]?0:1;distanceMatrix[i][j]=Math.min(distanceMatrix[i-1][j]+1,distanceMatrix[i][j-1]+1,distanceMatrix[i-1][j-1]+cost)}}return distanceMatrix[lenA][lenB]}function levenshteinSearch(text,pattern){const distance=levenshtein(pattern,text);const similarity=1-distance/Math.max(pattern.length,text.length);return similarity>=.3}function mergeAndSortMatches(matches){if(matches.length===0)return[];const sortedMatches=matches.sort(((a,b)=>a.start-b.start));const merged=[];for(const match of sortedMatches){const lastMerged=merged[merged.length-1];if(lastMerged&&match.start<=lastMerged.end){lastMerged.end=Math.max(lastMerged.end,match.end);lastMerged.text=lastMerged.text+match.text.slice(lastMerged.end-match.start)}else{merged.push({...match})}}return merged}function findWildcardMatches(text,pattern){if(!text||!pattern)return[];if(pattern.includes("*")||pattern.includes("?")){const wildcardMatches=findWildcardPatternMatches(text,pattern);if(wildcardMatches.length>0){return mergeAndSortMatches(wildcardMatches)}}const literalMatches=findLiteralMatches(text,pattern);if(literalMatches.length>0){return literalMatches.map((match=>({...match,type:"wildcard"})))}if(levenshteinSearch(text,pattern)){return[{start:0,end:text.length,text:text,type:"wildcard"}]}return[]}function findWildcardPatternMatches(text,pattern){const matches=[];const regexPattern=pattern.replace(/\*/g,".*");const regex=new RegExp(regexPattern,"gi");let match;let lastIndex=0;while((match=regex.exec(text))!==null){if(match.index===lastIndex&&match[0].length===0){break}lastIndex=match.index;matches.push({start:match.index,end:match.index+match[0].length,text:match[0],type:"wildcard"});if(match[0].length===text.length){break}}return matches}class SearchStrategy{constructor(matchFunction,findMatchesFunction){this.matchFunction=matchFunction;this.findMatchesFunction=findMatchesFunction}matches(text,criteria){if(text===null||text.trim()===""||!criteria){return false}return this.matchFunction(text,criteria)}findMatches(text,criteria){if(text===null||text.trim()===""||!criteria){return[]}return this.findMatchesFunction(text,criteria)}}const LiteralSearchStrategy=new SearchStrategy(((text,criteria)=>{if(!text||!criteria)return false;const lowerText=text.trim().toLowerCase();const pattern=criteria.endsWith(" ")?[criteria.toLowerCase()]:criteria.trim().toLowerCase().split(" ");return pattern.filter((word=>lowerText.indexOf(word)>=0)).length===pattern.length}),findLiteralMatches);const FuzzySearchStrategy=new SearchStrategy(((text,criteria)=>{const pattern=criteria.trimEnd();if(pattern.length===0)return true;const lowerPattern=pattern.toLowerCase();const lowerText=text.toLowerCase();let remainingText=lowerText,currentIndex=-1;for(const char of lowerPattern){const nextIndex=remainingText.indexOf(char);if(nextIndex===-1||currentIndex!==-1&&remainingText.slice(0,nextIndex).split(" ").length-1>2){const lowerText2=text.trim().toLowerCase();const pattern2=criteria.endsWith(" ")?[criteria.toLowerCase()]:criteria.trim().toLowerCase().split(" ");return pattern2.filter((word=>lowerText2.indexOf(word)>=0)).length===pattern2.length}currentIndex=nextIndex;remainingText=remainingText.slice(nextIndex+1)}return true}),findFuzzyMatches);const WildcardSearchStrategy=new SearchStrategy(((text,criteria)=>{if(criteria.includes("*")||criteria.includes("?")){const wildcardMatches=findWildcardMatches(text,criteria);return wildcardMatches.length>0}if(!text||!criteria)return false;const lowerText=text.trim().toLowerCase();const pattern=criteria.endsWith(" ")?[criteria.toLowerCase()]:criteria.trim().toLowerCase().split(" ");return pattern.filter((word=>lowerText.indexOf(word)>=0)).length===pattern.length}),findWildcardMatches);function merge(target,source){return{...target,...source}}function isJSON(json){try{return!!(json instanceof Object&&JSON.parse(JSON.stringify(json)))}catch(_err){return false}}function NoSort(){return 0}function isObject(obj){return Boolean(obj)&&Object.prototype.toString.call(obj)==="[object Object]"}function clone(input){if(input===null||typeof input!=="object"){return input}if(Array.isArray(input)){return input.map((item=>clone(item)))}const output={};for(const key in input){if(Object.prototype.hasOwnProperty.call(input,key)){output[key]=clone(input[key])}}return output}const DEFAULT_OPTIONS={searchInput:null,resultsContainer:null,json:[],success:function(){},searchResultTemplate:'<li><a href="{url}" title="{desc}">{title}</a></li>',templateMiddleware:(_prop,_value,_template,_query)=>void 0,sortMiddleware:NoSort,noResultsText:"No results found",limit:10,fuzzy:false,strategy:"literal",debounceTime:null,exclude:[],onSearch:()=>{}};const REQUIRED_OPTIONS=["searchInput","resultsContainer","json"];const WHITELISTED_KEYS=new Set(["Enter","Shift","CapsLock","ArrowLeft","ArrowUp","ArrowRight","ArrowDown","Meta"]);class Repository{constructor(initialOptions={}){this.data=[];this.setOptions(initialOptions)}put(input){if(isObject(input)){return this.addObject(input)}if(Array.isArray(input)){return this.addArray(input)}return void 0}clear(){this.data.length=0;return this.data}search(criteria){if(!criteria){return[]}return clone(this.findMatches(this.data,criteria).sort(this.options.sortMiddleware))}setOptions(newOptions){this.options={fuzzy:(newOptions==null?void 0:newOptions.fuzzy)||DEFAULT_OPTIONS.fuzzy,limit:(newOptions==null?void 0:newOptions.limit)||DEFAULT_OPTIONS.limit,searchStrategy:this.searchStrategy((newOptions==null?void 0:newOptions.strategy)||newOptions.fuzzy&&"fuzzy"||DEFAULT_OPTIONS.strategy),sortMiddleware:(newOptions==null?void 0:newOptions.sortMiddleware)||DEFAULT_OPTIONS.sortMiddleware,exclude:(newOptions==null?void 0:newOptions.exclude)||DEFAULT_OPTIONS.exclude,strategy:(newOptions==null?void 0:newOptions.strategy)||DEFAULT_OPTIONS.strategy}}addObject(obj){this.data.push(obj);return this.data}addArray(arr){const added=[];this.clear();for(const item of arr){if(isObject(item)){added.push(this.addObject(item)[0])}}return added}findMatches(data,criteria){const matches=[];for(let i=0;i<data.length&&matches.length<this.options.limit;i++){const match=this.findMatchesInObject(data[i],criteria);if(match){matches.push(match)}}return matches}findMatchesInObject(obj,criteria){let hasMatch=false;const result={...obj};result._matchInfo={};for(const key in obj){if(!this.isExcluded(obj[key])&&this.options.searchStrategy.matches(obj[key],criteria)){hasMatch=true;const matchInfo=this.options.searchStrategy.findMatches(obj[key],criteria);if(matchInfo&&matchInfo.length>0){result._matchInfo[key]=matchInfo}}}return hasMatch?result:void 0}isExcluded(term){for(const excludedTerm of this.options.exclude){if(new RegExp(excludedTerm).test(String(term))){return true}}return false}searchStrategy(strategy){switch(strategy){case"fuzzy":return FuzzySearchStrategy;case"wildcard":return WildcardSearchStrategy;default:return LiteralSearchStrategy}}}const options={pattern:/\{(.*?)\}/g,template:"",middleware:function(){return void 0}};function setOptions(_options){if(_options.pattern){options.pattern=_options.pattern}if(_options.template){options.template=_options.template}if(typeof _options.middleware==="function"){options.middleware=_options.middleware}}function compile(data,query){return options.template.replace(options.pattern,(function(match,prop){const matchInfo=data._matchInfo&&data._matchInfo[prop]?data._matchInfo[prop]:void 0;const value=options.middleware(prop,data[prop],options.template,query,matchInfo);if(typeof value!=="undefined"){return value}return data[prop]||match}))}let SimpleJekyllSearch$1=class SimpleJekyllSearch{constructor(){this.debounceTimerHandle=null;this.options={...DEFAULT_OPTIONS};this.repository=new Repository;this.optionsValidator=new OptionsValidator({required:REQUIRED_OPTIONS})}debounce(func,delayMillis){if(delayMillis){if(this.debounceTimerHandle){clearTimeout(this.debounceTimerHandle)}this.debounceTimerHandle=setTimeout(func,delayMillis)}else{func()}}throwError(message){throw new Error(`SimpleJekyllSearch --- ${message}`)}emptyResultsContainer(){this.options.resultsContainer.innerHTML=""}initWithJSON(json){this.repository.put(json);this.registerInput()}initWithURL(url){load(url,((err,json)=>{if(err){this.throwError(`Failed to load JSON from ${url}: ${err.message}`)}this.initWithJSON(json)}))}registerInput(){this.options.searchInput.addEventListener("input",(e=>{const inputEvent=e;if(!WHITELISTED_KEYS.has(inputEvent.key)){this.emptyResultsContainer();this.debounce((()=>{this.search(e.target.value)}),this.options.debounceTime??null)}}))}search(query){var _a,_b;if((query==null?void 0:query.trim().length)>0){this.emptyResultsContainer();const results=this.repository.search(query);this.render(results,query);(_b=(_a=this.options).onSearch)==null?void 0:_b.call(_a)}}render(results,query){if(results.length===0){this.options.resultsContainer.insertAdjacentHTML("beforeend",this.options.noResultsText);return}const fragment=document.createDocumentFragment();results.forEach((result=>{result.query=query;const div=document.createElement("div");div.innerHTML=compile(result,query);fragment.appendChild(div)}));this.options.resultsContainer.appendChild(fragment)}init(_options){var _a;const errors=this.optionsValidator.validate(_options);if(errors.length>0){this.throwError(`Missing required options: ${REQUIRED_OPTIONS.join(", ")}`)}this.options=merge(this.options,_options);setOptions({template:this.options.searchResultTemplate,middleware:this.options.templateMiddleware});this.repository.setOptions({fuzzy:this.options.fuzzy,limit:this.options.limit,sortMiddleware:this.options.sortMiddleware,strategy:this.options.strategy,exclude:this.options.exclude});if(isJSON(this.options.json)){this.initWithJSON(this.options.json)}else{this.initWithURL(this.options.json)}const rv={search:this.search.bind(this)};(_a=this.options.success)==null?void 0:_a.call(rv);return rv}};function createHighlightMiddleware(options2={}){const{highlightClass:highlightClass="sjs-highlight",contextBefore:contextBefore=50,contextAfter:contextAfter=50,maxLength:maxLength=250,ellipsis:ellipsis="..."}=options2;return function(result,query){if(!query||!result){return result}const highlightedResult={...result};const textFields=["title","desc","content","excerpt"];for(const field of textFields){if(highlightedResult[field]&&typeof highlightedResult[field]==="string"){const highlighted=highlightText(highlightedResult[field],query,{highlightClass:highlightClass,contextBefore:contextBefore,contextAfter:contextAfter,maxLength:maxLength,ellipsis:ellipsis});if(highlighted.highlightedText!==highlightedResult[field]){highlightedResult[field]=highlighted.highlightedText}}}return highlightedResult}}function highlightText(text,query,options2={}){const{highlightClass:highlightClass="sjs-highlight",contextBefore:contextBefore=50,contextAfter:contextAfter=50,maxLength:maxLength=250,ellipsis:ellipsis="..."}=options2;if(!text||!query){return{highlightedText:text,matchCount:0}}const originalText=text;const searchTerms=query.trim().toLowerCase().split(/\s+/).filter((term=>term.length>0));if(searchTerms.length===0){return{highlightedText:text,matchCount:0}}const matches=[];for(const term of searchTerms){let index=0;while(index<text.length){const found=text.toLowerCase().indexOf(term,index);if(found===-1)break;matches.push({start:found,end:found+term.length,term:text.substring(found,found+term.length)});index=found+1}}if(matches.length===0){return{highlightedText:text,matchCount:0}}matches.sort(((a,b)=>a.start-b.start));const mergedMatches=[];for(const match of matches){if(mergedMatches.length===0||mergedMatches[mergedMatches.length-1].end<match.start){mergedMatches.push(match)}else{const lastMatch=mergedMatches[mergedMatches.length-1];lastMatch.end=Math.max(lastMatch.end,match.end);lastMatch.term=text.substring(lastMatch.start,lastMatch.end)}}if(text.length<=maxLength){let highlightedText2=text;for(let i=mergedMatches.length-1;i>=0;i--){const match=mergedMatches[i];const before=highlightedText2.substring(0,match.start);const after=highlightedText2.substring(match.end);const matchText=highlightedText2.substring(match.start,match.end);highlightedText2=before+`<span class="${highlightClass}">${matchText}</span>`+after}return{highlightedText:highlightedText2,matchCount:mergedMatches.length}}let highlightedText="";let totalLength=0;let lastEnd=0;for(let i=0;i<mergedMatches.length;i++){const match=mergedMatches[i];const contextStart=Math.max(lastEnd,match.start-contextBefore);const contextEnd=Math.min(text.length,match.end+contextAfter);if(contextStart>lastEnd&&lastEnd>0){highlightedText+=ellipsis;totalLength+=ellipsis.length}if(contextStart<match.start){const beforeText=text.substring(contextStart,match.start);highlightedText+=beforeText;totalLength+=beforeText.length}const matchText=text.substring(match.start,match.end);highlightedText+=`<span class="${highlightClass}">${matchText}</span>`;totalLength+=matchText.length;if(match.end<contextEnd){const afterText=text.substring(match.end,contextEnd);highlightedText+=afterText;totalLength+=afterText.length}lastEnd=contextEnd;if(totalLength>=maxLength){if(contextEnd<text.length){highlightedText+=ellipsis}break}}return{highlightedText:highlightedText||originalText,matchCount:mergedMatches.length}}const defaultHighlightMiddleware=createHighlightMiddleware();function highlightWithMatchInfo(text,matchInfo,options2){if(matchInfo.length===0)return text;const sortedMatches=[...matchInfo].sort(((a,b)=>b.start-a.start));let highlightedText=text;for(const match of sortedMatches){const before=highlightedText.substring(0,match.start);const after=highlightedText.substring(match.end);const matchText=highlightedText.substring(match.start,match.end);highlightedText=before+`<span class="${options2.highlightClass}">${matchText}</span>`+after}return highlightedText}function createHighlightTemplateMiddleware(options2={}){const highlightOptions={highlightClass:"sjs-highlight",...options2};return function(prop,value,_template,query,matchInfo){if((prop==="content"||prop==="desc")&&query&&typeof value==="string"){if(matchInfo&&matchInfo.length>0){const highlighted=highlightWithMatchInfo(value,matchInfo,highlightOptions);return highlighted!==value?highlighted:void 0}}return void 0}}const defaultHighlightTemplateMiddleware=createHighlightTemplateMiddleware();function SimpleJekyllSearch(options2){const instance=new SimpleJekyllSearch$1;return instance.init(options2)}if(typeof window!=="undefined"){window.SimpleJekyllSearch=SimpleJekyllSearch;window.SimpleJekyllSearch.createHighlightMiddleware=createHighlightMiddleware;window.SimpleJekyllSearch.createHighlightTemplateMiddleware=createHighlightTemplateMiddleware;window.SimpleJekyllSearch.highlightText=highlightText;window.SimpleJekyllSearch.defaultHighlightMiddleware=defaultHighlightMiddleware;window.SimpleJekyllSearch.defaultHighlightTemplateMiddleware=defaultHighlightTemplateMiddleware}exports2.createHighlightMiddleware=createHighlightMiddleware;exports2.createHighlightTemplateMiddleware=createHighlightTemplateMiddleware;exports2.default=SimpleJekyllSearch;exports2.defaultHighlightMiddleware=defaultHighlightMiddleware;exports2.defaultHighlightTemplateMiddleware=defaultHighlightTemplateMiddleware;exports2.highlightText=highlightText;Object.defineProperties(exports2,{__esModule:{value:true},[Symbol.toStringTag]:{value:"Module"}})}));
\ No newline at end of file
diff --git a/src/SearchStrategies/SearchStrategy.ts b/src/SearchStrategies/SearchStrategy.ts
index 4b00591..0d5d0cd 100644
--- a/src/SearchStrategies/SearchStrategy.ts
+++ b/src/SearchStrategies/SearchStrategy.ts
@@ -5,38 +5,16 @@ import { SearchStrategy } from './types';
 
 export const LiteralSearchStrategy = new SearchStrategy(
   (text: string, criteria: string) => {
-    if (!text || !criteria) return false;
-    const lowerText = text.trim().toLowerCase();
-    const pattern = criteria.endsWith(' ') ? [criteria.toLowerCase()] : criteria.trim().toLowerCase().split(' ');
-    return pattern.filter((word: string) => lowerText.indexOf(word) >= 0).length === pattern.length;
+    const literalMatches = findLiteralMatches(text, criteria);
+    return literalMatches.length > 0;
   },
   findLiteralMatches
 );
 
 export const FuzzySearchStrategy = new SearchStrategy(
   (text: string, criteria: string) => {
-    const pattern = criteria.trimEnd();
-    if (pattern.length === 0) return true;
-
-    const lowerPattern = pattern.toLowerCase();
-    const lowerText = text.toLowerCase();
-
-    let remainingText = lowerText, currentIndex = -1;
-    
-    for (const char of lowerPattern) {
-      const nextIndex = remainingText.indexOf(char);
-
-      if (nextIndex === -1 || (currentIndex !== -1 && remainingText.slice(0, nextIndex).split(' ').length - 1 > 2)) {
-        const lowerText2 = text.trim().toLowerCase();
-        const pattern2 = criteria.endsWith(' ') ? [criteria.toLowerCase()] : criteria.trim().toLowerCase().split(' ');
-        return pattern2.filter((word: string) => lowerText2.indexOf(word) >= 0).length === pattern2.length;
-      }
-
-      currentIndex = nextIndex;
-      remainingText = remainingText.slice(nextIndex + 1);
-    }
-
-    return true;
+    const fuzzyMatches = findFuzzyMatches(text, criteria);
+    return fuzzyMatches.length > 0;
   },
   findFuzzyMatches
 );
diff --git a/src/SearchStrategies/search/fuzzySearch.ts b/src/SearchStrategies/search/fuzzySearch.ts
index b4ea960..5d726b6 100644
--- a/src/SearchStrategies/search/fuzzySearch.ts
+++ b/src/SearchStrategies/search/fuzzySearch.ts
@@ -15,6 +15,7 @@ export function findFuzzyMatches(text: string, pattern: string): MatchInfo[] {
   
   if (lowerPattern.length === 0) return [];
   
+  // Try character-by-character fuzzy matching first
   const matches: MatchInfo[] = [];
   for (let i = 0; i < lowerText.length; i++) {
     const match = findFuzzySequenceMatch(lowerText, lowerPattern, i);
@@ -31,6 +32,29 @@ export function findFuzzyMatches(text: string, pattern: string): MatchInfo[] {
     }
   }
   
+  // If no fuzzy matches found, try literal word matching as fallback
+  if (matches.length === 0) {
+    const words = lowerPattern.split(/\s+/);
+    if (words.length > 1) {
+      // For multi-word patterns, check if all words are present (flexible word order)
+      for (const word of words) {
+        if (word.length === 0) continue;
+        const wordIndex = lowerText.indexOf(word);
+        if (wordIndex !== -1) {
+          matches.push({
+            start: wordIndex,
+            end: wordIndex + word.length,
+            text: text.substring(wordIndex, wordIndex + word.length),
+            type: 'exact'
+          });
+        } else {
+          // If any word is not found, return empty array
+          return [];
+        }
+      }
+    }
+  }
+  
   return matches;
 }
 
diff --git a/src/SearchStrategies/search/literalSearch.ts b/src/SearchStrategies/search/literalSearch.ts
index f3cd76c..da46f15 100644
--- a/src/SearchStrategies/search/literalSearch.ts
+++ b/src/SearchStrategies/search/literalSearch.ts
@@ -15,11 +15,10 @@ export function findLiteralMatches(text: string, criteria: string): MatchInfo[]
   const words = criteria.trim().toLowerCase().split(/\s+/);
   const matches: MatchInfo[] = [];
   
-  let textIndex = 0;
   for (const word of words) {
     if (word.length === 0) continue;
     
-    let wordIndex = lowerText.indexOf(word, textIndex);
+    let wordIndex = lowerText.indexOf(word);
     
     if (hasTrailingSpace && word === words[words.length - 1]) {
       while (wordIndex !== -1) {
@@ -38,7 +37,9 @@ export function findLiteralMatches(text: string, criteria: string): MatchInfo[]
         text: text.substring(wordIndex, wordIndex + word.length),
         type: 'exact'
       });
-      textIndex = wordIndex + word.length;
+    } else {
+      // If any word is not found, return empty array
+      return [];
     }
   }
   
diff --git a/src/SearchStrategies/search/wildcardSearch.ts b/src/SearchStrategies/search/wildcardSearch.ts
index fed5ede..d9e6505 100644
--- a/src/SearchStrategies/search/wildcardSearch.ts
+++ b/src/SearchStrategies/search/wildcardSearch.ts
@@ -12,10 +12,13 @@ import { mergeAndSortMatches } from './utils';
 export function findWildcardMatches(text: string, pattern: string): MatchInfo[] {
   if (!text || !pattern) return [];
   
+  // Try wildcard matching first
   const wildcardMatches = findWildcardPatternMatches(text, pattern);
   if (wildcardMatches.length > 0) {
     return mergeAndSortMatches(wildcardMatches);
   }
+  
+  // Fall back to levenshtein matching for fuzzy search
   if (levenshteinSearch(text, pattern)) {
     return [{
       start: 0,
@@ -33,7 +36,18 @@ export function findWildcardMatches(text: string, pattern: string): MatchInfo[]
  */
 function findWildcardPatternMatches(text: string, pattern: string): MatchInfo[] {
   const matches: MatchInfo[] = [];
-  const regexPattern = pattern.replace(/\*/g, '.*');
+  
+  // Convert pattern to regex
+  let regexPattern: string;
+  if (pattern.includes('*') || pattern.includes('?')) {
+    // For wildcard patterns, use regex matching
+    regexPattern = pattern.replace(/\*/g, '.*').replace(/\?/g, '.');
+  } else {
+    // For non-wildcard patterns, use partial word matching (no word boundaries)
+    const escapedPattern = pattern.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+    regexPattern = escapedPattern;
+  }
+  
   const regex = new RegExp(regexPattern, 'gi');
   let match;
   let lastIndex = 0;
diff --git a/tests/SearchStrategies/wildcardSearch.test.ts b/tests/SearchStrategies/wildcardSearch.test.ts
index 31b6a26..a3ba50e 100644
--- a/tests/SearchStrategies/wildcardSearch.test.ts
+++ b/tests/SearchStrategies/wildcardSearch.test.ts
@@ -2,10 +2,28 @@ import { describe, expect, it } from 'vitest';
 import { findWildcardMatches } from '../../src/SearchStrategies/search/wildcardSearch';
 
 describe('findWildcardMatches', () => {
-  it('should find exact matches', () => {
+  it('should find exact matches for non-wildcard patterns', () => {
     const matches = findWildcardMatches('hello', 'hello');
     expect(matches.length).toBeGreaterThan(0);
     expect(matches[0].type).toBe('wildcard');
+    expect(matches[0].text).toBe('hello');
+    expect(matches[0].start).toBe(0);
+    expect(matches[0].end).toBe(5);
+  });
+
+  it('should find exact matches within longer text', () => {
+    const matches = findWildcardMatches('hello world test', 'world');
+    expect(matches.length).toBeGreaterThan(0);
+    expect(matches[0].type).toBe('wildcard');
+    expect(matches[0].text).toBe('world');
+    expect(matches[0].start).toBe(6);
+    expect(matches[0].end).toBe(11);
+  });
+
+  it('should find fuzzy matches for similar non-wildcard patterns', () => {
+    const matches = findWildcardMatches('testing', 'test');
+    expect(matches.length).toBeGreaterThan(0); // Should find fuzzy match via Levenshtein
+    expect(matches[0].type).toBe('wildcard');
   });
 
   it('should find matches with wildcards', () => {
diff --git a/tests/highlightMiddleware.test.ts b/tests/highlightMiddleware.test.ts
index c6ae407..b16af97 100644
--- a/tests/highlightMiddleware.test.ts
+++ b/tests/highlightMiddleware.test.ts
@@ -420,4 +420,130 @@ describe('createHighlightTemplateMiddleware', () => {
       expect(result).toBeUndefined();
     });
   });
+
+  describe('Fallback Removal Verification', () => {
+    it('should NOT fallback to query-based highlighting when matchInfo is missing', () => {
+      const middleware = createHighlightTemplateMiddleware();
+      const text = 'This is a test content with search terms';
+      const query = 'test search';
+      
+      // This should return undefined because there's no matchInfo and no fallback
+      const result = middleware('content', text, '<div>{content}</div>', query);
+      
+      expect(result).toBeUndefined();
+    });
+
+    it('should NOT fallback to query-based highlighting when matchInfo is empty', () => {
+      const middleware = createHighlightTemplateMiddleware();
+      const text = 'This is a test content with search terms';
+      const query = 'test search';
+      
+      // This should return undefined because matchInfo is empty and no fallback
+      const result = middleware('content', text, '<div>{content}</div>', query, []);
+      
+      expect(result).toBeUndefined();
+    });
+
+    it('should work correctly with different match types', () => {
+      const middleware = createHighlightTemplateMiddleware();
+      const text = 'This is a test content with search terms';
+      
+      // Test with exact matches - correct positions
+      const exactMatches = [
+        { start: 10, end: 14, text: 'test', type: 'exact' as const },
+        { start: 28, end: 34, text: 'search', type: 'exact' as const }
+      ];
+      const exactResult = middleware('content', text, '<div>{content}</div>', 'test search', exactMatches);
+      expect(exactResult).toContain('<span class="sjs-highlight">test</span>');
+      expect(exactResult).toContain('<span class="sjs-highlight">search</span>');
+
+      // Test with fuzzy matches - correct positions
+      const fuzzyMatches = [
+        { start: 10, end: 14, text: 'test', type: 'fuzzy' as const },
+        { start: 28, end: 34, text: 'search', type: 'fuzzy' as const }
+      ];
+      const fuzzyResult = middleware('content', text, '<div>{content}</div>', 'test search', fuzzyMatches);
+      expect(fuzzyResult).toContain('<span class="sjs-highlight">test</span>');
+      expect(fuzzyResult).toContain('<span class="sjs-highlight">search</span>');
+
+      // Test with wildcard matches - correct positions
+      const wildcardMatches = [
+        { start: 10, end: 14, text: 'test', type: 'wildcard' as const },
+        { start: 28, end: 34, text: 'search', type: 'wildcard' as const }
+      ];
+      const wildcardResult = middleware('content', text, '<div>{content}</div>', 'test search', wildcardMatches);
+      expect(wildcardResult).toContain('<span class="sjs-highlight">test</span>');
+      expect(wildcardResult).toContain('<span class="sjs-highlight">search</span>');
+    });
+
+    it('should handle overlapping matches correctly', () => {
+      const middleware = createHighlightTemplateMiddleware();
+      const text = 'This is a test test content';
+      
+      const overlappingMatches = [
+        { start: 10, end: 14, text: 'test', type: 'exact' as const },
+        { start: 15, end: 19, text: 'test', type: 'exact' as const }
+      ];
+      
+      const result = middleware('content', text, '<div>{content}</div>', 'test', overlappingMatches);
+      
+      expect(result).toContain('<span class="sjs-highlight">test</span>');
+      expect(result).toContain('<span class="sjs-highlight">test</span>');
+    });
+
+    it('should handle non-content properties without highlighting', () => {
+      const middleware = createHighlightTemplateMiddleware();
+      const text = 'This is a test content';
+      const query = 'test';
+      const matchInfo = [{ start: 10, end: 14, text: 'test', type: 'exact' as const }];
+      
+      // Should not highlight non-content properties
+      const titleResult = middleware('title', text, '<div>{title}</div>', query, matchInfo);
+      expect(titleResult).toBeUndefined();
+      
+      const urlResult = middleware('url', text, '<div>{url}</div>', query, matchInfo);
+      expect(urlResult).toBeUndefined();
+      
+      // Should only highlight content and desc properties
+      const contentResult = middleware('content', text, '<div>{content}</div>', query, matchInfo);
+      expect(contentResult).toContain('<span class="sjs-highlight">test</span>');
+      
+      const descResult = middleware('desc', text, '<div>{desc}</div>', query, matchInfo);
+      expect(descResult).toContain('<span class="sjs-highlight">test</span>');
+    });
+
+    it('should handle custom highlight options', () => {
+      const customOptions = {
+        highlightClass: 'custom-highlight',
+        contextBefore: 5,
+        contextAfter: 5,
+        maxLength: 20,
+        ellipsis: '...'
+      };
+      
+      const middleware = createHighlightTemplateMiddleware(customOptions);
+      const text = 'This is a very long test content that should be truncated';
+      const matchInfo = [{ start: 20, end: 24, text: 'test', type: 'exact' as const }];
+      
+      const result = middleware('content', text, '<div>{content}</div>', 'test', matchInfo);
+      
+      expect(result).toContain('<span class="custom-highlight">test</span>');
+      // Verify the custom class is used
+      expect(result).toContain('custom-highlight');
+      // Verify the result contains the highlighted text
+      expect(result).toContain('test');
+    });
+
+    it('should verify no fallback search is performed', () => {
+      const middleware = createHighlightTemplateMiddleware();
+      const text = 'This is a test content';
+      const query = 'nonexistent';
+      
+      // Even though 'nonexistent' is not in the text, without matchInfo it should return undefined
+      // This proves no fallback search is happening
+      const result = middleware('content', text, '<div>{content}</div>', query);
+      
+      expect(result).toBeUndefined();
+    });
+  });
 });