recker 1.0.26 → 1.0.27

package/dist/browser/types/udp.d.ts

@@ -0,0 +1,138 @@
+import type { ReckerRequest, ReckerResponse, Transport } from './index.js';
+export interface UDPTimings {
+    queued: number;
+    send: number;
+    receive: number;
+    retransmissions: number;
+    total: number;
+}
+export interface DTLSTimings extends UDPTimings {
+    handshake: number;
+}
+export interface QUICTimings extends UDPTimings {
+    quicHandshake: number;
+    streamOpen: number;
+    firstByte: number;
+    zeroRTT: boolean;
+}
+export interface UDPConnection {
+    protocol: 'udp' | 'dtls' | 'quic';
+    localAddress: string;
+    localPort: number;
+    remoteAddress: string;
+    remotePort: number;
+}
+export interface DTLSConnection extends UDPConnection {
+    protocol: 'dtls';
+    cipher: string;
+    version: string;
+}
+export interface QUICConnection extends UDPConnection {
+    protocol: 'quic';
+    alpn: string;
+    congestion: 'bbr' | 'cubic' | 'reno';
+    quicVersion: string;
+    migrated: boolean;
+}
+export interface BaseUDPTransportOptions {
+    timeout?: number;
+    retransmissions?: number;
+    maxPacketSize?: number;
+    observability?: boolean;
+    debug?: boolean;
+    localAddress?: string;
+    localPort?: number;
+}
+export interface UDPTransportOptions extends BaseUDPTransportOptions {
+    broadcast?: boolean;
+    multicastTTL?: number;
+    multicastGroups?: string[];
+    multicastLoopback?: boolean;
+    type?: 'udp4' | 'udp6';
+    recvBufferSize?: number;
+    sendBufferSize?: number;
+}
+export interface DTLSTransportOptions extends BaseUDPTransportOptions {
+    cert?: string | Buffer;
+    key?: string | Buffer;
+    ca?: string | Buffer | Array<string | Buffer>;
+    passphrase?: string;
+    ciphers?: string;
+    minVersion?: 'DTLSv1.0' | 'DTLSv1.2';
+    rejectUnauthorized?: boolean;
+    servername?: string;
+    handshakeTimeout?: number;
+    mtu?: number;
+}
+export interface QUICTransportOptions extends BaseUDPTransportOptions {
+    maxStreams?: number;
+    idleTimeout?: number;
+    congestionControl?: 'bbr' | 'cubic' | 'reno';
+    earlyData?: boolean;
+    sessionCache?: Map<string, Buffer>;
+    cert?: string | Buffer;
+    key?: string | Buffer;
+    ca?: string | Buffer | Array<string | Buffer>;
+    alpnProtocols?: string[];
+    initialRtt?: number;
+    connectionMigration?: boolean;
+}
+export interface UDPRequestOptions {
+    broadcast?: boolean;
+    multicast?: string;
+    ttl?: number;
+    port?: number;
+}
+export interface UDPRequest extends ReckerRequest {
+    udp?: UDPRequestOptions;
+}
+export interface UDPResponse<T = unknown> extends ReckerResponse<T> {
+    timings: UDPTimings;
+    connection: UDPConnection;
+    buffer(): Promise<Buffer>;
+    packets(): AsyncGenerator<Buffer>;
+}
+export interface UDPTransport extends Transport {
+    dispatch(req: UDPRequest): Promise<UDPResponse>;
+    send(host: string, port: number, data: Buffer): Promise<void>;
+    broadcast(port: number, data: Buffer): Promise<void>;
+    joinMulticast(group: string): void;
+    leaveMulticast(group: string): void;
+    close(): Promise<void>;
+}
+export interface DTLSTransportInterface extends Transport {
+    dispatch(req: UDPRequest): Promise<UDPResponse>;
+    handshake(): Promise<void>;
+    getSession(): Buffer | null;
+    close(): Promise<void>;
+}
+export interface QUICTransportInterface extends Transport {
+    dispatch(req: ReckerRequest): Promise<ReckerResponse>;
+    getSessionTicket(): Buffer | null;
+    migrate(newLocalAddress: string): Promise<void>;
+    close(): Promise<void>;
+}
+export interface UDPBatchResult<T> {
+    results: Array<T | Error>;
+    stats: {
+        total: number;
+        successful: number;
+        failed: number;
+        duration: number;
+    };
+}
+export interface UDPDiscoveryResult {
+    address: string;
+    port: number;
+    data: Buffer;
+    latency: number;
+}
+export interface SimpleUDPAPI {
+    send(address: string, data: Buffer, options?: UDPTransportOptions): Promise<UDPResponse>;
+    broadcast(port: number, data: Buffer, options?: UDPTransportOptions & {
+        timeout?: number;
+    }): Promise<UDPDiscoveryResult[]>;
+    discover(group: string, port: number, data: Buffer, options?: UDPTransportOptions & {
+        timeout?: number;
+    }): Promise<UDPDiscoveryResult[]>;
+}

