@arbetsformedlingen/yrkesvaljaren 2.0.5

package/dist/esm/loader.js

@@ -0,0 +1,10 @@
+import { g as globalScripts, b as bootstrapLazy } from './index-CGXZllj2.js';
+export { s as setNonce } from './index-CGXZllj2.js';
+
+const defineCustomElements = async (win, options) => {
+  if (typeof window === 'undefined') return undefined;
+  await globalScripts();
+  return bootstrapLazy([["job-selector-demo",[[512,"job-selector-demo",{"afHideHeader":[4,"af-hide-header"],"afHidePreamble":[4,"af-hide-preamble"],"variant":[32],"version":[32],"required":[32],"allowFreeText":[32],"history":[32],"size":[32],"framework":[32],"codeInstallationMode":[32],"lastSingleSelection":[32],"lastMultiSelection":[32],"implementationCode":[32],"readmeMainContent":[32],"readmeCodeContent":[32],"availableYvVersions":[32],"latestYvDataVersion":[32],"latestVersion":[32],"latestDate":[32],"latestType":[32],"latestChanges":[32],"isTaxonomyLoading":[32]},[[0,"afJobSelected","handleSelection"]]]]],["geo-valjaren",[[513,"geo-valjaren",{"label":[513,"af-label"],"placeholder":[513,"af-placeholder"],"selectorState":[32]},[[0,"csInput","handleInput"],[0,"csFocus","handleFocus"],[0,"csRequestHistory","handleRequestHistory"],[0,"csSelect","handleSelect"],[0,"csBlur","handleBlur"],[0,"csClear","handleClear"],[0,"csClearHistory","handleCsClearHistory"],[0,"csEditSelection","handleEdit"]]]]],["neobrutal-search",[[513,"neobrutal-search",{"engine":[32],"results":[32],"inputValue":[32],"isLoading":[32],"error":[32],"selectedItem":[32],"isFlipped":[32]}]]],["core-selector",[[785,"core-selector",{"state":[16],"config":[16],"label":[1],"labelDescription":[1,"label-description"],"componentId":[1,"component-id"],"size":[513,"cs-size"],"afFocused":[4,"af-focused"],"activeIndex":[32],"isFocusedInternal":[32],"isNavigatingWithKeyboard":[32],"setFocus":[64]},null,{"afFocused":[{"handleAfFocusedChange":0}],"config":[{"handleConfigChange":0}],"state":[{"handleStateChange":0}]}]]],["digi-service-job-selector",[[593,"digi-service-job-selector",{"name":[513],"taxonomyUrl":[513,"af-taxonomy-url"],"placeholder":[513,"af-placeholder"],"label":[513,"af-label"],"disabled":[516],"enableMultiple":[516,"af-enable-multiple"],"showSearchIcon":[516,"af-show-search-icon"],"errorMessage":[513,"af-error-message"],"labelDescription":[513,"af-label-description"],"required":[516,"af-required"],"manualInput":[516,"af-manual-input"],"history":[516,"af-history"],"popular":[516,"af-popular"],"size":[513,"af-size"],"taxonomyData":[1040],"afFocused":[32],"state":[32],"activeErrorType":[32],"animatingItemId":[32],"updateData":[64],"setSelection":[64],"setFocus":[64],"validate":[64],"checkValidity":[64],"reportValidity":[64],"getValidity":[64],"getValidationMessage":[64]},[[0,"afJobValidationChange","handleFormValidationSync"],[8,"hashchange","handleHashFocus"],[0,"csInput","handleInput"],[0,"csSelect","handleCsSelect"],[0,"csClear","handleCsClear"],[0,"csClearHistory","handleCsClearHistory"],[0,"csRequestHistory","handleCsRequestHistory"],[0,"csLoadMore","handleCsLoadMore"],[0,"csRemoveItem","handleCsRemoveItem"],[0,"csFocus","handleCsFocus"],[0,"csBlur","handleCsBlur"],[0,"csEditSelection","handleCsEditSelection"]],{"required":[{"watchRequired":0}],"manualInput":[{"watchManualInput":0}],"history":[{"watchHistory":0}],"popular":[{"watchPopular":0}],"enableMultiple":[{"watchEnableMultiple":0}],"disabled":[{"watchDisabled":0}],"taxonomyData":[{"watchTaxonomyData":0}]}]]]], options);
+};
+
+export { defineCustomElements };

package/dist/esm/neobrutal-search.entry.js

