@lingya-ai/agents-sdk 0.4.0 → 0.7.0

package/dist/esm/subscription.d.ts

@@ -0,0 +1,72 @@
+import { ApiError, RequestOptions } from './lifecycle';
+import { type AiChatBriefEvent } from './events';
+export interface ConnectionEvent {
+    connectionId?: string;
+    type: 'opened' | 'ready' | 'heartbeat' | 'closed';
+    transport: 'sse' | 'websocket';
+    requestId?: string;
+    reason?: string;
+    closeCode?: number;
+}
+export interface StreamOptions extends RequestOptions {
+    xRequestID?: string;
+    transport?: 'sse' | 'websocket';
+    idleTimeoutMs?: number;
+    onConnectionEvent?: (event: ConnectionEvent) => void;
+}
+export interface StreamCloseInfo {
+    reason: 'end' | 'complete' | 'normal' | 'closed' | 'cancelled' | 'timeout' | 'error';
+    error?: ApiError;
+    closeCode?: number;
+}
+export interface WebSocketLike {
+    serverRequestId?: string;
+    handshakeError?: ApiError;
+    onopen: ((event: any) => void) | null;
+    onmessage: ((event: {
+        data: any;
+    }) => void) | null;
+    onerror: ((event: any) => void) | null;
+    onclose: ((event: {
+        code: number;
+        reason: string;
+    }) => void) | null;
+    close(code?: number, reason?: string): void;
+}
+export type WebSocketFactory = (url: string, options: {
+    protocols: string[];
+    headers?: Record<string, string>;
+}) => WebSocketLike;
+export type WebSocketConnector = (url: string, signal: AbortSignal, requestId?: string) => Promise<WebSocketLike>;
+export type StreamRequest = (signal: AbortSignal) => Promise<Response>;
+/** One connection, no replay, retry, UI merging or recovery policy. */
+export declare class ChatSubscription implements AsyncIterable<AiChatBriefEvent> {
+    private readonly request;
+    private readonly url;
+    private readonly messageId;
+    private readonly options;
+    private readonly connect?;
+    readonly events: AsyncIterable<AiChatBriefEvent>;
+    readonly closed: Promise<StreamCloseInfo>;
+    private readonly scope;
+    private readonly queue;
+    private wake?;
+    private done;
+    private failure?;
+    private finish;
+    private idleTimer?;
+    private reason;
+    private serverRequestId?;
+    private closeCode?;
+    private readonly connectionId;
+    constructor(request: StreamRequest, url: string, messageId: string, options?: StreamOptions, connect?: WebSocketConnector);
+    close(): void;
+    private diagnostic;
+    private activity;
+    private push;
+    private run;
+    private websocket;
+    [Symbol.asyncIterator](): AsyncGenerator<AiChatBriefEvent>;
+}
+/** Finite SSE endpoints permit EOF, while sharing cancellation and idle semantics. */
+export declare function finiteSse(request: StreamRequest, options?: StreamOptions): AsyncGenerator<string>;

package/dist/esm/subscription.js