package/dist/browser/types/udp.js

@@ -0,0 +1 @@
+export {};

package/dist/browser/utils/agent-manager.d.ts

@@ -0,0 +1,29 @@
+import { Agent } from 'undici';
+import type { AgentOptions } from '../types/index.js';
+export interface AgentStats {
+    agentCount: number;
+    domains: string[];
+    totalConnections: number;
+}
+export declare class AgentManager {
+    private globalAgent?;
+    private domainAgents;
+    private options;
+    constructor(options?: AgentOptions);
+    getGlobalAgent(): Agent;
+    getAgentForDomain(domain: string, options?: Partial<AgentOptions>): Agent;
+    getAgentForUrl(url: string): Agent;
+    createBatchAgent(concurrency: number, requestCount: number, options?: Partial<AgentOptions>): Agent;
+    createStressTestAgent(concurrency: number): Agent;
+    private createAgent;
+    getStats(): AgentStats;
+    closeDomainAgent(domain: string): Promise<void>;
+    closeAll(): Promise<void>;
+    destroy(): Promise<void>;
+}
+export declare function createAgent(options?: AgentOptions): Agent;
+export declare function extractDomain(url: string): string | null;
+export declare function analyzeBatchDomains(urls: string[]): {
+    strategy: 'single' | 'multi';
+    domains: Set<string>;
+};

package/dist/browser/utils/agent-manager.js