@@ -0,0 +1,169 @@
+import { r as registerInstance, a as getElement, h } from './index-CGXZllj2.js';
+import { T as TaxonomySearchEngine } from './search.engine-nZ7AcXba.js';
+import { g as getRegisteredTaxonomy } from './taxonomy-registry-Dw0VR9Aw.js';
+import './fuse-BPnhMTul.js';
+
+const neobrutalSearchCss = () => `:host{display:block;font-family:'Courier New', Courier, monospace;--bg-color:#fff4e6;--primary:#ff00ff;--secondary:#00ffff;--text:#000;--border:4px solid #000;--shadow:8px 8px 0px #000}.neobrutal-container{background-color:var(--bg-color);padding:40px;border:var(--border);box-shadow:var(--shadow);max-width:600px;margin:20px auto;min-height:600px;position:relative;box-sizing:border-box;display:flex;flex-direction:column;transition:min-height 0.6s cubic-bezier(0.23, 1, 0.32, 1)}.flip-container{perspective:1000px;width:100%}.flipper{transition:0.6s;transform-style:preserve-3d;position:relative;width:100%}.flip-container.flipped .flipper{transform:rotateY(180deg)}.front,.back{backface-visibility:hidden;top:0;left:0;width:100%}.front{z-index:2;transform:rotateY(0deg);position:relative}.flip-container.flipped .front{position:absolute}.back{transform:rotateY(180deg);box-sizing:border-box;position:absolute}.flip-container.flipped .back{position:relative;z-index:3}h1.glitch{font-size:3rem;font-weight:900;text-transform:uppercase;margin-bottom:30px;background-color:var(--primary);color:var(--text);display:inline-block;padding:5px 15px;border:var(--border);box-shadow:4px 4px 0px #000}.input-wrapper{margin-bottom:50px;padding-right:10px;padding-bottom:10px}input{width:100%;padding:20px;font-size:1.5rem;font-family:inherit;font-weight:bold;border:var(--border);background:white;outline:none;text-transform:uppercase;box-shadow:8px 8px 0px #000;transition:all 0.1s;box-sizing:border-box}.status{font-size:1.5rem;font-weight:bold;background-color:yellow;border:var(--border);padding:10px;margin-bottom:20px;text-align:center}.fire-status{font-size:1.8rem;font-weight:900;background-color:#ff4500;color:#fff;border:var(--border);padding:15px;margin-bottom:15px;text-align:center;position:relative;box-shadow:10px 10px 0px #000;animation:fire-flicker 0.2s infinite alternate}@keyframes fire-flicker{0%{transform:scale(1) rotate(-0.5deg)}100%{transform:scale(1.01) rotate(0.5deg)}}.fire-emoji{font-size:2rem;display:inline-block;margin:0 10px}.raw-data-container{margin-top:10px;margin-bottom:30px;background:#000;border:2px solid #fff;padding:15px;text-align:left;box-shadow:5px 5px 0px #ff00ff}.raw-label{font-size:0.8rem;color:#0f0;margin-bottom:5px;font-weight:bold}.raw-output{font-family:'Courier New', Courier, monospace;font-size:0.8rem;color:#0f0;margin:0;white-space:pre-wrap;word-break:break-all}.flip-btn{position:absolute;top:10px;right:10px;background:#000;color:#fff;border:2px solid #fff;padding:5px 10px;font-weight:bold;cursor:pointer;font-family:'Courier New', Courier, monospace;z-index:10}.flip-btn:hover{background:#ff00ff;color:#000}.source-view{background:#0d1117 !important;color:#e6edf3 !important;border-color:#30363d !important;padding:30px !important;display:flex;flex-direction:column}.source-header{font-size:2rem;color:#ff00ff;margin-bottom:20px;text-shadow:2px 2px 0 #000}.code-scroll-container{flex:1;background:#161b22;border:1px solid #30363d;border-radius:6px;padding:10px}.code-block{margin-bottom:25px;text-align:left}.code-label{background:#238636;color:#fff;display:inline-block;padding:4px 8px;font-weight:bold;font-size:0.8rem;border-radius:4px 4px 0 0}pre{background:#0d1117;margin:0;padding:10px;border:1px solid #30363d}pre code{font-family:'Courier New', Courier, monospace;font-size:0.85rem;line-height:1.4;background:transparent !important;color:#e6edf3}.result-card{background-color:white;border:var(--border);box-shadow:5px 5px 0px #000;padding:15px;transition:all 0.1s;cursor:pointer}.result-card:hover{transform:translate(2px, 2px);box-shadow:3px 3px 0px #000;background-color:var(--secondary)}.card-header{display:flex;justify-content:space-between;margin-bottom:10px;border-bottom:2px solid #000;padding-bottom:5px}.type-badge{background-color:yellow;padding:2px 8px;font-weight:bold;border:2px solid #000}.score-badge{background-color:lime;padding:2px 8px;font-weight:bold;border:2px solid #000}.label{font-size:1.2rem;font-weight:800}`;
+
+// VIKTIGT: Dessa strängar representerar den FAKTISKA källkoden som användaren ser.
+const SOURCE_CODE_JS = `import { Component, h, State, Element } from '@stencil/core';
+import { TaxonomySearchEngine } from '../job-selector/logic/search.engine';
+import { getRegisteredTaxonomy } from '../job-selector/taxonomy-registry';
+
+@Component({ tag: 'neobrutal-search', styleUrl: 'neobrutal-search.css', shadow: true })
+export class NeobrutalSearch {
+  @Element() el!: HTMLElement;
+  @State() engine: TaxonomySearchEngine | null = null;
+  @State() results: any[] = [];
+  @State() inputValue: string = '';
+  @State() isLoading: boolean = true;
+  @State() error: string = '';
+  @State() selectedItem: any | null = null;
+  @State() isFlipped: boolean = false;
+
+  async componentWillLoad() {
+    try {
+      const taxonomyData = getRegisteredTaxonomy();
+      this.engine = new TaxonomySearchEngine(taxonomyData);
+      this.isLoading = false;
+    } catch (err) {
+      this.error = 'DATA FAILURE';
+      this.isLoading = false;
+    }
+  }
+
+  componentDidUpdate() {
+    if (this.isFlipped) this.highlightCode();
+  }
+
+  highlightCode() {
+    const hljs = (window as any).hljs;
+    if (hljs && this.el?.shadowRoot) {
+      const blocks = this.el.shadowRoot.querySelectorAll('pre code');
+      blocks.forEach((block) => hljs.highlightElement(block));
+    }
+  }
+
+  handleInput(event: Event) {
+    const query = (event.target as HTMLInputElement).value;
+    this.inputValue = query;
+    this.selectedItem = null;
+
+    if (!this.engine || query.length < 2) {
+      this.results = [];
+      return;
+    }
+
+    this.results = this.engine.search(query, 3);
+  }
+
+  handleSelect(item: any) {
+    this.selectedItem = item;
+    this.results = [];
+    this.inputValue = item.label;
+  }
+
+  toggleFlip() {
+    this.isFlipped = !this.isFlipped;
+    if (this.isFlipped) setTimeout(() => this.highlightCode(), 100);
+  }
+
+  render() {
+    return (
+      <div class="neobrutal-container">
+        {/* ... UI structure ... */}
+      </div>
+    );
+  }
+}`;
+const SOURCE_CODE_CSS = `.neobrutal-container {
+    background-color: #fff4e6;
+    padding: 40px;
+    border: 4px solid #000;
+    box-shadow: 8px 8px 0px #000;
+    font-family: 'Courier New', Courier, monospace;
+}
+
+.fire-status {
+    background-color: #ff4500;
+    animation: fire-flicker 0.2s infinite alternate;
+}
+
+.raw-data-container {
+    background: #000;
+    color: #0f0;
+    padding: 15px;
+    box-shadow: 5px 5px 0px #ff00ff;
+}`;
+const NeobrutalSearch = class {
+    constructor(hostRef) {
+        registerInstance(this, hostRef);
+    }
+    get el() { return getElement(this); }
+    engine = null;
+    results = [];
+    inputValue = '';
+    isLoading = true;
+    error = '';
+    selectedItem = null;
+    isFlipped = false;
+    async componentWillLoad() {
+        try {
+            console.log('[NeobrutalSearch] Initializing...');
+            const taxonomyData = getRegisteredTaxonomy();
+            this.engine = new TaxonomySearchEngine(taxonomyData);
+            this.isLoading = false;
+        }
+        catch (err) {
+            console.error('[NeobrutalSearch] Init failed:', err);
+            this.error = 'DATA FAILURE';
+            this.isLoading = false;
+        }
+    }
+    componentDidUpdate() {
+        if (this.isFlipped) {
+            this.highlightCode();
+        }
+    }
+    highlightCode() {
+        const hljs = window.hljs;
+        if (hljs && this.el?.shadowRoot) {
+            const blocks = this.el.shadowRoot.querySelectorAll('pre code');
+            blocks.forEach((block) => {
+                hljs.highlightElement(block);
+            });
+        }
+    }
+    handleInput(event) {
+        const query = event.target.value;
+        this.inputValue = query;
+        this.selectedItem = null;
+        if (!this.engine || query.length < 2) {
+            this.results = [];
+            return;
+        }
+        const searchResults = this.engine.search(query, 3);
+        this.results = searchResults;
+    }
+    handleSelect(item) {
+        this.selectedItem = item;
+        this.results = [];
+        this.inputValue = item.label;
+    }
+    toggleFlip() {
+        this.isFlipped = !this.isFlipped;
+        if (this.isFlipped) {
+            setTimeout(() => this.highlightCode(), 100);
+        }
+    }
+    render() {
+        return (h("div", { key: '032a555551974ef504c703419db83581652a5083', class: `flip-container ${this.isFlipped ? 'flipped' : ''}` }, h("link", { key: '8af8fac02cd7b8ac1112c08c51e32be3845b7647', rel: "stylesheet", href: "https://cdnjs.cloudflare.com/ajax/libs/highlight.js/11.11.1/styles/atom-one-dark.min.css" }), h("div", { key: '5f63de826af07f1139126a64fb205f65e14f5060', class: "flipper" }, h("div", { key: 'a7878c0a9db257884cedab104366639d2edb506b', class: "front neobrutal-container" }, h("button", { key: '6d65c76d93c717e7c056f0e2da60d2f825efd781', class: "flip-btn", onClick: () => this.toggleFlip() }, "FLIP_ME \uD83D\uDD04"), h("h1", { key: '56981f916be340a827e376cb713e6b6fb5e097bb', class: "glitch", "data-text": "YRKE_S\u00D6K" }, "YRKE_S\u00D6K"), h("div", { key: 'ba3c2e76b631e0d48c5f2ecee1095a999393822e', class: "input-wrapper" }, h("input", { key: '75a8e4553a2e77992efa9591a64fba83c3dbe3ea', type: "text", placeholder: "VAD VILL DU BLI?", onInput: (e) => this.handleInput(e), value: this.inputValue, disabled: this.isLoading })), this.isLoading && h("div", { key: '46ec1526451477d7ecf90ffe46dd964986096903', class: "status" }, "LOADING_DATA..."), this.error && h("div", { key: '01bc30a4d4e17e493d8deb08c7e5b71da9c23df7', class: "status error" }, this.error), this.selectedItem && (h("div", { key: '0e6d79bc76dbecd7a79bbf0b00246acdef45eda3' }, h("div", { key: 'f942688584b54c4b43679903549781fbe346e154', class: "fire-status" }, h("span", { key: 'efde5818a4449b710d22e43e9c8148f380f89f3d', class: "fire-emoji" }, "\uD83D\uDD25 \uD83D\uDD25 \uD83D\uDD25"), "HETT VAL: ", this.selectedItem.label.toUpperCase(), "!", h("span", { key: '7764fa1ed1fd7b0541f5ad3a49e3135f4a61edfe', class: "fire-emoji" }, "\uD83D\uDD25 \uD83D\uDD25 \uD83D\uDD25")), h("div", { key: '415e1ee36443cc50cddb0f87e8750b34084fd485', class: "raw-data-container" }, h("div", { key: 'ed730d664599ecac4a89ccdf597833ea3f9fb47a', class: "raw-label" }, "RAW_JSON_DATA:"), h("pre", { key: '0921ef8ebccb5add5e9d379e31872b2798b399f8', class: "raw-output" }, JSON.stringify(this.selectedItem, null, 2))))), h("div", { key: '9af42c5d7cb9d901b6909e8ea4260da7dfee09fd', class: "results-container" }, this.results.map(result => {
+            const metadata = result?.metadata || {};
+            const original = metadata?.originalResult;
+            return (h("div", { class: "result-card", onClick: () => this.handleSelect(result) }, h("div", { class: "card-header" }, h("span", { class: "type-badge" }, original?.category === 'job-title' ? 'YRK' : 'GRP'), h("span", { class: "score-badge" }, "SCR: ", Math.round((metadata?.score || 0) * 10))), h("div", { class: "card-body" }, h("div", { class: "label" }, result.displayLabel || result.label))));
+        }))), h("div", { key: '349e56ba67845d6b63ab8616823c5909452ed593', class: "back neobrutal-container source-view" }, h("button", { key: '1de742d808b48a65bb266ea19a83ccf567a76ac6', class: "flip-btn", onClick: () => this.toggleFlip() }, "BACK \uD83D\uDD19"), h("h1", { key: 'b2400cbd8d36417df1cbb3c487fa7e3d824f4a02', class: "source-header" }, "FULL_SOURCE_CODE"), h("p", { key: '59c3e040a7177810b53200426da4543f99c7ca73', class: "source-desc" }, "Exakt den koden du ser, inga fejk snippets h\u00E4r inte:"), h("div", { key: '8ed08d5d1d79ec49c6e6bb6a5be504ddd6ed84c2', class: "code-scroll-container" }, h("div", { key: '5018114c97191ccf174ae197d56917f35848dcef', class: "code-block" }, h("div", { key: '466523ef6acb91d435248d5d399fef5a79bc2e6f', class: "code-label" }, "neobrutal-search.tsx"), h("pre", { key: '2a3ad662ac5a0346131aaa13dfd9544169338e48' }, h("code", { key: '76b3240d79589217899d74f6727b64d1c8495d7a', class: "language-typescript" }, SOURCE_CODE_JS))), h("div", { key: '2990f5d3da12a8c8ffeccbb4f786945b7eb70483', class: "code-block" }, h("div", { key: '5b957f082c75f5de3f5bd766c9fd135e1ee06471', class: "code-label" }, "neobrutal-search.css"), h("pre", { key: '8a2c509035923387c2dac463b72feda6c2c41ba2' }, h("code", { key: '581e2ccebcef975ac6dd79059da4c82cb0ffe176', class: "language-css" }, SOURCE_CODE_CSS))))))));
+    }
+};
+NeobrutalSearch.style = neobrutalSearchCss();
+
+export { NeobrutalSearch as neobrutal_search };