@@ -0,0 +1,282 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __asyncValues = (this && this.__asyncValues) || function (o) {
+    if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+    var m = o[Symbol.asyncIterator], i;
+    return m ? m.call(o) : (o = typeof __values === "function" ? __values(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i);
+    function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }
+    function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }
+};
+var __await = (this && this.__await) || function (v) { return this instanceof __await ? (this.v = v, this) : new __await(v); }
+var __asyncGenerator = (this && this.__asyncGenerator) || function (thisArg, _arguments, generator) {
+    if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+    var g = generator.apply(thisArg, _arguments || []), i, q = [];
+    return i = Object.create((typeof AsyncIterator === "function" ? AsyncIterator : Object).prototype), verb("next"), verb("throw"), verb("return", awaitReturn), i[Symbol.asyncIterator] = function () { return this; }, i;
+    function awaitReturn(f) { return function (v) { return Promise.resolve(v).then(f, reject); }; }
+    function verb(n, f) { if (g[n]) { i[n] = function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]) > 1 || resume(n, v); }); }; if (f) i[n] = f(i[n]); } }
+    function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(q[0][3], e); } }
+    function step(r) { r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r); }
+    function fulfill(value) { resume("next", value); }
+    function reject(value) { resume("throw", value); }
+    function settle(f, v) { if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]); }
+};
+import { ApiError, RequestScope, abortable, normalizeError } from './lifecycle';
+import { decodeAiChatBriefEvent } from './events';
+import { decodeSse } from './sse';
+let nextConnectionId = 0;
+/** One connection, no replay, retry, UI merging or recovery policy. */
+export class ChatSubscription {
+    constructor(request, url, messageId, options = {}, connect) {
+        this.request = request;
+        this.url = url;
+        this.messageId = messageId;
+        this.options = options;
+        this.connect = connect;
+        this.events = this;
+        this.queue = [];
+        this.done = false;
+        this.reason = 'closed';
+        this.connectionId = `connection-${++nextConnectionId}`;
+        if (options.idleTimeoutMs !== undefined && (!Number.isFinite(options.idleTimeoutMs) || options.idleTimeoutMs <= 0))
+            throw new RangeError('idleTimeoutMs must be positive');
+        this.scope = new RequestScope(options);
+        this.closed = new Promise(resolve => { this.finish = resolve; });
+        void this.run();
+    }
+    close() { this.reason = 'closed'; this.scope.controller.abort(); }
+    diagnostic(type, requestId = this.serverRequestId) {
+        var _a, _b, _c;
+        try {
+            (_b = (_a = this.options).onConnectionEvent) === null || _b === void 0 ? void 0 : _b.call(_a, { type, connectionId: this.connectionId, transport: (_c = this.options.transport) !== null && _c !== void 0 ? _c : 'sse', requestId, reason: type === 'closed' ? this.reason : undefined, closeCode: this.closeCode });
+        }
+        catch ( /* Observers do not own connection state. */_d) { /* Observers do not own connection state. */ }
+    }
+    activity() {
+        clearTimeout(this.idleTimer);
+        if (this.options.idleTimeoutMs !== undefined)
+            this.idleTimer = setTimeout(() => this.scope.controller.abort(new ApiError('', '', undefined, '', { kind: 'timeout' })), this.options.idleTimeoutMs);
+    }
+    push(data) {
+        var _a;
+        const event = decodeAiChatBriefEvent(data);
+        if (this.queue.length >= 1024)
+            throw new ApiError('', '', undefined, '', { kind: 'protocol' });
+        this.queue.push(event);
+        (_a = this.wake) === null || _a === void 0 ? void 0 : _a.call(this);
+        if (event.type === 'end') {
+            this.reason = 'end';
+            return true;
+        }
+        return false;
+    }
+    run() {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a, e_1, _b, _c;
+            var _d, _e, _f;
+            let requestId;
+            try {
+                if (this.options.transport === 'websocket')
+                    yield this.websocket();
+                else {
+                    const response = yield abortable(this.request(this.scope.signal), this.scope.signal);
+                    requestId = (_d = response.headers.get('X-Request-ID')) !== null && _d !== void 0 ? _d : undefined;
+                    this.diagnostic('opened', requestId);
+                    this.activity();
+                    try {
+                        for (var _g = true, _h = __asyncValues(decodeSse(response, this.scope.signal, comment => {
+                            this.activity();
+                            this.diagnostic(comment === 'ready' ? 'ready' : 'heartbeat', requestId);
+                        })), _j; _j = yield _h.next(), _a = _j.done, !_a; _g = true) {
+                            _c = _j.value;
+                            _g = false;
+                            const data = _c;
+                            this.activity();
+                            if (this.push(data))
+                                break;
+                        }
+                    }
+                    catch (e_1_1) { e_1 = { error: e_1_1 }; }
+                    finally {
+                        try {
+                            if (!_g && !_a && (_b = _h.return)) yield _b.call(_h);
+                        }
+                        finally { if (e_1) throw e_1.error; }
+                    }
+                    if (this.reason !== 'end')
+                        throw new ApiError('', '', undefined, '', { kind: 'unexpected_eof', requestId });
+                }
+            }
+            catch (error) {
+                if (!this.scope.signal.aborted || ((_e = this.options.signal) === null || _e === void 0 ? void 0 : _e.aborted) || this.scope.signal.reason instanceof ApiError) {
+                    this.failure = yield normalizeError(error, this.scope.signal);
+                    this.reason = this.failure.kind === 'timeout' ? 'timeout' : this.failure.kind === 'cancelled' ? 'cancelled' : 'error';
+                }
+            }
+            finally {
+                this.scope.controller.abort();
+                this.scope.dispose();
+                clearTimeout(this.idleTimer);
+                this.done = true;
+                (_f = this.wake) === null || _f === void 0 ? void 0 : _f.call(this);
+                this.diagnostic('closed', requestId);
+                this.finish({ reason: this.reason, error: this.failure, closeCode: this.closeCode });
+            }
+        });
+    }
+    websocket() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.connect)
+                throw new ApiError('', '', undefined, '', { kind: 'protocol' });
+            const socket = yield abortable(this.connect(this.url, this.scope.signal, this.options.xRequestID), this.scope.signal);
+            yield new Promise((resolve, reject) => {
+                let settled = false, ready = false;
+                const settle = (error) => {
+                    if (settled)
+                        return;
+                    settled = true;
+                    this.scope.signal.removeEventListener('abort', abort);
+                    socket.onopen = socket.onmessage = socket.onerror = socket.onclose = null;
+                    try {
+                        socket.close(1000, 'client-close');
+                    }
+                    catch ( /* Already closed. */_a) { /* Already closed. */ }
+                    error ? reject(error) : resolve();
+                };
+                const abort = () => settle(new ApiError('', '', undefined, '', { kind: 'cancelled' }));
+                this.scope.signal.addEventListener('abort', abort, { once: true });
+                if (this.scope.signal.aborted) {
+                    abort();
+                    return;
+                }
+                socket.onopen = () => { this.serverRequestId = socket.serverRequestId; this.diagnostic('opened'); this.activity(); };
+                socket.onmessage = frame => {
+                    try {
+                        this.activity();
+                        if (typeof frame.data !== 'string')
+                            throw new Error('Expected text frame');
+                        const value = JSON.parse(frame.data);
+                        if (value.id !== this.messageId || typeof value.event !== 'string')
+                            throw new Error('Invalid envelope');
+                        if (value.event === 'ready') {
+                            ready = true;
+                            this.diagnostic('ready');
+                        }
+                        else if (value.event === 'complete') {
+                            this.reason = 'complete';
+                            settle();
+                        }
+                        else if (value.event === 'transport-error')
+                            throw new ApiError('', '', undefined, JSON.stringify(value.data), { kind: 'protocol' });
+                        else {
+                            if (!ready || !value.data || typeof value.data.type !== 'string')
+                                throw new Error('Invalid business frame');
+                            if (this.push(JSON.stringify(value.data)))
+                                settle();
+                        }
+                    }
+                    catch (error) {
+                        settle(error instanceof ApiError ? error : new ApiError('', '', undefined, '', { kind: 'protocol' }));
+                    }
+                };
+                socket.onerror = () => { var _a; return settle((_a = socket.handshakeError) !== null && _a !== void 0 ? _a : new ApiError('', '', undefined, '', { kind: 'network' })); };
+                socket.onclose = event => { this.closeCode = event.code; if (event.code === 1000) {
+                    this.reason = 'normal';
+                    settle();
+                }
+                else
+                    settle(new ApiError('', '', undefined, '', { kind: 'unexpected_eof' })); };
+            });
+        });
+    }
+    [Symbol.asyncIterator]() {
+        return __asyncGenerator(this, arguments, function* _a() {
+            try {
+                for (;;) {
+                    if (this.queue.length) {
+                        yield yield __await(this.queue.shift());
+                        continue;
+                    }
+                    if (this.done) {
+                        if (this.failure)
+                            throw this.failure;
+                        return yield __await(void 0);
+                    }
+                    yield __await(new Promise(resolve => { this.wake = resolve; }));
+                }
+            }
+            finally {
+                this.close();
+                yield __await(this.closed);
+            }
+        });
+    }
+}
+/** Finite SSE endpoints permit EOF, while sharing cancellation and idle semantics. */
+export function finiteSse(request_1) {
+    return __asyncGenerator(this, arguments, function* finiteSse_1(request, options = {}) {
+        var _a, e_2, _b, _c;
+        var _d;
+        if (options.idleTimeoutMs !== undefined && (!Number.isFinite(options.idleTimeoutMs) || options.idleTimeoutMs <= 0))
+            throw new RangeError('idleTimeoutMs must be positive');
+        const scope = new RequestScope(options);
+        let timer;
+        let reason = 'closed', requestId;
+        const connectionId = `connection-${++nextConnectionId}`;
+        const diagnostic = (type) => {
+            var _a;
+            try {
+                (_a = options.onConnectionEvent) === null || _a === void 0 ? void 0 : _a.call(options, { type, transport: 'sse', connectionId, requestId, reason: type === 'closed' ? reason : undefined });
+            }
+            catch ( /* Observer only. */_b) { /* Observer only. */ }
+        };
+        const activity = () => {
+            clearTimeout(timer);
+            if (options.idleTimeoutMs !== undefined)
+                timer = setTimeout(() => scope.controller.abort(new ApiError('', '', undefined, '', { kind: 'timeout' })), options.idleTimeoutMs);
+        };
+        try {
+            if (options.transport === 'websocket')
+                throw new ApiError('', '', undefined, '', { kind: 'protocol' });
+            const response = yield __await(abortable(request(scope.signal), scope.signal));
+            requestId = (_d = response.headers.get('X-Request-ID')) !== null && _d !== void 0 ? _d : undefined;
+            diagnostic('opened');
+            activity();
+            try {
+                for (var _e = true, _f = __asyncValues(decodeSse(response, scope.signal, comment => { activity(); diagnostic(comment === 'ready' ? 'ready' : 'heartbeat'); })), _g; _g = yield __await(_f.next()), _a = _g.done, !_a; _e = true) {
+                    _c = _g.value;
+                    _e = false;
+                    const data = _c;
+                    activity();
+                    yield yield __await(data);
+                }
+            }
+            catch (e_2_1) { e_2 = { error: e_2_1 }; }
+            finally {
+                try {
+                    if (!_e && !_a && (_b = _f.return)) yield __await(_b.call(_f));
+                }
+                finally { if (e_2) throw e_2.error; }
+            }
+            reason = 'normal';
+        }
+        catch (error) {
+            const normalized = yield __await(normalizeError(error, scope.signal));
+            requestId !== null && requestId !== void 0 ? requestId : (requestId = normalized.requestId);
+            reason = normalized.kind === 'timeout' ? 'timeout' : normalized.kind === 'cancelled' ? 'cancelled' : 'error';
+            throw normalized;
+        }
+        finally {
+            scope.controller.abort();
+            scope.dispose();
+            clearTimeout(timer);
+            diagnostic('closed');
+        }
+    });
+}