@@ -0,0 +1,160 @@
+import { Agent } from 'undici';
+export class AgentManager {
+    globalAgent;
+    domainAgents;
+    options;
+    constructor(options = {}) {
+        this.domainAgents = new Map();
+        this.options = {
+            connections: options.connections ?? 10,
+            pipelining: options.pipelining ?? 1,
+            keepAlive: options.keepAlive ?? true,
+            keepAliveTimeout: options.keepAliveTimeout ?? 4 * 1000,
+            keepAliveMaxTimeout: options.keepAliveMaxTimeout ?? 10 * 60 * 1000,
+            keepAliveTimeoutThreshold: options.keepAliveTimeoutThreshold ?? 1 * 1000,
+            connectTimeout: options.connectTimeout ?? 10 * 1000,
+            perDomainPooling: options.perDomainPooling ?? true,
+            localAddress: options.localAddress,
+            maxRequestsPerClient: options.maxRequestsPerClient ?? 0,
+            maxCachedSessions: options.maxCachedSessions ?? 100,
+            maxHeaderSize: options.maxHeaderSize,
+            clientTtl: options.clientTtl ?? null,
+        };
+    }
+    getGlobalAgent() {
+        if (!this.globalAgent) {
+            this.globalAgent = this.createAgent(this.options);
+        }
+        return this.globalAgent;
+    }
+    getAgentForDomain(domain, options) {
+        if (!this.options.perDomainPooling) {
+            return this.getGlobalAgent();
+        }
+        let agent = this.domainAgents.get(domain);
+        if (!agent) {
+            const agentOptions = { ...this.options, ...options };
+            agent = this.createAgent(agentOptions);
+            this.domainAgents.set(domain, agent);
+        }
+        return agent;
+    }
+    getAgentForUrl(url) {
+        try {
+            const parsedUrl = new URL(url);
+            return this.getAgentForDomain(parsedUrl.hostname);
+        }
+        catch {
+            return this.getGlobalAgent();
+        }
+    }
+    createBatchAgent(concurrency, requestCount, options) {
+        const smartConnections = Math.max(1, Math.min(Math.ceil(concurrency / 2), 50, requestCount));
+        const smartPipelining = requestCount > 20 && concurrency > 5
+            ? 2
+            : 1;
+        const batchOptions = {
+            ...this.options,
+            connections: options?.connections ?? smartConnections,
+            pipelining: options?.pipelining ?? smartPipelining,
+            ...options,
+        };
+        return this.createAgent(batchOptions);
+    }
+    createStressTestAgent(concurrency) {
+        const pipelining = 10;
+        const connections = Math.min(Math.ceil(concurrency / pipelining), 100);
+        return this.createAgent({
+            connections,
+            pipelining,
+            keepAliveTimeout: 30000,
+            keepAliveMaxTimeout: 120000,
+            connectTimeout: 5000,
+        });
+    }
+    createAgent(options) {
+        return new Agent({
+            connections: options.connections,
+            pipelining: options.pipelining,
+            maxHeaderSize: options.maxHeaderSize,
+            maxRequestsPerClient: options.maxRequestsPerClient,
+            maxCachedSessions: options.maxCachedSessions,
+            clientTtl: options.clientTtl ?? null,
+            keepAliveTimeout: options.keepAliveTimeout,
+            keepAliveMaxTimeout: options.keepAliveMaxTimeout,
+            keepAliveTimeoutThreshold: options.keepAliveTimeoutThreshold,
+            connectTimeout: options.connectTimeout,
+            socketPath: undefined,
+            connect: {
+                timeout: options.connectTimeout,
+                keepAlive: options.keepAlive,
+                keepAliveInitialDelay: options.keepAliveTimeout,
+                localAddress: options.localAddress,
+            },
+        });
+    }
+    getStats() {
+        return {
+            agentCount: 1 + this.domainAgents.size,
+            domains: Array.from(this.domainAgents.keys()),
+            totalConnections: (1 + this.domainAgents.size) * this.options.connections,
+        };
+    }
+    async closeDomainAgent(domain) {
+        const agent = this.domainAgents.get(domain);
+        if (agent) {
+            await agent.close();
+            this.domainAgents.delete(domain);
+        }
+    }
+    async closeAll() {
+        const closePromises = [];
+        if (this.globalAgent) {
+            closePromises.push(this.globalAgent.close());
+            this.globalAgent = undefined;
+        }
+        for (const agent of this.domainAgents.values()) {
+            closePromises.push(agent.close());
+        }
+        this.domainAgents.clear();
+        await Promise.all(closePromises);
+    }
+    async destroy() {
+        const destroyPromises = [];
+        if (this.globalAgent) {
+            destroyPromises.push(this.globalAgent.destroy());
+            this.globalAgent = undefined;
+        }
+        for (const agent of this.domainAgents.values()) {
+            destroyPromises.push(agent.destroy());
+        }
+        this.domainAgents.clear();
+        await Promise.all(destroyPromises);
+    }
+}
+export function createAgent(options = {}) {
+    const manager = new AgentManager(options);
+    return manager.getGlobalAgent();
+}
+export function extractDomain(url) {
+    try {
+        const parsed = new URL(url);
+        return parsed.hostname;
+    }
+    catch {
+        return null;
+    }
+}
+export function analyzeBatchDomains(urls) {
+    const domains = new Set();
+    for (const url of urls) {
+        const domain = extractDomain(url);
+        if (domain) {
+            domains.add(domain);
+        }
+    }
+    return {
+        strategy: domains.size <= 1 ? 'single' : 'multi',
+        domains,
+    };
+}

package/dist/browser/utils/body.d.ts

@@ -0,0 +1,10 @@
+export type BodyInput = string | Blob | ArrayBuffer | FormData | URLSearchParams | ReadableStream | Record<string, any> | null | undefined;
+export interface ProcessedBody {
+    body: any;
+    contentType?: string;
+}
+export declare function isPlainObject(value: any): boolean;
+export declare function processBody(body: BodyInput): ProcessedBody;
+export declare function createFormData(data: Record<string, any>): FormData;
+export declare function createMultipart(data: Record<string, any>): FormData;
+export declare function isFileUpload(body: any): boolean;

package/dist/browser/utils/body.js

