@limetech/lime-elements 39.6.0 → 39.7.0

package/dist/collection/components/code-diff/content-utils.js

@@ -0,0 +1,49 @@
+/**
+ * Pure utility functions for extracting text content from diff structures.
+ */
+/**
+ * Extract the text content of removed lines from a unified change block.
+ *
+ * @param lines - consecutive changed lines from a unified diff hunk
+ * @returns the removed lines joined by newlines, or empty string if none
+ */
+export function extractRemovedContent(lines) {
+    return lines
+        .filter((line) => line.type === 'removed')
+        .map((line) => line.content)
+        .join('\n');
+}
+/**
+ * Extract the text content of removed lines from a split change block.
+ *
+ * @param rows - consecutive changed rows from a split diff hunk
+ * @returns the removed lines joined by newlines, or empty string if none
+ */
+export function extractRemovedContentFromSplit(rows) {
+    return rows
+        .filter((row) => { var _a; return ((_a = row.left) === null || _a === void 0 ? void 0 : _a.type) === 'removed'; })
+        .map((row) => row.left.content)
+        .join('\n');
+}
+/**
+ * Format a screen-reader summary of diff additions and deletions.
+ *
+ * @param additions - number of added lines
+ * @param deletions - number of removed lines
+ * @returns human-readable summary string, or null if no changes
+ */
+export function formatDiffSummary(additions, deletions) {
+    if (additions === 0 && deletions === 0) {
+        return null;
+    }
+    const parts = [];
+    if (additions > 0) {
+        const suffix = additions === 1 ? '' : 's';
+        parts.push(`${additions} addition${suffix}`);
+    }
+    if (deletions > 0) {
+        const suffix = deletions === 1 ? '' : 's';
+        parts.push(`${deletions} deletion${suffix}`);
+    }
+    return `Diff: ${parts.join(', ')}. Use arrow keys to navigate lines.`;
+}

package/dist/collection/components/code-diff/diff-engine.js