package/dist/esm/token.d.ts

@@ -0,0 +1,20 @@
+import type { WebSocketFactory } from './subscription';
+/** A fresh token must be issued for every invocation, including concurrent calls. */
+export type TokenProvider = (context: {
+    channelId: string;
+    signal?: AbortSignal;
+    fetch: typeof fetch;
+}) => string | Promise<string>;
+export interface TokenAuth {
+    type: 'token';
+    tokenProvider: TokenProvider;
+}
+export interface ClientOptions<Auth> {
+    baseUrl: string;
+    channelId: string;
+    auth: Auth;
+    fetch?: typeof fetch;
+    webSocketFactory?: WebSocketFactory;
+}
+/** Browser-safe transport: no cache, HMAC headers, redirects, or automatic retries. */
+export declare function createTokenFetch(provider: TokenProvider, channelId: string, network?: typeof fetch): typeof fetch;

package/dist/esm/token.js

@@ -0,0 +1,38 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { ApiError, abortable, checkSignal, fetchResponse } from './lifecycle';
+/** Browser-safe transport: no cache, HMAC headers, redirects, or automatic retries. */
+export function createTokenFetch(provider, channelId, network = globalThis.fetch) {
+    if (typeof provider !== 'function')
+        throw new Error('tokenProvider must be a function');
+    return (input, init) => __awaiter(this, void 0, void 0, function* () {
+        const request = new Request(input, init);
+        checkSignal(request.signal);
+        if (new URL(request.url).pathname.endsWith('/presign'))
+            throw new ApiError('POST', '/presign', undefined, '{"message":"presign requires HMAC authentication"}', { kind: 'authentication' });
+        if (Array.from(request.headers.keys()).some(name => name.toLowerCase().startsWith('x-openapi-'))) {
+            throw new Error('Authentication headers are managed by the SDK');
+        }
+        let token;
+        try {
+            token = yield abortable(Promise.resolve().then(() => provider({ channelId, signal: request.signal, fetch: network })), request.signal);
+        }
+        catch (_a) {
+            checkSignal(request.signal);
+            throw Object.assign(new ApiError('', '', undefined, '', { kind: 'authentication' }), { message: 'OpenAPI token provider failed' });
+        }
+        checkSignal(request.signal);
+        if (typeof token !== 'string' || !/^[\x21-\x7e]+$/.test(token))
+            throw Object.assign(new ApiError('', '', undefined, '', { kind: 'authentication' }), { message: 'Invalid OpenAPI token' });
+        const headers = new Headers(request.headers);
+        headers.set('X-OpenAPI-Token', token);
+        return fetchResponse(network, new Request(request, { headers, redirect: 'error' }));
+    });
+}