@@ -0,0 +1,148 @@
+export function isPlainObject(value) {
+    if (typeof value !== 'object' || value === null) {
+        return false;
+    }
+    if (value instanceof Blob ||
+        value instanceof FormData ||
+        value instanceof URLSearchParams ||
+        value instanceof ArrayBuffer ||
+        value instanceof ReadableStream) {
+        return false;
+    }
+    if (typeof File !== 'undefined') {
+        try {
+            if (value instanceof File) {
+                return false;
+            }
+        }
+        catch {
+        }
+    }
+    return true;
+}
+export function processBody(body) {
+    if (body === null || body === undefined) {
+        return { body: undefined };
+    }
+    if (typeof body === 'string') {
+        return {
+            body,
+            contentType: 'text/plain; charset=utf-8'
+        };
+    }
+    if (body instanceof FormData) {
+        return {
+            body,
+            contentType: undefined
+        };
+    }
+    if (body instanceof URLSearchParams) {
+        return {
+            body: body.toString(),
+            contentType: 'application/x-www-form-urlencoded'
+        };
+    }
+    if (body instanceof Blob || isFile(body)) {
+        return {
+            body,
+            contentType: body.type || 'application/octet-stream'
+        };
+    }
+    if (body instanceof ArrayBuffer) {
+        return {
+            body,
+            contentType: 'application/octet-stream'
+        };
+    }
+    if (body instanceof ReadableStream) {
+        return {
+            body,
+            contentType: 'application/octet-stream'
+        };
+    }
+    if (isPlainObject(body)) {
+        if (isFileUpload(body)) {
+            return {
+                body: createFormData(body),
+                contentType: undefined
+            };
+        }
+        return {
+            body: JSON.stringify(body),
+            contentType: 'application/json'
+        };
+    }
+    if (Array.isArray(body)) {
+        return {
+            body: JSON.stringify(body),
+            contentType: 'application/json'
+        };
+    }
+    return {
+        body: String(body),
+        contentType: 'text/plain; charset=utf-8'
+    };
+}
+export function createFormData(data) {
+    const formData = new FormData();
+    for (const [key, value] of Object.entries(data)) {
+        if (value === null || value === undefined) {
+            continue;
+        }
+        if (Array.isArray(value)) {
+            value.forEach((item) => {
+                if (item instanceof Blob || isFile(item)) {
+                    formData.append(key, item);
+                }
+                else {
+                    formData.append(key, String(item));
+                }
+            });
+            continue;
+        }
+        if (value instanceof Blob || isFile(value)) {
+            formData.append(key, value);
+            continue;
+        }
+        if (typeof value === 'object') {
+            formData.append(key, JSON.stringify(value));
+            continue;
+        }
+        formData.append(key, String(value));
+    }
+    return formData;
+}
+export function createMultipart(data) {
+    return createFormData(data);
+}
+function isFile(value) {
+    if (typeof File === 'undefined') {
+        return false;
+    }
+    return value instanceof File;
+}
+export function isFileUpload(body) {
+    if (!body)
+        return false;
+    if (body instanceof Blob || isFile(body)) {
+        return true;
+    }
+    if (body instanceof FormData) {
+        for (const value of body.values()) {
+            if (value instanceof Blob || isFile(value)) {
+                return true;
+            }
+        }
+    }
+    if (isPlainObject(body)) {
+        for (const value of Object.values(body)) {
+            if (value instanceof Blob || isFile(value)) {
+                return true;
+            }
+            if (Array.isArray(value) && value.some(v => v instanceof Blob || isFile(v))) {
+                return true;
+            }
+        }
+    }
+    return false;
+}

package/dist/browser/utils/charset.d.ts

@@ -0,0 +1,15 @@
+export interface CharsetInfo {
+    charset: string;
+    source: 'header' | 'bom' | 'xml' | 'html-meta' | 'default';
+    confidence: 'high' | 'medium' | 'low';
+}
+export declare function normalizeCharset(charset: string): string;
+export declare function detectFromContentType(contentType: string | null): string | null;
+export declare function detectFromBOM(buffer: Uint8Array): CharsetInfo | null;
+export declare function stripBOM(buffer: Uint8Array): Uint8Array;
+export declare function detectFromXMLDeclaration(content: string): string | null;
+export declare function detectFromHTMLMeta(html: string): string | null;
+export declare function detectCharset(buffer: Uint8Array, contentType?: string | null): CharsetInfo;
+export declare function decodeText(buffer: Uint8Array, charsetOrInfo?: string | CharsetInfo): string;
+export declare function getSupportedEncodings(): string[];
+export declare function isCharsetSupported(charset: string): boolean;

