@simon_he/vue-tui 0.0.7 → 1.0.0-rc.0

package/dist/vue/components/input/plugins/promptMentionState.d.ts

@@ -0,0 +1,98 @@
+import type { ComputedRef, Ref } from "vue";
+import type { FsEntryKind } from "../../../../core/path-provider-types.js";
+import type { PathPickMode, PathSuggestion } from "../../../../core/path-suggest.js";
+import type { Terminal } from "../../../../core/types.js";
+import type { Rect } from "../../../../events/manager/types.js";
+export type PromptSuggestion = Readonly<{
+    value: string;
+    insert?: string;
+    label?: string;
+    detail?: string;
+    keywords?: readonly string[];
+    mentionValue?: string;
+    mentionBehavior?: "collect" | "inline";
+    onSelect?: (info: Readonly<{
+        value: string;
+        query: string;
+    }>) => void | boolean;
+}>;
+export type MentionSuggestionProvider = (info: Readonly<{
+    query: string;
+    tokenText: string;
+    trigger: string;
+    workspace: string;
+    maxItems: number;
+}>) => readonly PromptSuggestion[] | Promise<readonly PromptSuggestion[]>;
+export type MentionPathProvider = Readonly<{
+    stat?: (absPath: string) => FsEntryKind | null | undefined | Promise<FsEntryKind | null | undefined>;
+    suggest?: (info: Readonly<{
+        workspaceAbs: string;
+        input: string;
+        mode: PathPickMode;
+        max: number;
+        showHidden: boolean;
+        maxDepth: number;
+    }>) => readonly PathSuggestion[] | Promise<readonly PathSuggestion[]>;
+}>;
+export type PromptContext = Readonly<{
+    tokenStart: number;
+    tokenEnd: number;
+    tokenText: string;
+    query: string;
+    key: string;
+    trigger: string;
+}>;
+type PromptMatch = Readonly<{
+    item: PromptSuggestion;
+    score: number;
+    order: number;
+}>;
+export declare function fuzzyScore(query: string, candidate: string): number | null;
+export type UsePromptMentionStateOptions = Readonly<{
+    props: Readonly<{
+        promptSuggestions: readonly PromptSuggestion[];
+        promptTrigger: string;
+        promptTriggers?: readonly string[];
+        promptMaxItems: number;
+        promptAlign: "input" | "center";
+        mentionTrigger: string;
+        mentionWorkspace: string;
+        mentionMode: PathPickMode;
+        mentionShowHidden: boolean;
+        mentionSuggestions: readonly PromptSuggestion[];
+        mentionMaxItems: number;
+        mentions: readonly string[];
+        skillTrigger?: string;
+        skillSuggestions?: readonly PromptSuggestion[];
+    }>;
+    mentionSuggestionProviders?: readonly MentionSuggestionProvider[];
+    mentionPathProvider?: MentionPathProvider;
+    focused: Ref<boolean>;
+    cursor: Ref<number>;
+    getValue: () => string;
+    rawAbsRect: ComputedRef<Rect>;
+    terminal: Terminal;
+    scheduler: Readonly<{
+        invalidate: () => void;
+    }>;
+    multilineToken: string;
+    mentionToken: string;
+}>;
+export declare function usePromptMentionState(options: UsePromptMentionStateOptions): Readonly<{
+    promptActive: Ref<number>;
+    promptSuppressedKey: Ref<string | null>;
+    mentionKindByPath: Map<string, "file" | "directory" | "other">;
+    mentionKindVersion: Ref<number>;
+    promptContext: ComputedRef<PromptContext | null>;
+    mentionContext: ComputedRef<PromptContext | null>;
+    activeContext: ComputedRef<PromptContext | null>;
+    /** Full match list (not windowed). */
+    promptMatches: ComputedRef<readonly PromptMatch[]>;
+    /** Windowed list used for rendering and click mapping. */
+    promptMatchesVisible: ComputedRef<readonly PromptMatch[]>;
+    promptWindowStart: ComputedRef<number>;
+    promptActiveVisible: ComputedRef<number>;
+    promptVisible: ComputedRef<boolean>;
+    promptRect: ComputedRef<Rect>;
+}>;
+export {};

package/dist/vue/components/input/plugins/restrictText.d.ts