package/dist/events.js

@@ -4,7 +4,7 @@ exports.decodeAiChatBriefEvent = decodeAiChatBriefEvent;
 exports.decodeToolExtension = decodeToolExtension;
 const knownEventTypes = new Set([
     'user-query', 'compressor-context-start', 'compressor-context-end', 'compactor-warning', 'manual-interrupt',
-    'error', 'start', 'think', 'chat-client-request', 'chat-client-response', 'message', 'tool-execution',
+    'error', 'start', 'think', 'message', 'tool-execution',
     'tool-execution-sub-agent-call', 'tool-execution-awaiting-user-input', 'end',
 ]);
 const knownToolCategories = new Set([

package/dist/hmac.d.ts

@@ -14,7 +14,7 @@ export interface OpenApiCredentials {
  * @param externalUserId - UTF-8 编码后为 1..256 字节且不含 NUL 的外部用户 ID。
  * @returns 与原生 fetch 兼容的签名 transport。
  */
-export declare function createSignedFetch(credentials: OpenApiCredentials, externalUserId: string): typeof fetch;
+export declare function createSignedFetch(credentials: OpenApiCredentials, externalUserId: string, network?: typeof fetch): typeof fetch;
 /**
  * 对固定 canonical string 计算 HMAC。 / Computes HMAC for a fixed canonical string.
  *

package/dist/hmac.js

@@ -11,6 +11,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createSignedFetch = createSignedFetch;
 exports.signCanonical = signCanonical;
+const lifecycle_1 = require("./lifecycle");
 const node_crypto_1 = require("node:crypto");
 /**
  * 构造已签名 fetch；每次调用都会重新生成 timestamp、nonce 和签名。 / Creates a fetch that signs every attempt independently.
@@ -21,7 +22,7 @@ const node_crypto_1 = require("node:crypto");
  * @param externalUserId - UTF-8 编码后为 1..256 字节且不含 NUL 的外部用户 ID。
  * @returns 与原生 fetch 兼容的签名 transport。
  */
-function createSignedFetch(credentials, externalUserId) {
+function createSignedFetch(credentials, externalUserId, network = globalThis.fetch) {
     const userBytes = Buffer.from(externalUserId, 'utf8');
     if (userBytes.length < 1 || userBytes.length > 256 || userBytes.includes(0)) {
         throw new Error('externalUserId must contain 1 to 256 UTF-8 bytes and no NUL');
@@ -52,7 +53,7 @@ function createSignedFetch(credentials, externalUserId) {
         headers.set('X-OpenAPI-Nonce', nonce);
         headers.set('X-OpenAPI-User', encodedUser);
         headers.set('X-OpenAPI-Signature', (0, node_crypto_1.createHmac)('sha256', credentials.secretKey).update(canonical).digest('hex'));
-        return fetch(new Request(request, { headers }));
+        return (0, lifecycle_1.fetchResponse)(network, new Request(request, { headers, redirect: 'error' }));
     });
 }
 /**

package/dist/lifecycle.d.ts

@@ -0,0 +1,55 @@
+export type ErrorKind = 'http' | 'network' | 'authentication' | 'protocol' | 'cancelled' | 'timeout' | 'unexpected_eof';
+export interface RequestOptions {
+    signal?: AbortSignal;
+    timeoutMs?: number;
+}
+export interface ErrorDetails {
+    kind?: ErrorKind;
+    code?: string;
+    fields?: Array<{
+        field: string;
+        message: string;
+    }>;
+    requestId?: string;
+    cause?: unknown;
+}
+export declare class ApiError extends Error {
+    readonly method: string;
+    readonly path: string;
+    readonly status: number | undefined;
+    readonly responseBody: string;
+    readonly kind: ErrorKind;
+    readonly code?: string;
+    readonly fields?: Array<{
+        field: string;
+        message: string;
+    }>;
+    readonly requestId?: string;
+    readonly cause?: unknown;
+    constructor(method: string, path: string, status: number | undefined, responseBody?: string, details?: ErrorDetails);
+}
+export declare function abortError(signal: AbortSignal): ApiError;
+export declare function checkSignal(signal?: AbortSignal): void;
+export declare function abortable<T>(promise: PromiseLike<T>, signal?: AbortSignal): Promise<T>;
+export declare class RequestScope {
+    private readonly options;
+    readonly controller: AbortController;
+    readonly signal: AbortSignal;
+    private timer?;
+    private readonly abort;
+    constructor(options?: RequestOptions);
+    dispose(): void;
+}
+export declare function normalizeError(error: unknown, signal?: AbortSignal): Promise<ApiError>;
+export declare function execute<T>(options: RequestOptions, operation: (signal: AbortSignal) => Promise<T>): Promise<T>;
+export interface DownloadResponse {
+    bytes: Uint8Array;
+    filename?: string;
+    contentType?: string;
+    headers: Headers;
+    status: number;
+    requestId?: string;
+}
+export declare function downloadResponse(response: Response): Promise<DownloadResponse>;
+/** Enforce cancellation even when an injected Fetch ignores its signal. */
+export declare function fetchResponse(network: typeof fetch, request: Request): Promise<Response>;