@@ -0,0 +1,308 @@
+import { diffLines, diffWords } from "diff";
+/**
+ * Compute a structured diff between two strings.
+ *
+ * @param oldText - the "before" text
+ * @param newText - the "after" text
+ * @param contextLines - number of unchanged lines to show around each change
+ * @returns a DiffResult with hunks, additions, and deletions counts
+ */
+export function computeDiff(oldText, newText, contextLines = 3) {
+    const allLines = buildDiffLines(oldText, newText);
+    return groupIntoHunks(allLines, contextLines);
+}
+/**
+ * Re-group previously computed flat lines into hunks.
+ * Used when expanding collapsed sections without re-diffing.
+ *
+ * @param allLines - the full flat diff lines from a previous computation
+ * @param contextLines - number of context lines around changes
+ * @returns a DiffResult with new hunk groupings
+ */
+export function regroupLines(allLines, contextLines) {
+    return groupIntoHunks(allLines, contextLines);
+}
+/**
+ * Build paired rows for split (side-by-side) view from flat diff lines.
+ * Context lines appear on both sides. Adjacent removed+added lines
+ * are paired into the same row.
+ *
+ * @param lines - flat diff lines
+ * @returns paired rows for split rendering
+ */
+export function buildSplitLines(lines) {
+    const rows = [];
+    let i = 0;
+    while (i < lines.length) {
+        const line = lines[i];
+        if (line.type === 'context') {
+            rows.push({ left: line, right: line });
+            i++;
+            continue;
+        }
+        i = collectAndPairChanges(lines, i, rows);
+    }
+    return rows;
+}
+/**
+ * Collect consecutive removed then added lines starting at `index`,
+ * pair them into split rows, and return the new index.
+ * @param lines - flat diff lines
+ * @param index - starting index
+ * @param rows - output array to push paired rows into
+ */
+function collectAndPairChanges(lines, index, rows) {
+    const removed = [];
+    while (index < lines.length && lines[index].type === 'removed') {
+        removed.push(lines[index]);
+        index++;
+    }
+    const added = [];
+    while (index < lines.length && lines[index].type === 'added') {
+        added.push(lines[index]);
+        index++;
+    }
+    const maxPairs = Math.max(removed.length, added.length);
+    for (let j = 0; j < maxPairs; j++) {
+        rows.push({
+            left: j < removed.length ? removed[j] : undefined,
+            right: j < added.length ? added[j] : undefined,
+        });
+    }
+    return index;
+}
+/**
+ * Normalize values for diffing. If `reformatJson` is true,
+ * parse and re-stringify with sorted keys and consistent indentation.
+ * @param value
+ * @param reformatJson
+ */
+export function normalizeForDiff(value, reformatJson = false) {
+    if (typeof value === 'object' && value !== null) {
+        return JSON.stringify(sortKeysDeep(value), null, 4);
+    }
+    if (typeof value === 'string' && reformatJson) {
+        try {
+            const parsed = JSON.parse(value);
+            return JSON.stringify(sortKeysDeep(parsed), null, 4);
+        }
+        catch (_a) {
+            return value;
+        }
+    }
+    return String(value !== null && value !== void 0 ? value : '');
+}
+function sortKeysDeep(obj) {
+    if (Array.isArray(obj)) {
+        return obj.map(sortKeysDeep);
+    }
+    if (obj !== null && typeof obj === 'object') {
+        const sorted = {};
+        const keys = Object.keys(obj).sort((a, b) => a.localeCompare(b));
+        for (const key of keys) {
+            sorted[key] = sortKeysDeep(obj[key]);
+        }
+        return sorted;
+    }
+    return obj;
+}
+/**
+ * Build a flat list of DiffLines from two text strings.
+ * @param oldText
+ * @param newText
+ */
+function buildDiffLines(oldText, newText) {
+    const changes = diffLines(oldText, newText);
+    const lines = [];
+    let oldLineNum = 1;
+    let newLineNum = 1;
+    for (const change of changes) {
+        const changeLines = splitIntoLines(change.value);
+        for (const line of changeLines) {
+            if (change.added) {
+                lines.push({
+                    type: 'added',
+                    content: line,
+                    newLineNumber: newLineNum++,
+                });
+            }
+            else if (change.removed) {
+                lines.push({
+                    type: 'removed',
+                    content: line,
+                    oldLineNumber: oldLineNum++,
+                });
+            }
+            else {
+                lines.push({
+                    type: 'context',
+                    content: line,
+                    oldLineNumber: oldLineNum++,
+                    newLineNumber: newLineNum++,
+                });
+            }
+        }
+    }
+    addWordLevelHighlighting(lines);
+    return lines;
+}
+/**
+ * Split a string into lines, handling the trailing newline
+ * that jsdiff includes in each change value.
+ * @param text
+ */
+function splitIntoLines(text) {
+    if (!text) {
+        return [];
+    }
+    const lines = text.split('\n');
+    // jsdiff includes a trailing newline, producing an empty last element
+    if (lines.length > 0 && lines.at(-1) === '') {
+        lines.pop();
+    }
+    return lines;
+}
+/**
+ * Pair adjacent removed+added lines and compute word-level diffs
+ * to highlight only the specific segments that changed.
+ * @param lines
+ */
+function addWordLevelHighlighting(lines) {
+    let i = 0;
+    while (i < lines.length) {
+        // Find consecutive removed lines
+        const removedStart = i;
+        while (i < lines.length && lines[i].type === 'removed') {
+            i++;
+        }
+        const removedEnd = i;
+        // Find consecutive added lines right after
+        const addedStart = i;
+        while (i < lines.length && lines[i].type === 'added') {
+            i++;
+        }
+        const addedEnd = i;
+        const removedCount = removedEnd - removedStart;
+        const addedCount = addedEnd - addedStart;
+        // Pair them up for word-level highlighting
+        if (removedCount > 0 && addedCount > 0) {
+            const pairCount = Math.min(removedCount, addedCount);
+            for (let j = 0; j < pairCount; j++) {
+                const removedLine = lines[removedStart + j];
+                const addedLine = lines[addedStart + j];
+                const [removedSegments, addedSegments] = computeWordSegments(removedLine.content, addedLine.content);
+                removedLine.segments = removedSegments;
+                addedLine.segments = addedSegments;
+            }
+        }
+        // Skip context lines
+        if (i === removedStart) {
+            i++;
+        }
+    }
+}
+/**
+ * Compute word-level diff segments for a pair of lines.
+ * @param oldContent
+ * @param newContent
+ */
+function computeWordSegments(oldContent, newContent) {
+    const wordChanges = diffWords(oldContent, newContent);
+    const removedSegments = [];
+    const addedSegments = [];
+    for (const change of wordChanges) {
+        if (change.added) {
+            addedSegments.push({ value: change.value, type: 'added' });
+        }
+        else if (change.removed) {
+            removedSegments.push({ value: change.value, type: 'removed' });
+        }
+        else {
+            removedSegments.push({ value: change.value, type: 'equal' });
+            addedSegments.push({ value: change.value, type: 'equal' });
+        }
+    }
+    return [removedSegments, addedSegments];
+}
+/**
+ * Group a flat list of diff lines into hunks with context.
+ * @param lines
+ * @param contextLines
+ */
+function groupIntoHunks(lines, contextLines) {
+    if (lines.length === 0) {
+        return { hunks: [], additions: 0, deletions: 0, allLines: lines };
+    }
+    let additions = 0;
+    let deletions = 0;
+    for (const line of lines) {
+        if (line.type === 'added') {
+            additions++;
+        }
+        else if (line.type === 'removed') {
+            deletions++;
+        }
+    }
+    // If there are no changes, return a single empty result
+    if (additions === 0 && deletions === 0) {
+        return { hunks: [], additions: 0, deletions: 0, allLines: lines };
+    }
+    // Find ranges of changed lines with their context
+    const changeIndices = [];
+    for (const [i, line] of lines.entries()) {
+        if (line.type !== 'context') {
+            changeIndices.push(i);
+        }
+    }
+    // Build hunk boundaries
+    const hunkBoundaries = buildHunkBoundaries(changeIndices, lines.length, contextLines);
+    const hunks = [];
+    let prevEnd = 0;
+    for (const boundary of hunkBoundaries) {
+        const hunkLines = lines.slice(boundary.start, boundary.end);
+        const hiddenBefore = boundary.start - prevEnd;
+        const collapsedBefore = hiddenBefore > 0 ? hiddenBefore : undefined;
+        hunks.push({
+            lines: hunkLines,
+            collapsedBefore,
+            startIndex: boundary.start,
+        });
+        prevEnd = boundary.end;
+    }
+    // Calculate collapsed lines after the last hunk
+    const lastBoundary = hunkBoundaries.at(-1);
+    const collapsedAfter = lastBoundary.end < lines.length
+        ? lines.length - lastBoundary.end
+        : undefined;
+    return { hunks, additions, deletions, collapsedAfter, allLines: lines };
+}
+/**
+ * Build the start/end boundaries of each hunk based on change positions.
+ * Merges hunks that overlap or are adjacent.
+ * @param changeIndices
+ * @param totalLines
+ * @param contextLines
+ */
+function buildHunkBoundaries(changeIndices, totalLines, contextLines) {
+    if (changeIndices.length === 0) {
+        return [];
+    }
+    const boundaries = [];
+    let currentStart = Math.max(0, changeIndices[0] - contextLines);
+    let currentEnd = Math.min(totalLines, changeIndices[0] + contextLines + 1);
+    for (let i = 1; i < changeIndices.length; i++) {
+        const changeStart = Math.max(0, changeIndices[i] - contextLines);
+        const changeEnd = Math.min(totalLines, changeIndices[i] + contextLines + 1);
+        if (changeStart <= currentEnd) {
+            // Merge overlapping hunks
+            currentEnd = Math.max(currentEnd, changeEnd);
+        }
+        else {
+            boundaries.push({ start: currentStart, end: currentEnd });
+            currentStart = changeStart;
+            currentEnd = changeEnd;
+        }
+    }
+    boundaries.push({ start: currentStart, end: currentEnd });
+    return boundaries;
+}