@@ -0,0 +1,27 @@
+import type { TInputPlugin } from "./types.js";
+export type TextRestrictionRule = Readonly<{
+    allowChars: RegExp;
+} | {
+    denyChars: RegExp;
+} | {
+    replace: Readonly<{
+        from: RegExp;
+        to: string;
+    }>;
+} | {
+    allow: RegExp;
+} | {
+    filter: (info: Readonly<{
+        text: string;
+        value: string;
+        cursor: number;
+        selection: null | Readonly<{
+            start: number;
+            end: number;
+        }>;
+    }>) => string;
+}>;
+export declare function createTextRestrictionPlugin(options: Readonly<{
+    name?: string;
+    rules: readonly TextRestrictionRule[];
+}>): TInputPlugin;

package/dist/vue/components/input/plugins/types.d.ts

@@ -0,0 +1,90 @@
+import type { ComputedRef, Ref } from "vue";
+import type { PathPickMode } from "../../../../core/path-suggest.js";
+import type { TerminalRenderPlane } from "../../../../core/render-plane.js";
+import type { Style, Terminal } from "../../../../core/types.js";
+import type { Rect, TerminalKeyboardEvent } from "../../../../events/manager/types.js";
+import type { TerminalScheduler } from "../../../context.js";
+import type { TInputHostAdapter } from "../host.js";
+export type PromptSuggestion = Readonly<{
+    value: string;
+    insert?: string;
+    label?: string;
+    detail?: string;
+    keywords?: readonly string[];
+    mentionValue?: string;
+    mentionBehavior?: "collect" | "inline";
+    onSelect?: (info: Readonly<{
+        value: string;
+        query: string;
+    }>) => void | boolean;
+}>;
+export type TInputPluginContext = Readonly<{
+    getProps: () => Readonly<{
+        zIndex: number;
+        style?: Style;
+        promptSuggestions: readonly PromptSuggestion[];
+        promptTrigger: string;
+        promptTriggers?: readonly string[];
+        promptMaxItems: number;
+        promptAlign: "input" | "center";
+        promptSelectedStyle?: Style;
+        promptPopupStyle?: Style;
+        promptPopupBorderStyle?: Style;
+        promptPopupMatchStyle?: Style;
+        mentionTrigger: string;
+        mentionWorkspace: string;
+        mentionMode: PathPickMode;
+        mentionShowHidden: boolean;
+        mentionSuggestions: readonly PromptSuggestion[];
+        mentionMaxItems: number;
+        mentionChipStyle?: Style;
+        collectMentions: boolean;
+        mentions: readonly string[];
+        skillTrigger?: string;
+        skillSuggestions?: readonly PromptSuggestion[];
+    }>;
+    emit: (event: string, ...args: any[]) => void;
+    terminal: Terminal;
+    scheduler: TerminalScheduler;
+    defaultStyle: Ref<Style>;
+    render: Readonly<{
+        rootStack: any;
+        createStack: (parent: any, z: number) => any;
+        invalidatePlane: (plane: TerminalRenderPlane) => void;
+    }>;
+    visible: Ref<boolean>;
+    rawAbsRect: ComputedRef<Rect>;
+    eventZ: ComputedRef<number>;
+    focused: Ref<boolean>;
+    cursor: Ref<number>;
+    getValue: () => string;
+    insertText: (text: string) => void;
+    pushUndoSnapshot: (nextValue: string) => void;
+    applyEdit: (nextValue: string, nextCursor: number) => void;
+    registerKeydownInterceptor: (fn: (e: TerminalKeyboardEvent) => boolean) => void;
+    registerTextFilter: (fn: (info: Readonly<{
+        text: string;
+        value: string;
+        cursor: number;
+        selection: null | Readonly<{
+            start: number;
+            end: number;
+        }>;
+    }>) => string) => void;
+    registerChipStyleProvider: (provider: Readonly<{
+        getStyle: (baseStyle: Style, chip: Readonly<{
+            kind: "multiline" | "mention";
+            absPath?: string;
+        }>) => Style | null | undefined;
+        version: Ref<number>;
+    }> | null) => void;
+    registerHostAdapter: (adapter: TInputHostAdapter | null) => void;
+    resolvePath: (input: string, opts?: Readonly<{
+        preserveBackslash?: boolean;
+    }>) => string;
+    mentionToken: string;
+}>;
+export type TInputPlugin = Readonly<{
+    name: string;
+    install: (ctx: TInputPluginContext) => void;
+}>;

