@nldd/design-system 0.8.94 → 0.8.95

package/dist/components/content/blockquote/blockquote.styles.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"blockquote.styles.d.ts","sourceRoot":"","sources":["../../../../src/components/content/blockquote/blockquote.styles.ts"],"names":[],"mappings":"AAMA,eAAO,MAAM,gBAAgB,yBAoF5B,CAAC"}
+{"version":3,"file":"blockquote.styles.d.ts","sourceRoot":"","sources":["../../../../src/components/content/blockquote/blockquote.styles.ts"],"names":[],"mappings":"AAMA,eAAO,MAAM,gBAAgB,yBAqF5B,CAAC"}

package/dist/components/content/blockquote/blockquote.styles.js

@@ -48,6 +48,7 @@ export const blockquoteStyles = css `
 		flex-direction: column;
 		gap: calc(var(--_spacing) / 2);
 		color: var(--semantics-content-color);
+		text-wrap: pretty;
 	}
 
 

package/dist/components/content/blockquote/blockquote.styles.js.map

@@ -1 +1 @@
-{"version":3,"file":"blockquote.styles.js","sourceRoot":"","sources":["../../../../src/components/content/blockquote/blockquote.styles.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,GAAG,EAAE,SAAS,EAAE,MAAM,KAAK,CAAC;AACrC,OAAO,EAAE,WAAW,EAAE,MAAM,uCAAuC,CAAC;AACpE,OAAO,EAAE,YAAY,EAAE,kBAAkB,EAAE,MAAM,yCAAyC,CAAC;AAE3F,MAAM,KAAK,GAAG,SAAS,CAAC,WAAW,CAAC,KAAK,CAAC,CAAC;AAE3C,MAAM,CAAC,MAAM,gBAAgB,GAAG,GAAG,CAAA;;;;;;;;;;;;;uBAaZ,KAAK;;;;;;4CAMgB,KAAK;;;;;;IAM7C,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAmDlB,YAAY;IACZ,kBAAkB;;;;;;;CAOrB,CAAC"}
+{"version":3,"file":"blockquote.styles.js","sourceRoot":"","sources":["../../../../src/components/content/blockquote/blockquote.styles.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,GAAG,EAAE,SAAS,EAAE,MAAM,KAAK,CAAC;AACrC,OAAO,EAAE,WAAW,EAAE,MAAM,uCAAuC,CAAC;AACpE,OAAO,EAAE,YAAY,EAAE,kBAAkB,EAAE,MAAM,yCAAyC,CAAC;AAE3F,MAAM,KAAK,GAAG,SAAS,CAAC,WAAW,CAAC,KAAK,CAAC,CAAC;AAE3C,MAAM,CAAC,MAAM,gBAAgB,GAAG,GAAG,CAAA;;;;;;;;;;;;;uBAaZ,KAAK;;;;;;4CAMgB,KAAK;;;;;;IAM7C,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAoDlB,YAAY;IACZ,kBAAkB;;;;;;;CAOrB,CAAC"}

package/dist/components/{decorate-lwt_OrAG.js → decorate-CO88j7Lc.js}

@@ -1,4 +1,4 @@
-//#region \0@oxc-project+runtime@0.147.0/helpers/esm/decorate.js
+//#region \0@oxc-project+runtime@0.152.0/helpers/esm/decorate.js
 function __decorate(decorators, target, key, desc) {
 	var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
 	if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);

package/dist/components/{dist-M6GKopqu.js → dist-BWEAw34D.js}

@@ -1,4 +1,4 @@
-import { A as syntaxTree, C as indentNodeProp, M as styleTags, N as tags, W as EditorView, lt as EditorSelection, n as ExternalTokenizer, p as bracketMatchingHandle, r as LRParser, s as LRLanguage, t as ContextTracker, u as LanguageSupport, y as foldNodeProp } from "./dist-Dn3c5gfb.js";
+import { A as syntaxTree, C as indentNodeProp, M as styleTags, N as tags, W as EditorView, lt as EditorSelection, n as ExternalTokenizer, p as bracketMatchingHandle, r as LRParser, s as LRLanguage, t as ContextTracker, u as LanguageSupport, y as foldNodeProp } from "./dist-CpW8MF-L.js";
 //#region node_modules/@lezer/xml/dist/index.js
 var StartTag = 1;
 var StartCloseTag = 2;

package/dist/components/{dist-OlffRM7-.js → dist-BWRYv3Mp.js}

@@ -1,4 +1,4 @@
-import { C as indentNodeProp, M as styleTags, N as tags, g as delimitedIndent, n as ExternalTokenizer, r as LRParser, s as LRLanguage, t as ContextTracker, u as LanguageSupport, v as foldInside, y as foldNodeProp } from "./dist-Dn3c5gfb.js";
+import { C as indentNodeProp, M as styleTags, N as tags, g as delimitedIndent, n as ExternalTokenizer, r as LRParser, s as LRLanguage, t as ContextTracker, u as LanguageSupport, v as foldInside, y as foldNodeProp } from "./dist-CpW8MF-L.js";
 //#region node_modules/@lezer/yaml/dist/index.js
 var blockEnd = 63;
 var eof = 64;

package/dist/components/{dist-CSYXsT7W.js → dist-Bi4EHsFY.js}

@@ -1,5 +1,5 @@
-import { A as syntaxTree, C as indentNodeProp, M as styleTags, N as tags, P as IterMode, R as NodeWeakMap, g as delimitedIndent, n as ExternalTokenizer, r as LRParser, s as LRLanguage, t as ContextTracker, u as LanguageSupport, v as foldInside, y as foldNodeProp } from "./dist-Dn3c5gfb.js";
-import { a as ifNotIn, o as snippetCompletion, r as completeFromList } from "./dist-BUu-NW5O.js";
+import { A as syntaxTree, C as indentNodeProp, M as styleTags, N as tags, P as IterMode, R as NodeWeakMap, g as delimitedIndent, n as ExternalTokenizer, r as LRParser, s as LRLanguage, t as ContextTracker, u as LanguageSupport, v as foldInside, y as foldNodeProp } from "./dist-CpW8MF-L.js";
+import { a as ifNotIn, o as snippetCompletion, r as completeFromList } from "./dist-DTOshgo1.js";
 //#region node_modules/@lezer/python/dist/index.js
 var printKeyword = 1;
 var indent = 194;

package/dist/components/{dist-B5ie2Bo9.js → dist-C3uWRipu.js}

@@ -1,4 +1,4 @@
-import { C as indentNodeProp, M as styleTags, N as tags, m as continuedIndent, n as ExternalTokenizer, r as LRParser, s as LRLanguage, u as LanguageSupport, v as foldInside, y as foldNodeProp } from "./dist-Dn3c5gfb.js";
+import { C as indentNodeProp, M as styleTags, N as tags, m as continuedIndent, n as ExternalTokenizer, r as LRParser, s as LRLanguage, u as LanguageSupport, v as foldInside, y as foldNodeProp } from "./dist-CpW8MF-L.js";
 //#region node_modules/@lezer/rust/dist/index.js
 var closureParamDelim = 1;
 var tpOpen = 2;

package/dist/components/{dist-CoUVHSu-.js → dist-CH9m014O.js}

@@ -1,4 +1,4 @@
-import { C as indentNodeProp, M as styleTags, N as tags, m as continuedIndent, r as LRParser, s as LRLanguage, u as LanguageSupport, v as foldInside, y as foldNodeProp } from "./dist-Dn3c5gfb.js";
+import { C as indentNodeProp, M as styleTags, N as tags, m as continuedIndent, r as LRParser, s as LRLanguage, u as LanguageSupport, v as foldInside, y as foldNodeProp } from "./dist-CpW8MF-L.js";
 //#region node_modules/@lezer/json/dist/index.js
 var jsonHighlighting = styleTags({
 	String: tags.string,

package/dist/components/{dist-Dn3c5gfb.js → dist-CpW8MF-L.js}

@@ -2376,7 +2376,7 @@ var EditorState = class EditorState {
 				to: range.to,
 				insert: text
 			},
-			range: EditorSelection.cursor(range.from + text.length)
+			range: EditorSelection.cursor(range.from + text.length, -1)
 		}));
 	}
 	/**
@@ -4665,8 +4665,15 @@ function trivialOrder(length) {
 var movedOver = "";
 function moveVisually(line, order, dir, start, forward) {
 	var _a;
-	let startIndex = start.head - line.from;
-	let spanI = BidiSpan.find(order, startIndex, (_a = start.bidiLevel) !== null && _a !== void 0 ? _a : -1, start.assoc);
+	if (!line.length) return null;
+	let startIndex = start.head - line.from, spanI;
+	if (start.head == line.from && start.assoc < 0) {
+		if (!forward) return null;
+		startIndex = order[spanI = 0].side(false, dir);
+	} else if (start.head == line.to && start.assoc > 0) {
+		if (forward) return null;
+		startIndex = order[spanI = order.length - 1].side(true, dir);
+	} else spanI = BidiSpan.find(order, startIndex, (_a = start.bidiLevel) !== null && _a !== void 0 ? _a : -1, start.assoc);
 	let span = order[spanI], spanEnd = span.side(forward, dir);
 	if (startIndex == spanEnd) {
 		let nextI = spanI += forward ? 1 : -1;
@@ -4679,7 +4686,10 @@ function moveVisually(line, order, dir, start, forward) {
 	if (nextIndex < span.from || nextIndex > span.to) nextIndex = spanEnd;
 	movedOver = line.text.slice(Math.min(startIndex, nextIndex), Math.max(startIndex, nextIndex));
 	let nextSpan = spanI == (forward ? order.length - 1 : 0) ? null : order[spanI + (forward ? 1 : -1)];
-	if (nextSpan && nextIndex == spanEnd && nextSpan.level + (forward ? 0 : 1) < span.level) return EditorSelection.cursor(nextSpan.side(!forward, dir) + line.from, nextSpan.forward(forward, dir) ? 1 : -1, nextSpan.level);
+	if (nextIndex == spanEnd) {
+		if (!nextSpan) return forward ? EditorSelection.cursor(line.to, 1) : EditorSelection.cursor(line.from, -1);
+		if (nextSpan.level + (forward ? 0 : 1) < span.level) return EditorSelection.cursor(nextSpan.side(!forward, dir) + line.from, nextSpan.forward(forward, dir) ? 1 : -1, nextSpan.level);
+	}
 	return EditorSelection.cursor(nextIndex + line.from, span.forward(forward, dir) ? -1 : 1, span.level);
 }
 function autoDirection(text, from, to) {
@@ -6699,8 +6709,6 @@ function moveToLineBoundary(view, start, forward, includeWrap) {
 		});
 		if (pos != null) return EditorSelection.cursor(pos, forward ? -1 : 1);
 	}
-	let line = view.state.doc.lineAt(start.head);
-	if (forward ? line.to == block.to : line.from == block.from) return view.visualLineSide(line, forward);
 	return EditorSelection.cursor(forward ? block.to : block.from, forward ? -1 : 1);
 }
 function moveByChar(view, start, forward, by) {
@@ -6713,7 +6721,7 @@ function moveByChar(view, start, forward, by) {
 			char = "\n";
 			line = view.state.doc.line(line.number + (forward ? 1 : -1));
 			spans = view.bidiSpans(line);
-			next = view.visualLineSide(line, !forward);
+			next = forward ? EditorSelection.cursor(line.from, -1) : EditorSelection.cursor(line.to, 1);
 		}
 		if (!check) {
 			if (!by) return next;
@@ -7312,7 +7320,7 @@ function selectionPoints(view) {
 function selectionFromPoints(points, base) {
 	if (points.length == 0) return null;
 	let anchor = points[0].pos, head = points.length == 2 ? points[1].pos : anchor;
-	return anchor > -1 && head > -1 ? EditorSelection.single(anchor + base, head + base) : null;
+	return anchor < 0 || head < 0 ? null : anchor == head ? EditorSelection.create([EditorSelection.cursor(head + base, -1)]) : EditorSelection.single(anchor + base, head + base);
 }
 function sameSelPos(selection, range) {
 	return range.head == selection.main.head && range.anchor == selection.main.anchor;
@@ -7406,12 +7414,14 @@ var InputState = class {
 				shiftKey: event.shiftKey
 			};
 			if (mods.shiftKey && browser.ios && !/^(off|none)$/.test(this.view.contentDOM.autocapitalize) && iosVirtualKeyboardOpen(this.view.win)) mods.shiftKey = false;
-			this.pendingIOSKey = {
+			let pending = this.pendingIOSKey = {
 				key: event.key,
 				keyCode: event.keyCode,
 				mods
 			};
-			setTimeout(() => this.flushIOSKey(), 50);
+			setTimeout(() => {
+				if (this.pendingIOSKey == pending) this.flushIOSKey();
+			}, 50);
 			return true;
 		}
 		if (event.keyCode != 229) this.view.observer.forceFlush();
@@ -7673,7 +7683,7 @@ function doPaste(view, input) {
 					from: line.from,
 					insert
 				},
-				range: EditorSelection.cursor(range.from + insert.length)
+				range: EditorSelection.cursor(range.from + insert.length, -1)
 			};
 		});
 	} else if (byLine) changes = state.changeByRange((range) => {
@@ -7684,7 +7694,7 @@ function doPaste(view, input) {
 				to: range.to,
 				insert: line.text
 			},
-			range: EditorSelection.cursor(range.from + line.length)
+			range: EditorSelection.cursor(range.from + line.length, -1)
 		};
 	});
 	else changes = state.replaceSelection(text);
@@ -8283,12 +8293,12 @@ var HeightMap = class HeightMap {
 			let next = nodes[--j];
 			if (next) after += next.size;
 		}
-		let brk = 0;
+		let brk = false;
 		if (nodes[i - 1] == null) {
-			brk = 1;
+			brk = true;
 			i--;
 		} else if (nodes[i] == null) {
-			brk = 1;
+			brk = true;
 			j++;
 		}
 		return new HeightMapBranch(HeightMap.of(nodes.slice(0, i)), brk, HeightMap.of(nodes.slice(j)));
@@ -8487,7 +8497,7 @@ var HeightMapGap = class HeightMapGap extends HeightMap {
 };
 var HeightMapBranch = class extends HeightMap {
 	constructor(left, brk, right) {
-		super(left.length + brk + right.length, left.height + right.height, brk | (left.outdated || right.outdated ? 2 : 0));
+		super(left.length + (brk ? 1 : 0) + right.length, left.height + right.height, (brk ? 1 : 0) | (left.outdated || right.outdated ? 2 : 0));
 		this.left = left;
 		this.right = right;
 		this.size = left.size + right.size;
@@ -8515,9 +8525,9 @@ var HeightMapBranch = class extends HeightMap {
 			if (to >= rightOffset) this.right.forEachLine(from, to, oracle, rightTop, rightOffset, f);
 		} else {
 			let mid = this.lineAt(rightOffset, QueryType.ByPos, oracle, top, offset);
-			if (from < mid.from) this.left.forEachLine(from, mid.from - 1, oracle, top, offset, f);
+			if (from < mid.from) this.left.forEachLine(from, Math.min(to, mid.from - 1), oracle, top, offset, f);
 			if (mid.to >= from && mid.from <= to) f(mid);
-			if (to > mid.to) this.right.forEachLine(mid.to + 1, to, oracle, rightTop, rightOffset, f);
+			if (to > mid.to) this.right.forEachLine(Math.max(from, mid.to + 1), to, oracle, rightTop, rightOffset, f);
 		}
 	}
 	replace(from, to, nodes) {
@@ -10642,15 +10652,11 @@ var EditorView = class EditorView {
 		return skipAtoms(this, start, moveByChar(this, start, forward, (initial) => byGroup(this, start.head, initial)));
 	}
 	/**
-	Get the cursor position visually at the start or end of a line.
-	Note that this may differ from the _logical_ position at its
-	start or end (which is simply at `line.from`/`line.to`) if text
-	at the start or end goes against the line's base text direction.
+	**\[DEPRECATED]** Get the cursor position visually at the start
+	or end of a line.
 	*/
 	visualLineSide(line, end) {
-		let order = this.bidiSpans(line), dir = this.textDirectionAt(line.from);
-		let span = order[end ? order.length - 1 : 0];
-		return EditorSelection.cursor(span.side(end, dir) + line.from, span.forward(!end, dir) ? 1 : -1);
+		return end ? EditorSelection.cursor(line.to, 1) : EditorSelection.cursor(line.from, -1);
 	}
 	/**
 	Move to the next line boundary in the given direction. If
@@ -10719,6 +10725,15 @@ var EditorView = class EditorView {
 		this.readMeasured();
 		let line = this.state.doc.lineAt(pos), order = this.bidiSpans(line);
 		let span = order[BidiSpan.find(order, pos - line.from, -1, side)];
+		if (line.length && (pos == line.from && side < 0 || pos == line.to && side > 0) && span.dir != this.textDirectionAt(line.from)) {
+			if (pos == line.to) {
+				pos = line.from + span.from;
+				side = 1;
+			} else {
+				pos = line.from + span.to;
+				side = -1;
+			}
+		}
 		return this.docView.coordsAt(pos, side, span.dir == Direction.RTL);
 	}
 	/**
@@ -14661,7 +14676,7 @@ function styleTags(spec) {
 var ruleNodeProp = new NodeProp({ combine(a, b) {
 	let cur, root, take;
 	while (a || b) {
-		if (!a || b && a.depth >= b.depth) {
+		if (!a || b && a.depth <= b.depth) {
 			take = b;
 			b = b.next;
 		} else {
@@ -14844,7 +14859,7 @@ and necessarily incomplete. A full ontology of syntactic
 constructs would fill a stack of books, and be impractical to
 write themes for. So try to make do with this set. If all else
 fails, [open an
-issue](https://github.com/codemirror/codemirror.next) to propose a
+issue](https://code.haverbeke.berlin/codemirror/dev/issues) to propose a
 new tag, or [define](#highlight.Tag^define) a local custom tag for
 your use case.
 

package/dist/components/{dist-RPaf2J9c.js → dist-CvL6_ezZ.js}

@@ -1,5 +1,5 @@
-import { A as syntaxTree, C as indentNodeProp, M as styleTags, N as tags, m as continuedIndent, n as ExternalTokenizer, r as LRParser, s as LRLanguage, u as LanguageSupport, y as foldNodeProp } from "./dist-Dn3c5gfb.js";
-import { a as ifNotIn, r as completeFromList } from "./dist-BUu-NW5O.js";
+import { A as syntaxTree, C as indentNodeProp, M as styleTags, N as tags, m as continuedIndent, n as ExternalTokenizer, r as LRParser, s as LRLanguage, u as LanguageSupport, y as foldNodeProp } from "./dist-CpW8MF-L.js";
+import { a as ifNotIn, r as completeFromList } from "./dist-DTOshgo1.js";
 //#region node_modules/@codemirror/lang-sql/dist/index.js
 var whitespace = 36;
 var LineComment = 1;

package/dist/components/{dist-CGOykrJw.js → dist-DMHTTJRJ.js}

@@ -1,6 +1,6 @@
 import { t as __exportAll } from "./rolldown-runtime-D7D4PA-g.js";
-import { A as syntaxTree, C as indentNodeProp, M as styleTags, N as tags, O as sublanguageProp, P as IterMode, R as NodeWeakMap, W as EditorView, _ as flatIndent, g as delimitedIndent, h as defineLanguageFacet, i as LocalTokenGroup, lt as EditorSelection, m as continuedIndent, n as ExternalTokenizer, r as LRParser, s as LRLanguage, t as ContextTracker, u as LanguageSupport, v as foldInside, y as foldNodeProp } from "./dist-Dn3c5gfb.js";
-import { a as ifNotIn, o as snippetCompletion, r as completeFromList } from "./dist-BUu-NW5O.js";
+import { A as syntaxTree, C as indentNodeProp, M as styleTags, N as tags, O as sublanguageProp, P as IterMode, R as NodeWeakMap, W as EditorView, _ as flatIndent, g as delimitedIndent, h as defineLanguageFacet, i as LocalTokenGroup, lt as EditorSelection, m as continuedIndent, n as ExternalTokenizer, r as LRParser, s as LRLanguage, t as ContextTracker, u as LanguageSupport, v as foldInside, y as foldNodeProp } from "./dist-CpW8MF-L.js";
+import { a as ifNotIn, o as snippetCompletion, r as completeFromList } from "./dist-DTOshgo1.js";
 //#region node_modules/@lezer/javascript/dist/index.js
 var noSemi = 316;
 var noSemiType = 317;

package/dist/components/{dist-BUu-NW5O.js → dist-DTOshgo1.js}

@@ -1,4 +1,4 @@
-import { A as syntaxTree, H as Decoration, K as ViewPlugin, Q as keymap, St as combineConfig, T as indentUnit, Tt as fromCodePoint, U as Direction, W as EditorView, Z as getTooltip, _t as StateField, at as Annotation, bt as codePointAt, dt as Facet, ft as MapMode, gt as StateEffect, ht as RangeValue, lt as EditorSelection, pt as Prec, q as WidgetType, rt as showTooltip, tt as logException, vt as Text, xt as codePointSize, yt as Transaction } from "./dist-Dn3c5gfb.js";
+import { A as syntaxTree, H as Decoration, K as ViewPlugin, Q as keymap, St as combineConfig, T as indentUnit, Tt as fromCodePoint, U as Direction, W as EditorView, Z as getTooltip, _t as StateField, at as Annotation, bt as codePointAt, dt as Facet, ft as MapMode, gt as StateEffect, ht as RangeValue, lt as EditorSelection, pt as Prec, q as WidgetType, rt as showTooltip, tt as logException, vt as Text, xt as codePointSize, yt as Transaction } from "./dist-CpW8MF-L.js";
 //#region node_modules/@codemirror/autocomplete/dist/index.js
 /**
 An instance of this is passed to completion source functions.

package/dist/components/{dist-Dxn9Up8K.js → dist-DV6Mp5N1.js}

@@ -1,7 +1,7 @@
 import { t as __exportAll } from "./rolldown-runtime-D7D4PA-g.js";
-import { A as syntaxTree, C as indentNodeProp, M as styleTags, N as tags, V as parseMixed, W as EditorView, lt as EditorSelection, n as ExternalTokenizer, p as bracketMatchingHandle, r as LRParser, s as LRLanguage, t as ContextTracker, u as LanguageSupport, y as foldNodeProp } from "./dist-Dn3c5gfb.js";
-import { n as cssLanguage, t as css } from "./dist-CQzaKTa8.js";
-import { a as tsxLanguage, i as jsxLanguage, n as javascript, o as typescriptLanguage, r as javascriptLanguage } from "./dist-CGOykrJw.js";
+import { A as syntaxTree, C as indentNodeProp, M as styleTags, N as tags, V as parseMixed, W as EditorView, lt as EditorSelection, n as ExternalTokenizer, p as bracketMatchingHandle, r as LRParser, s as LRLanguage, t as ContextTracker, u as LanguageSupport, y as foldNodeProp } from "./dist-CpW8MF-L.js";
+import { n as cssLanguage, t as css } from "./dist-PlhQXXtE.js";
+import { a as tsxLanguage, i as jsxLanguage, n as javascript, o as typescriptLanguage, r as javascriptLanguage } from "./dist-DMHTTJRJ.js";
 //#region node_modules/@lezer/html/dist/index.js
 var scriptText = 55;
 var StartCloseScriptTag = 1;

package/dist/components/{dist-CQzaKTa8.js → dist-PlhQXXtE.js}

@@ -1,5 +1,5 @@
 import { t as __exportAll } from "./rolldown-runtime-D7D4PA-g.js";
-import { A as syntaxTree, C as indentNodeProp, M as styleTags, N as tags$1, P as IterMode, R as NodeWeakMap, i as LocalTokenGroup, m as continuedIndent, n as ExternalTokenizer, r as LRParser, s as LRLanguage, u as LanguageSupport, v as foldInside, y as foldNodeProp } from "./dist-Dn3c5gfb.js";
+import { A as syntaxTree, C as indentNodeProp, M as styleTags, N as tags$1, P as IterMode, R as NodeWeakMap, i as LocalTokenGroup, m as continuedIndent, n as ExternalTokenizer, r as LRParser, s as LRLanguage, u as LanguageSupport, v as foldInside, y as foldNodeProp } from "./dist-CpW8MF-L.js";
 //#region node_modules/@lezer/css/dist/index.js
 var descendantOp = 148;
 var Unit = 1;

package/dist/components/{icon-DWNVcttg.js → icon-Typdp4av.js}

@@ -1,5 +1,5 @@
 import { t as __exportAll } from "./rolldown-runtime-D7D4PA-g.js";
-import { t as __decorate } from "./decorate-lwt_OrAG.js";
+import { t as __decorate } from "./decorate-CO88j7Lc.js";
 import { t as reflectNonDefault } from "./reflect-non-default-OLaK60rT.js";
 import { LitElement, css, html } from "lit";
 import { customElement, property, state } from "lit/decorators.js";

package/dist/components/{icon-button-DHzLMmj0.js → icon-button-9mo3oIyL.js}

@@ -1,8 +1,8 @@
 import { t as inheritedTextReset } from "./shadow-resets-aG-rgyNQ.js";
-import { i as linkRel, r as translate, t as withTranslations } from "./with-translations-Dt2DTXJF.js";
-import { t as __decorate } from "./decorate-lwt_OrAG.js";
+import { i as linkRel, r as translate, t as withTranslations } from "./with-translations-C8_0-9y8.js";
+import { t as __decorate } from "./decorate-CO88j7Lc.js";
 import { t as reflectNonDefault } from "./reflect-non-default-OLaK60rT.js";
-import "./icon-DWNVcttg.js";
+import "./icon-Typdp4av.js";
 import { r as isTouchMode } from "./input-modality-DhTeUxKi.js";
 import { LitElement, css, html, nothing } from "lit";
 import { customElement, property, state } from "lit/decorators.js";
@@ -1498,8 +1498,7 @@ var nlddIconButtonTranslations = { "components.icon-button.opens-in-new-tab-labe
 *
 * @fires click - When button is clicked (not fired when disabled)
 */
-var _NLDDIconButton;
-var NLDDIconButton = (_NLDDIconButton = class NLDDIconButton extends withTranslations(LitElement, nlddIconButtonTranslations) {
+var _NLDDIconButton = class NLDDIconButton extends withTranslations(LitElement, nlddIconButtonTranslations) {
 	constructor(..._args) {
 		super(..._args);
 		this._internals = this.attachInternals();
@@ -1571,7 +1570,8 @@ var NLDDIconButton = (_NLDDIconButton = class NLDDIconButton extends withTransla
 	render() {
 		return template.call(this);
 	}
-}, _NLDDIconButton.styles = iconButtonStyles, _NLDDIconButton.formAssociated = true, _NLDDIconButton);
+};
+var NLDDIconButton = (_NLDDIconButton.styles = iconButtonStyles, _NLDDIconButton.formAssociated = true, _NLDDIconButton);
 __decorate([property({
 	reflect: true,
 	converter: reflectNonDefault("neutral-tinted")

package/dist/components/lists-and-tables/cells/timeline-track-cell/timeline-track-cell.d.ts

@@ -18,7 +18,7 @@
  * @attr {'past' | 'current' | 'future'} status - How far along this row is (default 'past'); the same values as `nldd-step-indicator-item`. It colors the dot and the track around it: covered above where you are, still ahead below
  * @attr {'sm' | 'md'} size - How wide the lane is and so how big the dot: `sm` (default, 16px) for a timeline of events, `md` (24px) where a number or an icon has to fit. Every row in one list takes the same size, or the track jumps
  * @attr {'down' | 'up'} direction - The direction the timeline moves forward in: `down` (default) puts the past above, `up` below. Only the current step has half a track, so this only has an effect there
- * @attr {'first' | 'between' | 'last' | 'only'} position - Place in the series (default 'between'): decides whether the line continues above the dot, below it, or on both sides. `only` is the single row in the series and gets a line on neither side: a track of one dot leads nowhere. On a `level="none"` row, which is nothing but line, `only` leaves it out altogether: the track ends above it
+ * @attr {'first' | 'between' | 'last' | 'only'} position - Place of the row in the list as it stands on screen (default 'between'): decides whether the line continues above the dot, below it, or on both sides. `first` is the top row and only has a line below, `last` the bottom row and only has a line above, also with `direction="up"`: position is about where the row stands, `direction` about which way time runs. `only` is the single row in the series and gets a line on neither side: a track of one dot leads nowhere. On a `level="none"` row, which is nothing but line, `only` leaves it out altogether: the track ends above it
  * @attr {'auto' | 'top' | 'bottom' | 'both' | 'none'} line - Which halves of the track you have covered, when `status` and `direction` get it wrong (default 'auto', which is what those two say). The halves you name are drawn as covered and the other one as still ahead, so `none` covers neither. Which halves are drawn at all stays with `position`, except that naming a half draws it: `line="both"` on a `first` row draws one above too. A row that opens a group of its own is the case for `both`, since the going carries on below it. A `level="none"` row has one line rather than two halves, and no point where a fill could change over, so there the status colors the whole of it and `line` overrules the whole of it. On a `current` row that leans the way the timeline runs: what belongs to a point usually comes after it, so going `down` the stretch reads as still ahead and going `up` as behind you
  * @attr {string} text - Number or short text in the dot
  * @attr {string} icon - Icon name in the dot; wins over `text`

package/dist/components/lists-and-tables/cells/timeline-track-cell/timeline-track-cell.js

@@ -24,7 +24,7 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
  * @attr {'past' | 'current' | 'future'} status - How far along this row is (default 'past'); the same values as `nldd-step-indicator-item`. It colors the dot and the track around it: covered above where you are, still ahead below
  * @attr {'sm' | 'md'} size - How wide the lane is and so how big the dot: `sm` (default, 16px) for a timeline of events, `md` (24px) where a number or an icon has to fit. Every row in one list takes the same size, or the track jumps
  * @attr {'down' | 'up'} direction - The direction the timeline moves forward in: `down` (default) puts the past above, `up` below. Only the current step has half a track, so this only has an effect there
- * @attr {'first' | 'between' | 'last' | 'only'} position - Place in the series (default 'between'): decides whether the line continues above the dot, below it, or on both sides. `only` is the single row in the series and gets a line on neither side: a track of one dot leads nowhere. On a `level="none"` row, which is nothing but line, `only` leaves it out altogether: the track ends above it
+ * @attr {'first' | 'between' | 'last' | 'only'} position - Place of the row in the list as it stands on screen (default 'between'): decides whether the line continues above the dot, below it, or on both sides. `first` is the top row and only has a line below, `last` the bottom row and only has a line above, also with `direction="up"`: position is about where the row stands, `direction` about which way time runs. `only` is the single row in the series and gets a line on neither side: a track of one dot leads nowhere. On a `level="none"` row, which is nothing but line, `only` leaves it out altogether: the track ends above it
  * @attr {'auto' | 'top' | 'bottom' | 'both' | 'none'} line - Which halves of the track you have covered, when `status` and `direction` get it wrong (default 'auto', which is what those two say). The halves you name are drawn as covered and the other one as still ahead, so `none` covers neither. Which halves are drawn at all stays with `position`, except that naming a half draws it: `line="both"` on a `first` row draws one above too. A row that opens a group of its own is the case for `both`, since the going carries on below it. A `level="none"` row has one line rather than two halves, and no point where a fill could change over, so there the status colors the whole of it and `line` overrules the whole of it. On a `current` row that leans the way the timeline runs: what belongs to a point usually comes after it, so going `down` the stretch reads as still ahead and going `up` as behind you
  * @attr {string} text - Number or short text in the dot
  * @attr {string} icon - Icon name in the dot; wins over `text`

package/dist/components/navigation/top-navigation-bar/top-navigation-bar.styles.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"top-navigation-bar.styles.d.ts","sourceRoot":"","sources":["../../../../src/components/navigation/top-navigation-bar/top-navigation-bar.styles.ts"],"names":[],"mappings":"AASA,eAAO,MAAM,sBAAsB,yBAsblC,CAAC"}
+{"version":3,"file":"top-navigation-bar.styles.d.ts","sourceRoot":"","sources":["../../../../src/components/navigation/top-navigation-bar/top-navigation-bar.styles.ts"],"names":[],"mappings":"AASA,eAAO,MAAM,sBAAsB,yBAoclC,CAAC"}

package/dist/components/navigation/top-navigation-bar/top-navigation-bar.styles.js

@@ -102,7 +102,9 @@ export const topNavigationBarStyles = css `
 		justify-content: center;
 	}
 
