ensis-ui 0.0.0-stage → 3.0.1

package/dist/components/alert/src/alert-utils.js

@@ -0,0 +1,71 @@
+//#region src/components/alert/src/alert-utils.ts
+var RS_ALERT_TONES = [
+	"default",
+	"info",
+	"success",
+	"warning",
+	"danger"
+];
+var RS_ALERT_VARIANTS = [
+	"soft",
+	"outline",
+	"solid"
+];
+var RS_ALERT_SIZES = [
+	"sm",
+	"md",
+	"lg"
+];
+var RS_ALERT_DEFAULT_TONE = "info";
+var RS_ALERT_DEFAULT_VARIANT = "soft";
+var ALERT_ICONS = {
+	default: "info",
+	info: "info",
+	success: "circle-check",
+	warning: "triangle-alert",
+	danger: "circle-alert"
+};
+function isRsAlertTone(value) {
+	return typeof value === "string" && RS_ALERT_TONES.includes(value);
+}
+function isRsAlertVariant(value) {
+	return typeof value === "string" && RS_ALERT_VARIANTS.includes(value);
+}
+function isRsAlertSize(value) {
+	return typeof value === "string" && RS_ALERT_SIZES.includes(value);
+}
+/**
+* tone 优先，type 是兼容别名。两边都无效时回落 info（与旧默认一致）。
+*/
+function resolveAlertTone(tone, type) {
+	if (isRsAlertTone(tone)) return tone;
+	if (isRsAlertTone(type)) return type;
+	return RS_ALERT_DEFAULT_TONE;
+}
+function resolveAlertVariant(variant) {
+	return isRsAlertVariant(variant) ? variant : RS_ALERT_DEFAULT_VARIANT;
+}
+/** 未传或非法落到 md；ssm 并到 sm。 */
+function resolveAlertSize(size) {
+	if (size === "ssm" || size === "sm") return "sm";
+	if (isRsAlertSize(size)) return size;
+	return "md";
+}
+function resolveAlertIcon(tone) {
+	return ALERT_ICONS[tone];
+}
+/** 警告 / 错误用 alert（断言）；信息 / 成功 / 中性用 status，避免进页就打断读屏。 */
+function resolveAlertRole(tone) {
+	return tone === "warning" || tone === "danger" ? "alert" : "status";
+}
+function shouldShowAlertIcon(showIcon, hasIconSlot) {
+	return hasIconSlot || showIcon;
+}
+function hasAlertTitle(title, hasTitleSlot = false) {
+	return hasTitleSlot || Boolean(title);
+}
+function hasAlertDescription(description, hasDefaultSlot = false) {
+	return hasDefaultSlot || Boolean(description);
+}
+//#endregion
+export { RS_ALERT_DEFAULT_TONE, RS_ALERT_DEFAULT_VARIANT, RS_ALERT_SIZES, RS_ALERT_TONES, RS_ALERT_VARIANTS, hasAlertDescription, hasAlertTitle, isRsAlertSize, isRsAlertTone, isRsAlertVariant, resolveAlertIcon, resolveAlertRole, resolveAlertSize, resolveAlertTone, resolveAlertVariant, shouldShowAlertIcon };

package/dist/components/anchor/index.d.ts

@@ -0,0 +1,3 @@
+export { default as RsAnchor } from './src/RsAnchor.js';
+export type { RsAnchorDirection, RsAnchorExpose, RsAnchorFlatItem, RsAnchorInstance, RsAnchorItem, RsAnchorScrollBehavior, } from './src/anchor-utils';
+export { flattenAnchorItems, hrefToAnchorId, pickActiveAnchorHref, } from './src/anchor-utils';

package/dist/components/anchor/src/RsAnchor.css