package/dist/vue/components/input/utils/inlineText.d.ts

@@ -0,0 +1,57 @@
+import { textCellWidth as baseTextCellWidth } from "../../../utils/text.js";
+export declare const textCellWidth: typeof baseTextCellWidth;
+export declare function padEndByCells(text: string, width: number): string;
+export declare function sliceByCellsWindow(text: string, startCell: number, width: number): string;
+export type LineInfo = Readonly<{
+    start: number;
+    end: number;
+}>;
+export type WrappedLineInfo = Readonly<{
+    start: number;
+    end: number;
+}>;
+export declare function computeLines(value: string): LineInfo[];
+export declare function countMultilineTokens(value: string, multilineToken: string, endIndex?: number): number;
+export declare function countMentionTokens(value: string, mentionToken: string, endIndex?: number): number;
+export declare function tokenIndexAt(value: string, multilineToken: string, index: number): number;
+export declare function mentionIndexAt(value: string, mentionToken: string, index: number): number;
+export declare function textCellWidthInline(value: string, multilineToken: string, mentionToken: string, multilineTexts: readonly string[] | undefined, mentions: readonly string[] | undefined, start: number, end: number): number;
+export declare function wrapToLinesInline(value: string, multilineToken: string, mentionToken: string, multilineTexts: readonly string[] | undefined, mentions: readonly string[] | undefined, width: number): WrappedLineInfo[];
+export declare function wrapToLinesFirstWidthInline(value: string, multilineToken: string, mentionToken: string, multilineTexts: readonly string[] | undefined, mentions: readonly string[] | undefined, firstWidth: number, width: number): WrappedLineInfo[];
+export declare function indexToWrappedCellColFirstWidthInline(value: string, multilineToken: string, mentionToken: string, multilineTexts: readonly string[] | undefined, mentions: readonly string[] | undefined, index: number, firstWidth: number, width: number): {
+    line: number;
+    col: number;
+    lines: WrappedLineInfo[];
+};
+export declare function indexToLineCellColInline(value: string, multilineToken: string, mentionToken: string, multilineTexts: readonly string[] | undefined, mentions: readonly string[] | undefined, index: number): {
+    line: number;
+    col: number;
+    lines: LineInfo[];
+};
+export type InlineHit = Readonly<{
+    kind: "multiline" | "mention";
+    index: number;
+}>;
+export declare function lineCellColToIndexInline(value: string, multilineToken: string, mentionToken: string, multilineTexts: readonly string[] | undefined, mentions: readonly string[] | undefined, lineStart: number, lineEnd: number, col: number): {
+    index: number;
+    hit: InlineHit | null;
+};
+export type InlineChipRender = Readonly<{
+    startCell: number;
+    label: string;
+    kind: "multiline" | "mention";
+    index: number;
+    absPath?: string;
+}>;
+export declare function buildInlineRow(value: string, displayValue: string, multilineToken: string, mentionToken: string, multilineTexts: readonly string[] | undefined, mentions: readonly string[] | undefined, lineStart: number, lineEnd: number, rowTextW: number, offX: number): {
+    text: string;
+    chips: InlineChipRender[];
+};
+export type InlineSelectionSegment = Readonly<{
+    startCell: number;
+    text: string;
+}>;
+export declare function buildInlineSelectionSegments(value: string, displayValue: string, multilineToken: string, mentionToken: string, multilineTexts: readonly string[] | undefined, mentions: readonly string[] | undefined, lineStart: number, lineEnd: number, selection: Readonly<{
+    start: number;
+    end: number;
+}>, rowTextW: number, offX: number): InlineSelectionSegment[];

package/dist/vue/components/input/utils/inlineTextTokens.d.ts