package/dist/collection/components/code-diff/search-utils.js

@@ -0,0 +1,41 @@
+/**
+ * Pure utility functions for search-within-diff functionality.
+ */
+/**
+ * Escape special regex characters in a search term so it can
+ * be used as a literal pattern in a RegExp constructor.
+ *
+ * @param term - the raw search string
+ * @returns regex-safe string
+ */
+export function escapeRegex(term) {
+    return term.replaceAll(/[.*+?^${}()|[\]\\]/g, String.raw `\$&`);
+}
+/**
+ * Build a case-insensitive regex that captures the search term.
+ * Returns `null` when the term is empty.
+ *
+ * @param term - the raw search string
+ * @returns a RegExp with a single capture group, or null
+ */
+export function buildSearchRegex(term) {
+    if (!term) {
+        return null;
+    }
+    return new RegExp(`(${escapeRegex(term)})`, 'gi');
+}
+/**
+ * Calculate the next match index when navigating forward or backward,
+ * wrapping around at the boundaries.
+ *
+ * @param currentIndex - current zero-based match index
+ * @param direction - +1 for next, -1 for previous
+ * @param total - total number of matches
+ * @returns the new match index
+ */
+export function navigateMatchIndex(currentIndex, direction, total) {
+    if (total === 0) {
+        return 0;
+    }
+    return (currentIndex + direction + total) % total;
+}

package/dist/collection/components/code-diff/syntax-highlighter.js

