@pgcorp/ui-kit 0.10.0 → 0.10.2

package/dist/src/internal/codeEditorExtensions.js

@@ -0,0 +1,14 @@
+import { inject as e, provide as t } from "vue";
+//#region src/internal/codeEditorExtensions.ts
+var n = Symbol("sputnig-ui-kit-trusted-code-editor-extensions");
+function r(e, r) {
+	t(n, {
+		owner: e,
+		extensions: r
+	});
+}
+function i() {
+	return e(n, null);
+}
+//#endregion
+export { r as provideTrustedCodeEditorExtensions, i as useTrustedCodeEditorExtensions };

package/dist/src/internal/codeHighlight.d.ts

@@ -0,0 +1,11 @@
+import { CodeEditorLanguageContract } from './codeEditorContract';
+export type CodeHighlightToken = string | {
+    readonly scope: string | null;
+    readonly children: readonly CodeHighlightToken[];
+};
+export declare function isCodeHighlightLanguageSupported(language: CodeEditorLanguageContract): boolean;
+/** Returns trusted library markup only for the legacy sanitized-document pipeline. */
+export declare function highlightCodeToHtml(code: string, language: CodeEditorLanguageContract): string;
+/** Converts the Highlight.js emitter boundary into a closed, validated token tree without HTML rendering. */
+export declare function highlightCodeToTokens(code: string, language: CodeEditorLanguageContract): readonly CodeHighlightToken[];
+export declare function highlightScopeClass(scope: string): string;

package/dist/src/internal/codeHighlight.js