@@ -0,0 +1,96 @@
+
+.rs-anchor[data-v-ad557668] {
+  position: relative;
+  display: flex;
+  gap: var(--rs-anchor-gap);
+  min-width: var(--rs-anchor-min-width);
+}
+.rs-anchor--affix[data-v-ad557668] {
+  position: sticky;
+  top: var(--rs-anchor-affix-top);
+}
+.rs-anchor--horizontal[data-v-ad557668] {
+  flex-direction: column;
+  min-width: 0;
+  width: 100%;
+}
+.rs-anchor__rail[data-v-ad557668] {
+  position: relative;
+  flex-shrink: 0;
+  width: var(--rs-anchor-rail-width);
+  border-radius: var(--rs-radius-full);
+  background: var(--rs-anchor-rail);
+}
+.rs-anchor--horizontal .rs-anchor__rail[data-v-ad557668] {
+  width: 100%;
+  height: var(--rs-anchor-rail-width);
+}
+.rs-anchor__ink[data-v-ad557668] {
+  position: absolute;
+  inset-inline-start: 0;
+  top: 0;
+  width: var(--rs-anchor-rail-width);
+  border-radius: inherit;
+  background: var(--rs-anchor-ink);
+  box-shadow: 0 0 0 1px var(--rs-anchor-ink-ring);
+  opacity: 0;
+  pointer-events: none;
+  transition:
+    transform var(--rs-transition-fast),
+    width var(--rs-transition-fast),
+    height var(--rs-transition-fast),
+    opacity var(--rs-transition-fast);
+}
+.rs-anchor__list[data-v-ad557668],
+.rs-anchor__item[data-v-ad557668] {
+  margin: 0;
+  padding: 0;
+  list-style: none;
+}
+.rs-anchor__list[data-v-ad557668] {
+  display: flex;
+  flex-direction: column;
+  min-width: 0;
+  flex: 1;
+}
+.rs-anchor--horizontal .rs-anchor__list[data-v-ad557668] {
+  flex-direction: row;
+  flex-wrap: wrap;
+  column-gap: var(--rs-space-sm);
+}
+.rs-anchor__link[data-v-ad557668] {
+  display: block;
+  padding-block: var(--rs-anchor-link-pad-block);
+  padding-inline: var(--rs-anchor-link-pad-inline);
+  color: var(--rs-anchor-link);
+  font-size: var(--rs-font-size-xs);
+  line-height: var(--rs-line-height-relaxed);
+  font-weight: var(--rs-font-weight-regular);
+  text-decoration: none;
+  border-radius: var(--rs-radius-xs);
+  transition: color var(--rs-transition-fast), background-color var(--rs-transition-fast);
+}
+.rs-anchor__link[data-v-ad557668]:hover {
+  color: var(--rs-anchor-link-hover);
+}
+.rs-anchor__link[data-v-ad557668]:focus-visible {
+  outline: var(--rs-focus-ring-width) solid var(--rs-focus-ring);
+  outline-offset: 2px;
+}
+.rs-anchor__link--active[data-v-ad557668] {
+  color: var(--rs-anchor-link-active);
+  font-weight: var(--rs-anchor-link-active-weight);
+}
+.rs-anchor__link--disabled[data-v-ad557668] {
+  opacity: var(--rs-anchor-disabled-opacity);
+  cursor: not-allowed;
+}
+.rs-anchor--lineless .rs-anchor__link--active[data-v-ad557668] {
+  background: var(--rs-anchor-link-active-bg);
+}
+@media (prefers-reduced-motion: reduce) {
+.rs-anchor__ink[data-v-ad557668],
+  .rs-anchor__link[data-v-ad557668] {
+    transition: none;
+}
+}

package/dist/components/anchor/src/RsAnchor.d.ts