@@ -0,0 +1,34 @@
+import type { InlineHit, LineInfo, WrappedLineInfo } from "./inlineText.js";
+import { buildInlineRow as buildInlineRowCore, buildInlineSelectionSegments as buildInlineSelectionSegmentsCore } from "./inlineText.js";
+export declare const MULTILINE_TOKEN = "\uFFFC";
+export declare const MENTION_TOKEN = "\uFFF9";
+export declare function isMultilineToken(value: string, index: number): boolean;
+export declare function isMentionToken(value: string, index: number): boolean;
+export declare function countMultilineTokens(value: string, endIndex?: number): number;
+export declare function countMentionTokens(value: string, endIndex?: number): number;
+export declare function tokenIndexAt(value: string, index: number): number;
+export declare function mentionIndexAt(value: string, index: number): number;
+export declare function wrapToLinesFirstWidthInline(value: string, multilineTexts: readonly string[] | undefined, mentions: readonly string[] | undefined, firstWidth: number, width: number): WrappedLineInfo[];
+export declare function indexToWrappedCellColFirstWidthInline(value: string, multilineTexts: readonly string[] | undefined, mentions: readonly string[] | undefined, index: number, firstWidth: number, width: number): {
+    line: number;
+    col: number;
+    lines: WrappedLineInfo[];
+};
+export declare function indexToLineCellColInline(value: string, multilineTexts: readonly string[] | undefined, mentions: readonly string[] | undefined, index: number): {
+    line: number;
+    col: number;
+    lines: LineInfo[];
+};
+export declare function lineCellColToIndexInline(value: string, multilineTexts: readonly string[] | undefined, mentions: readonly string[] | undefined, lineStart: number, lineEnd: number, col: number): {
+    index: number;
+    hit: InlineHit | null;
+};
+export declare function wrappedCellColToIndexInline(value: string, multilineTexts: readonly string[] | undefined, mentions: readonly string[] | undefined, info: WrappedLineInfo, col: number): {
+    index: number;
+    hit: InlineHit | null;
+};
+export declare function buildInlineRow(value: string, displayValue: string, multilineTexts: readonly string[] | undefined, mentions: readonly string[] | undefined, lineStart: number, lineEnd: number, rowTextW: number, offX: number): ReturnType<typeof buildInlineRowCore>;
+export declare function buildInlineSelectionSegments(value: string, displayValue: string, multilineTexts: readonly string[] | undefined, mentions: readonly string[] | undefined, lineStart: number, lineEnd: number, selection: Readonly<{
+    start: number;
+    end: number;
+}>, rowTextW: number, offX: number): ReturnType<typeof buildInlineSelectionSegmentsCore>;

package/dist/vue/components/input/utils/primitives.d.ts

@@ -0,0 +1,3 @@
+export declare function clamp(n: number, min: number, max: number): number;
+export declare function isWhitespace(ch: string): boolean;
+export declare function isWordChar(ch: string): boolean;

package/dist/vue/components/input/utils/wordNavigation.d.ts

@@ -0,0 +1,6 @@
+export declare function findWordLeft(text: string, index: number): number;
+export declare function findWordRight(text: string, index: number): number;
+export declare function tokenRangeAt(value: string, index: number): {
+    start: number;
+    end: number;
+} | null;

package/dist/vue/components/list/list-geometry.d.ts

@@ -0,0 +1,16 @@
+import type { Rect } from "../../../events/manager/types.js";
+export type ListClipOffsets = Readonly<{
+    x: number;
+    y: number;
+}>;
+export type ListVisibleRange = Readonly<{
+    start: number;
+    end: number;
+    h: number;
+}>;
+export declare function clipOffsets(full: Rect, clip: Rect): ListClipOffsets;
+export declare function maxScrollTop(itemsLength: number, clipY: number, clipH: number): number;
+export declare function maxScrollTopForClamp(fullH: number, clipH: number, itemsLength: number, clipY: number): number | null;
+export declare function clampScrollTop(value: number, max: number | null): number;
+export declare function visibleRange(scrollTop: number, itemsLength: number, full: Rect, clip: Rect): ListVisibleRange;
+export declare function hasPaintableViewport(visible: boolean, rect: Rect): boolean;

package/dist/vue/components/list/list-paint.d.ts

@@ -0,0 +1 @@
+export declare function formatClippedInlineCellLine(raw: string, fullWidth: number, clipX: number, width: number): string;

package/dist/vue/components/list/scroll-state.d.ts