-	@supports (animation-timeline: scroll()) {
+	/* WebKit only: Chrome paints nothing above the page and leaves the fixed
+	   ::after behind, so a hard pull shows a gap between it and the logo. */
+	@supports (animation-timeline: scroll()) and (font: -apple-system-body) {
 		.top-navigation-bar__logo {
 			position: relative;
 		}
@@ -176,10 +178,22 @@ export const topNavigationBarStyles = css `
 		grid-column: 2;
 	}
 
+	/* The link spans the wordmark's whole track so the ribbon stays centered;
+	   only the ribbon and the text take the click, not the space beside them. */
 	a.top-navigation-bar__logo-and-wordmark {
+		pointer-events: none;
 		text-decoration: none;
 	}
 
+	a.top-navigation-bar__logo-and-wordmark > .top-navigation-bar__logo,
+	a.top-navigation-bar__logo-and-wordmark .top-navigation-bar__wordmark-content > p {
+		pointer-events: auto;
+	}
+
+	a.top-navigation-bar__logo-and-wordmark .top-navigation-bar__wordmark-content > p {
+		width: fit-content;
+	}
+
 	a.top-navigation-bar__logo-and-wordmark:focus-visible {
 		outline: none;
 	}

package/dist/components/navigation/top-navigation-bar/top-navigation-bar.styles.js.map

@@ -1 +1 @@
-{"version":3,"file":"top-navigation-bar.styles.js","sourceRoot":"","sources":["../../../../src/components/navigation/top-navigation-bar/top-navigation-bar.styles.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,GAAG,EAAE,SAAS,EAAE,MAAM,KAAK,CAAC;AACrC,OAAO,EAAE,WAAW,EAAE,MAAM,uCAAuC,CAAC;AACpE,OAAO,EAAE,kBAAkB,EAAE,MAAM,yCAAyC,CAAC;AAE7E,MAAM,KAAK,GAAG,SAAS,CAAC,WAAW,CAAC,KAAK,CAAC,CAAC;AAC3C,MAAM,KAAK,GAAG,SAAS,CAAC,WAAW,CAAC,KAAK,CAAC,CAAC;AAC3C,MAAM,KAAK,GAAG,SAAS,CAAC,WAAW,CAAC,KAAK,CAAC,CAAC;AAC3C,MAAM,KAAK,GAAG,SAAS,CAAC,WAAW,CAAC,KAAK,CAAC,CAAC;AAE3C,MAAM,CAAC,MAAM,sBAAsB,GAAG,GAAG,CAAA;;;;;;;;;;;;;;;;IAgBrC,kBAAkB;;;;;;;;;;;;;;;;;;;2BAmBK,KAAK;;;;2BAIL,KAAK,qBAAqB,KAAK;;;;2BAI/B,KAAK;;;;;;;;;;;;;2BAaL,KAAK;;;;2BAIL,KAAK,qBAAqB,KAAK;;;;2BAI/B,KAAK;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2BA4IL,KAAK;;;;;;;;;;;;2BAYL,KAAK;;;;;;;;;;;;;;;;;;;;;;2BAsBL,KAAK;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2BAiCL,KAAK;;;;2BAIL,KAAK,qBAAqB,KAAK;;;;;;2BAM/B,KAAK;;;;;;;;;;;;;2BAaL,KAAK;;;;2BAIL,KAAK;;;;;;;;;;;2BAWL,KAAK;;;;;;;;;;;;;;;;;2BAiBL,KAAK;;;;2BAIL,KAAK;;;;2BAIL,KAAK;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2BAoCL,KAAK;;;;;2BAKL,KAAK;;;;;;;;;;;;;2BAaL,KAAK;;;;;2BAKL,KAAK;;;;;;;;;;;;;2BAaL,KAAK;;;;;;;;;;;;2BAYL,KAAK;;;;;;;;;;;;;;;;;;;;CAoB/B,CAAC"}
+{"version":3,"file":"top-navigation-bar.styles.js","sourceRoot":"","sources":["../../../../src/components/navigation/top-navigation-bar/top-navigation-bar.styles.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,GAAG,EAAE,SAAS,EAAE,MAAM,KAAK,CAAC;AACrC,OAAO,EAAE,WAAW,EAAE,MAAM,uCAAuC,CAAC;AACpE,OAAO,EAAE,kBAAkB,EAAE,MAAM,yCAAyC,CAAC;AAE7E,MAAM,KAAK,GAAG,SAAS,CAAC,WAAW,CAAC,KAAK,CAAC,CAAC;AAC3C,MAAM,KAAK,GAAG,SAAS,CAAC,WAAW,CAAC,KAAK,CAAC,CAAC;AAC3C,MAAM,KAAK,GAAG,SAAS,CAAC,WAAW,CAAC,KAAK,CAAC,CAAC;AAC3C,MAAM,KAAK,GAAG,SAAS,CAAC,WAAW,CAAC,KAAK,CAAC,CAAC;AAE3C,MAAM,CAAC,MAAM,sBAAsB,GAAG,GAAG,CAAA;;;;;;;;;;;;;;;;IAgBrC,kBAAkB;;;;;;;;;;;;;;;;;;;2BAmBK,KAAK;;;;2BAIL,KAAK,qBAAqB,KAAK;;;;2BAI/B,KAAK;;;;;;;;;;;;;2BAaL,KAAK;;;;2BAIL,KAAK,qBAAqB,KAAK;;;;2BAI/B,KAAK;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2BA0JL,KAAK;;;;;;;;;;;;2BAYL,KAAK;;;;;;;;;;;;;;;;;;;;;;2BAsBL,KAAK;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2BAiCL,KAAK;;;;2BAIL,KAAK,qBAAqB,KAAK;;;;;;2BAM/B,KAAK;;;;;;;;;;;;;2BAaL,KAAK;;;;2BAIL,KAAK;;;;;;;;;;;2BAWL,KAAK;;;;;;;;;;;;;;;;;2BAiBL,KAAK;;;;2BAIL,KAAK;;;;2BAIL,KAAK;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2BAoCL,KAAK;;;;;2BAKL,KAAK;;;;;;;;;;;;;2BAaL,KAAK;;;;;2BAKL,KAAK;;;;;;;;;;;;;2BAaL,KAAK;;;;;;;;;;;;2BAYL,KAAK;;;;;;;;;;;;;;;;;;;;CAoB/B,CAAC"}

package/dist/components/status-and-feedback/step-indicator/step-indicator.d.ts

@@ -5,9 +5,15 @@
  * number (or a check mark on what is done), a label under each and a line
  * connecting them.
  *
- * The parent holds the truth: `current` (1-based) derives the status of every
- * child — `past` before it, `future` after. A child can override that with a
- * `status` of its own, for flows that jump back or skip a step.
+ * Mark the step you are on with `status="current"`. The parent derives the
+ * rest from its position: `past` before it, `future` after. With none marked,
+ * step 1 is current. With more than one, the last one wins and a warning goes
+ * to the console in a dev build: a flow that forgets to clear the previous
+ * step still points at the furthest one. A `status="past"` or
+ * `status="future"` on another step overrides what is derived for that step,
+ * for flows that jump back or skip a step. One attribute, the same three
+ * values as `nldd-timeline-track-cell`, so a flow reads in one vocabulary
+ * whether it runs across or down.
  *
  * Horizontal only. For steps under each other, build an `nldd-list` with an
  * `nldd-timeline-track-cell` and an `nldd-title-cell` per row: vertical steps
@@ -27,18 +33,14 @@
  *
  * @attr {string} accessible-label - Name of the nav; defaults to the i18n value ("Voortgang")
  * @attr {object} translations - Override translation keys; unset keys fall back to Dutch
- * @attr {number} current - 1-based number of the current step (default 1)
  *
  * @slot - `nldd-step-indicator-item` children
  *
  * @example
  * ```html
- * <nldd-step-indicator
- * 	current="2"
- * 	accessible-label="Voortgang aanvraag"
- * >
+ * <nldd-step-indicator accessible-label="Voortgang aanvraag">
  *   <nldd-step-indicator-item text="Gegevens"></nldd-step-indicator-item>
- *   <nldd-step-indicator-item text="Controle"></nldd-step-indicator-item>
+ *   <nldd-step-indicator-item text="Controle" status="current"></nldd-step-indicator-item>
  *   <nldd-step-indicator-item text="Bevestigen"></nldd-step-indicator-item>
  * </nldd-step-indicator>
  * ```
@@ -49,16 +51,17 @@ import '../../content/icon/icon.js';
  *  single vocabulary whether it runs horizontally or vertically. */
 export type StepIndicatorStatus = 'past' | 'current' | 'future';
 /**
- * One step in an `nldd-step-indicator`. The parent decides the status and the
- * number; those live here as internal state rather than as public API, except
- * for `status`, which overrides what `current` derives.
+ * One step in an `nldd-step-indicator`. `status="current"` marks the step you
+ * are on; the parent derives the status of the others and the number of each,
+ * which live here as internal state rather than as public API. `past` and
+ * `future` override what is derived for this step.
  *
  * @element nldd-step-indicator-item
  *
- * @attr {string} status - `past` | `current` | `future`; overrides what the parent derives
- * @attr {string} text   - Label under the disc
- * @attr {string} icon   - Icon in the disc instead of the number or the check mark
- * @attr {string} href   - Makes the step a link (back to a completed step, for instance)
+ * @attr {'past' | 'current' | 'future'} status - How far along this step is. `current` marks the step you are on (`aria-current="step"`) and the parent derives the others from it: with none marked step 1 is current, with more than one the last wins. `past` and `future` override what is derived for this step only
+ * @attr {string} text - Label under the disc
+ * @attr {string} icon - Icon in the disc instead of the number or the check mark
+ * @attr {string} href - Makes the step a link (back to a completed step, for instance)
  * @attr {boolean} button - Makes the step a button, for flows without a URL per step; ignored when `href` is set
  *
  * @slot - Label (an alternative to `text`)
@@ -78,7 +81,10 @@ export declare class NLDDStepIndicatorItem extends LitElement {
     _derivedStatus: StepIndicatorStatus;
     _index: number;
     _statusText: string;
-    /** The status that counts: the item's own wins over the derived one. */
+    /** The status that counts. An own `past` or `future` wins over the derived
+     *  one. An own `current` is what the parent derives from, so the derived
+     *  status already says it, and on a step that lost to a later one it does not
+     *  hold. */
     get resolvedStatus(): StepIndicatorStatus;
     connectedCallback(): void;
     updated(changed: PropertyValues): void;
@@ -97,23 +103,32 @@ declare const NLDDStepIndicator_base: (abstract new (...args: any[]) => LitEleme
 export declare class NLDDStepIndicator extends NLDDStepIndicator_base {
     static styles: import("lit").CSSResult;
     accessibleLabel: string;
-    current: number;
     /** The steps, tracked so the compact view (text + bar) is driven by the same
      *  source as the row of markers. */
     _items: NLDDStepIndicatorItem[];
     get total(): number;
-    /** The current step, clamped to the number of steps: an out-of-range
-     *  `current` would otherwise mark every step past (or none at all). */
+    /** 1-based position of the last item with `status="current"`, or 1 when none has it. */
     get resolvedCurrent(): number;
     get currentItem(): NLDDStepIndicatorItem | undefined;
+    /** `status` lives on the children, so a change there has to reach this
+     *  element: the derived statuses and the compact view follow it. */
+    private _observer;
+    private _warnedMultipleCurrent;
+    connectedCallback(): void;
+    /** `current` is no longer an attribute of this element. Watched anyway, so a
+     *  leftover one gets a hint, also when a framework sets it after the first
+     *  render: Vue and React fall back to the attribute for an unknown property. */
+    static get observedAttributes(): string[];
+    attributeChangedCallback(name: string, old: string | null, value: string | null): void;
+    disconnectedCallback(): void;
     _onSlotChange: (e: Event) => void;
     /** Before render, not after: the compact view reads the current item back out
      *  of the children, so their statuses have to be fresh by the time this
      *  element renders. */
     willUpdate(changed: PropertyValues): void;
+    private _warnOnMultipleCurrent;
     /** Push position, derived status and status text down to the children. Push
-     *  rather than pull: a child reading its own parent has no way of knowing
-     *  when `current` changes. */
+     *  rather than pull: a child cannot see where the current step sits. */
     private _syncItems;
     render(): import("lit-html").TemplateResult;
 }

package/dist/components/status-and-feedback/step-indicator/step-indicator.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"step-indicator.d.ts","sourceRoot":"","sources":["../../../../src/components/status-and-feedback/step-indicator/step-indicator.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4CG;AACH,OAAO,EAAE,UAAU,EAAE,KAAK,cAAc,EAAE,MAAM,KAAK,CAAC;AAOtD,OAAO,4BAA4B,CAAC;AAEpC;oEACoE;AACpE,MAAM,MAAM,mBAAmB,GAAG,MAAM,GAAG,SAAS,GAAG,QAAQ,CAAC;AAKhE;;;;;;;;;;;;;;GAcG;AACH,qBAAa,qBAAsB,SAAQ,UAAU;IACpD,OAAgB,MAAM,0BAA2B;IAGjD,MAAM,CAAC,EAAE,mBAAmB,CAAC;IAG7B,IAAI,SAAM;IAGV,IAAI,SAAM;IAGV,IAAI,SAAM;IAEV;;yDAEqD;IAErD,MAAM,UAAS;IAEf;uEACmE;IAEnE,cAAc,EAAE,mBAAmB,CAAY;IAG/C,MAAM,SAAK;IAGX,WAAW,SAAM;IAEjB,wEAAwE;IACxE,IAAI,cAAc,IAAI,mBAAmB,CAExC;IAEQ,iBAAiB,IAAI,IAAI;IAOzB,OAAO,CAAC,OAAO,EAAE,cAAc,GAAG,IAAI;IAQtC,MAAM;CAGf;;;;;;;;;;;AAYD,qBACa,iBAAkB,SAAQ,sBAGtC;IACA,OAAgB,MAAM,0BAAuB;IAG7C,eAAe,SAAM;IAGrB,OAAO,SAAK;IAEZ;wCACoC;IAEpC,MAAM,EAAE,qBAAqB,EAAE,CAAM;IAErC,IAAI,KAAK,IAAI,MAAM,CAElB;IAED;2EACuE;IACvE,IAAI,eAAe,IAAI,MAAM,CAG5B;IAED,IAAI,WAAW,IAAI,qBAAqB,GAAG,SAAS,CAGnD;IAED,aAAa,GAAI,GAAG,KAAK,KAAG,IAAI,CAI9B;IAEF;;2BAEuB;IACd,UAAU,CAAC,OAAO,EAAE,cAAc,GAAG,IAAI;IAOlD;;kCAE8B;IAC9B,OAAO,CAAC,UAAU;IAUT,MAAM;CAGf;AAED,OAAO,CAAC,MAAM,CAAC;IACd,UAAU,qBAAqB;QAC9B,qBAAqB,EAAE,iBAAiB,CAAC;QACzC,0BAA0B,EAAE,qBAAqB,CAAC;KAClD;CACD"}
+{"version":3,"file":"step-indicator.d.ts","sourceRoot":"","sources":["../../../../src/components/status-and-feedback/step-indicator/step-indicator.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8CG;AACH,OAAO,EAAE,UAAU,EAAE,KAAK,cAAc,EAAE,MAAM,KAAK,CAAC;AAOtD,OAAO,4BAA4B,CAAC;AAEpC;oEACoE;AACpE,MAAM,MAAM,mBAAmB,GAAG,MAAM,GAAG,SAAS,GAAG,QAAQ,CAAC;AAKhE;;;;;;;;;;;;;;;GAeG;AACH,qBAAa,qBAAsB,SAAQ,UAAU;IACpD,OAAgB,MAAM,0BAA2B;IAGjD,MAAM,CAAC,EAAE,mBAAmB,CAAC;IAG7B,IAAI,SAAM;IAGV,IAAI,SAAM;IAGV,IAAI,SAAM;IAEV;;yDAEqD;IAErD,MAAM,UAAS;IAEf;uEACmE;IAEnE,cAAc,EAAE,mBAAmB,CAAY;IAG/C,MAAM,SAAK;IAGX,WAAW,SAAM;IAEjB;;;gBAGY;IACZ,IAAI,cAAc,IAAI,mBAAmB,CAExC;IAEQ,iBAAiB,IAAI,IAAI;IAOzB,OAAO,CAAC,OAAO,EAAE,cAAc,GAAG,IAAI;IAQtC,MAAM;CAGf;;;;;;;;;;;AAYD,qBACa,iBAAkB,SAAQ,sBAGtC;IACA,OAAgB,MAAM,0BAAuB;IAG7C,eAAe,SAAM;IAErB;wCACoC;IAEpC,MAAM,EAAE,qBAAqB,EAAE,CAAM;IAErC,IAAI,KAAK,IAAI,MAAM,CAElB;IAED,wFAAwF;IACxF,IAAI,eAAe,IAAI,MAAM,CAG5B;IAED,IAAI,WAAW,IAAI,qBAAqB,GAAG,SAAS,CAGnD;IAED;wEACoE;IACpE,OAAO,CAAC,SAAS,CAAoD;IAErE,OAAO,CAAC,sBAAsB,CAAS;IAE9B,iBAAiB,IAAI,IAAI;IAKlC;;oFAEgF;IAChF,WAAoB,kBAAkB,IAAI,MAAM,EAAE,CAEjD;IAEQ,wBAAwB,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,GAAG,IAAI,EAAE,KAAK,EAAE,MAAM,GAAG,IAAI,GAAG,IAAI;IAOtF,oBAAoB,IAAI,IAAI;IAKrC,aAAa,GAAI,GAAG,KAAK,KAAG,IAAI,CAI9B;IAEF;;2BAEuB;IACd,UAAU,CAAC,OAAO,EAAE,cAAc,GAAG,IAAI;IAQlD,OAAO,CAAC,sBAAsB;IAS9B;4EACwE;IACxE,OAAO,CAAC,UAAU;IAUT,MAAM;CAGf;AAED,OAAO,CAAC,MAAM,CAAC;IACd,UAAU,qBAAqB;QAC9B,qBAAqB,EAAE,iBAAiB,CAAC;QACzC,0BAA0B,EAAE,qBAAqB,CAAC;KAClD;CACD"}