package/dist/browser/utils/charset.js

@@ -0,0 +1,169 @@
+const charsetAliases = {
+    'utf8': 'utf-8',
+    'utf_8': 'utf-8',
+    'utf16': 'utf-16',
+    'utf_16': 'utf-16',
+    'utf16le': 'utf-16le',
+    'utf16be': 'utf-16be',
+    'latin1': 'iso-8859-1',
+    'latin-1': 'iso-8859-1',
+    'iso8859-1': 'iso-8859-1',
+    'iso_8859-1': 'iso-8859-1',
+    'cp1252': 'windows-1252',
+    'win1252': 'windows-1252',
+    'us-ascii': 'ascii',
+    'usascii': 'ascii',
+    'gbk': 'gbk',
+    'gb2312': 'gb2312',
+    'gb18030': 'gb18030',
+    'shift-jis': 'shift_jis',
+    'shiftjis': 'shift_jis',
+    'sjis': 'shift_jis',
+    'euc-jp': 'euc-jp',
+    'eucjp': 'euc-jp',
+    'iso-2022-jp': 'iso-2022-jp',
+    'euc-kr': 'euc-kr',
+    'euckr': 'euc-kr',
+};
+export function normalizeCharset(charset) {
+    const lower = charset.toLowerCase().trim();
+    return charsetAliases[lower] || lower;
+}
+export function detectFromContentType(contentType) {
+    if (!contentType)
+        return null;
+    const charsetMatch = contentType.match(/charset=["']?([^"';\s]+)["']?/i);
+    if (charsetMatch) {
+        return normalizeCharset(charsetMatch[1]);
+    }
+    return null;
+}
+export function detectFromBOM(buffer) {
+    if (buffer.length < 2)
+        return null;
+    if (buffer.length >= 4 && buffer[0] === 0x00 && buffer[1] === 0x00 &&
+        buffer[2] === 0xFE && buffer[3] === 0xFF) {
+        return { charset: 'utf-32be', source: 'bom', confidence: 'high' };
+    }
+    if (buffer.length >= 4 && buffer[0] === 0xFF && buffer[1] === 0xFE &&
+        buffer[2] === 0x00 && buffer[3] === 0x00) {
+        return { charset: 'utf-32le', source: 'bom', confidence: 'high' };
+    }
+    if (buffer.length >= 3 && buffer[0] === 0xEF && buffer[1] === 0xBB && buffer[2] === 0xBF) {
+        return { charset: 'utf-8', source: 'bom', confidence: 'high' };
+    }
+    if (buffer[0] === 0xFE && buffer[1] === 0xFF) {
+        return { charset: 'utf-16be', source: 'bom', confidence: 'high' };
+    }
+    if (buffer[0] === 0xFF && buffer[1] === 0xFE) {
+        return { charset: 'utf-16le', source: 'bom', confidence: 'high' };
+    }
+    return null;
+}
+export function stripBOM(buffer) {
+    const bomInfo = detectFromBOM(buffer);
+    if (!bomInfo)
+        return buffer;
+    switch (bomInfo.charset) {
+        case 'utf-8':
+            return buffer.slice(3);
+        case 'utf-16le':
+        case 'utf-16be':
+            return buffer.slice(2);
+        case 'utf-32le':
+        case 'utf-32be':
+            return buffer.slice(4);
+        default:
+            return buffer;
+    }
+}
+export function detectFromXMLDeclaration(content) {
+    const xmlMatch = content.match(/<\?xml[^?]*encoding=["']([^"']+)["'][^?]*\?>/i);
+    if (xmlMatch) {
+        return normalizeCharset(xmlMatch[1]);
+    }
+    return null;
+}
+export function detectFromHTMLMeta(html) {
+    const head = html.slice(0, 1024);
+    const charsetMeta = head.match(/<meta[^>]+charset=["']?([^"'>\s]+)["']?/i);
+    if (charsetMeta) {
+        return normalizeCharset(charsetMeta[1]);
+    }
+    const httpEquiv = head.match(/<meta[^>]+http-equiv=["']?Content-Type["']?[^>]+content=["']?[^"'>]*charset=([^"'>\s;]+)/i);
+    if (httpEquiv) {
+        return normalizeCharset(httpEquiv[1]);
+    }
+    const httpEquivReverse = head.match(/<meta[^>]+content=["']?[^"'>]*charset=([^"'>\s;]+)[^>]+http-equiv=["']?Content-Type["']?/i);
+    if (httpEquivReverse) {
+        return normalizeCharset(httpEquivReverse[1]);
+    }
+    return null;
+}
+export function detectCharset(buffer, contentType) {
+    const headerCharset = detectFromContentType(contentType || null);
+    if (headerCharset) {
+        return { charset: headerCharset, source: 'header', confidence: 'high' };
+    }
+    const bomResult = detectFromBOM(buffer);
+    if (bomResult) {
+        return bomResult;
+    }
+    const textDecoder = new TextDecoder('utf-8', { fatal: false });
+    const text = textDecoder.decode(buffer.slice(0, 1024));
+    if (text.trimStart().startsWith('<?xml')) {
+        const xmlCharset = detectFromXMLDeclaration(text);
+        if (xmlCharset) {
+            return { charset: xmlCharset, source: 'xml', confidence: 'medium' };
+        }
+    }
+    if (text.toLowerCase().includes('<html') || text.toLowerCase().includes('<!doctype html')) {
+        const htmlCharset = detectFromHTMLMeta(text);
+        if (htmlCharset) {
+            return { charset: htmlCharset, source: 'html-meta', confidence: 'medium' };
+        }
+    }
+    return { charset: 'utf-8', source: 'default', confidence: 'low' };
+}
+export function decodeText(buffer, charsetOrInfo) {
+    let charset = 'utf-8';
+    if (typeof charsetOrInfo === 'string') {
+        charset = normalizeCharset(charsetOrInfo);
+    }
+    else if (charsetOrInfo) {
+        charset = charsetOrInfo.charset;
+    }
+    const cleanBuffer = stripBOM(buffer);
+    try {
+        const decoder = new TextDecoder(charset);
+        return decoder.decode(cleanBuffer);
+    }
+    catch {
+        const decoder = new TextDecoder('utf-8', { fatal: false });
+        return decoder.decode(cleanBuffer);
+    }
+}
+export function getSupportedEncodings() {
+    return [
+        'utf-8', 'utf-16le', 'utf-16be',
+        'iso-8859-1', 'iso-8859-2', 'iso-8859-3', 'iso-8859-4', 'iso-8859-5',
+        'iso-8859-6', 'iso-8859-7', 'iso-8859-8', 'iso-8859-9', 'iso-8859-10',
+        'iso-8859-11', 'iso-8859-13', 'iso-8859-14', 'iso-8859-15', 'iso-8859-16',
+        'windows-1250', 'windows-1251', 'windows-1252', 'windows-1253',
+        'windows-1254', 'windows-1255', 'windows-1256', 'windows-1257', 'windows-1258',
+        'koi8-r', 'koi8-u',
+        'gbk', 'gb2312', 'gb18030',
+        'big5', 'big5-hkscs',
+        'shift_jis', 'euc-jp', 'iso-2022-jp',
+        'euc-kr',
+    ];
+}
+export function isCharsetSupported(charset) {
+    try {
+        new TextDecoder(normalizeCharset(charset));
+        return true;
+    }
+    catch {
+        return false;
+    }
+}

package/dist/browser/utils/concurrency.d.ts

@@ -0,0 +1,20 @@
+import type { AgentOptions, ClientOptions } from '../types/index.js';
+export interface NormalizedConcurrencyConfig {
+    max: number;
+    requestsPerInterval: number;
+    interval: number;
+    runner: {
+        concurrency: number;
+        retries?: number;
+        retryDelay?: number;
+    };
+    agent: AgentOptions & {
+        connections: number;
+    };
+    http2: {
+        maxConcurrentStreams: number;
+    };
+}
+export declare function normalizeConcurrency(options: Pick<ClientOptions, 'concurrency' | 'http2'>): NormalizedConcurrencyConfig;
+export declare function calculateOptimalConnections(maxConcurrent: number, http2Enabled: boolean, http2MaxStreams?: number, pipelining?: number): number;
+export declare function createBatchConfig(baseConcurrency: NormalizedConcurrencyConfig, batchConcurrency: number, requestCount: number): NormalizedConcurrencyConfig;