@aiquants/select-box 0.1.0

package/dist/index.js

@@ -0,0 +1,1084 @@
+import * as J from "react";
+import he, { useState as M, useMemo as j, useRef as K, useEffect as S, useCallback as v } from "react";
+import { VirtualScroll as Ze } from "@aiquants/virtualscroll";
+var $ = { exports: {} }, B = {};
+var de;
+function be() {
+  if (de) return B;
+  de = 1;
+  var e = /* @__PURE__ */ Symbol.for("react.transitional.element"), l = /* @__PURE__ */ Symbol.for("react.fragment");
+  function t(a, r, d) {
+    var n = null;
+    if (d !== void 0 && (n = "" + d), r.key !== void 0 && (n = "" + r.key), "key" in r) {
+      d = {};
+      for (var c in r)
+        c !== "key" && (d[c] = r[c]);
+    } else d = r;
+    return r = d.ref, {
+      $$typeof: e,
+      type: a,
+      key: n,
+      ref: r !== void 0 ? r : null,
+      props: d
+    };
+  }
+  return B.Fragment = l, B.jsx = t, B.jsxs = t, B;
+}
+var O = {};
+var ce;
+function Ge() {
+  return ce || (ce = 1, process.env.NODE_ENV !== "production" && (function() {
+    function e(s) {
+      if (s == null) return null;
+      if (typeof s == "function")
+        return s.$$typeof === se ? null : s.displayName || s.name || null;
+      if (typeof s == "string") return s;
+      switch (s) {
+        case T:
+          return "Fragment";
+        case u:
+          return "Profiler";
+        case y:
+          return "StrictMode";
+        case f:
+          return "Suspense";
+        case le:
+          return "SuspenseList";
+        case ae:
+          return "Activity";
+      }
+      if (typeof s == "object")
+        switch (typeof s.tag == "number" && console.error(
+          "Received an unexpected object in getComponentNameFromType(). This is likely a bug in React. Please file an issue."
+        ), s.$$typeof) {
+          case k:
+            return "Portal";
+          case H:
+            return s.displayName || "Context";
+          case p:
+            return (s._context.displayName || "Context") + ".Consumer";
+          case U:
+            var h = s.render;
+            return s = s.displayName, s || (s = h.displayName || h.name || "", s = s !== "" ? "ForwardRef(" + s + ")" : "ForwardRef"), s;
+          case te:
+            return h = s.displayName || null, h !== null ? h : e(s.type) || "Memo";
+          case E:
+            h = s._payload, s = s._init;
+            try {
+              return e(s(h));
+            } catch {
+            }
+        }
+      return null;
+    }
+    function l(s) {
+      return "" + s;
+    }
+    function t(s) {
+      try {
+        l(s);
+        var h = !1;
+      } catch {
+        h = !0;
+      }
+      if (h) {
+        h = console;
+        var V = h.error, Y = typeof Symbol == "function" && Symbol.toStringTag && s[Symbol.toStringTag] || s.constructor.name || "Object";
+        return V.call(
+          h,
+          "The provided key is an unsupported type %s. This value must be coerced to a string before using it here.",
+          Y
+        ), l(s);
+      }
+    }
+    function a(s) {
+      if (s === T) return "<>";
+      if (typeof s == "object" && s !== null && s.$$typeof === E)
+        return "<...>";
+      try {
+        var h = e(s);
+        return h ? "<" + h + ">" : "<...>";
+      } catch {
+        return "<...>";
+      }
+    }
+    function r() {
+      var s = P.A;
+      return s === null ? null : s.getOwner();
+    }
+    function d() {
+      return Error("react-stack-top-frame");
+    }
+    function n(s) {
+      if (i.call(s, "key")) {
+        var h = Object.getOwnPropertyDescriptor(s, "key").get;
+        if (h && h.isReactWarning) return !1;
+      }
+      return s.key !== void 0;
+    }
+    function c(s, h) {
+      function V() {
+        F || (F = !0, console.error(
+          "%s: `key` is not a prop. Trying to access it will result in `undefined` being returned. If you need to access the same value within the child component, you should pass it as a different prop. (https://react.dev/link/special-props)",
+          h
+        ));
+      }
+      V.isReactWarning = !0, Object.defineProperty(s, "key", {
+        get: V,
+        configurable: !0
+      });
+    }
+    function b() {
+      var s = e(this.type);
+      return x[s] || (x[s] = !0, console.error(
+        "Accessing element.ref was removed in React 19. ref is now a regular prop. It will be removed from the JSX Element type in a future release."
+      )), s = this.props.ref, s !== void 0 ? s : null;
+    }
+    function X(s, h, V, Y, A, re) {
+      var z = V.ref;
+      return s = {
+        $$typeof: N,
+        type: s,
+        key: h,
+        props: V,
+        _owner: Y
+      }, (z !== void 0 ? z : null) !== null ? Object.defineProperty(s, "ref", {
+        enumerable: !1,
+        get: b
+      }) : Object.defineProperty(s, "ref", { enumerable: !1, value: null }), s._store = {}, Object.defineProperty(s._store, "validated", {
+        configurable: !1,
+        enumerable: !1,
+        writable: !0,
+        value: 0
+      }), Object.defineProperty(s, "_debugInfo", {
+        configurable: !1,
+        enumerable: !1,
+        writable: !0,
+        value: null
+      }), Object.defineProperty(s, "_debugStack", {
+        configurable: !1,
+        enumerable: !1,
+        writable: !0,
+        value: A
+      }), Object.defineProperty(s, "_debugTask", {
+        configurable: !1,
+        enumerable: !1,
+        writable: !0,
+        value: re
+      }), Object.freeze && (Object.freeze(s.props), Object.freeze(s)), s;
+    }
+    function m(s, h, V, Y, A, re) {
+      var z = h.children;
+      if (z !== void 0)
+        if (Y)
+          if (R(z)) {
+            for (Y = 0; Y < z.length; Y++)
+              G(z[Y]);
+            Object.freeze && Object.freeze(z);
+          } else
+            console.error(
+              "React.jsx: Static children should always be an array. You are likely explicitly calling React.jsxs or React.jsxDEV. Use the Babel transform instead."
+            );
+        else G(z);
+      if (i.call(h, "key")) {
+        z = e(s);
+        var I = Object.keys(h).filter(function(ue) {
+          return ue !== "key";
+        });
+        Y = 0 < I.length ? "{key: someKey, " + I.join(": ..., ") + ": ...}" : "{key: someKey}", D[z + Y] || (I = 0 < I.length ? "{" + I.join(": ..., ") + ": ...}" : "{}", console.error(
+          `A props object containing a "key" prop is being spread into JSX:
+  let props = %s;
+  <%s {...props} />
+React keys must be passed directly to JSX without using spread:
+  let props = %s;
+  <%s key={someKey} {...props} />`,
+          Y,
+          z,
+          I,
+          z
+        ), D[z + Y] = !0);
+      }
+      if (z = null, V !== void 0 && (t(V), z = "" + V), n(h) && (t(h.key), z = "" + h.key), "key" in h) {
+        V = {};
+        for (var ne in h)
+          ne !== "key" && (V[ne] = h[ne]);
+      } else V = h;
+      return z && c(
+        V,
+        typeof s == "function" ? s.displayName || s.name || "Unknown" : s
+      ), X(
+        s,
+        z,
+        V,
+        r(),
+        A,
+        re
+      );
+    }
+    function G(s) {
+      o(s) ? s._store && (s._store.validated = 1) : typeof s == "object" && s !== null && s.$$typeof === E && (s._payload.status === "fulfilled" ? o(s._payload.value) && s._payload.value._store && (s._payload.value._store.validated = 1) : s._store && (s._store.validated = 1));
+    }
+    function o(s) {
+      return typeof s == "object" && s !== null && s.$$typeof === N;
+    }
+    var Z = he, N = /* @__PURE__ */ Symbol.for("react.transitional.element"), k = /* @__PURE__ */ Symbol.for("react.portal"), T = /* @__PURE__ */ Symbol.for("react.fragment"), y = /* @__PURE__ */ Symbol.for("react.strict_mode"), u = /* @__PURE__ */ Symbol.for("react.profiler"), p = /* @__PURE__ */ Symbol.for("react.consumer"), H = /* @__PURE__ */ Symbol.for("react.context"), U = /* @__PURE__ */ Symbol.for("react.forward_ref"), f = /* @__PURE__ */ Symbol.for("react.suspense"), le = /* @__PURE__ */ Symbol.for("react.suspense_list"), te = /* @__PURE__ */ Symbol.for("react.memo"), E = /* @__PURE__ */ Symbol.for("react.lazy"), ae = /* @__PURE__ */ Symbol.for("react.activity"), se = /* @__PURE__ */ Symbol.for("react.client.reference"), P = Z.__CLIENT_INTERNALS_DO_NOT_USE_OR_WARN_USERS_THEY_CANNOT_UPGRADE, i = Object.prototype.hasOwnProperty, R = Array.isArray, g = console.createTask ? console.createTask : function() {
+      return null;
+    };
+    Z = {
+      react_stack_bottom_frame: function(s) {
+        return s();
+      }
+    };
+    var F, x = {}, L = Z.react_stack_bottom_frame.bind(
+      Z,
+      d
+    )(), w = g(a(d)), D = {};
+    O.Fragment = T, O.jsx = function(s, h, V) {
+      var Y = 1e4 > P.recentlyCreatedOwnerStacks++;
+      return m(
+        s,
+        h,
+        V,
+        !1,
+        Y ? Error("react-stack-top-frame") : L,
+        Y ? g(a(s)) : w
+      );
+    }, O.jsxs = function(s, h, V) {
+      var Y = 1e4 > P.recentlyCreatedOwnerStacks++;
+      return m(
+        s,
+        h,
+        V,
+        !0,
+        Y ? Error("react-stack-top-frame") : L,
+        Y ? g(a(s)) : w
+      );
+    };
+  })()), O;
+}
+var ie;
+function Xe() {
+  return ie || (ie = 1, process.env.NODE_ENV === "production" ? $.exports = be() : $.exports = Ge()), $.exports;
+}
+var W = Xe(), ee = class {
+  constructor(e = 2, l = "[fuzzy-search]", t = console) {
+    this.level = e, this.prefix = l, this.impl = t;
+  }
+  setLevel(e) {
+    this.level = e;
+  }
+  setImplementation(e) {
+    this.impl = e;
+  }
+  setPrefix(e) {
+    this.prefix = e;
+  }
+  formatMessage(e) {
+    return typeof e == "string" ? [`${this.prefix} ${e}`] : [this.prefix, e];
+  }
+  debug(e, ...l) {
+    this.level <= 0 && this.impl.debug(...this.formatMessage(e), ...l);
+  }
+  info(e, ...l) {
+    this.level <= 1 && this.impl.info(...this.formatMessage(e), ...l);
+  }
+  warn(e, ...l) {
+    this.level <= 2 && this.impl.warn(...this.formatMessage(e), ...l);
+  }
+  error(e, ...l) {
+    this.level <= 3 && this.impl.error(...this.formatMessage(e), ...l);
+  }
+}, _ = { threshold: 0.4, caseSensitive: !1, learningWeight: 1.2, debounceMs: 300, multiTermOperator: "and", autoSearchOnIndexRebuild: !0, customWeights: {}, ngramSize: 2, minNgramOverlap: 1, sortBy: "relevance", sortOrder: "desc", enableIndexFiltering: !0, enableLevenshtein: !0, parallelSearchStrategy: "balanced", logLevel: 2, indexWorkerOptions: { strategy: "hybrid", threshold: 0.4, ngramOverlapThreshold: 0.3, minCandidatesRatio: 0.1, maxCandidatesRatio: 0.5, jaroWinklerPrefix: 0.1, maxResults: 1e3, relevanceFieldWeight: 0.2, relevancePerfectMatchBonus: 0.1 }, levenshteinWorkerOptions: { threshold: 0.3, lengthSimilarityThreshold: 0.1, partialMatchBonus: 0.1, lengthDiffPenalty: 1, maxResults: 1e3, relevanceFieldWeight: 0.15 } }, me = class q {
+  constructor(l) {
+    this.indexWorker = null, this.levenshteinWorker = null, this.initializationPromise = null, this.referenceCount = 0, this.lastIndexedDataHash = null, this.buildingDataHash = null, this.buildingPromise = null, this.id = l;
+    let t = l !== "default" ? `[GlobalWorkerManager:${l}]` : "[GlobalWorkerManager]";
+    this.logger = new ee(2, t);
+  }
+  static getInstance(l = "default") {
+    let t = q.instances.get(l);
+    return t || (t = new q(l), q.instances.set(l, t)), t;
+  }
+  getLastIndexedDataHash() {
+    return this.lastIndexedDataHash;
+  }
+  setLastIndexedDataHash(l) {
+    this.lastIndexedDataHash = l;
+  }
+  getBuildingPromise(l) {
+    return this.buildingDataHash === l ? this.buildingPromise : null;
+  }
+  setBuildingPromise(l, t) {
+    this.buildingDataHash = l, this.buildingPromise = t, t.finally(() => {
+      this.buildingDataHash === l && (this.buildingDataHash = null, this.buildingPromise = null);
+    });
+  }
+  async getWorkers(l) {
+    return l.logLevel !== void 0 && this.logger.setLevel(l.logLevel), l.logger && this.logger.setImplementation(l.logger), this.referenceCount++, this.indexWorker && this.levenshteinWorker ? (this.logger.debug(`🔧 Using existing global Workers (ref count: ${this.referenceCount})`), l.logLevel !== void 0 && (this.indexWorker.postMessage({ type: "setLogLevel", id: "system", logLevel: l.logLevel, workerId: this.id }), this.levenshteinWorker.postMessage({ type: "setLogLevel", id: "system", logLevel: l.logLevel, workerId: this.id })), { indexWorker: this.indexWorker, levenshteinWorker: this.levenshteinWorker }) : (this.initializationPromise || (this.initializationPromise = this.initializeWorkers(l)), await this.initializationPromise, this.indexWorker && this.levenshteinWorker && l.logLevel !== void 0 && (this.indexWorker.postMessage({ type: "setLogLevel", id: "system", logLevel: l.logLevel, workerId: this.id }), this.levenshteinWorker.postMessage({ type: "setLogLevel", id: "system", logLevel: l.logLevel, workerId: this.id })), { indexWorker: this.indexWorker, levenshteinWorker: this.levenshteinWorker });
+  }
+  async initializeWorkers(l) {
+    if (!(typeof Worker > "u")) try {
+      if (!this.indexWorker) {
+        let t = import.meta.url.includes(".ts") ? new URL("../worker/indexWorker.ts", import.meta.url) : new URL("data:text/javascript;base64,var C=class{constructor(s=2,t="[fuzzy-search]",e=console){this.level=s,this.prefix=t,this.impl=e}setLevel(s){this.level=s}setImplementation(s){this.impl=s}setPrefix(s){this.prefix=s}formatMessage(s){return typeof s=="string"?[`${this.prefix} ${s}`]:[this.prefix,s]}debug(s,...t){this.level<=0&&this.impl.debug(...this.formatMessage(s),...t)}info(s,...t){this.level<=1&&this.impl.info(...this.formatMessage(s),...t)}warn(s,...t){this.level<=2&&this.impl.warn(...this.formatMessage(s),...t)}error(s,...t){this.level<=3&&this.impl.error(...this.formatMessage(s),...t)}};var u={threshold:.4,caseSensitive:!1,learningWeight:1.2,debounceMs:300,multiTermOperator:"and",autoSearchOnIndexRebuild:!0,customWeights:{},ngramSize:2,minNgramOverlap:1,sortBy:"relevance",sortOrder:"desc",enableIndexFiltering:!0,enableLevenshtein:!0,parallelSearchStrategy:"balanced",logLevel:2,indexWorkerOptions:{strategy:"hybrid",threshold:.4,ngramOverlapThreshold:.3,minCandidatesRatio:.1,maxCandidatesRatio:.5,jaroWinklerPrefix:.1,maxResults:1e3,relevanceFieldWeight:.2,relevancePerfectMatchBonus:.1},levenshteinWorkerOptions:{threshold:.3,lengthSimilarityThreshold:.1,partialMatchBonus:.1,lengthDiffPenalty:1,maxResults:1e3,relevanceFieldWeight:.15}};var z=class{constructor(){this.stats={totalSearches:0,totalProcessingTime:0,averageSearchTime:0,lastSearchTime:0,errorCount:0,timestamp:Date.now()};this.baseLogPrefix="[fuzzy-search-worker]";this.logger=new C(2,this.baseLogPrefix);this.detailedStats=new Map;this.performanceHistory=[];this.operationDistribution=new Map;this.fieldStats=new Map;this.metrics={timings:{averageProcessingTime:0,fastestProcessing:1/0,slowestProcessing:0,lastProcessingTime:0},throughput:{operationsPerSecond:0,totalOperations:0},quality:{successRate:1,errorRate:0,timeoutRate:0}}}setLogLevel(s){this.logger.setLevel(s)}setWorkerId(s){let t=s?`${this.baseLogPrefix.slice(0,-1)}:${s}]`:this.baseLogPrefix;this.logger.setPrefix(t)}updateStats(s,t=!0){this.stats.totalSearches++,this.stats.totalProcessingTime+=s,this.stats.averageSearchTime=this.stats.totalProcessingTime/this.stats.totalSearches,this.stats.lastSearchTime=s,this.metrics.timings.lastProcessingTime=s,this.metrics.timings.averageProcessingTime=this.stats.averageSearchTime,this.metrics.timings.fastestProcessing=Math.min(this.metrics.timings.fastestProcessing,s),this.metrics.timings.slowestProcessing=Math.max(this.metrics.timings.slowestProcessing,s),this.metrics.throughput.totalOperations++,this.metrics.timings.averageProcessingTime>0&&(this.metrics.throughput.operationsPerSecond=1e3/this.metrics.timings.averageProcessingTime),t||this.stats.errorCount++;let e=this.metrics.throughput.totalOperations;this.metrics.quality.successRate=(e-this.stats.errorCount)/e,this.metrics.quality.errorRate=this.stats.errorCount/e}getStats(){return{...this.stats}}getMetrics(){return{...this.metrics}}resetStats(){this.stats={totalSearches:0,totalProcessingTime:0,averageSearchTime:0,lastSearchTime:0,errorCount:0,timestamp:Date.now()},this.metrics={timings:{averageProcessingTime:0,fastestProcessing:1/0,slowestProcessing:0,lastProcessingTime:0},throughput:{operationsPerSecond:0,totalOperations:0},quality:{successRate:1,errorRate:0,timeoutRate:0}},this.detailedStats.clear(),this.performanceHistory=[],this.operationDistribution.clear(),this.fieldStats.clear(),this.logger.info(`\u{1F4CA} ${this.getWorkerType()} Worker: Statistics reset completed`)}updateWorkerStats(s,t,e={}){this.updateStats(t,!0);let r=this.operationDistribution.get(s)||0;this.operationDistribution.set(s,r+1),Object.entries(e).forEach(([i,n])=>{this.detailedStats.set(i,n)}),this.addPerformanceEntry({timestamp:Date.now(),operationType:s,processingTime:t,queryLength:e.queryLength||0,itemCount:e.itemCount||0,resultCount:e.resultCount||0,additionalMetrics:e})}updateFieldStats(s,t){let e=this.fieldStats.get(s)||{matchCount:0,averageScore:0,totalScore:0,bestScore:0,worstScore:1};e.matchCount+=1,e.totalScore+=t,e.averageScore=e.totalScore/e.matchCount,e.bestScore=Math.max(e.bestScore,t),e.worstScore=Math.min(e.worstScore,t),this.fieldStats.set(s,e)}addPerformanceEntry(s){this.performanceHistory.push(s),this.performanceHistory.length>100&&(this.performanceHistory=this.performanceHistory.slice(-100))}getWorkerStats(){return{basic:{...this.stats,timestamp:Date.now()},workerSpecific:{workerType:this.getWorkerType(),operationCount:this.getTotalOperations(),operationDistribution:Object.fromEntries(this.operationDistribution),specificMetrics:this.getSpecificMetrics()},analysis:{fieldPerformance:Object.fromEntries(this.fieldStats),performanceInsights:this.generatePerformanceInsights(),recentHistory:this.performanceHistory.slice(-10)}}}sendStatsUpdate(){let s={type:"stats",id:`stats-${Date.now()}`,stats:this.getWorkerStats(),metrics:this.getMetrics(),processingTime:0,workerType:this.getWorkerType(),operationMeta:{}};this.logger.info(`\u{1F4CA} ${this.getWorkerType()} Worker: Sending unified stats update`),self.postMessage(s)}getTotalOperations(){return Array.from(this.operationDistribution.values()).reduce((s,t)=>s+t,0)}generatePerformanceInsights(){if(this.performanceHistory.length===0)return{recentAverageProcessingTime:0,recentAverageResultCount:0,throughputPerSecond:0,totalHistoryEntries:0,mostCommonQueryLength:0,bestPerformingField:"",similarityDistribution:{highSimilarity:0,mediumSimilarity:0,lowSimilarity:0,veryLowSimilarity:0}};let s=this.performanceHistory.slice(-10),t=s.reduce((o,h)=>o+h.processingTime,0)/s.length,e=s.reduce((o,h)=>o+h.resultCount,0)/s.length,r=new Map;this.performanceHistory.forEach(o=>{let h=r.get(o.queryLength)||0;r.set(o.queryLength,h+1)});let i=0,n=0;r.forEach((o,h)=>{o>n&&(n=o,i=h)});let a="",c=0;return this.fieldStats.forEach((o,h)=>{o.averageScore>c&&(c=o.averageScore,a=h)}),{recentAverageProcessingTime:t,recentAverageResultCount:e,throughputPerSecond:t>0?1e3/t:0,totalHistoryEntries:this.performanceHistory.length,mostCommonQueryLength:i,bestPerformingField:a,similarityDistribution:{highSimilarity:0,mediumSimilarity:0,lowSimilarity:0,veryLowSimilarity:0}}}handleMessage(s){this.logger.warn("\u26A0\uFE0F BaseWorker.handleMessage: No implementation provided")}};var I=class extends z{constructor(){super();this.ngramCache=new Map;this.wordCache=new Map;this.phoneticCache=new Map;this.currentItems=[];this.currentSearchFields=[];this.indexMetadata=null;this.indexStats={totalIndexBuilds:0,currentDataSize:0,lastIndexTime:0};this.similarityThresholdStats={above80:0,above60:0,above40:0,below40:0};this.baseLogPrefix="[fuzzy-search-index]",this.logger.setPrefix(this.baseLogPrefix),this.setupMessageHandler()}getWorkerType(){return"index"}getSpecificMetrics(){return{totalIndexBuilds:this.indexStats.totalIndexBuilds,currentDataSize:this.indexStats.currentDataSize,lastIndexTime:this.indexStats.lastIndexTime,cacheSize:{ngram:this.ngramCache.size,word:this.wordCache.size,phonetic:this.phoneticCache.size},indexMetadata:this.indexMetadata||{},similarityThresholds:{...this.similarityThresholdStats}}}resetStats(){super.resetStats(),this.indexStats={totalIndexBuilds:0,currentDataSize:0,lastIndexTime:0},this.similarityThresholdStats={above80:0,above60:0,above40:0,below40:0},this.logger.info("\u{1F527} Index Worker: All statistics reset completed")}updateSimilarityStats(t){t>=.8?this.similarityThresholdStats.above80++:t>=.6?this.similarityThresholdStats.above60++:t>=.4?this.similarityThresholdStats.above40++:this.similarityThresholdStats.below40++}generatePerformanceInsights(){let t=super.generatePerformanceInsights(),e=this.similarityThresholdStats.above80+this.similarityThresholdStats.above60+this.similarityThresholdStats.above40+this.similarityThresholdStats.below40,r=e>0?{highSimilarity:Math.round(this.similarityThresholdStats.above80/e*100),mediumSimilarity:Math.round(this.similarityThresholdStats.above60/e*100),lowSimilarity:Math.round(this.similarityThresholdStats.above40/e*100),veryLowSimilarity:Math.round(this.similarityThresholdStats.below40/e*100)}:{highSimilarity:0,mediumSimilarity:0,lowSimilarity:0,veryLowSimilarity:0};return{...t,similarityDistribution:r}}setupMessageHandler(){self.onmessage=t=>{this.handleMessage(t)}}handleMessage(t){let e=performance.now(),{data:r}=t;try{switch(r.type){case"ping":self.postMessage({type:"pong",id:r.id});break;case"buildIndex":this.handleBuildIndex(r,e);break;case"indexSearch":this.handleIndexSearch(r,e);break;case"getStats":this.handleGetStats(r,e);break;case"resetStats":this.handleResetStats(r,e);break;case"setLogLevel":r.logLevel!==void 0&&this.setLogLevel(r.logLevel),r.workerId!==void 0&&this.setWorkerId(r.workerId);break;default:this.sendError(r.id,`Unknown request type: ${r.type}`,e)}}catch(i){this.sendError(r.id,i instanceof Error?i.message:String(i),e)}}handleBuildIndex(t,e){if(!(t.items&&t.searchFields)){this.sendError(t.id,"Items and searchFields are required for buildIndex",e);return}let{items:r,searchFields:i,options:n}=t,a=n?.ngramSize||u.ngramSize;this.ngramCache.clear(),this.wordCache.clear(),this.phoneticCache.clear(),this.currentItems=r,this.currentSearchFields=i,r.forEach((h,m)=>{i.forEach(S=>{let p=String(h[S]??"");if(!p)return;let d=p.toLowerCase();this.buildNgramIndex(d,m,a),this.buildWordIndex(d,m),this.buildPhoneticIndex(d,m)})});let c=performance.now()-e;this.indexMetadata={itemCount:r.length,buildTime:c,createdAt:Date.now(),indexedFields:[...i],ngramSize:a,strategy:n?.indexWorkerOptions?.strategy||"hybrid",totalIndexSize:this.ngramCache.size+this.wordCache.size+this.phoneticCache.size,indexSizes:{ngram:this.ngramCache.size,word:this.wordCache.size,phonetic:this.phoneticCache.size}},this.indexStats.totalIndexBuilds++,this.indexStats.currentDataSize=r.length,this.indexStats.lastIndexTime=c,this.updateWorkerStats("buildIndex",c,{itemCount:r.length,fieldCount:i.length,ngramSize:a,indexSize:this.ngramCache.size+this.wordCache.size+this.phoneticCache.size,strategy:"hybrid"});let o={type:"indexReady",id:t.id,stats:this.getWorkerStats(),metrics:this.getMetrics(),processingTime:c,workerType:this.getWorkerType(),operationMeta:{itemCount:r.length,indexSize:{total:this.ngramCache.size+this.wordCache.size+this.phoneticCache.size,ngram:this.ngramCache.size,word:this.wordCache.size,phonetic:this.phoneticCache.size},strategy:"hybrid",ngramSize:a}};this.logger.info(`\u{1F527} Index Worker: Built composite index - N-gram: ${this.ngramCache.size}, Word: ${this.wordCache.size}, Phonetic: ${this.phoneticCache.size}`),self.postMessage(o)}handleGetStats(t,e){let r={type:"stats",id:t.id,stats:this.getWorkerStats(),metrics:this.getMetrics(),processingTime:performance.now()-e,workerType:this.getWorkerType(),operationMeta:{totalIndexBuilds:this.indexStats.totalIndexBuilds,currentDataSize:this.indexStats.currentDataSize,indexSizes:{total:this.ngramCache.size+this.wordCache.size+this.phoneticCache.size,ngram:this.ngramCache.size,word:this.wordCache.size,phonetic:this.phoneticCache.size}}};this.logger.info("\u{1F4CA} Index Worker: Sending stats update",r.stats),self.postMessage(r)}handleResetStats(t,e){this.resetStats();let r=performance.now()-e,i={type:"resetStats",id:t.id,stats:this.getWorkerStats(),metrics:this.getMetrics(),processingTime:r,workerType:this.getWorkerType(),operationMeta:{resetCompleted:!0,timestamp:Date.now()}};this.logger.info("\u{1F504} Index Worker: Statistics reset completed"),self.postMessage(i)}handleIndexSearch(t,e){if(!t.query){this.sendError(t.id,"Query is required for indexSearch",e);return}if(this.currentItems.length===0){this.sendError(t.id,"Index is not built. Send buildIndex request first.",e);return}let{query:r,options:i}=t,n=i?.indexWorkerOptions?.strategy||"hybrid",a;switch(n){case"fast":a=this.getFastCandidates(r,i||{});break;case"accurate":a=this.getAccurateCandidates(r,i||{});break;default:a=this.getHybridCandidates(r,i||{});break}let c=this.createSearchResults(Array.from(a),r,i||{}),o=performance.now()-e;this.updateWorkerStats("indexSearch",o,{queryLength:r.length,itemCount:this.currentItems.length,resultCount:c.length,candidateCount:a.size,strategy:n}),c.forEach(m=>{m.matchedFields.forEach(S=>{this.updateFieldStats(S,m.score)})});let h={type:"indexSearchResults",id:t.id,results:c,stats:this.getWorkerStats(),metrics:this.getMetrics(),processingTime:o,workerType:this.getWorkerType(),operationMeta:{candidateCount:a.size,strategy:n,queryLength:r.length,threshold:i?.indexWorkerOptions?.threshold||u.indexWorkerOptions?.threshold||.4}};this.logger.info(`\u{1F50D} Index Worker: Found ${c.length} results for "${r}" (strategy: ${n})`),self.postMessage(h),this.sendStatsUpdate()}buildNgramIndex(t,e,r){this.generateNgrams(t,r).forEach(n=>{this.ngramCache.has(n)||this.ngramCache.set(n,new Set);let a=this.ngramCache.get(n);a&&a.add(e)})}buildWordIndex(t,e){t.split(/\s+/).filter(i=>i.length>0).forEach(i=>{this.wordCache.has(i)||this.wordCache.set(i,new Set);let n=this.wordCache.get(i);n&&n.add(e)})}buildPhoneticIndex(t,e){let r=this.generatePhoneticKey(t);this.phoneticCache.has(r)||this.phoneticCache.set(r,new Set);let i=this.phoneticCache.get(r);i&&i.add(e)}generateNgrams(t,e){let r=new Set,i=t.toLowerCase().trim();for(let n=0;n<=i.length-e;n++)r.add(i.substring(n,n+e));return r}generatePhoneticKey(t){return t.replace(/[ァ-ヶ]/g,e=>String.fromCharCode(e.charCodeAt(0)-96)).replace(/[っゃゅょ]/g,e=>({\u3063:"\u3064",\u3083:"\u3084",\u3085:"\u3086",\u3087:"\u3088"})[e]??e).replace(/ー/g,"").toLowerCase().replace(/\s+/g,"")}getFastCandidates(t,e){let r=new Set,i=e.caseSensitive?t:t.toLowerCase();return i.split(/\s+/).filter(a=>a.length>0).forEach(a=>{let c=this.wordCache.get(a);c&&c.forEach(o=>{r.add(o)})}),r.size===0&&this.generateNgrams(i,e.ngramSize||u.ngramSize).forEach(c=>{let o=this.ngramCache.get(c);o&&o.forEach(h=>{r.add(h)})}),r}getAccurateCandidates(t,e){let r=new Set,i=e.caseSensitive?t:t.toLowerCase(),n=e.ngramSize||u.ngramSize,a=e.minNgramOverlap||u.minNgramOverlap,c=new Map,o=this.generateNgrams(i,n);o.forEach(g=>{let f=this.ngramCache.get(g);f&&f.forEach(l=>{c.set(l,(c.get(l)||0)+1)})}),i.split(/\s+/).filter(g=>g.length>0).forEach(g=>{let f=this.wordCache.get(g);f&&f.forEach(l=>{r.add(l)})});let m=this.generatePhoneticKey(i),S=this.phoneticCache.get(m);S&&S.forEach(g=>{r.add(g)});let p=e.indexWorkerOptions?.ngramOverlapThreshold||u.indexWorkerOptions?.ngramOverlapThreshold||.3,d=Math.max(a,o.size*p);return c.forEach((g,f)=>{g>=d&&r.add(f)}),r}getHybridCandidates(t,e){let r=this.getFastCandidates(t,e),i=e.indexWorkerOptions?.minCandidatesRatio||u.indexWorkerOptions?.minCandidatesRatio||.1;r.size<Math.min(this.currentItems.length*i,10)&&this.getAccurateCandidates(t,e).forEach(c=>{r.add(c)});let n=e.indexWorkerOptions?.maxCandidatesRatio||u.indexWorkerOptions?.maxCandidatesRatio||.5;return r.size>this.currentItems.length*n&&(r=this.filterByNgramOverlap(t,r,e.ngramSize||u.ngramSize,e)),r}filterByNgramOverlap(t,e,r,i){let n=new Set,a=this.generateNgrams(t.toLowerCase(),r),c=i?.indexWorkerOptions?.ngramOverlapThreshold||u.indexWorkerOptions?.ngramOverlapThreshold||.3,o=Math.max(1,a.size*c);return e.forEach(h=>{let m=0;a.forEach(S=>{this.ngramCache.get(S)?.has(h)&&m++}),m>=o&&n.add(h)}),n}createSearchResults(t,e,r){let i=[],n=r.caseSensitive?e:e.toLowerCase(),a=this.getQueryTokens(e,r),o=this.getMultiTermOperator(r)==="and"&&a.length>1,h=r.sortBy||u.sortBy,m=h==="relevance",S=m?r.indexWorkerOptions?.relevanceFieldWeight??u.indexWorkerOptions?.relevanceFieldWeight??.2:0,p=m?r.indexWorkerOptions?.relevancePerfectMatchBonus??u.indexWorkerOptions?.relevancePerfectMatchBonus??.1:0;t.forEach(l=>{if(l>=this.currentItems.length)return;let b=this.currentItems[l],y=0,x=0,k=[],M=r.indexWorkerOptions?.threshold??r.threshold??u.indexWorkerOptions?.threshold??.4;if(o&&!this.itemMatchesTokens(b,a,r))return;for(let v of this.currentSearchFields){let P=String(b[v]??"");if(!P)continue;let O=r.caseSensitive?P:P.toLowerCase(),w=this.calculateJaroWinkler(n,O,r),L=r.customWeights?.[v]??1,R=w*L;w>0&&k.push(v),w>x&&(x=w),R>y&&(y=R)}let T=y;if(m&&k.length>0){let v=x>=.99?p:0;T=y+k.length*S+v}T>=M&&(this.updateSimilarityStats(T),i.push({item:b,score:T,baseScore:x,matchedFields:k,originalIndex:l}))});let d=r.sortOrder||u.sortOrder,g;h==="relevance"?g=i.sort((l,b)=>d==="asc"?l.score-b.score:b.score-l.score):h==="original"?g=i.sort((l,b)=>{let y=l.originalIndex??0,x=b.originalIndex??0;return d==="asc"?y-x:x-y}):g=i.sort((l,b)=>d==="asc"?l.score-b.score:b.score-l.score);let f=r.indexWorkerOptions?.maxResults;return typeof f=="number"?g.slice(0,f):g}getMultiTermOperator(t){return t.multiTermOperator??u.multiTermOperator??"or"}getQueryTokens(t,e){return(e.caseSensitive?t:t.toLowerCase()).split(/\s+/).filter(i=>i.length>0)}itemMatchesTokens(t,e,r){if(e.length===0)return!0;let i=new Set(e);for(let n of this.currentSearchFields){if(i.size===0)break;let a=String(t[n]??"");if(!a)continue;let c=r.caseSensitive?a:a.toLowerCase();for(let o of e)if(i.has(o)&&c.includes(o)&&(i.delete(o),i.size===0))break}return i.size===0}calculateJaroWinkler(t,e,r){let i=0,n=Math.floor(Math.max(t.length,e.length)/2)-1,a=new Array(t.length).fill(!1),c=new Array(e.length).fill(!1);for(let d=0;d<t.length;d++){let g=Math.max(0,d-n),f=Math.min(d+n+1,e.length);for(let l=g;l<f;l++)if(!c[l]&&t[d]===e[l]){a[d]=!0,c[l]=!0,i++;break}}if(i===0)return 0;let o=0,h=0;for(let d=0;d<t.length;d++)if(a[d]){for(;!c[h];)h++;t[d]!==e[h]&&o++,h++}let m=(i/t.length+i/e.length+(i-o/2)/i)/3,S=r?.indexWorkerOptions?.jaroWinklerPrefix||u.indexWorkerOptions?.jaroWinklerPrefix||.1,p=0;for(;p<4&&t[p]===e[p];)p++;return m+p*S*(1-m)}sendError(t,e,r){let i=performance.now()-r;this.updateWorkerStats("error",i,{errorMessage:e,hasError:!0});let n={type:"error",id:t,error:e,stats:this.getWorkerStats(),metrics:this.getMetrics(),processingTime:i,workerType:this.getWorkerType()};self.postMessage(n)}};new I;
", import.meta.url), a = l.workerUrls?.indexWorker ? new URL(l.workerUrls.indexWorker, window.location.origin) : t;
+        this.logger.debug("🔧 Global Index Worker URL:", a.toString()), this.indexWorker = new Worker(a, { type: "module" }), this.logger.info("🔧 Global Index Worker: Initialized successfully");
+      }
+      if (!this.levenshteinWorker) {
+        let t = import.meta.url.includes(".ts") ? new URL("../worker/levenshteinWorker.ts", import.meta.url) : new URL("data:text/javascript;base64,var T=class{constructor(i=2,e="[fuzzy-search]",t=console){this.level=i,this.prefix=e,this.impl=t}setLevel(i){this.level=i}setImplementation(i){this.impl=i}setPrefix(i){this.prefix=i}formatMessage(i){return typeof i=="string"?[`${this.prefix} ${i}`]:[this.prefix,i]}debug(i,...e){this.level<=0&&this.impl.debug(...this.formatMessage(i),...e)}info(i,...e){this.level<=1&&this.impl.info(...this.formatMessage(i),...e)}warn(i,...e){this.level<=2&&this.impl.warn(...this.formatMessage(i),...e)}error(i,...e){this.level<=3&&this.impl.error(...this.formatMessage(i),...e)}};var p={threshold:.4,caseSensitive:!1,learningWeight:1.2,debounceMs:300,multiTermOperator:"and",autoSearchOnIndexRebuild:!0,customWeights:{},ngramSize:2,minNgramOverlap:1,sortBy:"relevance",sortOrder:"desc",enableIndexFiltering:!0,enableLevenshtein:!0,parallelSearchStrategy:"balanced",logLevel:2,indexWorkerOptions:{strategy:"hybrid",threshold:.4,ngramOverlapThreshold:.3,minCandidatesRatio:.1,maxCandidatesRatio:.5,jaroWinklerPrefix:.1,maxResults:1e3,relevanceFieldWeight:.2,relevancePerfectMatchBonus:.1},levenshteinWorkerOptions:{threshold:.3,lengthSimilarityThreshold:.1,partialMatchBonus:.1,lengthDiffPenalty:1,maxResults:1e3,relevanceFieldWeight:.15}};var k=class{constructor(){this.stats={totalSearches:0,totalProcessingTime:0,averageSearchTime:0,lastSearchTime:0,errorCount:0,timestamp:Date.now()};this.baseLogPrefix="[fuzzy-search-worker]";this.logger=new T(2,this.baseLogPrefix);this.detailedStats=new Map;this.performanceHistory=[];this.operationDistribution=new Map;this.fieldStats=new Map;this.metrics={timings:{averageProcessingTime:0,fastestProcessing:1/0,slowestProcessing:0,lastProcessingTime:0},throughput:{operationsPerSecond:0,totalOperations:0},quality:{successRate:1,errorRate:0,timeoutRate:0}}}setLogLevel(i){this.logger.setLevel(i)}setWorkerId(i){let e=i?`${this.baseLogPrefix.slice(0,-1)}:${i}]`:this.baseLogPrefix;this.logger.setPrefix(e)}updateStats(i,e=!0){this.stats.totalSearches++,this.stats.totalProcessingTime+=i,this.stats.averageSearchTime=this.stats.totalProcessingTime/this.stats.totalSearches,this.stats.lastSearchTime=i,this.metrics.timings.lastProcessingTime=i,this.metrics.timings.averageProcessingTime=this.stats.averageSearchTime,this.metrics.timings.fastestProcessing=Math.min(this.metrics.timings.fastestProcessing,i),this.metrics.timings.slowestProcessing=Math.max(this.metrics.timings.slowestProcessing,i),this.metrics.throughput.totalOperations++,this.metrics.timings.averageProcessingTime>0&&(this.metrics.throughput.operationsPerSecond=1e3/this.metrics.timings.averageProcessingTime),e||this.stats.errorCount++;let t=this.metrics.throughput.totalOperations;this.metrics.quality.successRate=(t-this.stats.errorCount)/t,this.metrics.quality.errorRate=this.stats.errorCount/t}getStats(){return{...this.stats}}getMetrics(){return{...this.metrics}}resetStats(){this.stats={totalSearches:0,totalProcessingTime:0,averageSearchTime:0,lastSearchTime:0,errorCount:0,timestamp:Date.now()},this.metrics={timings:{averageProcessingTime:0,fastestProcessing:1/0,slowestProcessing:0,lastProcessingTime:0},throughput:{operationsPerSecond:0,totalOperations:0},quality:{successRate:1,errorRate:0,timeoutRate:0}},this.detailedStats.clear(),this.performanceHistory=[],this.operationDistribution.clear(),this.fieldStats.clear(),this.logger.info(`\u{1F4CA} ${this.getWorkerType()} Worker: Statistics reset completed`)}updateWorkerStats(i,e,t={}){this.updateStats(e,!0);let r=this.operationDistribution.get(i)||0;this.operationDistribution.set(i,r+1),Object.entries(t).forEach(([s,n])=>{this.detailedStats.set(s,n)}),this.addPerformanceEntry({timestamp:Date.now(),operationType:i,processingTime:e,queryLength:t.queryLength||0,itemCount:t.itemCount||0,resultCount:t.resultCount||0,additionalMetrics:t})}updateFieldStats(i,e){let t=this.fieldStats.get(i)||{matchCount:0,averageScore:0,totalScore:0,bestScore:0,worstScore:1};t.matchCount+=1,t.totalScore+=e,t.averageScore=t.totalScore/t.matchCount,t.bestScore=Math.max(t.bestScore,e),t.worstScore=Math.min(t.worstScore,e),this.fieldStats.set(i,t)}addPerformanceEntry(i){this.performanceHistory.push(i),this.performanceHistory.length>100&&(this.performanceHistory=this.performanceHistory.slice(-100))}getWorkerStats(){return{basic:{...this.stats,timestamp:Date.now()},workerSpecific:{workerType:this.getWorkerType(),operationCount:this.getTotalOperations(),operationDistribution:Object.fromEntries(this.operationDistribution),specificMetrics:this.getSpecificMetrics()},analysis:{fieldPerformance:Object.fromEntries(this.fieldStats),performanceInsights:this.generatePerformanceInsights(),recentHistory:this.performanceHistory.slice(-10)}}}sendStatsUpdate(){let i={type:"stats",id:`stats-${Date.now()}`,stats:this.getWorkerStats(),metrics:this.getMetrics(),processingTime:0,workerType:this.getWorkerType(),operationMeta:{}};this.logger.info(`\u{1F4CA} ${this.getWorkerType()} Worker: Sending unified stats update`),self.postMessage(i)}getTotalOperations(){return Array.from(this.operationDistribution.values()).reduce((i,e)=>i+e,0)}generatePerformanceInsights(){if(this.performanceHistory.length===0)return{recentAverageProcessingTime:0,recentAverageResultCount:0,throughputPerSecond:0,totalHistoryEntries:0,mostCommonQueryLength:0,bestPerformingField:"",similarityDistribution:{highSimilarity:0,mediumSimilarity:0,lowSimilarity:0,veryLowSimilarity:0}};let i=this.performanceHistory.slice(-10),e=i.reduce((a,o)=>a+o.processingTime,0)/i.length,t=i.reduce((a,o)=>a+o.resultCount,0)/i.length,r=new Map;this.performanceHistory.forEach(a=>{let o=r.get(a.queryLength)||0;r.set(a.queryLength,o+1)});let s=0,n=0;r.forEach((a,o)=>{a>n&&(n=a,s=o)});let c="",l=0;return this.fieldStats.forEach((a,o)=>{a.averageScore>l&&(l=a.averageScore,c=o)}),{recentAverageProcessingTime:e,recentAverageResultCount:t,throughputPerSecond:e>0?1e3/e:0,totalHistoryEntries:this.performanceHistory.length,mostCommonQueryLength:s,bestPerformingField:c,similarityDistribution:{highSimilarity:0,mediumSimilarity:0,lowSimilarity:0,veryLowSimilarity:0}}}handleMessage(i){this.logger.warn("\u26A0\uFE0F BaseWorker.handleMessage: No implementation provided")}};var L=class extends k{constructor(){super();this.currentItems=[];this.currentSearchFields=[];this.distanceDistribution=new Map;this.queryLengthStats=new Map;this.similarityThresholdStats={above80:0,above60:0,above40:0,below40:0};this.levenshteinStats={totalCalculations:0,totalDistanceCalculations:0,averageDistance:0,minDistance:1/0,maxDistance:0,partialMatches:0,perfectMatches:0};this.baseLogPrefix="[fuzzy-search-levenshtein]",this.logger.setPrefix(this.baseLogPrefix),this.setupMessageHandler()}getWorkerType(){return"levenshtein"}getSpecificMetrics(){return{totalCalculations:this.levenshteinStats.totalCalculations,totalDistanceCalculations:this.levenshteinStats.totalDistanceCalculations,averageDistance:this.levenshteinStats.averageDistance,minDistance:this.levenshteinStats.minDistance!==1/0?this.levenshteinStats.minDistance:void 0,maxDistance:this.levenshteinStats.maxDistance,partialMatches:this.levenshteinStats.partialMatches,perfectMatches:this.levenshteinStats.perfectMatches,distanceDistribution:Object.fromEntries(this.distanceDistribution),similarityThresholds:this.similarityThresholdStats,queryLengthStats:Object.fromEntries(this.queryLengthStats)}}resetStats(){super.resetStats(),this.distanceDistribution.clear(),this.queryLengthStats.clear(),this.similarityThresholdStats={above80:0,above60:0,above40:0,below40:0},this.levenshteinStats={totalCalculations:0,totalDistanceCalculations:0,averageDistance:0,minDistance:1/0,maxDistance:0,partialMatches:0,perfectMatches:0},this.logger.info("\u{1F4CA} Levenshtein Worker: All statistics have been reset")}updateSimilarityStats(e){e>=.8?this.similarityThresholdStats.above80++:e>=.6?this.similarityThresholdStats.above60++:e>=.4?this.similarityThresholdStats.above40++:this.similarityThresholdStats.below40++}setupMessageHandler(){self.onmessage=e=>{this.handleMessage(e)}}handleMessage(e){let t=performance.now(),{data:r}=e;try{switch(r.type){case"ping":self.postMessage({type:"pong",id:r.id});break;case"levenshteinSearch":this.handleLevenshteinSearch(r,t);break;case"getStats":this.handleGetStats(r,t);break;case"resetStats":this.handleResetStats(r,t);break;case"setLogLevel":r.logLevel!==void 0&&this.setLogLevel(r.logLevel),r.workerId!==void 0&&this.setWorkerId(r.workerId);break;default:this.sendError(r.id,`Unknown request type: ${r.type}`,t)}}catch(s){this.sendError(r.id,s instanceof Error?s.message:String(s),t)}}handleLevenshteinSearch(e,t){if(this.logger.info(`\u{1F4CF} Levenshtein Worker: Starting search for "${e.query}" with ${e.items?.length||0} items`),!(e.query&&e.items&&e.searchFields)){this.sendError(e.id,"Query, items, and searchFields are required for levenshteinSearch",t);return}let{query:r,items:s,searchFields:n,options:c}=e;this.currentItems=s,this.currentSearchFields=n,this.logger.info(`\u{1F4CF} Levenshtein Worker: Configuration - query: "${r}", fields: [${n.join(", ")}], threshold: ${c?.levenshteinWorkerOptions?.threshold??c?.threshold??p.levenshteinWorkerOptions?.threshold??.3}`);let l=c?.levenshteinWorkerOptions?.threshold??c?.threshold??p.levenshteinWorkerOptions?.threshold??.3,a=this.calculateSimilarity(r,Array.from({length:s.length},(h,u)=>u),c||{},l),o=performance.now()-t;this.updateWorkerStats("levenshteinSearch",o,{queryLength:r.length,itemCount:s.length,resultCount:a.length,threshold:l,averageDistance:a.reduce((h,u)=>h+(1-u.score),0)/(a.length||1)}),a.forEach(h=>{h.matchedFields.forEach(u=>{this.updateFieldStats(u,h.score)})});let m={type:"levenshteinSearch",id:e.id,results:a,stats:this.getWorkerStats(),metrics:this.getMetrics(),processingTime:o,workerType:this.getWorkerType(),operationMeta:{threshold:l,totalCalculations:a.length,averageDistance:a.reduce((h,u)=>h+(1-u.score),0)/(a.length||1)}};this.logger.info(`\u26A1 Levenshtein Worker: Calculated similarity for ${s.length} items, returned ${a.length} results`),this.logger.info("\u{1F4CA} Levenshtein Worker: Sending unified response with stats:",{totalCalculations:m.operationMeta?.totalCalculations,averageDistance:m.operationMeta?.averageDistance,statsKeys:Object.keys(m.stats||{}),processingTime:m.processingTime}),self.postMessage(m),this.sendStatsUpdate()}handleGetStats(e,t){let r={type:"stats",id:e.id,stats:this.getWorkerStats(),metrics:this.getMetrics(),processingTime:performance.now()-t,workerType:this.getWorkerType(),operationMeta:{}};self.postMessage(r)}handleResetStats(e,t){this.resetStats();let r={type:"resetStats",id:e.id,stats:this.getWorkerStats(),metrics:this.getMetrics(),processingTime:performance.now()-t,workerType:this.getWorkerType(),operationMeta:{resetCompleted:!0}};self.postMessage(r)}calculateSimilarity(e,t,r,s){this.logger.info(`\u{1F504} Levenshtein Worker: Processing ${t.length} candidates with threshold ${s}`);let n=[],c=r.caseSensitive?e:e.toLowerCase(),l=this.getQueryTokens(e,r),o=this.getMultiTermOperator(r)==="and"&&l.length>1,m=r.sortBy||p.sortBy,h=m==="relevance",u=h?r.levenshteinWorkerOptions?.relevanceFieldWeight??p.levenshteinWorkerOptions?.relevanceFieldWeight??.15:0,x=h?r.levenshteinWorkerOptions?.partialMatchBonus??p.levenshteinWorkerOptions?.partialMatchBonus??.1:0;for(let g of t){if(g>=this.currentItems.length)continue;let d=this.currentItems[g];if(o&&!this.itemMatchesTokens(d,l,r))continue;let S=0,f=0,y=[],C=[];for(let W of this.currentSearchFields){let M=String(d[W]??"");if(!M)continue;let F=r.caseSensitive?M:M.toLowerCase(),R=this.calculateLevenshteinSimilarity(c,F,r);this.levenshteinStats.totalCalculations++;let D=r.customWeights?.[W]??1,v=R*D;C.push(v),v>0&&y.push(W),R>f&&(f=R),v>S&&(S=v)}let w=S;h&&y.length>0&&(w=S+y.length*u+x),w>=s&&n.push({item:d,score:w,baseScore:f,matchedFields:y,originalIndex:g})}let P=r.sortOrder||p.sortOrder,b;m==="relevance"?b=n.sort((g,d)=>P==="asc"?g.score-d.score:d.score-g.score):m==="original"?b=n.sort((g,d)=>{let S=g.originalIndex??0,f=d.originalIndex??0;return P==="asc"?S-f:f-S}):b=n.sort((g,d)=>P==="asc"?g.score-d.score:d.score-g.score);let O=r.levenshteinWorkerOptions?.maxResults;return typeof O=="number"?b.slice(0,O):b}getMultiTermOperator(e){return e.multiTermOperator??p.multiTermOperator??"or"}getQueryTokens(e,t){return(t.caseSensitive?e:e.toLowerCase()).split(/\s+/).filter(s=>s.length>0)}itemMatchesTokens(e,t,r){if(t.length===0)return!0;let s=new Set(t);for(let n of this.currentSearchFields){if(s.size===0)break;let c=String(e[n]??"");if(!c)continue;let l=r.caseSensitive?c:c.toLowerCase();for(let a of t)if(s.has(a)&&l.includes(a)&&(s.delete(a),s.size===0))break}return s.size===0}calculateLevenshteinSimilarity(e,t,r){if(e===t)return this.levenshteinStats.perfectMatches++,1;if(e.length===0)return t.length===0?1:0;if(t.length===0)return 0;let s=Math.abs(e.length-t.length),n=Math.max(e.length,t.length),c=r.levenshteinWorkerOptions?.lengthDiffPenalty||p.levenshteinWorkerOptions?.lengthDiffPenalty||1,l=1-s/n*c,a=r.levenshteinWorkerOptions?.lengthSimilarityThreshold||p.levenshteinWorkerOptions?.lengthSimilarityThreshold||.1;if(l<a)return 0;let o=this.levenshteinDistance(e,t),m=1-o/n;this.levenshteinStats.totalDistanceCalculations+=1,this.levenshteinStats.minDistance=Math.min(this.levenshteinStats.minDistance,o),this.levenshteinStats.maxDistance=Math.max(this.levenshteinStats.maxDistance,o);let h=this.distanceDistribution.get(o)||0;this.distanceDistribution.set(o,h+1);let u=this.levenshteinStats.totalDistanceCalculations,x=this.levenshteinStats.averageDistance;return this.levenshteinStats.averageDistance=(x*(u-1)+o)/u,this.updateSimilarityStats(m),t.includes(e)&&this.levenshteinStats.partialMatches++,Math.max(0,m)}levenshteinDistance(e,t){let r=[];for(let s=0;s<=t.length;s++)r[s]=[s];for(let s=0;s<=e.length;s++)r[0][s]=s;for(let s=1;s<=t.length;s++)for(let n=1;n<=e.length;n++)t.charAt(s-1)===e.charAt(n-1)?r[s][n]=r[s-1][n-1]:r[s][n]=Math.min(r[s-1][n-1]+1,r[s][n-1]+1,r[s-1][n]+1);return r[t.length][e.length]}generatePerformanceInsights(){if(this.performanceHistory.length===0)return{recentAverageProcessingTime:0,recentAverageResultCount:0,throughputPerSecond:0,totalHistoryEntries:0,mostCommonQueryLength:0,bestPerformingField:"",similarityDistribution:{highSimilarity:0,mediumSimilarity:0,lowSimilarity:0,veryLowSimilarity:0}};let e=this.performanceHistory.slice(-10),t=e.reduce((s,n)=>s+n.processingTime,0)/e.length,r=e.reduce((s,n)=>s+n.resultCount,0)/e.length;return{recentAverageProcessingTime:t,recentAverageResultCount:r,throughputPerSecond:e.length>0?1e3/t:0,totalHistoryEntries:this.performanceHistory.length,mostCommonQueryLength:this.getMostCommonQueryLength(),bestPerformingField:this.getBestPerformingField(),similarityDistribution:{highSimilarity:this.similarityThresholdStats.above80,mediumSimilarity:this.similarityThresholdStats.above60,lowSimilarity:this.similarityThresholdStats.above40,veryLowSimilarity:this.similarityThresholdStats.below40}}}getMostCommonQueryLength(){let e=0,t=0;return this.queryLengthStats.forEach((r,s)=>{r.count>e&&(e=r.count,t=s)}),t}getBestPerformingField(){let e="",t=0;return this.fieldStats.forEach((r,s)=>{r.averageScore>t&&(t=r.averageScore,e=s)}),e}sendError(e,t,r){this.updateStats(performance.now()-r,!1);let s={type:"error",id:e,error:t,stats:this.getWorkerStats(),metrics:this.getMetrics(),processingTime:performance.now()-r,workerType:this.getWorkerType(),operationMeta:{}};self.postMessage(s)}};new L;
", import.meta.url), a = l.workerUrls?.levenshteinWorker ? new URL(l.workerUrls.levenshteinWorker, window.location.origin) : t;
+        this.logger.debug("🔧 Global Levenshtein Worker URL:", a.toString()), this.levenshteinWorker = new Worker(a, { type: "module" }), this.logger.info("🔧 Global Levenshtein Worker: Initialized successfully");
+      }
+    } catch (t) {
+      this.logger.warn("⚠️ Failed to initialize global Workers:", t);
+    }
+  }
+  releaseReference() {
+    this.referenceCount--, this.logger.debug(`🔧 Worker reference released (ref count: ${this.referenceCount})`);
+  }
+  dispose() {
+    this.indexWorker && (this.indexWorker.terminate(), this.indexWorker = null), this.levenshteinWorker && (this.levenshteinWorker.terminate(), this.levenshteinWorker = null), this.initializationPromise = null, this.referenceCount = 0, this.logger.info("🔧 Global Workers disposed");
+  }
+};
+me.instances = /* @__PURE__ */ new Map();
+var Q = me, pe = class {
+  constructor() {
+    this.listeners = /* @__PURE__ */ new Map(), this.logger = new ee(2);
+  }
+  setLogger(e) {
+    this.logger = e;
+  }
+  on(e, l) {
+    this.listeners.has(e) || this.listeners.set(e, /* @__PURE__ */ new Set()), this.listeners.get(e)?.add(l);
+  }
+  off(e, l) {
+    let t = this.listeners.get(e);
+    t && t.delete(l);
+  }
+  emit(e, l) {
+    let t = this.listeners.get(e);
+    t && t.forEach((a) => {
+      try {
+        a(l);
+      } catch (r) {
+        this.logger.error(`❌ Error in event listener for ${e}:`, r);
+      }
+    });
+  }
+  removeAllListeners() {
+    this.listeners.clear();
+  }
+}, We = class {
+  constructor(e = _) {
+    this.defaultOptions = e, this.indexWorker = null, this.levenshteinWorker = null, this.searchHistory = [], this.learningData = { fieldWeights: {}, queryPatterns: {}, userPreferences: { preferredThreshold: 0.4, frequentFields: [], searchStyle: "fuzzy", lastUsedOptions: {} }, performanceMetrics: { averageSearchTime: {}, indexBuildTime: 0 } }, this.requestId = 0, this.pendingRequests = /* @__PURE__ */ new Map(), this.eventEmitter = new pe(), this.isIndexBuilt = !1, this.lastIndexedDataHash = null, this.stats = { totalSearches: 0, averageSearchTime: 0, popularQueries: [], performanceBySize: {}, workers: { index: { stats: {} }, levenshtein: { stats: {} } } }, this.isDisposed = !1;
+    let l = "[fuzzy-search]";
+    e.instanceName ? l = `[fuzzy-search:${e.instanceName}]` : e.workerId && (l = `[fuzzy-search:${e.workerId}]`), this.logger = new ee(e.logLevel ?? 2, l, e.logger ?? console), this.eventEmitter.setLogger(this.logger), this.handleIndexWorkerMessageBound = this.handleIndexWorkerMessage.bind(this), this.handleIndexWorkerErrorBound = this.handleIndexWorkerError.bind(this), this.handleLevenshteinWorkerMessageBound = this.handleLevenshteinWorkerMessage.bind(this), this.handleLevenshteinWorkerErrorBound = this.handleLevenshteinWorkerError.bind(this), this.loadLearningData(), this.workersInitialized = this.initializeWorkers(), setInterval(() => this.cleanupPendingRequests(), 3e4);
+  }
+  async initializeWorkers() {
+    if (!(typeof Worker > "u")) try {
+      let e = await Q.getInstance(this.defaultOptions.workerId).getWorkers(this.defaultOptions);
+      if (this.isDisposed) {
+        this.logger.debug("🔧 Manager disposed before worker initialization completed");
+        return;
+      }
+      this.indexWorker = e.indexWorker, this.levenshteinWorker = e.levenshteinWorker, this.indexWorker && (this.indexWorker.addEventListener("message", this.handleIndexWorkerMessageBound), this.indexWorker.addEventListener("error", this.handleIndexWorkerErrorBound), this.indexWorker.addEventListener("error", (l) => {
+        this.logger.error("🔧 Index Worker Error (Event Listener):", l);
+      })), this.levenshteinWorker && (this.levenshteinWorker.addEventListener("message", this.handleLevenshteinWorkerMessageBound), this.levenshteinWorker.addEventListener("error", this.handleLevenshteinWorkerErrorBound), this.levenshteinWorker.addEventListener("error", (l) => {
+        this.logger.error("🔧 Levenshtein Worker Error (Event Listener):", l);
+      })), this.eventEmitter.emit("workers:initialized", { indexWorker: !!this.indexWorker, levenshteinWorker: !!this.levenshteinWorker }), await this.testWorkerConnectivity();
+    } catch (e) {
+      this.logger.warn("⚠️ Failed to initialize Workers:", e);
+    }
+  }
+  async testWorkerConnectivity() {
+    try {
+      let e = [];
+      this.indexWorker && e.push(this.pingWorker(this.indexWorker, "index")), this.levenshteinWorker && e.push(this.pingWorker(this.levenshteinWorker, "levenshtein")), await Promise.all(e);
+    } catch (e) {
+      this.logger.error("🔧 Worker connectivity test failed:", e);
+    }
+  }
+  async pingWorker(e, l) {
+    let t = `ping-${l}-${Date.now()}`;
+    await new Promise((a, r) => {
+      let d = setTimeout(() => {
+        this.logger.warn(`🔧 ${l === "index" ? "Index" : "Levenshtein"} Worker: Ping timeout`), e.removeEventListener("message", n), r(new Error(`${l === "index" ? "Index" : "Levenshtein"} Worker ping timeout`));
+      }, 5e3), n = (c) => {
+        let b = c.data;
+        b.type === "pong" && b.id === t && (clearTimeout(d), e.removeEventListener("message", n), this.logger.debug(`🔧 ${l === "index" ? "Index" : "Levenshtein"} Worker: Ping successful`), a());
+      };
+      e.addEventListener("message", n), this.logger.debug(`🔧 ${l === "index" ? "Index" : "Levenshtein"} Worker: Sending ping message:`, t), e.postMessage({ type: "ping", id: t });
+    });
+  }
+  handleIndexWorkerMessage(e) {
+    let l = e.data;
+    if (this.logger.debug("🔧 Index Worker message received:", l.type, l), l.type === "indexSearchResults") {
+      let t = this.pendingRequests.get(l.id);
+      t && (this.pendingRequests.delete(l.id), l.error ? t.reject(new Error(l.error)) : t.resolve(l.results || [])), this.eventEmitter.emit("indexWorker:searchCompleted", { requestId: l.id, resultsCount: l.results?.length || 0, processingTime: l.processingTime });
+    } else if (l.type === "error") {
+      let t = this.pendingRequests.get(l.id);
+      t && (this.pendingRequests.delete(l.id), t.reject(new Error(l.error || "Index Worker error"))), this.logger.error("❌ Index Worker reported error:", { requestId: l.id, message: l.error, processingTime: l.processingTime }), this.eventEmitter.emit("indexWorker:error", { requestId: l.id, error: l.error, processingTime: l.processingTime });
+    } else l.type === "indexReady" ? (this.logger.info("✅ Index Worker: Index ready notification received", l), l.stats && (this.stats.workers.index.stats = l.stats, this.eventEmitter.emit("worker:statsUpdated", { worker: "index", stats: this.stats.workers.index.stats })), this.eventEmitter.emit("indexWorker:message", l)) : l.type === "pong" || l.type === "stats" && l.stats && (this.stats.workers.index.stats = l.stats, this.eventEmitter.emit("worker:statsUpdated", { worker: "index", stats: this.stats.workers.index.stats }));
+    this.eventEmitter.emit("indexWorker:message", l);
+  }
+  handleIndexWorkerError(e) {
+    this.logger.error("🔧 Index Worker Error:", { message: e.message, filename: e.filename, lineno: e.lineno, colno: e.colno, error: e.error, type: e.type }), this.eventEmitter.emit("indexWorker:error", e);
+  }
+  handleLevenshteinWorkerMessage(e) {
+    let l = e.data;
+    if (this.logger.debug("🔧 Levenshtein Worker message received:", l.type, "stats present:", !!l.stats), l.type === "levenshteinSearch") {
+      let t = this.pendingRequests.get(l.id);
+      t && (this.pendingRequests.delete(l.id), l.error ? t.reject(new Error(l.error)) : t.resolve(l.results || [])), l.stats && (this.stats.workers.levenshtein.stats = l.stats, this.eventEmitter.emit("worker:statsUpdated", { worker: "levenshtein", stats: this.stats.workers.levenshtein.stats })), this.eventEmitter.emit("levenshteinWorker:searchCompleted", { requestId: l.id, processingTime: l.processingTime, workerType: l.workerType, operationMeta: l.operationMeta });
+    } else l.type === "pong" || l.type === "stats" && l.stats && (this.stats.workers.levenshtein.stats = l.stats, this.eventEmitter.emit("worker:statsUpdated", { worker: "levenshtein", stats: this.stats.workers.levenshtein.stats }));
+    this.eventEmitter.emit("levenshteinWorker:message", l);
+  }
+  handleLevenshteinWorkerError(e) {
+    this.logger.error("🔧 Levenshtein Worker Error:", { message: e.message, filename: e.filename, lineno: e.lineno, colno: e.colno, error: e.error, type: e.type }), this.eventEmitter.emit("levenshteinWorker:error", e);
+  }
+  isLocalStorageAvailable() {
+    try {
+      return typeof window < "u" && window.localStorage !== void 0;
+    } catch {
+      return !1;
+    }
+  }
+  loadLearningData() {
+    try {
+      if (this.isLocalStorageAvailable()) {
+        let e = localStorage.getItem("fuzzy-search-learning-data");
+        e ? this.learningData = JSON.parse(e) : this.initializeDefaultLearningData();
+      } else this.initializeDefaultLearningData();
+    } catch (e) {
+      this.logger.warn("⚠️ Failed to load learning data:", e), this.initializeDefaultLearningData();
+    }
+  }
+  initializeDefaultLearningData() {
+    this.learningData = { fieldWeights: {}, queryPatterns: {}, userPreferences: { preferredThreshold: this.defaultOptions.threshold, frequentFields: [], searchStyle: "fuzzy", lastUsedOptions: {} }, performanceMetrics: { averageSearchTime: {}, indexBuildTime: 0 } };
+  }
+  saveLearningData() {
+    try {
+      this.isLocalStorageAvailable() && localStorage.setItem("fuzzy-search-learning-data", JSON.stringify(this.learningData));
+    } catch (e) {
+      this.logger.warn("⚠️ Failed to save learning data:", e);
+    }
+  }
+  async search(e, l, t, a) {
+    let r = performance.now(), d = { ...this.defaultOptions, ...a };
+    a?.threshold !== void 0 && (a.levenshteinWorkerOptions || (d.levenshteinWorkerOptions = { ...d.levenshteinWorkerOptions, threshold: a.threshold }), a.indexWorkerOptions || (d.indexWorkerOptions = { ...d.indexWorkerOptions, threshold: a.threshold })), this.logger.debug(`🚀 FuzzySearchManager.search called: query="${e}", items.length=${l.length}`), this.eventEmitter.emit("search:start", { query: e, options: d });
+    try {
+      if (await this.workersInitialized, this.isDisposed) return this.logger.debug("🚫 search skipped because manager is disposed"), [];
+      let n = this.generateDataHash(l, t), c = Q.getInstance(this.defaultOptions.workerId), b = c.getLastIndexedDataHash();
+      if (b !== n) {
+        let o = c.getBuildingPromise(n);
+        if (o) this.logger.debug("🔧 Index build already in progress globally, waiting..."), await o, this.isIndexBuilt = !0, this.lastIndexedDataHash = n;
+        else {
+          this.logger.debug(`🔧 Building index: isIndexBuilt=${this.isIndexBuilt}, dataChanged=${b !== n}`);
+          let Z = (async () => {
+            await this.buildIndex(l, t, d), this.isIndexBuilt = !0, this.lastIndexedDataHash = n, c.setLastIndexedDataHash(n);
+          })();
+          c.setBuildingPromise(n, Z), await Z;
+        }
+      } else this.isIndexBuilt ? this.logger.debug("🔧 Index already built for current data, skipping rebuild") : (this.logger.debug("🔧 Index already built globally for current data, skipping rebuild"), this.isIndexBuilt = !0, this.lastIndexedDataHash = n);
+      if (!(this.indexWorker && this.levenshteinWorker)) {
+        if (this.isDisposed) return this.logger.debug("🚫 search skipped because manager is disposed"), [];
+        throw new Error("Web Workers are not available or not initialized.");
+      }
+      let X = await this.searchParallel(e, l, t, d), m = performance.now() - r;
+      this.updateStats(e, m), this.updateLearningData(e, l.length, m);
+      let G = { results: X, totalItems: l.length, processingTime: m, query: e, options: d };
+      return this.eventEmitter.emit("search:complete", G), X;
+    } catch (n) {
+      let c = n instanceof Error ? n : new Error("Unknown search error");
+      throw this.eventEmitter.emit("search:error", { error: c, query: e }), c;
+    }
+  }
+  async buildIndex(e, l, t) {
+    if (this.isDisposed) {
+      this.logger.debug("🚫 buildIndex skipped because manager is disposed");
+      return;
+    }
+    if (!this.indexWorker) {
+      if (this.isDisposed) {
+        this.logger.debug("🚫 buildIndex skipped because manager is disposed");
+        return;
+      }
+      throw new Error("Index Worker not available");
+    }
+    let a = `build-index-${++this.requestId}`;
+    this.logger.debug(`📤 Building index: requestId=${a}`);
+    let r = { type: "buildIndex", id: a, items: e, searchFields: l, options: t };
+    return new Promise((d, n) => {
+      let c = null, b = (m) => {
+        let G = m;
+        G.type === "indexReady" && G.id === a && (this.logger.info(`✅ Index Worker: Index built successfully (requestId=${a})`), this.logger.debug(`🎯 buildIndex: Match found! Resolving promise for requestId=${a}`), this.eventEmitter.off("indexWorker:message", b), this.eventEmitter.off("indexWorker:message", X), c && (clearTimeout(c), c = null), d());
+      }, X = (m) => {
+        let G = m;
+        G.type === "error" && G.id === a && (this.logger.warn(`❌ buildIndex: Worker reported error for requestId=${a}`, G.error), this.eventEmitter.off("indexWorker:message", b), this.eventEmitter.off("indexWorker:message", X), c && (clearTimeout(c), c = null), n(new Error(G.error || "Index Worker error")));
+      };
+      this.eventEmitter.on("indexWorker:message", b), this.eventEmitter.on("indexWorker:message", X), this.indexWorker?.postMessage(r), c = setTimeout(() => {
+        this.eventEmitter.off("indexWorker:message", b), this.eventEmitter.off("indexWorker:message", X), c = null, n(new Error("Index build timeout"));
+      }, 6e4);
+    });
+  }
+  async searchParallel(e, l, t, a) {
+    if (this.isDisposed) return this.logger.debug("🚫 searchParallel skipped because manager is disposed"), [];
+    this.logger.debug(`🌐 searchParallel: query="${e}", items.length=${l.length}`);
+    let { enableIndexFiltering: r, enableLevenshtein: d } = a;
+    if (!(r || d)) return this.logger.warn("⚠️ Both search stages are disabled. Returning empty results."), [];
+    let n = r ? this.runIndexStage(e, l, t, a) : Promise.resolve({ stage: "index", results: [], processingTime: 0, confidence: 0, candidatesProcessed: 0 }), c = d ? this.runLevenshteinStage(e, l, t, a) : Promise.resolve({ stage: "levenshtein", results: [], processingTime: 0, confidence: 0, candidatesProcessed: 0 }), [b, X] = await Promise.all([n, c]), m = this.mergeParallelResults(b, X, a.parallelSearchStrategy || "balanced", a);
+    return this.logger.debug(`🔧 Parallel search completed: Index=${b.results.length}, Levenshtein=${X.results.length}, Merged=${m.results.length}`), m.results;
+  }
+  async runIndexStage(e, l, t, a) {
+    let r = `index-${++this.requestId}`;
+    this.logger.debug(`📤 Index Stage: requestId=${r}`);
+    let d = { type: "indexSearch", id: r, query: e, items: l, searchFields: t, options: a };
+    return this.executeWorkerStage(this.indexWorker, d, { stage: "index", confidence: 0.8, timeoutMessage: "Index search timeout", unavailableMessage: "Index Worker not available" });
+  }
+  async runLevenshteinStage(e, l, t, a) {
+    let r = `levenshtein-${++this.requestId}`;
+    this.logger.debug(`📤 Levenshtein Stage: requestId=${r}`);
+    let d = { type: "levenshteinSearch", id: r, query: e, items: l, searchFields: t, options: a };
+    return this.executeWorkerStage(this.levenshteinWorker, d, { stage: "levenshtein", confidence: 0.9, timeoutMessage: "Levenshtein search timeout", unavailableMessage: "Levenshtein Worker not available" });
+  }
+  executeWorkerStage(e, l, t) {
+    if (!e) throw new Error(t.unavailableMessage);
+    return new Promise((a, r) => {
+      let d = setTimeout(() => {
+        this.pendingRequests.has(l.id) && (this.pendingRequests.delete(l.id), r(new Error(t.timeoutMessage)));
+      }, 3e4);
+      this.pendingRequests.set(l.id, { resolve: (n) => {
+        clearTimeout(d), a({ stage: t.stage, results: n, processingTime: 0, confidence: t.confidence, candidatesProcessed: n.length });
+      }, reject: (n) => {
+        clearTimeout(d), r(n);
+      }, timestamp: Date.now() }), e.postMessage(l);
+    });
+  }
+  mergeParallelResults(e, l, t, a) {
+    let r = [];
+    switch (t) {
+      case "index-first":
+        r = e.results.length > 0 ? e.results : l.results;
+        break;
+      case "levenshtein-first":
+        r = l.results.length > 0 ? l.results : e.results;
+        break;
+      default:
+        r = this.mergeByScore([...e.results, ...l.results], a);
+        break;
+    }
+    return { results: r, totalProcessingTime: e.processingTime + l.processingTime, indexStage: e, levenshteinStage: l, mergeStrategy: t, mergeQuality: 0.8 };
+  }
+  mergeByScore(e, l) {
+    let t = /* @__PURE__ */ new Map();
+    e.forEach((n) => {
+      if (n.originalIndex !== void 0) {
+        let c = t.get(n.originalIndex);
+        (!c || n.score > c.score) && t.set(n.originalIndex, n);
+      }
+    });
+    let a = Array.from(t.values()), r = l.sortBy || _.sortBy, d = l.sortOrder || _.sortOrder;
+    return r === "original" ? a.sort((n, c) => {
+      let b = n.originalIndex ?? 0, X = c.originalIndex ?? 0;
+      return d === "asc" ? b - X : X - b;
+    }) : a.sort((n, c) => d === "asc" ? n.score - c.score : c.score - n.score);
+  }
+  generateDataHash(e, l) {
+    return `${e.length}|${l.join(",")}|${JSON.stringify(e.slice(0, 3))}`;
+  }
+  updateStats(e, l) {
+    this.stats.totalSearches++, this.stats.averageSearchTime = (this.stats.averageSearchTime * (this.stats.totalSearches - 1) + l) / this.stats.totalSearches;
+  }
+  updateLearningData(e, l, t) {
+    this.learningData.queryPatterns[e] = (this.learningData.queryPatterns[e] ?? 0) + 1;
+    let a = this.getPerformanceSizeKey(l);
+    this.learningData.performanceMetrics.averageSearchTime[a] = t, this.stats.totalSearches % 10 === 0 && this.saveLearningData();
+  }
+  getPerformanceSizeKey(e) {
+    return e < 1e3 ? "small" : e < 1e4 ? "medium" : e < 1e5 ? "large" : "xlarge";
+  }
+  cleanupPendingRequests() {
+    let e = Date.now(), l = 3e4;
+    this.pendingRequests.forEach((t, a) => {
+      e - t.timestamp > l && (t.reject(new Error("Request timeout")), this.pendingRequests.delete(a));
+    });
+  }
+  updateSearchHistory(e, l, t = 0, a = 0) {
+    let r = { query: e, timestamp: Date.now(), selectedItemId: l, resultCount: t, processingTime: a, searchTime: a, successful: t > 0 };
+    this.searchHistory.unshift(r), this.searchHistory.length > 1e3 && (this.searchHistory = this.searchHistory.slice(0, 500));
+  }
+  async getStats(e = 5e3) {
+    return await Promise.all([this.waitForWorkerStats(this.indexWorker, "index", e), this.waitForWorkerStats(this.levenshteinWorker, "levenshtein", e)]), this.stats;
+  }
+  getCurrentStats() {
+    return this.stats;
+  }
+  async resetStats(e = 5e3) {
+    let l = [this.resetWorkerStats(this.indexWorker, "index", e), this.resetWorkerStats(this.levenshteinWorker, "levenshtein", e)];
+    this.stats = { totalSearches: 0, averageSearchTime: 0, popularQueries: [], performanceBySize: {}, workers: { index: { stats: this.createEmptyWorkerStats("index") }, levenshtein: { stats: this.createEmptyWorkerStats("levenshtein") } } }, this.searchHistory = [], await Promise.all(l), this.logger.info("📊 FuzzySearchManager: All statistics have been reset"), this.eventEmitter.emit("stats:reset", { timestamp: Date.now(), resetBy: "manager" });
+  }
+  waitForWorkerStats(e, l, t) {
+    return e ? new Promise((a) => {
+      let r = setTimeout(() => {
+        this.logger.warn(`⚠️ getStats: Timeout waiting for ${l} worker.`), this.eventEmitter.off("worker:statsUpdated", d), a();
+      }, t), d = (n) => {
+        let { worker: c } = n;
+        c === l && (clearTimeout(r), this.eventEmitter.off("worker:statsUpdated", d), a());
+      };
+      this.eventEmitter.on("worker:statsUpdated", d), e.postMessage({ type: "getStats" });
+    }) : Promise.resolve();
+  }
+  resetWorkerStats(e, l, t) {
+    return e ? new Promise((a) => {
+      let r = setTimeout(() => {
+        this.logger.warn(`⚠️ resetStats: Timeout waiting for ${l} worker.`), e.removeEventListener("message", d), a();
+      }, t), d = (c) => {
+        c.data.type === "resetStats" && (clearTimeout(r), e.removeEventListener("message", d), this.logger.info(`📊 ${l} worker statistics have been reset`), a());
+      };
+      e.addEventListener("message", d);
+      let n = { type: "resetStats", id: `resetStats-${Date.now()}-${l}` };
+      e.postMessage(n);
+    }) : Promise.resolve();
+  }
+  createEmptyWorkerStats(e) {
+    return { basic: { totalSearches: 0, totalProcessingTime: 0, averageSearchTime: 0, lastSearchTime: 0, errorCount: 0, timestamp: Date.now() }, workerSpecific: { workerType: e, operationCount: 0, operationDistribution: {}, specificMetrics: {} }, analysis: { fieldPerformance: {}, performanceInsights: { recentAverageProcessingTime: 0, recentAverageResultCount: 0, throughputPerSecond: 0, totalHistoryEntries: 0, mostCommonQueryLength: 0, bestPerformingField: "", similarityDistribution: { highSimilarity: 0, mediumSimilarity: 0, lowSimilarity: 0, veryLowSimilarity: 0 } }, recentHistory: [] } };
+  }
+  getSearchHistory() {
+    return [...this.searchHistory];
+  }
+  on(e, l) {
+    this.eventEmitter.on(e, l);
+  }
+  off(e, l) {
+    this.eventEmitter.off(e, l);
+  }
+  async prebuildIndex(e, l, t) {
+    this.logger.info(`🏗️ Pre-building index for ${e.length} items`);
+    try {
+      if (await this.workersInitialized, this.isDisposed) {
+        this.logger.debug("🚫 prebuildIndex skipped because manager is disposed");
+        return;
+      }
+      let a = this.generateDataHash(e, l), r = Q.getInstance(this.defaultOptions.workerId), d = r.getLastIndexedDataHash();
+      if (this.logger.debug(`🔧 Checking index status: globalHash=${d}, currentHash=${a}`), !this.isIndexBuilt || this.lastIndexedDataHash !== a) {
+        if (d === a) {
+          this.logger.debug("🔧 Index already built globally for current data, skipping pre-build"), this.isIndexBuilt = !0, this.lastIndexedDataHash = a;
+          return;
+        }
+        let n = r.getBuildingPromise(a);
+        if (n) {
+          this.logger.debug("🔧 Index build already in progress globally, waiting..."), await n, this.isIndexBuilt = !0, this.lastIndexedDataHash = a;
+          return;
+        }
+        this.logger.debug(`🔧 Pre-building index: isIndexBuilt=${this.isIndexBuilt}, dataChanged=${this.lastIndexedDataHash !== a}`);
+        let c = (async () => {
+          await this.rebuildIndex(e, l, t);
+        })();
+        r.setBuildingPromise(a, c), await c, this.logger.info(`✅ Index pre-built successfully for ${e.length} items`);
+      } else this.logger.debug("🔧 Index already built for current data, skipping pre-build");
+    } catch (a) {
+      throw this.logger.error("🔧 Error during index pre-building:", a), a;
+    }
+  }
+  async rebuildIndex(e, l, t) {
+    this.logger.info(`🔄 Starting forced index rebuild for ${e.length} items`);
+    let a = { ...this.defaultOptions, ...t };
+    try {
+      if (await this.workersInitialized, this.isDisposed) {
+        this.logger.debug("🚫 rebuildIndex skipped because manager is disposed");
+        return;
+      }
+      this.isIndexBuilt = !1, this.lastIndexedDataHash = null, await this.buildIndex(e, l, a), this.logger.info(`✅ Index rebuild completed successfully for ${e.length} items`), this.isIndexBuilt = !0, this.lastIndexedDataHash = this.generateDataHash(e, l), Q.getInstance(this.defaultOptions.workerId).setLastIndexedDataHash(this.lastIndexedDataHash), this.eventEmitter.emit("index:rebuilt", { itemCount: e.length, searchFields: l, timestamp: Date.now() });
+    } catch (r) {
+      throw this.logger.error("❌ Failed to rebuild index:", r), this.eventEmitter.emit("index:rebuildError", { error: r instanceof Error ? r.message : String(r), timestamp: Date.now() }), r;
+    }
+  }
+  dispose() {
+    this.isDisposed = !0, this.indexWorker && (this.indexWorker.removeEventListener("message", this.handleIndexWorkerMessageBound), this.indexWorker.removeEventListener("error", this.handleIndexWorkerErrorBound)), this.levenshteinWorker && (this.levenshteinWorker.removeEventListener("message", this.handleLevenshteinWorkerMessageBound), this.levenshteinWorker.removeEventListener("error", this.handleLevenshteinWorkerErrorBound)), Q.getInstance(this.defaultOptions.workerId).releaseReference(), this.indexWorker = null, this.levenshteinWorker = null, this.pendingRequests.clear(), this.eventEmitter.removeAllListeners(), this.saveLearningData();
+  }
+}, C = (e, l) => {
+  if (typeof e == "string" && e.trim()) return e;
+  if (e instanceof Error && e.message.trim()) return e.message;
+  if (typeof e == "object" && e !== null) {
+    if ("error" in e) return C(e.error, l);
+    if ("message" in e) return C(e.message, l);
+  }
+  return l;
+};
+function ye(e, l, t) {
+  let [a, r] = M(""), [d, n] = M([]), [c, b] = M(!1), [X, m] = M(!1), [G, o] = M(null), [Z, N] = M([]), [k, T] = M({ totalSearches: 0, averageSearchTime: 0, itemCount: e.length, resultsCount: 0, workerStats: void 0 }), y = j(() => {
+    let i = { ..._, ...t };
+    return t?.threshold !== void 0 && (t.levenshteinWorkerOptions || (i.levenshteinWorkerOptions = { ...i.levenshteinWorkerOptions, threshold: t.threshold }), t.indexWorkerOptions || (i.indexWorkerOptions = { ...i.indexWorkerOptions, threshold: t.threshold })), i;
+  }, [t]), u = j(() => {
+    let i = "[fuzzy-search-react]";
+    return y.instanceName ? i = `[fuzzy-search-react:${y.instanceName}]` : y.workerId && (i = `[fuzzy-search-react:${y.workerId}]`), new ee(y.logLevel ?? 2, i, y.logger ?? console);
+  }, [y.logLevel, y.logger, y.workerId, y.instanceName]), p = K(null), H = K(a);
+  S(() => {
+    H.current = a;
+  }, [a]);
+  let U = j(() => l.map((i) => String(i)), [l]);
+  S(() => (p.current = new We(y), u.debug("🔧 FuzzySearchManager created (initial setup)"), () => {
+    u.debug("🔧 FuzzySearchManager disposed (component unmount)"), p.current?.dispose(), p.current = null;
+  }), [y, u]), S(() => {
+    if (!p.current) return;
+    let i = () => {
+      if (p.current) {
+        let x = p.current.getCurrentStats(), L = { totalSearches: x?.totalSearches ?? 0, averageSearchTime: x?.averageSearchTime ?? 0, itemCount: e.length, resultsCount: d.length, workerStats: { index: x?.workers.index.stats, levenshtein: x?.workers.levenshtein.stats } };
+        T(L);
+      }
+    }, R = (x) => {
+      let L = C(x, "Index Worker error");
+      u.error("❌ Index worker error event", x), o(L), m(!1);
+    }, g = (x) => {
+      let L = C(x, "Index rebuild error");
+      u.error("❌ Index rebuild error event", x), o(L), m(!1);
+    }, F = (x) => {
+      let L = C(x, "Search execution failed");
+      u.error("❌ Search error event", x), o(L);
+    };
+    return p.current.on("worker:statsUpdated", i), p.current.on("search:complete", i), p.current.on("indexWorker:error", R), p.current.on("index:rebuildError", g), p.current.on("search:error", F), () => {
+      p.current && (p.current.off("worker:statsUpdated", i), p.current.off("search:complete", i), p.current.off("indexWorker:error", R), p.current.off("index:rebuildError", g), p.current.off("search:error", F));
+    };
+  });
+  let f = v(async (i) => {
+    if (p.current) {
+      if (u.debug(`🔍 performSearch called with query: "${i}"`), i !== H.current) {
+        u.debug(`🚫 performSearch skipped for stale query: "${i}" (current: "${H.current}")`);
+        return;
+      }
+      try {
+        if (u.debug(`📈 Setting isSearching to true for query: "${i}"`), b(!0), o(null), !i.trim()) {
+          if (i !== H.current) return;
+          n(e.map((L, w) => ({ item: L, score: 1, baseScore: 1, matchedFields: [], relevanceReason: "全件表示", originalIndex: w }))), u.debug(`📈 Setting isSearching to false for empty query: "${i}"`), b(!1);
+          return;
+        }
+        u.info(`🚀 Starting search with query: "${i}", items count: ${e.length}`);
+        let R = performance.now(), g = await p.current.search(i, e, U, y), F = performance.now() - R;
+        if (i !== H.current) {
+          u.debug(`🚫 Search result ignored for stale query: "${i}" (current: "${H.current}")`);
+          return;
+        }
+        u.info(`✅ Search completed with ${g.length} results in ${F}ms`), n(g);
+        let x = { query: i, timestamp: Date.now(), resultCount: g.length, processingTime: F, searchTime: F, successful: g.length > 0 };
+        N((L) => {
+          let w = L.filter((D) => D.query !== i);
+          return [x, ...w].slice(0, 50);
+        });
+      } catch (R) {
+        if (i !== H.current) return;
+        u.error(`❌ Search error for query: "${i}"`, R), o(R instanceof Error ? R.message : "Search failed"), n([]);
+      } finally {
+        i === H.current && (u.debug(`📈 Setting isSearching to false (finally) for query: "${i}"`), b(!1));
+      }
+    }
+  }, [e, U, y, u.info, u.error, u.debug]);
+  S(() => {
+    if (!p.current || e.length === 0) return;
+    let i = !1, R = y.autoSearchOnIndexRebuild ?? !0;
+    return u.info(`🏗️ Data changed, pre-building index for ${e.length} items`), m(!0), p.current.prebuildIndex(e, U, y).then(() => {
+      !i && R && (u.debug("🔁 Re-running search after index rebuild"), f(H.current));
+    }).catch((g) => {
+      u.warn("🔧 Failed to pre-build index:", g), o(C(g, "インデックスの事前構築中にエラーが発生しました"));
+    }).finally(() => {
+      i || m(!1);
+    }), () => {
+      i = !0;
+    };
+  }, [e, U, y, f, u.warn, u.info, u.debug]), S(() => {
+    u.debug(`🎯 useEffect triggered - searchTerm: "${a}", debounceMs: ${y.debounceMs}`);
+    let i = setTimeout(() => {
+      u.debug(`⏰ Timeout executing performSearch for: "${a}"`), f(a);
+    }, y.debounceMs);
+    return () => {
+      u.debug(`🚫 Timeout cleared for: "${a}"`), clearTimeout(i);
+    };
+  }, [a, y, f, u]), S(() => {
+    a.trim() || n(e.map((i, R) => ({ item: i, score: 1, baseScore: 1, matchedFields: [], relevanceReason: "全件表示", originalIndex: R })));
+  }, [e, a]);
+  let le = v((i, R) => {
+    u.info("🎯 Selected item:", i, "at index:", R);
+  }, [u]), te = v(() => {
+    r(""), o(null);
+  }, []), E = v(() => {
+    N([]);
+  }, []), ae = v(async () => {
+    if (p.current) {
+      await p.current.resetStats(), N([]), o(null);
+      let i = p.current.getCurrentStats(), R = { totalSearches: i?.totalSearches ?? 0, averageSearchTime: i?.averageSearchTime ?? 0, itemCount: e.length, resultsCount: d.length, workerStats: { index: i?.workers.index.stats, levenshtein: i?.workers.levenshtein.stats } };
+      T(R), u.info("📊 useFuzzySearch: Statistics have been reset and refreshed");
+    }
+  }, [e.length, d.length, u]), se = v((i, R = 5) => {
+    let g = Z.filter((F) => F.query.toLowerCase().includes(i.toLowerCase()) && F.query !== i).sort((F, x) => x.timestamp - F.timestamp).slice(0, R).map((F) => F.query);
+    return Array.from(new Set(g));
+  }, [Z]), P = v(async (i) => {
+    if (!p.current) {
+      u.warn("⚠️ Search manager is not initialized");
+      return;
+    }
+    u.info(`🔄 Rebuilding index for ${e.length} items`), m(!0), o(null);
+    try {
+      let R = i ? { ...y, ...i } : y;
+      await p.current.rebuildIndex(e, U, R), u.info("✅ Index rebuild completed successfully");
+    } catch (R) {
+      let g = R instanceof Error ? R.message : "インデックス再構築中にエラーが発生しました";
+      throw u.error("❌ Index rebuild failed:", g), o(g), R;
+    } finally {
+      m(!1);
+    }
+  }, [e, U, y, u]);
+  return { searchTerm: a, setSearchTerm: r, filteredItems: d, isSearching: c, isIndexBuilding: X, error: G, searchHistory: Z, options: y, selectItem: le, clearSearch: te, clearHistory: E, resetStats: ae, getSearchSuggestions: se, performanceMetrics: k, rebuildIndex: P };
+}
+function Re(e, l) {
+  const t = j(
+    () => ({
+      threshold: 0.3,
+      sortBy: "score",
+      sortOrder: "desc"
+    }),
+    []
+  ), a = j(() => ["label"], []), { setSearchTerm: r, filteredItems: d, isSearching: n } = ye(e, a, t);
+  S(() => {
+    r(l);
+  }, [l, r]);
+  const c = j(() => {
+    if (!l) return e;
+    const b = l.toLowerCase(), X = [], m = [];
+    for (const G of d) {
+      const o = G.item;
+      o.label.toLowerCase() === b ? X.push(o) : m.push(o);
+    }
+    return [...X, ...m];
+  }, [d, l, e]);
+  return {
+    filteredOptions: l ? c : e,
+    isSearching: n
+  };
+}
+function Ve({ value: e, onChange: l, multiple: t }) {
+  const [a, r] = M(!1), [d, n] = M(""), c = K(null);
+  S(() => {
+    const G = (o) => {
+      c.current && !c.current.contains(o.target) && r(!1);
+    };
+    return document.addEventListener("mousedown", G), () => {
+      document.removeEventListener("mousedown", G);
+    };
+  }, []);
+  const b = v(
+    (G) => {
+      if (t) {
+        const o = Array.isArray(e) ? e : e ? [e] : [], Z = o.some((k) => k.value === G.value);
+        let N;
+        Z ? N = o.filter((k) => k.value !== G.value) : N = [...o, G], l?.(N);
+      } else
+        l?.(G), r(!1), n("");
+    },
+    [t, e, l]
+  ), X = v(
+    (G) => {
+      if (!t) return;
+      const Z = (Array.isArray(e) ? e : e ? [e] : []).filter((N) => N.value !== G.value);
+      l?.(Z);
+    },
+    [t, e, l]
+  ), m = v(() => {
+    r((G) => !G);
+  }, []);
+  return {
+    isOpen: a,
+    setIsOpen: r,
+    query: d,
+    setQuery: n,
+    containerRef: c,
+    handleSelect: b,
+    handleRemove: X,
+    toggleOpen: m
+  };
+}
+function xe({
+  title: e,
+  titleId: l,
+  ...t
+}, a) {
+  return /* @__PURE__ */ J.createElement("svg", Object.assign({
+    xmlns: "http://www.w3.org/2000/svg",
+    viewBox: "0 0 20 20",
+    fill: "currentColor",
+    "aria-hidden": "true",
+    "data-slot": "icon",
+    ref: a,
+    "aria-labelledby": l
+  }, t), e ? /* @__PURE__ */ J.createElement("title", {
+    id: l
+  }, e) : null, /* @__PURE__ */ J.createElement("path", {
+    fillRule: "evenodd",
+    d: "M16.704 4.153a.75.75 0 0 1 .143 1.052l-8 10.5a.75.75 0 0 1-1.127.075l-4.5-4.5a.75.75 0 0 1 1.06-1.06l3.894 3.893 7.48-9.817a.75.75 0 0 1 1.05-.143Z",
+    clipRule: "evenodd"
+  }));
+}
+const oe = /* @__PURE__ */ J.forwardRef(xe);
+function ge({
+  title: e,
+  titleId: l,
+  ...t
+}, a) {
+  return /* @__PURE__ */ J.createElement("svg", Object.assign({
+    xmlns: "http://www.w3.org/2000/svg",
+    viewBox: "0 0 20 20",
+    fill: "currentColor",
+    "aria-hidden": "true",
+    "data-slot": "icon",
+    ref: a,
+    "aria-labelledby": l
+  }, t), e ? /* @__PURE__ */ J.createElement("title", {
+    id: l
+  }, e) : null, /* @__PURE__ */ J.createElement("path", {
+    fillRule: "evenodd",
+    d: "M5.22 8.22a.75.75 0 0 1 1.06 0L10 11.94l3.72-3.72a.75.75 0 1 1 1.06 1.06l-4.25 4.25a.75.75 0 0 1-1.06 0L5.22 9.28a.75.75 0 0 1 0-1.06Z",
+    clipRule: "evenodd"
+  }));
+}
+const Ye = /* @__PURE__ */ J.forwardRef(ge);
+function ze({
+  title: e,
+  titleId: l,
+  ...t
+}, a) {
+  return /* @__PURE__ */ J.createElement("svg", Object.assign({
+    xmlns: "http://www.w3.org/2000/svg",
+    viewBox: "0 0 20 20",
+    fill: "currentColor",
+    "aria-hidden": "true",
+    "data-slot": "icon",
+    ref: a,
+    "aria-labelledby": l
+  }, t), e ? /* @__PURE__ */ J.createElement("title", {
+    id: l
+  }, e) : null, /* @__PURE__ */ J.createElement("path", {
+    d: "M6.28 5.22a.75.75 0 0 0-1.06 1.06L8.94 10l-3.72 3.72a.75.75 0 1 0 1.06 1.06L10 11.06l3.72 3.72a.75.75 0 1 0 1.06-1.06L11.06 10l3.72-3.72a.75.75 0 0 0-1.06-1.06L10 8.94 6.28 5.22Z"
+  }));
+}
+const Ne = /* @__PURE__ */ J.forwardRef(ze), Fe = ({ option: e, isSelected: l, isFocused: t, onClick: a, multiple: r, style: d }) => /* @__PURE__ */ W.jsxs(
+  "div",
+  {
+    role: "option",
+    "aria-selected": l,
+    tabIndex: 0,
+    onKeyDown: (n) => {
+      (n.key === "Enter" || n.key === " ") && a(e);
+    },
+    style: d,
+    onClick: () => a(e),
+    className: `sb-option ${t ? "sb-option--focused" : ""}
+        ${l && !r ? "sb-option--selected" : "sb-option--not-selected"}
+      `,
+    children: [
+      r && /* @__PURE__ */ W.jsx(
+        "div",
+        {
+          className: `sb-checkbox ${l ? "sb-checkbox--checked" : "sb-checkbox--unchecked"}
+        `,
+          children: l && /* @__PURE__ */ W.jsx(oe, { className: "sb-check-icon-white" })
+        }
+      ),
+      /* @__PURE__ */ W.jsx("span", { className: "sb-option-label", children: e.label }),
+      !r && l && /* @__PURE__ */ W.jsx(oe, { className: "sb-check-icon-blue" })
+    ]
+  }
+), Le = ({ options: e, value: l, multiple: t, onSelect: a, className: r }) => {
+  const [d, n] = M(300), c = K(null), b = K(!1), X = (Z) => {
+    b.current = !0, Z.currentTarget.setPointerCapture(Z.pointerId), Z.preventDefault();
+  }, m = v((Z) => {
+    if (!(b.current && c.current)) return;
+    const N = c.current.getBoundingClientRect(), k = Z.clientY - N.top;
+    n(Math.max(100, Math.min(k, 600)));
+  }, []), G = v(() => {
+    b.current = !1;
+  }, []);
+  S(() => (document.addEventListener("pointermove", m), document.addEventListener("pointerup", G), () => {
+    document.removeEventListener("pointermove", m), document.removeEventListener("pointerup", G);
+  }), [m, G]);
+  const o = (Z) => t ? (Array.isArray(l) ? l : l ? [l] : []).some((k) => k.value === Z.value) : l?.value === Z.value;
+  return /* @__PURE__ */ W.jsxs("div", { ref: c, className: `sb-dropdown ${r || ""}`, style: { height: d }, children: [
+    e.length > 0 ? /* @__PURE__ */ W.jsx(
+      Ze,
+      {
+        itemCount: e.length,
+        getItem: (Z) => e[Z],
+        getItemHeight: () => 36,
+        viewportSize: d,
+        className: "h-full w-full",
+        scrollBarOptions: {
+          width: 10,
+          enableThumbDrag: !0,
+          enableTrackClick: !0
+        },
+        behaviorOptions: {
+          enableKeyboardNavigation: !0
+        },
+        children: (Z, N) => Z ? /* @__PURE__ */ W.jsx(Fe, { option: Z, isSelected: o(Z), onClick: a, multiple: t, style: { height: 36 } }, Z.value) : null
+      }
+    ) : /* @__PURE__ */ W.jsx("div", { className: "sb-no-options", children: "No options found" }),
+    /* @__PURE__ */ W.jsx("div", { onPointerDown: X, className: "sb-resize-handle", children: /* @__PURE__ */ W.jsxs("svg", { viewBox: "0 0 10 10", className: "sb-resize-icon", children: [
+      /* @__PURE__ */ W.jsx("title", { children: "Resize handle" }),
+      /* @__PURE__ */ W.jsx("path", { d: "M10 10L10 0L0 10Z" })
+    ] }) })
+  ] });
+}, ve = ({ value: e, multiple: l, query: t, onQueryChange: a, onRemove: r, onFocus: d, placeholder: n = "Select...", disabled: c, isLoading: b }) => {
+  const X = K(null), m = Array.isArray(e) ? e : e ? [e] : [], G = (o) => {
+    o.key === "Backspace" && !t && m.length > 0 && l && r(m[m.length - 1]);
+  };
+  return /* @__PURE__ */ W.jsxs(
+    "fieldset",
+    {
+      className: `sb-input-area ${c ? "sb-input-area--disabled" : "sb-input-area--active"}
+      `,
+      onMouseDown: (o) => {
+        const Z = o.target;
+        Z !== X.current && !Z.closest("button") && (o.preventDefault(), X.current?.focus());
+      },
+      children: [
+        l && m.map((o) => /* @__PURE__ */ W.jsxs("span", { className: "sb-tag", children: [
+          o.label,
+          /* @__PURE__ */ W.jsx(
+            "button",
+            {
+              type: "button",
+              onClick: (Z) => {
+                Z.stopPropagation(), r(o);
+              },
+              className: "sb-tag-remove",
+              children: /* @__PURE__ */ W.jsx(Ne, { className: "h-3 w-3" })
+            }
+          )
+        ] }, o.value)),
+        !l && m.length > 0 && !t && /* @__PURE__ */ W.jsx("span", { className: "sb-single-value", children: m[0].label }),
+        /* @__PURE__ */ W.jsx("input", { ref: X, type: "text", value: t, onChange: (o) => a(o.target.value), onFocus: d, onKeyDown: G, placeholder: m.length === 0 ? n : "", disabled: c, className: "sb-input" }),
+        /* @__PURE__ */ W.jsx("div", { className: "sb-indicators", children: b ? /* @__PURE__ */ W.jsxs("svg", { className: "sb-loading-icon", xmlns: "http://www.w3.org/2000/svg", fill: "none", viewBox: "0 0 24 24", children: [
+          /* @__PURE__ */ W.jsx("title", { children: "Loading" }),
+          /* @__PURE__ */ W.jsx("circle", { className: "opacity-25", cx: "12", cy: "12", r: "10", stroke: "currentColor", strokeWidth: "4" }),
+          /* @__PURE__ */ W.jsx("path", { className: "opacity-75", fill: "currentColor", d: "M4 12a8 8 0 018-8V0C5.373 0 0 5.373 0 12h4zm2 5.291A7.962 7.962 0 014 12H0c0 3.042 1.135 5.824 3 7.938l3-2.647z" })
+        ] }) : /* @__PURE__ */ W.jsx(Ye, { className: "sb-chevron-icon" }) })
+      ]
+    }
+  );
+}, He = (e) => {
+  const { isOpen: l, setIsOpen: t, query: a, setQuery: r, containerRef: d, handleSelect: n, handleRemove: c } = Ve(e), { filteredOptions: b, isSearching: X } = Re(e.options, a);
+  return /* @__PURE__ */ W.jsxs("div", { ref: d, className: `sb-container ${e.className || ""}`, children: [
+    /* @__PURE__ */ W.jsx(
+      ve,
+      {
+        value: e.value,
+        multiple: e.multiple,
+        query: a,
+        onQueryChange: (m) => {
+          r(m), l || t(!0);
+        },
+        onRemove: c,
+        onFocus: () => t(!0),
+        placeholder: e.placeholder,
+        disabled: e.disabled,
+        isLoading: X
+      }
+    ),
+    l && !e.disabled && /* @__PURE__ */ W.jsx(Le, { options: b, value: e.value, multiple: e.multiple, onSelect: n })
+  ] });
+};
+export {
+  He as SelectBox
+};