@@ -0,0 +1,25 @@
+export type ScrollTopChange = Readonly<{
+    changed: boolean;
+    dirty: boolean;
+    top: number;
+}>;
+export type ActiveChange = Readonly<{
+    changedActive: boolean;
+    changedScroll: boolean;
+    dirty: boolean;
+    next: number;
+}>;
+export type SyncModelResult = Readonly<{
+    canceledPendingWheel: boolean;
+    reattached: boolean;
+    changedActive: boolean;
+    changedScroll: boolean;
+    dirty: boolean;
+}>;
+export declare function getWheelScrollInput(e: {
+    deltaY?: number;
+    deltaMode?: number;
+}): {
+    deltaY: number;
+    mode: "auto" | "line" | "pixel";
+};

package/dist/vue/components/list/selection-state.d.ts

@@ -0,0 +1,6 @@
+import type { ListVisibleRange } from "./list-geometry.js";
+export declare function normalizeListIndex(value: unknown, itemsLength: number): number;
+export declare function isActiveVisible(active: number, range: ListVisibleRange): boolean;
+export declare function anchorActiveToViewport(active: number, itemsLength: number, range: ListVisibleRange, direction: -1 | 1): number;
+export declare function pageAnchor(active: number, itemsLength: number, range: ListVisibleRange, direction: -1 | 1): number;
+export declare function nearestVisibleActive(active: number, itemsLength: number, range: ListVisibleRange): number;

package/dist/vue/components/terminal-provider/copy-toast.d.ts

@@ -0,0 +1,6 @@
+export declare function createCopyToastState(defaultText?: string): {
+    readonly visible: import("vue").Ref<boolean>;
+    readonly text: import("vue").Ref<string>;
+    readonly show: (message?: string) => void;
+    readonly dispose: () => void;
+};

package/dist/vue/components/terminal-provider/portals.d.ts

@@ -0,0 +1,17 @@
+import type { Component } from "vue";
+import type { TerminalRenderPlane } from "../../../core/render-plane.js";
+import type { TerminalRuntimeHandle, TerminalSchedulerInvalidateOptions } from "../../context.js";
+export interface Portal {
+    id: string;
+    component: Component;
+    plane: TerminalRenderPlane;
+    props: Record<string, unknown>;
+}
+export declare function createTerminalPortals(invalidate: (options?: TerminalSchedulerInvalidateOptions) => void): {
+    readonly portals: import("vue").ShallowReactive<Portal[]>;
+    readonly runtime: Readonly<{
+        mount: (component: Component, props: Record<string, unknown>, options?: Readonly<{
+            plane?: TerminalRenderPlane;
+        }>) => TerminalRuntimeHandle;
+    }>;
+};

package/dist/vue/components/terminal-provider/scheduler.d.ts

@@ -0,0 +1,29 @@
+import type { ShallowRef } from "vue";
+import type { Terminal } from "../../../core/types.js";
+import type { FramePerfStore } from "../../../observability/frame-perf-store.js";
+import type { TuiProfiler } from "../../../observability/tui-profiler.js";
+import type { DomRenderer } from "../../../renderer/dom/dom-renderer.js";
+import type { TerminalSchedulerInvalidateOptions } from "../../context.js";
+import type { RenderManager } from "../../render/render-manager.js";
+export declare function createTerminalProviderScheduler(options: {
+    terminal: Terminal;
+    renderer: ShallowRef<DomRenderer | null>;
+    render: RenderManager;
+    framePerf: FramePerfStore;
+    profiler: TuiProfiler | null;
+    isUnmounting: () => boolean;
+    afterFlush: () => void;
+}): {
+    readonly api: Readonly<{
+        invalidate: (options?: TerminalSchedulerInvalidateOptions) => void;
+        flush: () => void;
+        flushNow: () => void;
+        configure: (options: import("../../context.js").TerminalSchedulerConfig) => void;
+        queueFrameTask: (task: import("../../context.js").TerminalFrameTask) => boolean | void;
+        cancelFrameTask?: (id: string) => boolean | void;
+        requestLive: (reason: string) => () => void;
+        dropLive: (reason: string) => void;
+        isInsideFrame: () => boolean;
+    }>;
+    readonly dispose: () => void;
+};

package/dist/vue/components/terminal-provider/selection-config.d.ts