@@ -0,0 +1,87 @@
+/**
+ * Tokenize a text fragment for syntax highlighting.
+ * Returns the original text as a single plain token when the
+ * language is not supported.
+ *
+ * @param text - the text to tokenize
+ * @param language - the language identifier (e.g. "json")
+ * @returns array of syntax tokens
+ */
+export function tokenize(text, language) {
+    if (!language || text.length === 0) {
+        return [{ value: text, type: 'plain' }];
+    }
+    if (language === 'json') {
+        return tokenizeJson(text);
+    }
+    return [{ value: text, type: 'plain' }];
+}
+// ─── JSON tokenizer ─────────────────────────────────────────────────
+/**
+ * Regex-based JSON tokenizer.
+ * Handles partial lines (individual lines of a JSON document).
+ */
+const JSON_PATTERNS = [
+    // String literals (keys and values)
+    [/"(?:[^"\\]|\\.)*"/, 'string'],
+    // Numbers
+    [/-?\d+(?:\.\d+)?(?:[eE][+-]?\d+)?/, 'number'],
+    // Booleans
+    [/\b(?:true|false)\b/, 'boolean'],
+    // Null
+    [/\bnull\b/, 'null'],
+    // Punctuation
+    [/[{}[\]:,]/, 'punctuation'],
+];
+const JSON_REGEX = new RegExp(JSON_PATTERNS.map(([re]) => `(${re.source})`).join('|'), 'g');
+function tokenizeJson(text) {
+    const tokens = [];
+    let lastIndex = 0;
+    JSON_REGEX.lastIndex = 0;
+    let match = JSON_REGEX.exec(text);
+    while (match !== null) {
+        // Plain text before this match
+        if (match.index > lastIndex) {
+            tokens.push({
+                value: text.slice(lastIndex, match.index),
+                type: 'plain',
+            });
+        }
+        // Determine which capture group matched
+        const tokenType = getMatchedTokenType(match);
+        const value = match[0];
+        // Distinguish JSON keys from string values:
+        // A key is a string followed by optional whitespace and a colon
+        if (tokenType === 'string') {
+            const afterMatch = text.slice(match.index + value.length);
+            if (/^\s*:/.test(afterMatch)) {
+                tokens.push({ value, type: 'key' });
+            }
+            else {
+                tokens.push({ value, type: 'string' });
+            }
+        }
+        else {
+            tokens.push({ value, type: tokenType });
+        }
+        lastIndex = match.index + value.length;
+        match = JSON_REGEX.exec(text);
+    }
+    // Remaining plain text
+    if (lastIndex < text.length) {
+        tokens.push({ value: text.slice(lastIndex), type: 'plain' });
+    }
+    return tokens;
+}
+/**
+ * Determine which pattern matched by checking capture groups.
+ * @param match - the regex match result
+ */
+function getMatchedTokenType(match) {
+    for (const [index, [, type]] of JSON_PATTERNS.entries()) {
+        if (match[index + 1] !== undefined) {
+            return type;
+        }
+    }
+    return 'plain';
+}

package/dist/collection/components/code-diff/types.js

@@ -0,0 +1 @@
+export {};

package/dist/collection/components/code-editor/code-editor.js

@@ -250,7 +250,7 @@ export class CodeEditor {
             'is-dark-mode': this.isDarkMode(),
             'is-light-mode': !this.isDarkMode(),
         };