@@ -0,0 +1,68 @@
+import { type RsAnchorDirection, type RsAnchorExpose, type RsAnchorItem, type RsAnchorScrollBehavior } from './anchor-utils';
+type __VLS_Props = {
+    items: RsAnchorItem[];
+    /** 判定「已滚过」的顶部偏移（px） */
+    offset?: number;
+    /** 点击滚动后标题距容器顶的距离 */
+    targetOffset?: number;
+    /** 额外容差，避免刚贴顶就跳下一项 */
+    bounds?: number;
+    /** sticky 吸附 */
+    affix?: boolean;
+    /** sticky 距滚动容器顶的距离（px），写入 --rs-anchor-affix-top */
+    affixOffset?: number;
+    /** 无轨道墨点（仅文字高亮） */
+    lineless?: boolean;
+    /**
+     * 是否改写 location.hash。
+     * Hash 路由（Vue Router createWebHashHistory）必须为 false，否则会丢掉当前路由。
+     */
+    changeHash?: boolean;
+    /** changeHash 时用 replaceState（默认）还是 pushState */
+    replace?: boolean;
+    direction?: RsAnchorDirection;
+    /** 覆盖滚动行为；未传时减少动态用 auto，否则 smooth */
+    scrollBehavior?: RsAnchorScrollBehavior;
+    /** 覆盖滚动判定后的激活 href */
+    getCurrentAnchor?: (activeHref: string) => string;
+    getContainer?: () => HTMLElement | Window | null | undefined;
+    id?: string;
+    ariaLabel?: string;
+};
+type __VLS_ModelProps = {
+    modelValue?: string;
+};
+type __VLS_PublicProps = __VLS_Props & __VLS_ModelProps;
+declare var __VLS_1: {
+    item: import("./anchor-utils").RsAnchorFlatItem;
+    active: boolean;
+    href: string;
+};
+type __VLS_Slots = {} & {
+    item?: (props: typeof __VLS_1) => any;
+};
+declare const __VLS_base: import("vue").DefineComponent<__VLS_PublicProps, RsAnchorExpose, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    change: (href: string) => any;
+    click: (href: string, event: MouseEvent) => any;
+    "update:modelValue": (value: string) => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_PublicProps> & Readonly<{
+    onChange?: ((href: string) => any) | undefined;
+    onClick?: ((href: string, event: MouseEvent) => any) | undefined;
+    "onUpdate:modelValue"?: ((value: string) => any) | undefined;
+}>, {
+    replace: boolean;
+    offset: number;
+    bounds: number;
+    affix: boolean;
+    lineless: boolean;
+    changeHash: boolean;
+    direction: RsAnchorDirection;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/components/anchor/src/RsAnchor.impl.js

@@ -0,0 +1,306 @@
+import { useRsI18n } from "../../../composables/useRsI18n.js";
+import { collectAnchorTops, computeScrollTopForTarget, flattenAnchorItems, hrefToAnchorId, isAnchorScrolledToEnd, isAnchorWindow, pickActiveAnchorHref, resolveAnchorContainer, scrollContainerTo, writeAnchorHash } from "./anchor-utils.js";
+import { Fragment, computed, createCommentVNode, createElementBlock, createElementVNode, createTextVNode, defineComponent, mergeModels, nextTick, normalizeClass, normalizeStyle, onMounted, onUnmounted, openBlock, ref, renderList, renderSlot, toDisplayString, useModel, watch } from "vue";
+//#region src/components/anchor/src/RsAnchor.vue?vue&type=script&setup=true&lang.ts
+var _hoisted_1 = ["id", "aria-label"];
+var _hoisted_2 = { class: "rs-anchor__list" };
+var _hoisted_3 = [
+	"href",
+	"data-rs-anchor-href",
+	"aria-current",
+	"aria-disabled",
+	"onClick"
+];
+var CLICK_LOCK_IDLE_MS = 120;
+var CLICK_LOCK_FALLBACK_MS = 360;
+var RsAnchor_vue_vue_type_script_setup_true_lang_default = /*@__PURE__*/ defineComponent({
+	name: "RsAnchor",
+	__name: "RsAnchor",
+	props: /*@__PURE__*/ mergeModels({
+		items: {},
+		offset: { default: 12 },
+		targetOffset: {},
+		bounds: { default: 8 },
+		affix: {
+			type: Boolean,
+			default: true
+		},
+		affixOffset: {},
+		lineless: {
+			type: Boolean,
+			default: false
+		},
+		changeHash: {
+			type: Boolean,
+			default: true
+		},
+		replace: {
+			type: Boolean,
+			default: true
+		},
+		direction: { default: "vertical" },
+		scrollBehavior: {},
+		getCurrentAnchor: {},
+		getContainer: {},
+		id: {},
+		ariaLabel: {}
+	}, {
+		"modelValue": { default: "" },
+		"modelModifiers": {}
+	}),
+	emits: /*@__PURE__*/ mergeModels(["change", "click"], ["update:modelValue"]),
+	setup(__props, { expose: __expose, emit: __emit }) {
+		const props = __props;
+		const activeHref = useModel(__props, "modelValue");
+		const emit = __emit;
+		const { t } = useRsI18n();
+		const rootRef = ref(null);
+		const railRef = ref(null);
+		const inkStyle = ref({});
+		const linkRefs = /* @__PURE__ */ new Map();
+		const flatItems = computed(() => flattenAnchorItems(props.items));
+		const resolvedTargetOffset = computed(() => props.targetOffset ?? props.offset);
+		const navLabel = computed(() => props.ariaLabel || t("anchor.label"));
+		const rootStyle = computed(() => {
+			if (props.affixOffset == null) return void 0;
+			return { "--rs-anchor-affix-top": `${props.affixOffset}px` };
+		});
+		const targetCache = /* @__PURE__ */ new Map();
+		let scrollTarget = null;
+		let rafId = 0;
+		let resizeObserver = null;
+		let clickLockHref = "";
+		let clickLockTimer = 0;
+		function findTarget(href) {
+			const cached = targetCache.get(href);
+			if (cached?.isConnected) return cached;
+			const id = hrefToAnchorId(href);
+			if (!id || typeof document === "undefined") return null;
+			const el = document.getElementById(id);
+			if (el) targetCache.set(href, el);
+			else targetCache.delete(href);
+			return el;
+		}
+		function setLinkRef(href, el) {
+			if (el instanceof HTMLElement) {
+				linkRefs.set(href, el);
+				return;
+			}
+			linkRefs.delete(href);
+		}
+		function setActive(href) {
+			const next = props.getCurrentAnchor?.(href) ?? href;
+			if (!next || next === activeHref.value) return;
+			activeHref.value = next;
+			emit("change", next);
+		}
+		function syncInk() {
+			if (props.lineless) return;
+			const current = activeHref.value || flatItems.value.find((item) => !item.disabled)?.href;
+			if (!current) {
+				inkStyle.value = { opacity: "0" };
+				return;
+			}
+			const link = linkRefs.get(current);
+			const rail = railRef.value;
+			if (!link || !rail) {
+				inkStyle.value = { opacity: "0" };
+				return;
+			}
+			const linkRect = link.getBoundingClientRect();
+			const railRect = rail.getBoundingClientRect();
+			if (props.direction === "horizontal") {
+				inkStyle.value = {
+					opacity: "1",
+					width: `${Math.max(0, linkRect.width)}px`,
+					height: "100%",
+					transform: `translate3d(${linkRect.left - railRect.left}px, 0, 0)`
+				};
+				return;
+			}
+			inkStyle.value = {
+				opacity: "1",
+				width: "100%",
+				height: `${Math.max(0, linkRect.height)}px`,
+				transform: `translate3d(0, ${linkRect.top - railRect.top}px, 0)`
+			};
+		}
+		function releaseClickLock() {
+			clickLockHref = "";
+			if (clickLockTimer) {
+				window.clearTimeout(clickLockTimer);
+				clickLockTimer = 0;
+			}
+			syncFromScroll();
+		}
+		function armClickLock(href) {
+			clickLockHref = href;
+			if (clickLockTimer) window.clearTimeout(clickLockTimer);
+			if (typeof window === "undefined") return;
+			clickLockTimer = window.setTimeout(releaseClickLock, CLICK_LOCK_FALLBACK_MS);
+		}
+		function bumpClickLock() {
+			if (!clickLockHref || typeof window === "undefined") return;
+			if (clickLockTimer) window.clearTimeout(clickLockTimer);
+			clickLockTimer = window.setTimeout(releaseClickLock, CLICK_LOCK_IDLE_MS);
+		}
+		function syncFromScroll() {
+			if (!scrollTarget || clickLockHref) return;
+			const next = pickActiveAnchorHref(collectAnchorTops(flatItems.value, scrollTarget, findTarget), props.offset + props.bounds, { atEnd: isAnchorScrolledToEnd(scrollTarget) });
+			if (next) setActive(next);
+		}
+		function cancelScrollFrame() {
+			if (!rafId) return;
+			cancelAnimationFrame(rafId);
+			rafId = 0;
+		}
+		function onScroll() {
+			if (clickLockHref) {
+				bumpClickLock();
+				return;
+			}
+			if (rafId) return;
+			rafId = requestAnimationFrame(() => {
+				rafId = 0;
+				syncFromScroll();
+			});
+		}
+		function unbindContainer() {
+			cancelScrollFrame();
+			clickLockHref = "";
+			if (clickLockTimer) {
+				window.clearTimeout(clickLockTimer);
+				clickLockTimer = 0;
+			}
+			scrollTarget?.removeEventListener("scroll", onScroll);
+			scrollTarget = null;
+			resizeObserver?.disconnect();
+			resizeObserver = null;
+		}
+		function bindContainer() {
+			const next = resolveAnchorContainer(props.getContainer);
+			if (next === scrollTarget && scrollTarget) {
+				syncFromScroll();
+				return;
+			}
+			unbindContainer();
+			scrollTarget = next;
+			if (!scrollTarget) return;
+			scrollTarget.addEventListener("scroll", onScroll, { passive: true });
+			if (typeof ResizeObserver !== "undefined") {
+				resizeObserver = new ResizeObserver(() => {
+					if (clickLockHref) return;
+					onScroll();
+					nextTick(syncInk);
+				});
+				if (!isAnchorWindow(scrollTarget)) resizeObserver.observe(scrollTarget);
+				if (rootRef.value) resizeObserver.observe(rootRef.value);
+			}
+			syncFromScroll();
+		}
+		function scrollToHref(href) {
+			if (flatItems.value.find((entry) => entry.href === href)?.disabled) return;
+			const target = findTarget(href);
+			const container = scrollTarget ?? resolveAnchorContainer(props.getContainer);
+			if (target && container) scrollContainerTo(container, computeScrollTopForTarget(target, container, resolvedTargetOffset.value), props.scrollBehavior);
+			setActive(href);
+			armClickLock(href);
+			if (props.changeHash) writeAnchorHash(href, props.replace);
+			nextTick(syncInk);
+		}
+		function onSelect(href, event, disabled) {
+			event.preventDefault();
+			emit("click", href, event);
+			if (disabled) return;
+			scrollToHref(href);
+		}
+		function onWindowResize() {
+			if (clickLockHref) bumpClickLock();
+			else onScroll();
+			nextTick(syncInk);
+		}
+		onMounted(() => {
+			bindContainer();
+			nextTick(bindContainer);
+			if (typeof window !== "undefined") window.addEventListener("resize", onWindowResize, { passive: true });
+		});
+		onUnmounted(() => {
+			unbindContainer();
+			targetCache.clear();
+			linkRefs.clear();
+			if (typeof window !== "undefined") window.removeEventListener("resize", onWindowResize);
+		});
+		watch(() => props.getContainer?.() ?? null, (next, prev) => {
+			if (next === prev) return;
+			nextTick(bindContainer);
+		});
+		watch(() => flatItems.value.map((item) => `${item.href}\0${item.title}\0${item.depth}\0${item.disabled ? 1 : 0}`).join("\n"), (signature) => {
+			targetCache.clear();
+			if (!signature) {
+				unbindContainer();
+				return;
+			}
+			nextTick(bindContainer);
+		});
+		watch(() => [
+			props.offset,
+			props.bounds,
+			props.direction,
+			props.lineless
+		], () => {
+			nextTick(syncFromScroll);
+		});
+		watch(activeHref, () => {
+			nextTick(syncInk);
+		});
+		__expose({ scrollTo: scrollToHref });
+		return (_ctx, _cache) => {
+			return flatItems.value.length ? (openBlock(), createElementBlock("nav", {
+				key: 0,
+				id: __props.id,
+				ref_key: "rootRef",
+				ref: rootRef,
+				class: normalizeClass(["rs-anchor", {
+					"rs-anchor--affix": __props.affix,
+					"rs-anchor--lineless": __props.lineless,
+					"rs-anchor--horizontal": __props.direction === "horizontal"
+				}]),
+				style: normalizeStyle(rootStyle.value),
+				"aria-label": navLabel.value
+			}, [!__props.lineless ? (openBlock(), createElementBlock("div", {
+				key: 0,
+				ref_key: "railRef",
+				ref: railRef,
+				class: "rs-anchor__rail",
+				"aria-hidden": "true"
+			}, [createElementVNode("span", {
+				class: "rs-anchor__ink",
+				style: normalizeStyle(inkStyle.value)
+			}, null, 4)], 512)) : createCommentVNode("", true), createElementVNode("ul", _hoisted_2, [(openBlock(true), createElementBlock(Fragment, null, renderList(flatItems.value, (item) => {
+				return openBlock(), createElementBlock("li", {
+					key: item.href,
+					class: "rs-anchor__item"
+				}, [createElementVNode("a", {
+					class: normalizeClass(["rs-anchor__link", {
+						"rs-anchor__link--active": item.href === activeHref.value,
+						"rs-anchor__link--disabled": item.disabled
+					}]),
+					style: normalizeStyle(__props.direction === "vertical" ? { paddingInlineStart: `calc(var(--rs-anchor-link-pad-inline) + ${item.depth} * var(--rs-anchor-indent))` } : void 0),
+					href: item.href,
+					ref_for: true,
+					ref: (el) => setLinkRef(item.href, el),
+					"data-rs-anchor-href": item.href,
+					"aria-current": item.href === activeHref.value ? "location" : void 0,
+					"aria-disabled": item.disabled ? "true" : void 0,
+					onClick: ($event) => onSelect(item.href, $event, item.disabled)
+				}, [renderSlot(_ctx.$slots, "item", {
+					item,
+					active: item.href === activeHref.value,
+					href: item.href
+				}, () => [createTextVNode(toDisplayString(item.title), 1)], true)], 14, _hoisted_3)]);
+			}), 128))])], 14, _hoisted_1)) : createCommentVNode("", true);
+		};
+	}
+});
+//#endregion
+export { RsAnchor_vue_vue_type_script_setup_true_lang_default as default };

package/dist/components/anchor/src/RsAnchor.js

@@ -0,0 +1,8 @@
+import './RsAnchor.css'
+import _plugin_vue_export_helper_default from "../../../_virtual/_plugin-vue_export-helper.js";
+import RsAnchor_vue_vue_type_script_setup_true_lang_default from "./RsAnchor.impl.js";
+
+//#region src/components/anchor/src/RsAnchor.vue
+var RsAnchor_default = /*#__PURE__*/ _plugin_vue_export_helper_default(RsAnchor_vue_vue_type_script_setup_true_lang_default, [["__scopeId", "data-v-ad557668"]]);
+//#endregion
+export { RsAnchor_default as default };

package/dist/components/anchor/src/anchor-utils.d.ts

@@ -0,0 +1,58 @@
+export interface RsAnchorItem {
+    href: string;
+    title: string;
+    disabled?: boolean;
+    children?: RsAnchorItem[];
+}
+export interface RsAnchorFlatItem {
+    href: string;
+    title: string;
+    depth: number;
+    disabled?: boolean;
+}
+export type RsAnchorDirection = 'vertical' | 'horizontal';
+export type RsAnchorScrollBehavior = 'smooth' | 'auto';
+export interface RsAnchorExpose {
+    /** 滚到对应章节并激活。禁用项或找不到目标时不滚动。 */
+    scrollTo: (href: string) => void;
+}
+/** 模板 ref 实例：expose + 根节点 */
+export type RsAnchorInstance = RsAnchorExpose & {
+    $el: HTMLElement;
+};
+/** `#overview` / `path#overview` / `#%E6%A6%82%E8%BF%B0` → `overview` / `概述` */
+export declare function hrefToAnchorId(href: string): string;
+export declare function flattenAnchorItems(items: RsAnchorItem[], depth?: number): RsAnchorFlatItem[];
+/**
+ * 滚动监听：取最后一个 top <= offset 的标题。
+ * entries 须按文档顺序（与 DOM 一致），top 为相对滚动容器顶部的距离。
+ * atEnd：容器已贴底时最后一节往往到不了判定线，仍应高亮最后一项。
+ */
+export declare function pickActiveAnchorHref(entries: ReadonlyArray<{
+    href: string;
+    top: number;
+}>, offset: number, options?: {
+    atEnd?: boolean;
+}): string;
+/** 用 scrollY / nodeType 判断，避免跨 iframe 的 `instanceof Window`。 */
+export declare function isAnchorWindow(container: unknown): container is Window;
+export declare function resolveAnchorContainer(getContainer?: () => HTMLElement | Window | null | undefined): HTMLElement | Window | null;
+export declare function readContainerScrollTop(container: HTMLElement | Window): number;
+export declare function readContainerScrollExtent(container: HTMLElement | Window): {
+    top: number;
+    max: number;
+};
+/** 贴底判定。slack 吃掉亚像素，避免最后一项永远亮不起来。 */
+export declare function isAnchorScrolledToEnd(container: HTMLElement | Window, slack?: number): boolean;
+export declare function targetTopInContainer(target: HTMLElement, container: HTMLElement | Window): number;
+export declare function prefersAnchorReducedMotion(): boolean;
+export declare function resolveAnchorScrollBehavior(behavior?: RsAnchorScrollBehavior): ScrollBehavior;
+export declare function scrollContainerTo(container: HTMLElement | Window, top: number, behavior?: RsAnchorScrollBehavior): void;
+export declare function computeScrollTopForTarget(target: HTMLElement, container: HTMLElement | Window, targetOffset: number): number;
+export declare function collectAnchorTops(items: ReadonlyArray<{
+    href: string;
+}>, container: HTMLElement | Window, findTarget: (href: string) => HTMLElement | null): Array<{
+    href: string;
+    top: number;
+}>;
+export declare function writeAnchorHash(href: string, replace: boolean): void;