@@ -0,0 +1,15 @@
+import type { TerminalSelectionCopyPayload, TerminalSelectionOptions } from "../../../selection/terminal-selection.js";
+import type { Style } from "../../../core/types.js";
+export type ResolvedTerminalSelectionConfig = Readonly<{
+    enabled: boolean;
+    autoCopy: boolean;
+    copyOnMouseUp: boolean;
+    style: Style;
+    toast: boolean;
+}>;
+export type TerminalProviderSelectionOptions = TerminalSelectionOptions & Readonly<{
+    toast?: boolean;
+}>;
+export type TerminalProviderSelectionConfig = boolean | TerminalProviderSelectionOptions;
+export declare function resolveSelectionConfig(config: TerminalProviderSelectionConfig): ResolvedTerminalSelectionConfig;
+export declare function selectionCopyToastText(payload: TerminalSelectionCopyPayload): string;

package/dist/vue/components/terminal-provider/utils.d.ts

@@ -0,0 +1,5 @@
+import type { DomRendererOptions } from "../../../renderer/dom/dom-renderer.js";
+export declare function isPlainObject(v: unknown): v is Record<string, unknown>;
+export declare function shallowEqualRecord(a: Record<string, unknown>, b: Record<string, unknown>): boolean;
+export declare function warnDev(message: string): void;
+export declare function pickInitOnlyDomOptions(options: DomRendererOptions | undefined): Record<string, unknown>;

package/dist/vue/composables/use-layout.d.ts

@@ -0,0 +1,2 @@
+import type { LayoutContext } from "../context.js";
+export declare function useLayout(): LayoutContext;

package/dist/vue/composables/use-render-node.d.ts

@@ -0,0 +1,19 @@
+import type { Ref } from "vue";
+import type { TerminalSchedulerPriority } from "../context.js";
+import type { RenderRect, RenderStack } from "../render/render-manager.js";
+export interface RenderNodeOptions {
+    zIndex?: number;
+    stack?: RenderStack;
+    rect?: RenderRect | null;
+    /**
+     * One-shot absolute terminal rows for row-local content changes on this node's plane only.
+     * Omit this when geometry, z-order, style, data identity, or paint semantics changed.
+     */
+    dirtyRowsHint?: readonly number[];
+    priority?: TerminalSchedulerPriority;
+    deps?: unknown;
+    paint: (dirtyRows?: readonly number[]) => void;
+}
+export declare function useRenderNode(getOptions: () => RenderNodeOptions): {
+    id: Ref<string | null>;
+};

package/dist/vue/composables/use-render-stack.d.ts

@@ -0,0 +1,3 @@
+import type { Ref } from "vue";
+import type { RenderStack } from "../render/render-manager.js";
+export declare function useRenderStack(): Ref<RenderStack>;

package/dist/vue/composables/use-runtime.d.ts

@@ -0,0 +1,5 @@
+export declare function useTerminalRuntime(): Readonly<{
+    mount: (component: import("vue").Component, props: Record<string, unknown>, options?: Readonly<{
+        plane?: import("../../core.js").TerminalRenderPlane;
+    }>) => import("../context.js").TerminalRuntimeHandle;
+}>;

package/dist/vue/composables/use-terminal-node.d.ts

@@ -0,0 +1,14 @@
+import type { Ref } from "vue";
+import type { Rect, TerminalEventHandlerMap } from "../../events/manager/types.js";
+export interface TerminalNodeOptions {
+    rect: Rect;
+    zIndex?: number;
+    visible?: boolean;
+    focusable?: boolean;
+    selectable?: boolean;
+    selectionScrollBy?: (deltaRows: number) => boolean | void;
+    handlers?: TerminalEventHandlerMap;
+}
+export declare function useTerminalNode(getOptions: () => TerminalNodeOptions): {
+    id: Ref<string | null>;
+};

package/dist/vue/composables/use-terminal.d.ts

@@ -0,0 +1,2 @@
+import type { TerminalContext } from "../context.js";
+export declare function useTerminal(): TerminalContext;

package/dist/vue/composables/use-visibility.d.ts

@@ -0,0 +1,12 @@
+import type { ComputedRef, VNode } from "vue";
+export type VisibilityRootProps = Readonly<{
+    style: Readonly<Record<string, string | number>>;
+    onVnodeBeforeMount: (vnode: VNode) => void;
+    onVnodeBeforeUnmount: (vnode: VNode) => void;
+}>;
+export declare function useVisibility(options?: {
+    provide?: boolean;
+}): Readonly<{
+    visible: ComputedRef<boolean>;
+    rootProps: VisibilityRootProps;
+}>;