-        return (h(Host, { key: '47f27484ea6a4271fba45f81aa97a9ab9c0d7c28' }, this.renderCopyButton(), h("limel-notched-outline", { key: 'cc455855470c242d667b80a1b778007c6582439b', labelId: this.labelId, label: this.label, required: this.required, invalid: this.invalid, disabled: this.disabled, readonly: this.readonly, hasValue: !!this.value, hasFloatingLabel: true }, h("div", { key: '11942b528f9110ee14cf8ef54f6c588fde1a6113', slot: "content", class: classList })), this.renderHelperLine()));
+        return (h(Host, { key: 'fd59cdeb74135398c33210af68d6129820c586bd' }, this.renderCopyButton(), h("limel-notched-outline", { key: '41214ae1f04b85a9462f3b71cd03871a7fd0401d', labelId: this.labelId, label: this.label, required: this.required, invalid: this.invalid, disabled: this.disabled, readonly: this.readonly, hasValue: !!this.value, hasFloatingLabel: true }, h("div", { key: '4d5caf3e80e342af2b8ea54411b11348949babd1', slot: "content", class: classList })), this.renderHelperLine()));
     }
     forceRedraw() {
         // eslint-disable-next-line sonarjs/pseudo-random

package/dist/collection/components/collapsible-section/collapsible-section.js

@@ -111,7 +111,7 @@ export class CollapsibleSection {
         removeEnterClickable(button);
     }
     render() {
-        return (h("section", { key: '8105890d7039702755935af1290f3ac170a6f724', class: `${this.isOpen ? 'open' : ''}`, "aria-invalid": this.invalid, "aria-labelledby": this.header ? this.headingId : null }, h("header", { key: '31e93e837d63d2a5954ec4c2780c2159467e0e8e' }, h("button", { key: '126c518c39c010b3745f26c8542e4a7e667687a2', class: "open-close-toggle", onClick: this.onClick, "aria-controls": this.bodyId, "aria-expanded": this.isOpen ? 'true' : 'false', "aria-label": this.getCollapsibleSectionAriaLabel(), type: "button" }), this.renderExpandCollapseSign(), this.renderIcon(), this.renderHeading(), h("div", { key: 'db0c2822ebcacee830c60a035386973a3680469b', class: "divider-line", role: "presentation" }), this.renderHeaderSlot(), this.renderActions()), h("div", { key: '5a4456a8c5a783fad2389c8d013a6eccf70990f1', class: "body", "aria-hidden": String(!this.isOpen), id: this.bodyId, role: "region" }, h("slot", { key: '4db8829dfc0ba669b555c18130541e54ec84f4b0' }))));
+        return (h("section", { key: 'a40f48753cc7e5ae281b0e2a169e19510e54cc55', class: `${this.isOpen ? 'open' : ''}`, "aria-invalid": this.invalid, "aria-labelledby": this.header ? this.headingId : null }, h("header", { key: '55784166942971de68e351914a6d96dc77ea75c4' }, h("button", { key: '0432b0b5a4af99b94fea4073de496785c8f87d36', class: "open-close-toggle", onClick: this.onClick, "aria-controls": this.bodyId, "aria-expanded": this.isOpen ? 'true' : 'false', "aria-label": this.getCollapsibleSectionAriaLabel(), type: "button" }), this.renderExpandCollapseSign(), this.renderIcon(), this.renderHeading(), h("div", { key: '11efcd91907a79ed0945749b4672809e466c1e00', class: "divider-line", role: "presentation" }), this.renderHeaderSlot(), this.renderActions()), h("div", { key: '4b74f9d5fc9533eb14180a23e20c402a436b53f7', class: "body", "aria-hidden": String(!this.isOpen), id: this.bodyId, role: "region" }, h("slot", { key: '42c969ae7787768247a41952f9cf6d528ca7d4fd' }))));
     }
     renderHeaderSlot() {
         return h("slot", { name: "header" });

package/dist/collection/components/color-picker/color-picker-palette.js

@@ -39,10 +39,10 @@ export class Palette {
     render() {
         const background = this.value ? { '--background': this.value } : {};
         return [
-            h("div", { key: 'd38a4c31e9d40150f157ba3954f7f14148c605a0', class: "color-picker-palette", style: {
+            h("div", { key: '184f8b9b74ebeb5611aa28ff3b14dbb225118af2', class: "color-picker-palette", style: {
                     '--color-picker-column-count': `${this.getColumnCount()}`,
                 } }, this.renderSwatches()),
-            h("div", { key: 'fd7b5ea679162d628a00f8f6c045aba5fde06ce5', class: "chosen-color-name" }, h("limel-input-field", { key: '11f4cb92ef40da77334d211d5a773abeb97fea7b', label: this.label, helperText: this.helperText, value: this.value, onChange: this.handleChange, required: this.required, invalid: this.invalid, placeholder: this.placeholder, disabled: !this.manualInput }), h("div", { key: '1d751628e6391e640005c63765a9e20f03b0386d', class: "chosen-color-preview", style: background })),
+            h("div", { key: '27b19d8906e5f28c86c27476ebe0287b6043eb66', class: "chosen-color-name" }, h("limel-input-field", { key: 'd055b72d5570bcb085b728eb0cf4698b80a44643', label: this.label, helperText: this.helperText, value: this.value, onChange: this.handleChange, required: this.required, invalid: this.invalid, placeholder: this.placeholder, disabled: !this.manualInput }), h("div", { key: '051cc6a16e9659aabb01f4b6b9f0b30036d440b4', class: "chosen-color-preview", style: background })),
         ];
     }
     getPalette() {

package/dist/collection/components/color-picker/color-picker.js

@@ -86,7 +86,7 @@ export class ColorPicker {
         }
     }
     render() {
-        return (h(Host, { key: 'e5e7516bc0e5e496acb92490b5ce638a1d8140f2' }, this.renderTooltip(), this.renderPickerPalette(), h("limel-input-field", { key: '147b1c5a85b6497c96ea471f7e2e101b0d98e3d8', label: this.label, helperText: this.helperText, value: this.value, onChange: this.handleChange, required: this.required, readonly: this.readonly, disabled: this.disabled || !this.manualInput, invalid: this.invalid, placeholder: this.placeholder })));
+        return (h(Host, { key: '33ce47843041f982dc448a4f954a434418d376ba' }, this.renderTooltip(), this.renderPickerPalette(), h("limel-input-field", { key: '74e6e705f7633d4a0ebba49352c24592209421d5', label: this.label, helperText: this.helperText, value: this.value, onChange: this.handleChange, required: this.required, readonly: this.readonly, disabled: this.disabled || !this.manualInput, invalid: this.invalid, placeholder: this.placeholder })));
     }
     static get is() { return "limel-color-picker"; }
     static get encapsulation() { return "shadow"; }

package/dist/collection/components/date-picker/flatpickr-adapter/flatpickr-adapter.js

@@ -89,7 +89,7 @@ export class DatePickerCalendar {
         this.flatPickrCreated = false;
     }
     render() {
-        return (h("div", { key: '33ab0c2d6f9f7f9907b98730d5f0f81de0c80535', class: "container", ref: (el) => (this.container = el), style: {
+        return (h("div", { key: '95bd84a535e4bcbf91a356e47b2fbaf440daf15d', class: "container", ref: (el) => (this.container = el), style: {
                 '--today-label': `"${translate.get('date-picker.today')}"`,
             } }));
     }

package/dist/collection/components/dialog/dialog.js

@@ -84,10 +84,10 @@ export class Dialog {
         this.mdcDialog.destroy();
     }
     render() {
-        return (h("div", { key: 'accd952fd2cd38b2bad0b70efd36a2d4c1144bc4', class: {
+        return (h("div", { key: '590a7ad1dc1deeab0481f36b9aaeea0aca24d34f', class: {
                 'mdc-dialog': true,
                 'full-screen': !!this.fullscreen,
-            }, role: "alertdialog", "aria-modal": "true", "aria-labelledby": 'limel-dialog-title-' + this.id, "aria-describedby": 'limel-dialog-content-' + this.id }, h("input", { key: '2df038083000033391b00e58a926de3c7c1599ea', hidden: true, id: "initialFocusEl" }), h("div", { key: 'cb46e1c402ce481f6221512a0ad37a79b52feb99', class: "mdc-dialog__container" }, h("div", { key: '4aecff6699303e13bdaf17811a66f08d6478a3f2', class: "mdc-dialog__surface" }, h("input", { key: '722ccb246db135c965475e5090ae5d5390e9b4f6', type: "button", id: "initialFocusElement" }), this.renderHeading(), h("div", { key: 'f7ba5d2eaafdc6da575be3be83057e6e2792448f', class: "mdc-dialog__content", id: 'limel-dialog-content-' + this.id }, h("slot", { key: 'c35e9ad834b08b8ad032a4108f7fa5607e59b2e1' })), this.renderFooter())), h("div", { key: '55cbe15e4e45fe34b7e2232c218c1e534b7d7d31', class: "mdc-dialog__scrim" })));
+            }, role: "alertdialog", "aria-modal": "true", "aria-labelledby": 'limel-dialog-title-' + this.id, "aria-describedby": 'limel-dialog-content-' + this.id }, h("input", { key: 'f7a96d6e0f7086ac47791cb895bb78a296e23ec7', hidden: true, id: "initialFocusEl" }), h("div", { key: 'c0755b202346c3b6bcf257d94872c1fb81f49db5', class: "mdc-dialog__container" }, h("div", { key: '6ccc11dae44838539b2e1fa6a074c74a0b76364c', class: "mdc-dialog__surface" }, h("input", { key: 'ae6bdad52ac6e44f25fa0396797f0ec013d27ab9', type: "button", id: "initialFocusElement" }), this.renderHeading(), h("div", { key: '45e3b2e05bed5dc4c8039502b81ca2384821fe6f', class: "mdc-dialog__content", id: 'limel-dialog-content-' + this.id }, h("slot", { key: '64979e861d307be41993ace61a7b0c5a616a6e2c' })), this.renderFooter())), h("div", { key: '0b7c0e8c2d8f0cac26e926a685ba5c985db976f8', class: "mdc-dialog__scrim" })));
     }
     watchHandler(newValue, oldValue) {
         if (oldValue === newValue) {

package/dist/collection/components/dock/dock.js

@@ -79,11 +79,11 @@ export class Dock {
         this.resizeObserver.disconnect();
     }
     render() {
-        return (h(Host, { key: 'a91777f29921127c54eb5b0bc6998a7d1caabaec', class: {
+        return (h(Host, { key: '3a859df9c1fb4b56bb1ba18b846a2da353075b0f', class: {
                 dock: true,
                 expanded: this.expanded,
                 'has-mobile-layout': this.useMobileLayout,
-            } }, h("nav", { key: '4aa4ffb606964daa058b4f81aba420a3a62b1597', "aria-label": this.accessibleLabel }, this.dockItems.map(this.renderDockItem), this.renderSeparator(), this.dockFooterItems.map(this.renderDockItem)), this.renderExpandShrinkToggle()));
+            } }, h("nav", { key: '75303da2b5c8f86a4a6e1be7e76811e3dce8a303', "aria-label": this.accessibleLabel }, this.dockItems.map(this.renderDockItem), this.renderSeparator(), this.dockFooterItems.map(this.renderDockItem)), this.renderExpandShrinkToggle()));
     }
     renderExpandShrinkToggle() {
         if (this.useMobileLayout || !this.allowResize) {

package/dist/collection/components/drag-handle/drag-handle.js

@@ -51,7 +51,7 @@ export class DragHandleComponent {
     render() {
         const tooltipLabel = translate.get('drag-handle.drag-to-reorder', this.language);
         const ariaLabel = translate.get('drag-handle.drag-handle', this.language);
-        return (h(Host, { key: 'cdc2934af9efc0aa9cd9a10ca95512c6585d59bd' }, h("button", { key: '77523e84ce813eed4b31f66dcdba296de46d2dd9', "data-drag-handle": true, type: "button", class: "limel-drag-handle", tabindex: -1, "aria-label": ariaLabel, id: this.dragHandleId, onClick: this.handleClick }, h("div", { key: '02c38fbc191483c6b1e8197516c3d462e8a2d894', class: "drag-icon", role: "presentation", "aria-hidden": "true" }, h("div", { key: "1" }), h("div", { key: "2" }), h("div", { key: "3" }), h("div", { key: "4" }), h("div", { key: "5" }), h("div", { key: "6" })), h("limel-tooltip", { key: '4cf2b4324230fae2faa607e7cec9758b4850b587', openDirection: this.tooltipOpenDirection, elementId: this.dragHandleId, label: tooltipLabel }))));
+        return (h(Host, { key: 'e83ce402fe42d2b8f457e381ace449847333ddc2' }, h("button", { key: '56956b7efc28c4c72a5d2538026495055ed810ff', "data-drag-handle": true, type: "button", class: "limel-drag-handle", tabindex: -1, "aria-label": ariaLabel, id: this.dragHandleId, onClick: this.handleClick }, h("div", { key: 'e51e6c69aeef13b6edd48f46e12e830cfdd3016c', class: "drag-icon", role: "presentation", "aria-hidden": "true" }, h("div", { key: "1" }), h("div", { key: "2" }), h("div", { key: "3" }), h("div", { key: "4" }), h("div", { key: "5" }), h("div", { key: "6" })), h("limel-tooltip", { key: 'ca44d8fe5178e099976c41a517f95ebfff780bcf', openDirection: this.tooltipOpenDirection, elementId: this.dragHandleId, label: tooltipLabel }))));
     }
     static get is() { return "limel-drag-handle"; }
     static get originalStyleUrls() {

package/dist/collection/components/email-viewer/email-viewer.js

@@ -61,7 +61,7 @@ export class EmailViewer {
         }
     }
     render() {
-        return (h(Host, { key: 'a004af12989a477f4a9404ee86e0429bc5c2d427' }, h("div", { key: 'fc3bdeb81d823ff1cd39b4f6d52b4a88d9326392', class: "email", part: "email" }, this.renderHeaders(), this.renderRemoteImageBanner(), h("section", { key: '6fdd1cfe50cc4b41f7e70413541dc5950d7c44fa' }, this.renderAttachments(), this.renderBody()))));
+        return (h(Host, { key: 'b37cad79c4d85f9cef78ef741d882d5384c039db' }, h("div", { key: '89e9fa6c9c39234ec9268d93837f0b27f328d046', class: "email", part: "email" }, this.renderHeaders(), this.renderRemoteImageBanner(), h("section", { key: '01f4c97918464218bc0d4ab4e79214027993360d' }, this.renderAttachments(), this.renderBody()))));
     }
     renderHeaders() {
         const headerFields = [

package/dist/collection/components/file/file.js

@@ -89,7 +89,7 @@ export class File {
         };
     }
     render() {
-        return (h(Host, { key: '2de03c65bb1c1aba3d2bb09717cc45f3ef618ebc' }, h("limel-file-dropzone", { key: '8cb9d8dcbbe0ca9b667bfea72992a11a25f73fdb', disabled: this.disabled || this.readonly || !!this.value, accept: this.accept, onFilesSelected: this.handleNewFiles }, this.renderChipset()), this.renderDragAndDropTip()));
+        return (h(Host, { key: '09d8f61392d489c41a083edb516b680f481d7b55' }, h("limel-file-dropzone", { key: '36812196ad3a91ce98ec13df0e26927fbe67b4a4', disabled: this.disabled || this.readonly || !!this.value, accept: this.accept, onFilesSelected: this.handleNewFiles }, this.renderChipset()), this.renderDragAndDropTip()));
     }
     renderDragAndDropTip() {
         if (this.value || this.disabled || this.readonly) {

package/dist/collection/components/file-dropzone/file-dropzone.js

@@ -90,7 +90,7 @@ export class FileDropzone {
         };
     }
     render() {
-        return (h(Host, { key: '4a002d8108fcb9d87b3f063171e0a531de31c1b1', onDrop: this.handleDrop, onDragOver: this.handleDragOver, onDragLeave: this.handleDragLeave }, h("slot", { key: 'ed0aa907729aab6bee39bad7c6f9f74fc718e286' }), this.renderOnDragLayout()));
+        return (h(Host, { key: '70e5213cc5470868f2442b908d9ffd39466edbac', onDrop: this.handleDrop, onDragOver: this.handleDragOver, onDragLeave: this.handleDragLeave }, h("slot", { key: '4d886da6bfad382dc9c579ad17ea73d62ccdf1d3' }), this.renderOnDragLayout()));
     }
     static get is() { return "limel-file-dropzone"; }
     static get encapsulation() { return "shadow"; }

package/dist/collection/components/file-input/file-input.js

@@ -71,7 +71,7 @@ export class FileInput {
         this.fileInput = this.element.shadowRoot.getElementById(this.fileInputId);
     }
     render() {
-        return (h(Host, { key: '64b0de513357ed03fa7ae508ec6382acd600f392', onClick: this.handleClick, onKeyUp: this.handleKeyUp, onKeyDown: this.handleKeyDown }, h("input", { key: '0685cf5051c06e7e246631a38b349c2492dbb5b8', hidden: true, id: this.fileInputId, onChange: this.handleFileChange, type: "file", accept: this.accept, disabled: this.disabled, multiple: this.multiple }), h("slot", { key: 'da931d302eef5ed81663cce0b2d191166539a51d' })));
+        return (h(Host, { key: '4ec87952fba90e1fff07a60b977edd1980e33738', onClick: this.handleClick, onKeyUp: this.handleKeyUp, onKeyDown: this.handleKeyDown }, h("input", { key: '2fdc5fbb81294f85ad02a175b0720f53ad13c4f0', hidden: true, id: this.fileInputId, onChange: this.handleFileChange, type: "file", accept: this.accept, disabled: this.disabled, multiple: this.multiple }), h("slot", { key: 'd72890dd7c622c71e6b46217891d88f770607bda' })));
     }
     handleKeyDown(event) {
         if (event.code === 'Tab' ||

package/dist/collection/components/flex-container/flex-container.js

@@ -31,7 +31,7 @@ export class FlexContainer {
         console.warn('limel-flex-container is deprecated, please use CSS instead: https://developer.mozilla.org/en-US/docs/Web/CSS/CSS_Flexible_Box_Layout/Basic_Concepts_of_Flexbox');
     }
     render() {
-        return h("slot", { key: '7e8db5fb4b796ae12f76ae2684599226f1229928' });
+        return h("slot", { key: 'f308350023b1ced85d78be3fe3f2365cb30aeabd' });
     }
     static get is() { return "limel-flex-container"; }
     static get encapsulation() { return "shadow"; }

package/dist/collection/components/form/form.js

@@ -72,7 +72,7 @@ export class Form {
         }
     }
     render() {
-        return h("div", { key: 'd78a035d42497e4b3204d04bccc30b4956b128a1', class: "root" });
+        return h("div", { key: '338235611cd3fd70cb5f0ce1728917bd648cb573', class: "root" });
     }
     reactRender() {
         if (!this.root) {