@@ -0,0 +1,71 @@
+import { resolveCodeLanguageKey as e } from "./codeLanguageIdentity.js";
+import t from "highlight.js/lib/core";
+import n from "highlight.js/lib/languages/bash";
+import r from "highlight.js/lib/languages/dockerfile";
+import i from "highlight.js/lib/languages/javascript";
+import a from "highlight.js/lib/languages/makefile";
+import o from "highlight.js/lib/languages/nginx";
+import s from "highlight.js/lib/languages/powershell";
+import c from "highlight.js/lib/languages/python";
+import l from "highlight.js/lib/languages/typescript";
+import u from "highlight.js/lib/languages/xml";
+import d from "highlight.js/lib/languages/yaml";
+//#region src/internal/codeHighlight.ts
+var f = {
+	shell: "bash",
+	text: "plaintext"
+}, p = /^[a-z][a-z0-9_.-]*$/u;
+t.registerLanguage("bash", n), t.registerLanguage("dockerfile", r), t.registerLanguage("javascript", i), t.registerLanguage("makefile", a), t.registerLanguage("nginx", o), t.registerLanguage("powershell", s), t.registerLanguage("python", c), t.registerLanguage("typescript", l), t.registerLanguage("xml", u), t.registerLanguage("yaml", d);
+function m(e) {
+	return e.replace(/&/gu, "&amp;").replace(/</gu, "&lt;").replace(/>/gu, "&gt;").replace(/"/gu, "&quot;").replace(/'/gu, "&#39;");
+}
+function h(t) {
+	let n = e(t);
+	return f[n] ?? n;
+}
+function g(e) {
+	return typeof e == "object" && !!e && !Array.isArray(e);
+}
+function _(e, t) {
+	if (typeof e == "string") return e;
+	if (!g(e)) throw TypeError(`codeHighlight: ${t} must be a token node or string.`);
+	let n = Object.keys(e).filter((e) => ![
+		"scope",
+		"children",
+		"language"
+	].includes(e));
+	if (n.length > 0) throw TypeError(`codeHighlight: ${t} contains unknown fields ${n.join(", ")}.`);
+	let r = e.scope;
+	if (r !== void 0 && (typeof r != "string" || !p.test(r))) throw TypeError(`codeHighlight: ${t}.scope is invalid.`);
+	if (!Array.isArray(e.children)) throw TypeError(`codeHighlight: ${t}.children must be an array.`);
+	return Object.freeze({
+		scope: r ?? null,
+		children: Object.freeze(e.children.map((e, n) => _(e, `${t}.children[${n}]`)))
+	});
+}
+function v(e, n) {
+	let r = h(n);
+	return t.getLanguage(r) ? t.highlight(e, {
+		language: r,
+		ignoreIllegals: !0
+	}) : null;
+}
+function y(e) {
+	return !!t.getLanguage(h(e));
+}
+function b(e, t) {
+	return v(e, t)?.value ?? m(e);
+}
+function x(e, t) {
+	let n = v(e, t);
+	if (n === null) return Object.freeze([e]);
+	let r = _(Reflect.get(n._emitter, "root"), "root");
+	if (typeof r == "string") throw TypeError("codeHighlight: emitter root must be a token node.");
+	return r.children;
+}
+function S(e) {
+	if (!p.test(e)) throw TypeError(`codeHighlight: invalid scope ${JSON.stringify(e)}.`);
+	return `hljs-${e.replace(/\./gu, "_")}`;
+}
+//#endregion
+export { b as highlightCodeToHtml, x as highlightCodeToTokens, S as highlightScopeClass, y as isCodeHighlightLanguageSupported };

package/dist/src/internal/codeLanguageIdentity.d.ts

@@ -0,0 +1,6 @@
+import { CodeEditorLanguageContract } from './codeEditorContract';
+/**
+ * Разрешает стабильную language identity без загрузки editor/highlighter runtime.
+ * Resolves stable language identity without loading editor or highlighter runtime.
+ */
+export declare function resolveCodeLanguageKey(input: CodeEditorLanguageContract): string;

package/dist/src/internal/codeLanguageIdentity.js

@@ -0,0 +1,70 @@
+import { validateCodeEditorLanguage as e } from "./codeEditorContract.js";
+//#region src/internal/codeLanguageIdentity.ts
+var t = {
+	"cmakelists.txt": "cmake",
+	dockerfile: "dockerfile",
+	"docker-compose.yml": "yaml",
+	"docker-compose.yaml": "yaml",
+	"compose.yml": "yaml",
+	"compose.yaml": "yaml",
+	".env": "properties",
+	".env.example": "properties",
+	".env.local": "properties",
+	".env.development": "properties",
+	".env.production": "properties",
+	makefile: "makefile",
+	"nginx.conf": "nginx"
+}, n = {
+	bash: "shell",
+	"c#": "cs",
+	csharp: "cs",
+	env: "properties",
+	fish: "shell",
+	handlebars: "handlebars",
+	htm: "html",
+	js: "javascript",
+	jsonc: "json",
+	json5: "json",
+	log: "text",
+	make: "makefile",
+	md: "markdown",
+	mk: "makefile",
+	plaintext: "text",
+	proto3: "proto",
+	ps1: "powershell",
+	psm1: "powershell",
+	psd1: "powershell",
+	py: "python",
+	pyw: "python",
+	pyi: "python",
+	rbw: "ruby",
+	sh: "shell",
+	shellsession: "shell",
+	ts: "typescript",
+	text: "text",
+	txt: "text",
+	yaml: "yaml",
+	yml: "yaml",
+	zsh: "shell"
+};
+function r(e) {
+	if (!e) return null;
+	let t = e.trim().toLowerCase().replace(/^\./u, "");
+	return t ? n[t] ?? t : null;
+}
+function i(e) {
+	if (!e) return null;
+	let n = e.trim().toLowerCase();
+	if (!n) return null;
+	let i = n.split("/").pop() ?? n, a = t[i];
+	return a === void 0 ? i.startsWith("dockerfile.") ? "dockerfile" : i.includes(".") ? r(i.split(".").pop()) : null : a;
+}
+function a(t) {
+	let r = e("codeLanguages", t);
+	if (r.mode === "explicit") return n[r.id] ?? r.id;
+	let a = i(r.filePath);
+	if (a !== null) return a;
+	throw RangeError(`codeLanguages: невозможно определить язык по filePath ${JSON.stringify(r.filePath)}. / codeLanguages: cannot detect a language from filePath ${JSON.stringify(r.filePath)}.`);
+}
+//#endregion
+export { a as resolveCodeLanguageKey };

package/dist/src/internal/diffEngine.d.ts

@@ -0,0 +1,7 @@
+import { SDiffComputationOptions, SDiffResult, SDiffSource } from '../components/shared/data-display/diff';
+export type DiffCancellationProbe = () => boolean;
+export declare class DiffEngineCancelledError extends Error {
+    constructor();
+}
+/** Pure deterministic engine used by both direct computation and the module worker. */
+export declare function computeDiffModel(beforeSource: SDiffSource, afterSource: SDiffSource, options: Required<SDiffComputationOptions>, isCancelled?: DiffCancellationProbe): SDiffResult;

package/dist/src/internal/diffEngine.js

@@ -0,0 +1,231 @@
+//#region src/internal/diffEngine.ts
+var e = class extends Error {
+	constructor() {
+		super("Diff computation was cancelled."), this.name = "DiffEngineCancelledError";
+	}
+}, t = 1024, n = class {
+	constructor(e) {
+		this.isCancelled = e, this.operations = 0;
+	}
+	check(n = !1) {
+		if (this.operations += 1, (n || this.operations % t === 0) && this.isCancelled?.() === !0) throw new e();
+	}
+};
+function r(e) {
+	if (e.length === 0) return Object.freeze([]);
+	let t = [], n = 0;
+	for (let r = 0; r < e.length; r += 1) {
+		if (e[r] !== "\n") continue;
+		let i = r > n && e[r - 1] === "\r";
+		t.push(Object.freeze({
+			text: e.slice(n, i ? r - 1 : r),
+			lineBreak: i ? "crlf" : "lf"
+		})), n = r + 1;
+	}
+	return n < e.length && t.push(Object.freeze({
+		text: e.slice(n),
+		lineBreak: "none"
+	})), Object.freeze(t);
+}
+function i(e, t) {
+	return e.text === t.text && e.lineBreak === t.lineBreak;
+}
+function a(e, t, n, r, a) {
+	for (let o = t; o < n; o += 1) if (a.check(), i(e[o], r)) return o;
+	return -1;
+}
+function o(e, t, n) {
+	for (let r = t; r < n; r += 1) e.push({
+		kind: "removed",
+		beforeIndex: r
+	});
+}
+function s(e, t, n) {
+	for (let r = t; r < n; r += 1) e.push({
+		kind: "added",
+		afterIndex: r
+	});
+}
+function c(e, t, n, r) {
+	for (let i = 0; i < r; i += 1) e.push({
+		kind: "unchanged",
+		beforeIndex: t + i,
+		afterIndex: n + i
+	});
+}
+function l(e, t, n, r, a, o, s) {
+	let c = n - t, l = o - a, u = Math.ceil((c + l) / 2), d = u, f = u * 2 + 1, p = new Int32Array(f), m = new Int32Array(f);
+	p.fill(-1), m.fill(-1), p[d + 1] = 0, m[d + 1] = 0;
+	let h = c - l, g = h % 2 != 0, _ = 0, v = 0, y = 0, b = 0;
+	for (let x = 0; x < u; x += 1) {
+		s.check(!0);
+		for (let n = -x + _; n <= x - v; n += 2) {
+			let o = d + n, u = n === -x || n !== x && p[o - 1] < p[o + 1] ? p[o + 1] : p[o - 1] + 1, y = u - n;
+			for (; u < c && y < l && i(e[t + u], r[a + y]);) s.check(), u += 1, y += 1;
+			if (p[o] = u, u > c) v += 2;
+			else if (y > l) _ += 2;
+			else if (g) {
+				let e = d + (h - n);
+				if (e >= 0 && e < f && m[e] !== -1 && u >= c - m[e]) return {
+					before: t + u,
+					after: a + y
+				};
+			}
+		}
+		for (let u = -x + y; u <= x - b; u += 2) {
+			let _ = d + u, v = u === -x || u !== x && m[_ - 1] < m[_ + 1] ? m[_ + 1] : m[_ - 1] + 1, S = v - u;
+			for (; v < c && S < l && i(e[n - v - 1], r[o - S - 1]);) s.check(), v += 1, S += 1;
+			if (m[_] = v, v > c) b += 2;
+			else if (S > l) y += 2;
+			else if (!g) {
+				let e = h - u, n = d + e;
+				if (n >= 0 && n < f && p[n] !== -1 && p[n] >= c - v) {
+					let r = t + p[n];
+					return {
+						before: r,
+						after: a + r - t - e
+					};
+				}
+			}
+		}
+	}
+	return null;
+}
+function u(e, t, n, r, d, f, p, m) {
+	m.check(!0);
+	let h = t, g = d;
+	for (; h < n && g < f && i(e[h], r[g]);) m.check(), p.push({
+		kind: "unchanged",
+		beforeIndex: h,
+		afterIndex: g
+	}), h += 1, g += 1;
+	let _ = n, v = f, y = 0;
+	for (; h < _ && g < v && i(e[_ - 1], r[v - 1]);) m.check(), --_, --v, y += 1;
+	let b = _ - h, x = v - g;
+	if (b === 0) s(p, g, v);
+	else if (x === 0) o(p, h, _);
+	else if (b === 1) {
+		let t = a(r, g, v, e[h], m);
+		t === -1 ? (o(p, h, _), s(p, g, v)) : (s(p, g, t), c(p, h, t, 1), s(p, t + 1, v));
+	} else if (x === 1) {
+		let t = a(e, h, _, r[g], m);
+		t === -1 ? (o(p, h, _), s(p, g, v)) : (o(p, h, t), c(p, t, g, 1), o(p, t + 1, _));
+	} else {
+		let t = l(e, h, _, r, g, v, m);
+		t === null || t.before === h && t.after === g || t.before === _ && t.after === v ? (o(p, h, _), s(p, g, v)) : (u(e, h, t.before, r, g, t.after, p, m), u(e, t.before, _, r, t.after, v, p, m));
+	}
+	c(p, _, v, y);
+}
+function d(e, t) {
+	return Object.freeze({
+		lineNumber: t,
+		text: e.text,
+		lineBreak: e.lineBreak
+	});
+}
+function f(e, t, n) {
+	return Object.freeze(n.map((n) => {
+		let r = n.beforeIndex, i = n.afterIndex, a = r === void 0 ? void 0 : d(e[r], r + 1), o = i === void 0 ? void 0 : d(t[i], i + 1), s = r === void 0 ? "-" : String(r + 1), c = i === void 0 ? "-" : String(i + 1);
+		return Object.freeze({
+			id: `line:${n.kind}:${s}:${c}`,
+			kind: n.kind,
+			...a === void 0 ? {} : { before: a },
+			...o === void 0 ? {} : { after: o }
+		});
+	}));
+}
+function p(e) {
+	let t = new Int32Array(e.length + 1), n = new Int32Array(e.length + 1);
+	for (let r = 0; r < e.length; r += 1) t[r + 1] = t[r] + (e[r].before === void 0 ? 0 : 1), n[r + 1] = n[r] + (e[r].after === void 0 ? 0 : 1);
+	return {
+		before: t,
+		after: n
+	};
+}
+function m(e, t) {
+	let n = [];
+	if (e.forEach((e, t) => {
+		e.kind !== "unchanged" && n.push(t);
+	}), n.length === 0) return {
+		hunks: Object.freeze([]),
+		gaps: Object.freeze([])
+	};
+	let r = [];
+	for (let i of n) {
+		let n = Math.max(0, i - t), a = Math.min(e.length, i + t + 1), o = r[r.length - 1];
+		o !== void 0 && n <= o.end ? o.end = Math.max(o.end, a) : r.push({
+			start: n,
+			end: a
+		});
+	}
+	let i = p(e), a = r.map((e) => Object.freeze({
+		id: `hunk:${i.before[e.start] + 1}:${i.after[e.start] + 1}`,
+		lineStart: e.start,
+		lineEnd: e.end,
+		beforeStart: i.before[e.start] + 1,
+		beforeLineCount: i.before[e.end] - i.before[e.start],
+		afterStart: i.after[e.start] + 1,
+		afterLineCount: i.after[e.end] - i.after[e.start]
+	})), o = [], s = 0;
+	for (let e of r) {
+		if (e.start > s) {
+			let t = e.start - s;
+			o.push(Object.freeze({
+				id: `gap:${i.before[s] + 1}:${i.after[s] + 1}:${t}`,
+				lineStart: s,
+				lineEnd: e.start,
+				beforeStart: i.before[s] + 1,
+				afterStart: i.after[s] + 1,
+				lineCount: t
+			}));
+		}
+		s = e.end;
+	}
+	if (s < e.length) {
+		let t = e.length - s;
+		o.push(Object.freeze({
+			id: `gap:${i.before[s] + 1}:${i.after[s] + 1}:${t}`,
+			lineStart: s,
+			lineEnd: e.length,
+			beforeStart: i.before[s] + 1,
+			afterStart: i.after[s] + 1,
+			lineCount: t
+		}));
+	}
+	return {
+		hunks: Object.freeze(a),
+		gaps: Object.freeze(o)
+	};
+}
+function h(e, t) {
+	return Object.freeze({
+		lineCount: t,
+		...e.label === void 0 ? {} : { label: e.label },
+		...e.revision === void 0 ? {} : { revision: e.revision },
+		...e.language === void 0 ? {} : { language: e.language }
+	});
+}
+function g(e, t, i, a) {
+	let o = new n(a);
+	o.check(!0);
+	let s = r(e.text), c = r(t.text), l = [];
+	u(s, 0, s.length, c, 0, c.length, l, o), o.check(!0);
+	let d = f(s, c, l), { hunks: p, gaps: g } = m(d, i.contextLines), _ = d.filter((e) => e.kind === "unchanged").length, v = d.filter((e) => e.kind === "removed").length, y = d.filter((e) => e.kind === "added").length;
+	return Object.freeze({
+		before: h(e, s.length),
+		after: h(t, c.length),
+		lines: d,
+		hunks: p,
+		gaps: g,
+		summary: Object.freeze({
+			beforeLineCount: s.length,
+			afterLineCount: c.length,
+			unchangedLineCount: _,
+			removedLineCount: v,
+			addedLineCount: y,
+			changedLineCount: v + y
+		})
+	});
+}
+//#endregion
+export { e as DiffEngineCancelledError, g as computeDiffModel };

package/dist/src/internal/diffRuntime.d.ts

@@ -0,0 +1,23 @@
+import { SDiffComputationOptions, SDiffResult, SDiffSource } from '../components/shared/data-display/diff';
+import { SDiffWorkerRequest } from '../workers/diffProtocol';
+export declare const S_DIFF_WORKER_TEXT_THRESHOLD = 32768;
+export declare const S_DIFF_WORKER_LINE_THRESHOLD = 1200;
+export interface SDiffWorkerLike {
+    postMessage(message: SDiffWorkerRequest): void;
+    addEventListener(type: 'message', listener: (event: MessageEvent<unknown>) => void): void;
+    addEventListener(type: 'error', listener: (event: ErrorEvent) => void): void;
+    removeEventListener(type: 'message', listener: (event: MessageEvent<unknown>) => void): void;
+    removeEventListener(type: 'error', listener: (event: ErrorEvent) => void): void;
+    terminate(): void;
+}
+export type SDiffWorkerFactory = () => SDiffWorkerLike;
+export interface SDiffRuntime {
+    compute(before: SDiffSource, after: SDiffSource, options?: SDiffComputationOptions, signal?: AbortSignal): Promise<SDiffResult>;
+    dispose(): void;
+}
+export declare class SDiffComputationCancelledError extends Error {
+    constructor(message?: string);
+}
+export declare function shouldUseDiffWorker(before: SDiffSource, after: SDiffSource): boolean;
+/** Creates an instance-owned worker runtime. Disposal cancels every retained computation resource. */
+export declare function createDiffRuntime(workerFactory?: SDiffWorkerFactory): SDiffRuntime;

package/dist/src/internal/diffRuntime.js

@@ -0,0 +1,102 @@
+import { computeDiff as e, validateDiffComputationOptions as t, validateDiffSource as n } from "../components/shared/data-display/diff.js";
+import { validateDiffWorkerResponse as r } from "../workers/diffProtocol.js";
+//#region src/internal/diffRuntime.ts
+var i = 32768, a = 1200, o = class extends Error {
+	constructor(e = "Diff computation was cancelled.") {
+		super(e), this.name = "SDiffComputationCancelledError";
+	}
+};
+function s(e) {
+	if (e.length === 0) return 0;
+	let t = +!e.endsWith("\n");
+	for (let n of e) n === "\n" && (t += 1);
+	return t;
+}
+function c(e, t) {
+	return e.text.length + t.text.length >= 32768 || s(e.text) + s(t.text) >= 1200;
+}
+function l() {
+	return new Worker(new URL(
+		/* @vite-ignore */
+		new URL("../../assets/diff.worker-Da8jAqQb.js", import.meta.url).href,
+		"" + import.meta.url
+	), {
+		type: "module",
+		name: "s-ui-kit-diff"
+	});
+}
+function u(i = l) {
+	let a = 0, s = !1, u = /* @__PURE__ */ new Map(), d = (e, t, n, s) => {
+		let c = `diff-request-${a += 1}`, l = i();
+		return new Promise((i, a) => {
+			let d = !1, f = () => {
+				s?.removeEventListener("abort", m), l.removeEventListener("message", g), l.removeEventListener("error", h), l.terminate(), u.delete(c);
+			}, p = (e) => {
+				if (!d) {
+					d = !0;
+					try {
+						l.postMessage({
+							version: 1,
+							type: "cancel",
+							requestId: c
+						});
+					} catch (e) {
+						f(), a(e);
+						return;
+					}
+					f(), a(new o(e));
+				}
+			}, m = () => p("Diff computation was aborted."), h = (e) => {
+				d || (d = !0, f(), a(/* @__PURE__ */ Error(`Diff worker failed: ${e.message}`)));
+			}, g = (e) => {
+				if (d) return;
+				let t;
+				try {
+					t = r(e.data);
+				} catch (e) {
+					d = !0, f(), a(e);
+					return;
+				}
+				if (t.requestId !== c) {
+					d = !0, f(), a(/* @__PURE__ */ Error(`Diff worker returned requestId ${JSON.stringify(t.requestId)} for active ${JSON.stringify(c)}.`));
+					return;
+				}
+				if (d = !0, f(), t.type === "result") i(t.result);
+				else if (t.type === "cancelled") a(new o());
+				else {
+					let e = Error(t.error.message);
+					e.name = t.error.name, a(e);
+				}
+			};
+			u.set(c, { cancel: p }), s?.addEventListener("abort", m, { once: !0 }), l.addEventListener("message", g), l.addEventListener("error", h);
+			try {
+				l.postMessage({
+					version: 1,
+					type: "compute",
+					requestId: c,
+					before: e,
+					after: t,
+					options: n
+				});
+			} catch (e) {
+				d = !0, f(), a(e);
+			}
+		});
+	};
+	return Object.freeze({
+		async compute(r, i, a, l) {
+			if (s) throw Error("Diff runtime is disposed.");
+			if (l?.aborted === !0) throw new o("Diff computation was aborted.");
+			let u = n("SDiffRuntime", "before", r), f = n("SDiffRuntime", "after", i), p = t("SDiffRuntime", a);
+			return c(u, f) ? d(u, f, p, l) : e(u, f, p);
+		},
+		dispose() {
+			if (!s) {
+				s = !0;
+				for (let e of [...u.values()]) e.cancel("Diff runtime was disposed.");
+			}
+		}
+	});
+}
+//#endregion
+export { o as SDiffComputationCancelledError, a as S_DIFF_WORKER_LINE_THRESHOLD, i as S_DIFF_WORKER_TEXT_THRESHOLD, u as createDiffRuntime, c as shouldUseDiffWorker };

package/dist/src/internal/es2020.d.ts

@@ -0,0 +1,16 @@
+/** Проверяет собственное свойство без зависимости от ES2022 Object.hasOwn. / Checks an own property without the ES2022 Object.hasOwn API. */
+export declare function hasOwn(object: object, key: PropertyKey): boolean;
+/** Возвращает последний элемент без зависимости от ES2022 Array.at. / Returns the last item without the ES2022 Array.at API. */
+export declare function lastItem<T>(items: readonly T[]): T | undefined;
+/** Ошибка с ES2022-compatible cause, доступная в ES2020 runtime. / An ES2022-compatible error cause for ES2020 runtimes. */
+export type ErrorWithCause<T extends Error = Error> = T & {
+    cause: unknown;
+};
+/** Добавляет стандартный non-enumerable cause без требования ES2022 lib. / Adds the standard non-enumerable cause without requiring the ES2022 lib. */
+export declare function withErrorCause<T extends Error>(error: T, cause: unknown): ErrorWithCause<T>;
+interface AggregateErrorLike extends Error {
+    readonly errors: readonly unknown[];
+}
+/** Создаёт native AggregateError при наличии и точный ES2020 fallback иначе. / Creates a native AggregateError when available and an exact ES2020 fallback otherwise. */
+export declare function createAggregateError(errors: readonly unknown[], message: string): AggregateErrorLike;
+export {};

package/dist/src/internal/es2020.js

@@ -0,0 +1,25 @@
+//#region src/internal/es2020.ts
+function e(e, t) {
+	return Object.prototype.hasOwnProperty.call(e, t);
+}
+function t(e) {
+	return e.length > 0 ? e[e.length - 1] : void 0;
+}
+function n(e, t) {
+	return Object.defineProperty(e, "cause", {
+		configurable: !0,
+		value: t,
+		writable: !0
+	}), e;
+}
+var r = class extends Error {
+	constructor(e, t) {
+		super(t), this.name = "AggregateError", this.errors = [...e];
+	}
+};
+function i(e, t) {
+	let n = globalThis.AggregateError;
+	return typeof n == "function" ? new n(e, t) : new r(e, t);
+}
+//#endregion
+export { i as createAggregateError, e as hasOwn, t as lastItem, n as withErrorCause };

package/dist/src/internal/feedbackPresentation.d.ts

@@ -0,0 +1,52 @@
+import { Component } from 'vue';
+import { UiKitTranslate } from '../locales/locale';
+export type FeedbackTone = 'neutral' | 'info' | 'success' | 'warn' | 'danger';
+export type FeedbackSeverity = Exclude<FeedbackTone, 'neutral'>;
+export type FeedbackLiveMode = 'off' | 'polite' | 'assertive' | 'auto';
+export type AsyncFeedbackStatus = 'loading' | 'empty' | 'error';
+export type FeedbackIndicatorState = FeedbackTone | 'progress';
+export interface FeedbackPresentation {
+    icon: Component;
+    iconName: 'info' | 'check-circle' | 'alert-triangle' | 'x-circle';
+    fallbackTitle: string;
+}
+export interface FeedbackLiveAttributes {
+    role?: 'status' | 'alert';
+    ariaLive?: 'polite' | 'assertive';
+    ariaAtomic?: 'true';
+}
+export interface AsyncFeedbackPresentation {
+    readonly tone: FeedbackTone;
+    readonly icon: Component | null;
+    readonly iconName: FeedbackPresentation['iconName'] | 'loader-circle' | null;
+    readonly fallbackMessage: string;
+    readonly busy: boolean;
+    readonly live: Readonly<FeedbackLiveAttributes>;
+}
+export interface FeedbackIndicatorPresentation {
+    readonly tone: FeedbackTone;
+    readonly icon: Component;
+    readonly iconName: FeedbackPresentation['iconName'] | 'loader-circle';
+    readonly fallbackTitle: string;
+    readonly motion: 'static' | 'spin';
+}
+/**
+ * Возвращает единую icon/title-презентацию для feedback tone.
+ * Returns the canonical icon/title presentation for a feedback tone.
+ */
+export declare function resolveFeedbackPresentation(tone: FeedbackTone, t?: UiKitTranslate): Readonly<FeedbackPresentation>;
+/**
+ * Возвращает единственный icon/tone/motion contract для status indicator.
+ * Returns the canonical icon/tone/motion contract for a status indicator.
+ */
+export declare function resolveFeedbackIndicator(state: FeedbackIndicatorState, t?: UiKitTranslate): Readonly<FeedbackIndicatorPresentation>;
+/**
+ * Выражает live-region contract без привязки к визуальному компоненту.
+ * Resolves live-region semantics independently from a visual component.
+ */
+export declare function resolveFeedbackLive(tone: FeedbackTone, mode: FeedbackLiveMode): Readonly<FeedbackLiveAttributes>;
+/**
+ * Возвращает единый визуальный и live-region contract для async surface state.
+ * Returns the canonical visual and live-region contract for an async surface state.
+ */
+export declare function resolveAsyncFeedbackPresentation(status: AsyncFeedbackStatus, t?: UiKitTranslate): Readonly<AsyncFeedbackPresentation>;