package/dist/esm/search.engine-nZ7AcXba.js

@@ -0,0 +1,479 @@
+import { e as entry_default } from './fuse-BPnhMTul.js';
+import { l as log } from './taxonomy-registry-Dw0VR9Aw.js';
+
+// Minimum number of characters required to trigger search
+const MIN_INPUT_LENGTH = 1;
+// Debounce time for search input (ms)
+const DEBOUNCE_TIME = 100; // ms - Återställt till 250 baserat på sok-box.tsx initialt
+// Default maximum number of results to display
+const MAX_RESULTS = 10;
+// Configuration for Fuse.js
+const FUSE_OPTIONS = {
+    keys: ['preferred_label'], // Ändrat från 'label' till 'preferred_label' för att matcha datastrukturen
+    includeScore: true,
+    ignoreDiacritics: true, // Lägg till för att matcha t.ex. vard -> vård
+    ignoreFieldNorm: true, // Lägg till för att ignorera fältlängd vid poängsättning
+    threshold: 0.6, // Behåll 0.6
+    minMatchCharLength: MIN_INPUT_LENGTH, // Refererar till konstant ovan
+    ignoreLocation: true, // Match anywhere in the string
+    distance: 100, // Allow matches further apart
+};
+// UI Text Strings
+const PLACEHOLDER_TEXT = "T.ex. frisör, vårdbiträde, snickare"; // Uppdaterad standardplaceholder enligt Figma-design
+
+const LabelFormatter = {
+    format: (label, query, occupationLabel) => {
+        // 1. Highlight the main label based on query
+        const labelSegments = highlightText(label, query);
+        // 2. Append occupation label if it exists (the "metadata" part)
+        if (occupationLabel) {
+            return [
+                ...labelSegments,
+                { text: ' ', isMatch: false },
+                { text: `(${occupationLabel})`, isMetadata: true }
+            ];
+        }
+        return labelSegments;
+    }
+};
+function calculateEditDistance$1(a, b) {
+    const m = a.length;
+    const n = b.length;
+    const dp = Array.from({ length: m + 1 }, () => new Array(n + 1).fill(0));
+    for (let i = 0; i <= m; i++)
+        dp[i][0] = i;
+    for (let j = 0; j <= n; j++)
+        dp[0][j] = j;
+    for (let i = 1; i <= m; i++) {
+        for (let j = 1; j <= n; j++) {
+            dp[i][j] = a[i - 1] === b[j - 1]
+                ? dp[i - 1][j - 1]
+                : 1 + Math.min(dp[i - 1][j], dp[i][j - 1], dp[i - 1][j - 1]);
+        }
+    }
+    return dp[m][n];
+}
+function findBestFuzzySubstring$1(text, qToken) {
+    const lowerText = text.toLowerCase();
+    const targetLen = qToken.length;
+    let bestDist = 99;
+    let bestStart = -1;
+    let bestLen = 0;
+    const minLen = Math.max(3, targetLen - 2);
+    const maxLen = Math.min(lowerText.length, targetLen + 2);
+    for (let start = 0; start <= lowerText.length - minLen; start++) {
+        for (let len = minLen; len <= maxLen && start + len <= lowerText.length; len++) {
+            const sub = lowerText.slice(start, start + len);
+            const dist = calculateEditDistance$1(qToken, sub);
+            if (dist < bestDist) {
+                bestDist = dist;
+                bestStart = start;
+                bestLen = len;
+            }
+        }
+    }
+    const maxAllowedDist = Math.max(2, Math.floor(targetLen * 0.25));
+    if (bestDist <= maxAllowedDist && bestStart !== -1) {
+        return { start: bestStart, length: bestLen };
+    }
+    return null;
+}
+/**
+ * Highlights matches in text based on query.
+ * Supports multi-word queries.
+ */
+function highlightText(text, query) {
+    if (!text)
+        return [];
+    if (!query || query.trim().length === 0) {
+        return [{ text, isMatch: false }];
+    }
+    const lowerText = text.toLowerCase();
+    const tokens = query.toLowerCase().split(/\s+/).filter(t => t.length > 0);
+    // Set of indices in the original text that should be highlighted
+    const highlightedIndices = new Set();
+    tokens.forEach(token => {
+        let startIndex = 0;
+        while ((startIndex = lowerText.indexOf(token, startIndex)) !== -1) {
+            for (let i = 0; i < token.length; i++) {
+                highlightedIndices.add(startIndex + i);
+            }
+            startIndex += token.length;
+        }
+    });
+    if (highlightedIndices.size === 0) {
+        // Fuzzy highlight fallback: Hitta bästa matchande delsträng i sammansatta ord eller felstavningar
+        tokens.forEach(qToken => {
+            const match = findBestFuzzySubstring$1(text, qToken);
+            if (match) {
+                for (let i = 0; i < match.length; i++) {
+                    highlightedIndices.add(match.start + i);
+                }
+            }
+        });
+    }
+    if (highlightedIndices.size === 0) {
+        return [{ text, isMatch: false }];
+    }
+    const segments = [];
+    let currentSegmentText = '';
+    let currentIsMatch = highlightedIndices.has(0);
+    for (let i = 0; i < text.length; i++) {
+        const isMatch = highlightedIndices.has(i);
+        if (isMatch !== currentIsMatch) {
+            // Push previous segment
+            if (currentSegmentText.length > 0) {
+                segments.push({ text: currentSegmentText, isMatch: currentIsMatch });
+            }
+            // Start new segment
+            currentSegmentText = text[i];
+            currentIsMatch = isMatch;
+        }
+        else {
+            currentSegmentText += text[i];
+        }
+    }
+    // Push the last segment
+    if (currentSegmentText.length > 0) {
+        segments.push({ text: currentSegmentText, isMatch: currentIsMatch });
+    }
+    return segments;
+}
+
+const MAX_WEAK_FUZZY_RESULTS = 3;
+const MIN_FUZZY_SCORE = 0.4;
+const MAX_FUZZY_SCORE = 0.84;
+{
+    log.setLevel(log.levels.DEBUG); // Set log level to DEBUG for development/testing
+}
+const normalizeForComparison = (text) => {
+    if (!text) {
+        return '';
+    }
+    const normalized = text.toLowerCase().trim();
+    return normalized;
+};
+function formatDisplayLabel(item) {
+    if (item.occupation_name_preferred_label) {
+        return `${item.preferred_label || ''} (${item.occupation_name_preferred_label})`;
+    }
+    return item.preferred_label || '';
+}
+function sortResultsStrict(results) {
+    return results.sort((a, b) => {
+        const scoreA = a.score ?? 0;
+        const scoreB = b.score ?? 0;
+        if (scoreA !== scoreB) {
+            return scoreB - scoreA;
+        }
+        const weightA = a.weight ?? 0;
+        const weightB = b.weight ?? 0;
+        if (weightA !== weightB) {
+            // Buggen är fixad här
+            return weightB - weightA;
+        }
+        return a.displayLabel.localeCompare(b.displayLabel, 'sv');
+    });
+}
+function segmentsToHtml(segments) {
+    return segments.map(seg => {
+        if (seg.isMatch) {
+            return `<strong>${seg.text}</strong>`;
+        }
+        if (seg.isMetadata) {
+            return `<span class="occupation-variant-label">${seg.text}</span>`;
+        }
+        return seg.text;
+    }).join('');
+}
+// Keep export for controller compatibility (it was used there)
+// But implement using new logic or just re-export if we want to keep it simple?
+// The controller passes HTML to it.
+// Actually, `styleParentheticalText` took a string (HTML) and did regex replacement.
+// If the controller uses it on `item.displayLabel` (which is plain text usually, or mapped),
+// the controller does: `const historyItem = { ...item, highlightedLabel: styleParentheticalText(item.displayLabel) };`
+// `displayLabel` for "Frontend (System)" is "Frontend (System)".
+// If we run that through `segmentsToHtml(LabelFormatter.format(label, ''))`, we get the same result!
+// So let's re-implement `styleParentheticalText` using `LabelFormatter`.
+const styleParentheticalText = (text) => {
+    if (!text)
+        return '';
+    return text.replace(/ (\([^)]+\))/g, ' <span class="occupation-variant-label">$1</span>');
+};
+function getDirectScore(normalizedLabel, normalizedQuery, searchTokens) {
+    if (normalizedLabel === normalizedQuery) {
+        return 1.0;
+    }
+    if (searchTokens.length > 1) {
+        return searchTokens.every(token => normalizedLabel.includes(token)) ? 0.98 : null;
+    }
+    if (normalizedLabel.startsWith(normalizedQuery)) {
+        return 0.99;
+    }
+    if (normalizedLabel.includes(normalizedQuery)) {
+        return 0.95;
+    }
+    return null;
+}
+function calculateEditDistance(a, b) {
+    const m = a.length;
+    const n = b.length;
+    const dp = Array.from({ length: m + 1 }, () => new Array(n + 1).fill(0));
+    for (let i = 0; i <= m; i++)
+        dp[i][0] = i;
+    for (let j = 0; j <= n; j++)
+        dp[0][j] = j;
+    for (let i = 1; i <= m; i++) {
+        for (let j = 1; j <= n; j++) {
+            dp[i][j] = a[i - 1] === b[j - 1]
+                ? dp[i - 1][j - 1]
+                : 1 + Math.min(dp[i - 1][j], dp[i][j - 1], dp[i - 1][j - 1]);
+        }
+    }
+    return dp[m][n];
+}
+function findBestFuzzySubstring(text, qToken) {
+    const lowerText = text.toLowerCase();
+    const targetLen = qToken.length;
+    let bestDist = 99;
+    const minLen = Math.max(3, targetLen - 2);
+    const maxLen = Math.min(lowerText.length, targetLen + 2);
+    for (let start = 0; start <= lowerText.length - minLen; start++) {
+        for (let len = minLen; len <= maxLen && start + len <= lowerText.length; len++) {
+            const sub = lowerText.slice(start, start + len);
+            const dist = calculateEditDistance(qToken, sub);
+            if (dist < bestDist) {
+                bestDist = dist;
+            }
+        }
+    }
+    const maxAllowedDist = Math.max(2, Math.floor(targetLen * 0.25));
+    return bestDist <= maxAllowedDist ? bestDist : null;
+}
+function isSingleWordOrCompoundRoot(query, label) {
+    const normQ = query.toLowerCase().trim();
+    const normL = label.toLowerCase().trim();
+    if (normL.includes(' ')) {
+        const dist = calculateEditDistance(normQ, normL);
+        return dist <= Math.max(2, Math.floor(normQ.length * 0.25)) && Math.abs(normQ.length - normL.length) <= 2;
+    }
+    const subDist = findBestFuzzySubstring(normL, normQ);
+    return subDist !== null;
+}
+function createSearchResult(item, query, score) {
+    const displayLabel = formatDisplayLabel(item);
+    const displaySegments = LabelFormatter.format(item.preferred_label || '', query, item.occupation_name_preferred_label);
+    return {
+        id: item.id,
+        type: item.type,
+        preferred_label: item.preferred_label || '',
+        rawLabel: item.preferred_label || '',
+        displayLabel,
+        highlightedLabel: segmentsToHtml(displaySegments),
+        displaySegments,
+        weight: item.weight ?? 0,
+        score,
+        occupationId: item.occupation_name_id,
+        occupationLabel: item.occupation_name_preferred_label,
+        ssyk_level_4_id: item.ssyk_level_4_id,
+        ssyk_code_2012: item.ssyk_code_2012,
+    };
+}
+function searchConcepts(query, items, fuseInstance, maxResults) {
+    if (!fuseInstance) {
+        return [];
+    }
+    if (!items || !Array.isArray(items)) {
+        log.warn('[searchConcepts] Ogiltig items array.');
+        return [];
+    }
+    if (!query || query.length < MIN_INPUT_LENGTH) {
+        return [];
+    }
+    const normalizedQuery = normalizeForComparison(query);
+    const searchTokens = normalizedQuery.split(' ').filter(t => t.length > 0);
+    const directResults = [];
+    const processedIds = new Set();
+    for (const item of items) {
+        const normalizedLabel = normalizeForComparison(item.preferred_label);
+        const score = getDirectScore(normalizedLabel, normalizedQuery, searchTokens);
+        if (score !== null) {
+            directResults.push(createSearchResult(item, query, score));
+            processedIds.add(item.id);
+        }
+    }
+    if (directResults.length > 0) {
+        return sortResultsStrict(directResults).slice(0, maxResults);
+    }
+    // Fuzzy är ren fallback när inga direkta träffar finns.
+    if (fuseInstance) {
+        const fuseSearchOutput = fuseInstance.search(normalizedQuery);
+        if (fuseSearchOutput.length === 0) {
+            return [];
+        }
+        const bestRawScore = fuseSearchOutput[0].score ?? 1.0;
+        const candidateResults = [];
+        let hasStrongRootMatch = false;
+        for (const fr of fuseSearchOutput) {
+            if (processedIds.has(fr.item.id)) {
+                continue;
+            }
+            const rawScore = fr.score ?? 1.0;
+            const baseFuzzyScore = 1 - rawScore;
+            if (baseFuzzyScore < MIN_FUZZY_SCORE) {
+                continue;
+            }
+            // Strikt gap-filter: Tillåt aldrig träffar som har mer än 0.12 sämre råpoäng än bästa träffen
+            if (rawScore > bestRawScore + 0.12) {
+                continue;
+            }
+            const label = normalizeForComparison(fr.item.preferred_label);
+            const weight = fr.item.weight ?? 0;
+            // Hitta om etiketten innehåller en rotterm eller sammansatt del som matchar sökningen
+            const isRootMatch = isSingleWordOrCompoundRoot(normalizedQuery, label);
+            if (isRootMatch && rawScore <= 0.25) {
+                hasStrongRootMatch = true;
+            }
+            let score = baseFuzzyScore * 0.70 + (weight * 0.10);
+            if (isRootMatch) {
+                score += 0.12;
+            }
+            const boundedScore = Math.min(MAX_FUZZY_SCORE, Math.max(MIN_FUZZY_SCORE, score));
+            candidateResults.push(createSearchResult(fr.item, query, boundedScore));
+            processedIds.add(fr.item.id);
+        }
+        const sortedFuzzy = sortResultsStrict(candidateResults);
+        if (sortedFuzzy.length === 0) {
+            return [];
+        }
+        // Dynamiskt maxantal vid fuzzy-sökningar:
+        // - Stark rotmatchning (t.ex. injenjör, barlnmorska): Visa upp till 5 relevanta förslag så att fritextfältet syns utan att skrolla.
+        // - Svag/osäker matchning (t.ex. böla fölkja, pensionär): Visa MAX 3 träffar.
+        const limit = hasStrongRootMatch ? Math.min(5, maxResults) : Math.min(MAX_WEAK_FUZZY_RESULTS, maxResults);
+        return sortedFuzzy.slice(0, limit);
+    }
+    return [];
+}
+
+const TaxonomyAdapter = {
+    /** Maps a raw TaxonomyItem to a GenericItem for the CoreSelector */
+    toGenericItem(item) {
+        return {
+            id: item.id,
+            label: item.preferred_label || '',
+            description: item.occupation_name_preferred_label,
+            metadata: {
+                original: item,
+                type: item.type,
+                ssyk_level_4_id: item.ssyk_level_4_id,
+                weight: item.weight
+            }
+        };
+    },
+    /** Maps a SearchResult (from our engine) to a GenericItem */
+    searchResultToGenericItem(result, query) {
+        const segments = LabelFormatter.format(result.preferred_label || '', query, result.occupation_name_preferred_label);
+        return {
+            id: result.id,
+            label: result.preferred_label || '',
+            displaySegments: segments,
+            highlightedLabel: segmentsToHtml(segments),
+            metadata: {
+                original: result,
+                ssyk_level_4_id: result.ssyk_level_4_id,
+                weight: result.weight
+            }
+        };
+    },
+    /** Maps a GenericItem back to our internal SearchResult format */
+    fromGenericItem(item) {
+        return {
+            id: item.id,
+            preferred_label: item.label,
+            weight: item.metadata?.weight,
+            ...item.metadata?.original
+        };
+    },
+    /** Maps an internal item to the public event format */
+    toPublicSelection(item) {
+        const id = item.id || '';
+        const preferredLabel = item.preferred_label || item.rawLabel || '';
+        if (!id) {
+            return {
+                type: 'manual-input',
+                id: null,
+                preferred_label: preferredLabel,
+            };
+        }
+        if (item.type !== 'job-title' && item.type !== 'occupation-name') {
+            throw new Error(`Ogiltig intern yrkestyp för ${id}: ${item.type}`);
+        }
+        const selection = {
+            type: item.type,
+            id,
+            preferred_label: preferredLabel,
+        };
+        if (item.ssyk_code_2012) {
+            selection.ssyk_code_2012 = item.ssyk_code_2012;
+        }
+        const occupationId = item.occupation_name_id || item.occupationId;
+        const occupationLabel = item.occupation_name_preferred_label || item.occupationLabel;
+        if (item.type === 'job-title' && occupationId && occupationLabel) {
+            selection.related = {
+                type: 'occupation-name',
+                id: occupationId,
+                preferred_label: occupationLabel,
+            };
+        }
+        return selection;
+    }
+};
+
+class TaxonomySearchEngine {
+    fuseInstance = null;
+    items = [];
+    constructor(data) {
+        this.items = data;
+        this.fuseInstance = new entry_default(data, FUSE_OPTIONS);
+    }
+    /**
+     * Public API: Performs a search and returns clean, official domain objects.
+     * This is what external consumers (headless) should use.
+     */
+    search(query, maxResults = 10) {
+        if (!this.fuseInstance)
+            return [];
+        const results = searchConcepts(query, this.items, this.fuseInstance, maxResults);
+        // Map directly to public selection objects
+        return results.map(result => TaxonomyAdapter.toPublicSelection(result));
+    }
+    /**
+     * Internal API: Performs a search and returns GenericItems for the CoreSelector UI ("Bucky").
+     * Includes highlighting, grouping and internal metadata.
+     */
+    searchAsGeneric(query, maxResults = 10) {
+        if (!this.fuseInstance)
+            return [];
+        // Use the existing robust search function
+        const results = searchConcepts(query, this.items, this.fuseInstance, maxResults);
+        // Adapt SearchResult -> GenericItem
+        return results.map(result => ({
+            id: result.id,
+            label: result.displayLabel, // Use the formatted label (e.g. "Nurse (Healthcare)")
+            description: result.occupationLabel,
+            group: result.type === 'job-title' ? 'Yrke' : 'Yrkesgrupp',
+            metadata: {
+                originalResult: result, // Keep full original result for consumers
+                highlightedLabel: result.highlightedLabel,
+                score: result.score,
+                weight: result.weight
+            }
+        }));
+    }
+    updateData(newData) {
+        this.items = newData;
+        this.fuseInstance = new entry_default(newData, FUSE_OPTIONS);
+    }
+}
+
+export { DEBOUNCE_TIME as D, LabelFormatter as L, MAX_RESULTS as M, PLACEHOLDER_TEXT as P, TaxonomySearchEngine as T, TaxonomyAdapter as a, MIN_INPUT_LENGTH as b, styleParentheticalText as c, segmentsToHtml as s };