allure-report-publisher 5.0.0-alpha.0

package/dist/lib/allure/report-generator.d.ts

@@ -0,0 +1,11 @@
+import { AllureConfig } from './config.js';
+export declare class ReportGenerator {
+    private readonly resultGlob;
+    private readonly allureConfig;
+    private readonly downloadHistory;
+    private _outputPath;
+    constructor(resultGlob: string, allureConfig: AllureConfig, downloadHistory: () => Promise<void>);
+    execute(): Promise<void>;
+    private outputPath;
+    private generateReport;
+}

package/dist/lib/allure/report-generator.js

@@ -0,0 +1,43 @@
+import spawn from 'nano-spawn';
+import { globPaths } from '../../utils/glob.js';
+import { logger } from '../../utils/logger.js';
+import { spin } from '../../utils/spinner.js';
+export class ReportGenerator {
+    resultGlob;
+    allureConfig;
+    downloadHistory;
+    _outputPath;
+    constructor(resultGlob, allureConfig, downloadHistory) {
+        this.resultGlob = resultGlob;
+        this.allureConfig = allureConfig;
+        this.downloadHistory = downloadHistory;
+    }
+    async execute() {
+        await spin(this.downloadHistory(), 'downloading previous run history', { ignoreError: true });
+        await spin(this.generateReport(), 'generating report');
+    }
+    async outputPath() {
+        if (!this._outputPath) {
+            this._outputPath = await this.allureConfig.outputPath();
+        }
+        return this._outputPath;
+    }
+    async generateReport() {
+        const args = ['generate', this.resultGlob, '-c', this.allureConfig.configPath(), '-o', await this.outputPath()];
+        try {
+            logger.debug(`Running allure with args: ${args.join(' ')}`);
+            const result = await spawn('allure', args, { preferLocal: true });
+            logger.debug('Allure report generation completed successfully');
+            if (result.output.trim().length > 0)
+                logger.debug(`Allure output:\n${result.output}`);
+            const generatedFiles = await globPaths(`${await this.outputPath()}/**/*`, { nodir: true });
+            logger.debug(`Total report files for upload: ${generatedFiles.length}`);
+        }
+        catch (error) {
+            const processError = error;
+            logger.debug(`Command '${processError.command}' failed with exit code ${processError.exitCode}`);
+            logger.debug(`Command execution time: ${processError.durationMs}ms`);
+            throw new Error(`Allure report generation failed.\nMessage: ${processError.message}\nOutput: ${processError.output}`);
+        }
+    }
+}

package/dist/lib/ci/info/base.d.ts

@@ -0,0 +1,6 @@
+export declare abstract class BaseCiInfo {
+    static ALLURE_JOB_NAME: string;
+    static ALLURE_RUN_ID: string;
+    abstract pr: boolean;
+    abstract runId: string | undefined;
+}

package/dist/lib/ci/info/base.js

@@ -0,0 +1,4 @@
+export class BaseCiInfo {
+    static ALLURE_JOB_NAME = 'ALLURE_JOB_NAME';
+    static ALLURE_RUN_ID = 'ALLURE_RUN_ID';
+}

package/dist/lib/ci/info/github.d.ts

@@ -0,0 +1,9 @@
+import { BaseCiInfo } from './base.js';
+export declare class GithubCiInfo extends BaseCiInfo {
+    get pr(): boolean;
+    get runId(): string | undefined;
+    get serverUrl(): string | undefined;
+    get buildName(): string | undefined;
+    get repository(): string | undefined;
+    get buildUrl(): string;
+}

package/dist/lib/ci/info/github.js

@@ -0,0 +1,21 @@
+import { BaseCiInfo } from './base.js';
+export class GithubCiInfo extends BaseCiInfo {
+    get pr() {
+        return process.env.GITHUB_EVENT_NAME === 'pull_request';
+    }
+    get runId() {
+        return process.env[BaseCiInfo.ALLURE_RUN_ID] || process.env.GITHUB_RUN_ID;
+    }
+    get serverUrl() {
+        return process.env.GITHUB_SERVER_URL;
+    }
+    get buildName() {
+        return process.env[BaseCiInfo.ALLURE_JOB_NAME] || process.env.GITHUB_JOB;
+    }
+    get repository() {
+        return process.env.GITHUB_REPOSITORY;
+    }
+    get buildUrl() {
+        return `${this.serverUrl}/${this.repository}/actions/runs/${this.runId}`;
+    }
+}

package/dist/lib/ci/info/gitlab.d.ts

@@ -0,0 +1,17 @@
+import { BaseCiInfo } from './base.js';
+export declare class GitlabCiInfo extends BaseCiInfo {
+    get pr(): boolean;
+    get runId(): string | undefined;
+    get jobId(): string | undefined;
+    get projectPath(): string | undefined;
+    get projectId(): string | undefined;
+    get buildDir(): string | undefined;
+    get branch(): string | undefined;
+    get serverUrl(): string | undefined;
+    get buildUrl(): string | undefined;
+    get allureProject(): string | undefined;
+    get mrIid(): string | undefined;
+    get allureMrIid(): string | undefined;
+    get buildName(): string | undefined;
+    get jobName(): string | undefined;
+}

package/dist/lib/ci/info/gitlab.js

@@ -0,0 +1,47 @@
+import { BaseCiInfo } from './base.js';
+export class GitlabCiInfo extends BaseCiInfo {
+    get pr() {
+        return Boolean((this.allureProject && this.allureMrIid) || this.mrIid);
+    }
+    get runId() {
+        const allureRunId = process.env[BaseCiInfo.ALLURE_RUN_ID];
+        const ciPipelineId = process.env.CI_PIPELINE_ID;
+        return allureRunId || ciPipelineId;
+    }
+    get jobId() {
+        return process.env.CI_JOB_ID;
+    }
+    get projectPath() {
+        return process.env.CI_PROJECT_PATH;
+    }
+    get projectId() {
+        return process.env.CI_PROJECT_ID;
+    }
+    get buildDir() {
+        return process.env.CI_PROJECT_DIR;
+    }
+    get branch() {
+        return process.env.CI_MERGE_REQUEST_SOURCE_BRANCH_NAME || process.env.CI_COMMIT_REF_NAME;
+    }
+    get serverUrl() {
+        return process.env.CI_SERVER_URL;
+    }
+    get buildUrl() {
+        return process.env.CI_PIPELINE_URL;
+    }
+    get allureProject() {
+        return process.env.ALLURE_PROJECT_PATH;
+    }
+    get mrIid() {
+        return this.allureMrIid || process.env.CI_MERGE_REQUEST_IID;
+    }
+    get allureMrIid() {
+        return process.env.ALLURE_MERGE_REQUEST_IID;
+    }
+    get buildName() {
+        return process.env[BaseCiInfo.ALLURE_JOB_NAME] || this.jobName;
+    }
+    get jobName() {
+        return process.env.CI_JOB_NAME;
+    }
+}

package/dist/lib/uploader/base.d.ts

@@ -0,0 +1,40 @@
+import { GithubCiInfo } from '../ci/info/github.js';
+import { GitlabCiInfo } from '../ci/info/gitlab.js';
+export declare abstract class BaseUploader {
+    protected copyLatest: boolean;
+    protected readonly bucketName: string;
+    protected readonly parallel: number;
+    protected readonly reportPath: string;
+    protected readonly historyPath: string;
+    protected readonly plugins: string[];
+    protected readonly prefix: string | undefined;
+    protected readonly baseUrl: string | undefined;
+    private _runId;
+    constructor(opts: {
+        bucket: string;
+        copyLatest: boolean;
+        historyPath: string;
+        output: string;
+        parallel: number;
+        plugins: string[];
+        baseUrl?: string;
+        prefix?: string;
+    });
+    protected abstract uploadHistory(): Promise<void>;
+    protected abstract uploadReport(): Promise<void>;
+    protected abstract reportUrlBase(): string;
+    protected abstract createLatestCopy(): Promise<void>;
+    protected get ciInfo(): GithubCiInfo | GitlabCiInfo | undefined;
+    protected get runId(): string | undefined;
+    downloadHistory(): Promise<void>;
+    upload(): Promise<void>;
+    protected getReportFiles(): Promise<{
+        plugin: string;
+        files: string[];
+    }[]>;
+    protected historyFileName(): string;
+    protected historyUuid(): any;
+    protected key(...components: (null | string | undefined)[]): string;
+    private getReportUrls;
+    private outputReportUrls;
+}

package/dist/lib/uploader/base.js

@@ -0,0 +1,101 @@
+/* eslint-disable unicorn/no-array-for-each */
+import { mkdirSync, readFileSync } from 'node:fs';
+import path from 'node:path';
+import { ciInfo } from '../../utils/ci.js';
+import { globPaths } from '../../utils/glob.js';
+import { logger } from '../../utils/logger.js';
+import { spin } from '../../utils/spinner.js';
+export class BaseUploader {
+    copyLatest;
+    bucketName;
+    parallel;
+    reportPath;
+    historyPath;
+    plugins;
+    prefix;
+    baseUrl;
+    _runId;
+    constructor(opts) {
+        this.bucketName = opts.bucket;
+        this.prefix = opts.prefix;
+        this.baseUrl = opts.baseUrl;
+        this.copyLatest = opts.copyLatest;
+        this.parallel = opts.parallel;
+        this.reportPath = opts.output;
+        this.historyPath = opts.historyPath;
+        this.plugins = opts.plugins;
+    }
+    get ciInfo() {
+        return ciInfo;
+    }
+    get runId() {
+        if (this._runId !== undefined)
+            return this._runId;
+        this._runId = this.ciInfo?.runId || this.historyUuid();
+        return this._runId;
+    }
+    async downloadHistory() {
+        const historyDir = path.dirname(this.historyPath);
+        logger.debug(`Creating destination directory for history file at ${historyDir}`);
+        mkdirSync(historyDir, { recursive: true });
+    }
+    async upload() {
+        await spin(this.uploadHistory(), 'uploading history file');
+        await spin(this.uploadReport(), 'uploading report files');
+        if (this.copyLatest)
+            await spin(this.createLatestCopy(), 'creating latest report copy');
+        this.outputReportUrls();
+    }
+    async getReportFiles() {
+        const globPattern = 
+        // when only 1 plugin is used, report files are directly under reportPath
+        this.plugins.length > 1
+            ? (plugin) => `${this.reportPath}/${plugin}/**/*`
+            : (_plugin) => `${this.reportPath}/**/*`;
+        return Promise.all(this.plugins.map(async (plugin) => ({
+            plugin,
+            files: await globPaths(globPattern(plugin), { nodir: true }),
+        })));
+    }
+    historyFileName() {
+        return path.basename(this.historyPath);
+    }
+    historyUuid() {
+        const content = readFileSync(this.historyPath, 'utf8');
+        const lines = content
+            .trim()
+            .split('\n')
+            .filter((line) => line.trim() !== '');
+        if (lines.length === 0)
+            throw new Error(`History file is empty: ${this.historyPath}`);
+        const { uuid } = JSON.parse(lines.at(-1));
+        return uuid;
+    }
+    key(...components) {
+        return [this.prefix, ...components]
+            .filter((c) => typeof c === 'string' && c.length > 0)
+            .map((c) => c.replace(/\/$/, ''))
+            .join('/');
+    }
+    getReportUrls() {
+        const urls = {
+            run: this.plugins.map((plugin) => `${this.reportUrlBase()}/${this.runId}/${plugin}/index.html`),
+            latest: this.plugins.map((plugin) => `${this.reportUrlBase()}/latest/${plugin}/index.html`),
+        };
+        if (this.plugins.length > 1) {
+            urls.run.unshift(`${this.reportUrlBase()}/${this.runId}/index.html`);
+            urls.latest.unshift(`${this.reportUrlBase()}/latest/index.html`);
+        }
+        return urls;
+    }
+    outputReportUrls() {
+        logger.section('Report URLs');
+        const urls = this.getReportUrls();
+        logger.success('Fetching current run urls:');
+        urls.run.forEach((url) => logger.info(`- ${url}`));
+        if (this.copyLatest) {
+            logger.success('Fetching latest report urls:');
+            urls.latest.forEach((url) => logger.info(`- ${url}`));
+        }
+    }
+}

package/dist/lib/uploader/s3.d.ts

@@ -0,0 +1,17 @@
+import { BaseUploader } from './base.js';
+export declare class S3Uploader extends BaseUploader {
+    private _reportUrlBase;
+    private _reportFileUploadArgs;
+    private readonly s3Client;
+    private get awsEndpoint();
+    private get forcePathStyle();
+    private get region();
+    protected reportUrlBase(): string;
+    downloadHistory(): Promise<void>;
+    protected uploadHistory(): Promise<void>;
+    protected uploadReport(): Promise<void>;
+    protected createLatestCopy(): Promise<void>;
+    private allUploadArgs;
+    private uploadFile;
+    private copyFile;
+}

package/dist/lib/uploader/s3.js

@@ -0,0 +1,113 @@
+import { CopyObjectCommand, GetObjectCommand, NoSuchKey, PutObjectCommand, S3Client, waitUntilObjectExists, } from '@aws-sdk/client-s3';
+import { lookup } from 'mime-types';
+import { readFileSync, writeFileSync } from 'node:fs';
+import pAll from 'p-all';
+import { config } from '../../utils/config.js';
+import { logger } from '../../utils/logger.js';
+import { BaseUploader } from './base.js';
+export class S3Uploader extends BaseUploader {
+    _reportUrlBase;
+    _reportFileUploadArgs;
+    s3Client = new S3Client({
+        endpoint: this.awsEndpoint,
+        forcePathStyle: this.forcePathStyle,
+        region: process.env.AWS_REGION || 'us-east-1',
+    });
+    get awsEndpoint() {
+        return process.env.AWS_ENDPOINT;
+    }
+    get forcePathStyle() {
+        return process.env.AWS_FORCE_PATH_STYLE === 'true';
+    }
+    get region() {
+        return process.env.AWS_REGION || 'us-east-1';
+    }
+    reportUrlBase() {
+        if (this._reportUrlBase)
+            return this._reportUrlBase;
+        let base = `https://${this.bucketName}.s3.${this.region}.amazonaws.com`;
+        if (this.awsEndpoint) {
+            base = this.forcePathStyle ? `${this.awsEndpoint}/${this.bucketName}` : this.awsEndpoint;
+        }
+        this._reportUrlBase = this.prefix ? `${base}/${this.prefix}` : base;
+        return this._reportUrlBase;
+    }
+    async downloadHistory() {
+        await super.downloadHistory();
+        const key = this.key(this.historyFileName());
+        logger.debug(`Downloading history file from s3://${this.bucketName}/${key}`);
+        try {
+            const response = await this.s3Client.send(new GetObjectCommand({
+                Bucket: this.bucketName,
+                Key: key,
+            }));
+            if (!response.Body) {
+                throw new Error('Received empty response body when downloading history file');
+            }
+            const content = await response.Body.transformToString();
+            if (content.trim().length === 0)
+                throw new Error('Received empty response body when downloading history file');
+            writeFileSync(this.historyPath, content, 'utf8');
+            logger.debug(`History file downloaded successfully to ${this.historyPath}`);
+        }
+        catch (error) {
+            throw error instanceof NoSuchKey ? new Error(`History file not found!`) : error;
+        }
+    }
+    async uploadHistory() {
+        logger.debug('Uploading history file');
+        await this.uploadFile({
+            filePath: this.historyPath,
+            key: this.key(this.historyFileName()),
+        });
+    }
+    async uploadReport() {
+        logger.debug(`Uploading report files with concurrency: ${this.parallel}`);
+        const uploads = (await this.allUploadArgs()).map(({ filePath, pathComponents }) => {
+            const key = this.key(this.runId, ...pathComponents);
+            return () => this.uploadFile({ filePath, key });
+        });
+        await pAll(uploads, { concurrency: config.parallel });
+    }
+    async createLatestCopy() {
+        logger.debug(`Creating latest report copy with concurrency: ${this.parallel}`);
+        const copies = (await this.allUploadArgs()).map(({ pathComponents }) => {
+            const sourceKey = this.key(this.runId, ...pathComponents);
+            const destinationKey = this.key('latest', ...pathComponents);
+            return () => this.copyFile({ sourceKey, destinationKey });
+        });
+        await pAll(copies, { concurrency: config.parallel });
+    }
+    async allUploadArgs() {
+        if (this._reportFileUploadArgs)
+            return this._reportFileUploadArgs;
+        const reportFiles = await this.getReportFiles();
+        this._reportFileUploadArgs = reportFiles.flatMap(({ plugin, files }) => files.map((file) => ({
+            filePath: file,
+            pathComponents: [plugin, file.replace(`${this.reportPath}/`, '')],
+        })));
+        return this._reportFileUploadArgs;
+    }
+    async uploadFile(opts) {
+        const content = readFileSync(opts.filePath);
+        const contentType = lookup(opts.filePath) || 'application/octet-stream';
+        logger.debug(`- uploading file: s3://${this.bucketName}/${opts.key} (type: ${contentType})`);
+        return this.s3Client.send(new PutObjectCommand({
+            Body: content,
+            Bucket: this.bucketName,
+            Key: opts.key,
+            CacheControl: opts.cacheControl || 'max-age=3600',
+            ContentType: contentType,
+        }));
+    }
+    async copyFile(opts) {
+        const source = `${this.bucketName}/${opts.sourceKey}`;
+        logger.debug(`- copying file: s3://${source} to s3://${this.bucketName}/${opts.destinationKey}`);
+        await this.s3Client.send(new CopyObjectCommand({
+            CopySource: source,
+            Bucket: this.bucketName,
+            Key: opts.destinationKey,
+        }));
+        await waitUntilObjectExists({ client: this.s3Client, maxWaitTime: 60 }, { Bucket: this.bucketName, Key: opts.destinationKey });
+    }
+}

package/dist/types/index.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Shared type definitions for allure-report-publisher
+ */
+export type StorageType = 'gcs' | 'gitlab-artifacts' | 's3';
+export type UpdatePRMode = 'actions' | 'comment' | 'description';
+export type SummaryType = 'behaviors' | 'packages' | 'suites' | 'total';
+export type SummaryTableType = 'ascii' | 'markdown';
+export type PluginName = 'allure2' | 'awesome' | 'classic' | 'csv' | 'dashboard';

package/dist/types/index.js

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

package/dist/utils/ci.d.ts

@@ -0,0 +1,5 @@
+import { Gitlab } from '@gitbeaker/rest';
+import { GithubCiInfo } from '../lib/ci/info/github.js';
+import { GitlabCiInfo } from '../lib/ci/info/gitlab.js';
+export declare const gitlabClient: Gitlab;
+export declare const ciInfo: GithubCiInfo | GitlabCiInfo | undefined;

package/dist/utils/ci.js

@@ -0,0 +1,13 @@
+import { Gitlab } from '@gitbeaker/rest';
+import { GithubCiInfo } from '../lib/ci/info/github.js';
+import { GitlabCiInfo } from '../lib/ci/info/gitlab.js';
+export const gitlabClient = new Gitlab({
+    host: process.env.CI_SERVER_URL || 'https://gitlab.com',
+    token: process.env.GITLAB_AUTH_TOKEN,
+});
+export const ciInfo = (() => {
+    if (process.env.GITLAB_CI)
+        return new GitlabCiInfo();
+    if (process.env.GITHUB_WORKFLOW)
+        return new GithubCiInfo();
+})();

package/dist/utils/config.d.ts

@@ -0,0 +1,17 @@
+declare class Config {
+    private _color;
+    private _debug;
+    private _parallel;
+    private initialized;
+    constructor();
+    get color(): boolean;
+    get debug(): boolean;
+    get parallel(): number;
+    initialize(options: {
+        color?: boolean;
+        debug?: boolean;
+        parallel?: number;
+    }): void;
+}
+export declare const config: Config;
+export {};

package/dist/utils/config.js

@@ -0,0 +1,43 @@
+class Config {
+    _color;
+    _debug;
+    _parallel;
+    initialized;
+    constructor() {
+        this._color = true;
+        this._debug = false;
+        this._parallel = 8;
+        this.initialized = false;
+    }
+    get color() {
+        if (!this.initialized)
+            console.warn("Config has not been initialized yet, returning default value");
+        return this._color;
+    }
+    get debug() {
+        if (!this.initialized)
+            console.warn("Config has not been initialized yet, returning default value");
+        return this._debug;
+    }
+    get parallel() {
+        if (!this.initialized)
+            console.warn("Config has not been initialized yet, returning default value");
+        return this._parallel;
+    }
+    initialize(options) {
+        if (this.initialized) {
+            throw new Error('Config has already been initialized');
+        }
+        if (options.color !== undefined) {
+            this._color = options.color;
+        }
+        if (options.debug !== undefined) {
+            this._debug = options.debug;
+        }
+        if (options.parallel !== undefined) {
+            this._parallel = options.parallel;
+        }
+        this.initialized = true;
+    }
+}
+export const config = new Config();

package/dist/utils/glob.d.ts

@@ -0,0 +1,4 @@
+export declare function globPaths(pattern: string, opts?: {
+    nodir?: boolean;
+}): Promise<string[]>;
+export declare function getAllureResultsPaths(pattern: string, ignoreMissing?: boolean): Promise<string[]>;

package/dist/utils/glob.js

@@ -0,0 +1,35 @@
+import { glob } from 'glob';
+import { statSync } from 'node:fs';
+import { logger } from './logger.js';
+export async function globPaths(pattern, opts = {}) {
+    return glob(pattern, {
+        absolute: true,
+        nodir: opts.nodir ?? false,
+        windowsPathsNoEscape: true,
+    });
+}
+export async function getAllureResultsPaths(pattern, ignoreMissing) {
+    const paths = await globPaths(pattern);
+    logger.debug(`Glob '${pattern}' found ${paths.length} entries`);
+    for (const path of paths) {
+        logger.debug(`- ${path}`);
+    }
+    if (paths.length === 0) {
+        const msg = [
+            `Pattern '${pattern}' did not match any paths`,
+            'Make sure the pattern is correct and points to directories containing allure results',
+        ];
+        if (!ignoreMissing)
+            msg.push('Use --ignore-missing-results to exit without error if no result paths are found');
+        throw new Error(msg.join('\n'));
+    }
+    const nonDirectories = paths.filter((path) => !statSync(path).isDirectory());
+    if (nonDirectories.length > 0) {
+        const msg = [
+            `Pattern '${pattern}' matched ${nonDirectories.length} non-directory paths`,
+            'All matched paths must be directories containing allure results',
+        ];
+        throw new Error(msg.join('\n'));
+    }
+    return paths;
+}

package/dist/utils/logger.d.ts

@@ -0,0 +1,14 @@
+export declare class Logger {
+    private _chalk?;
+    private debugBuffer;
+    private get chalk();
+    flushDebug(): void;
+    debug(message: string): void;
+    error(message: string): void;
+    info(message: string): void;
+    log(message: string): void;
+    success(message: string): void;
+    warn(message: string): void;
+    section(message: string): void;
+}
+export declare const logger: Logger;

package/dist/utils/logger.js

@@ -0,0 +1,51 @@
+// eslint-disable-next-line unicorn/import-style
+import { Chalk } from 'chalk';
+import { config } from './config.js';
+export class Logger {
+    _chalk;
+    debugBuffer = [];
+    get chalk() {
+        if (!this._chalk) {
+            this._chalk = new Chalk({ level: config.color ? 3 : 0 });
+        }
+        return this._chalk;
+    }
+    flushDebug() {
+        if (this.debugBuffer.length === 0)
+            return;
+        console.log(this.chalk.gray('====== DEBUG LOG OUTPUT ======'));
+        for (const message of this.debugBuffer) {
+            console.log(this.chalk.gray(message));
+        }
+        console.log(this.chalk.gray('====== DEBUG LOG OUTPUT ======'));
+        this.debugBuffer = [];
+    }
+    debug(message) {
+        const timestamp = new Date().toISOString();
+        this.debugBuffer.push(`[${timestamp}] ${message}`);
+    }
+    error(message) {
+        console.error(this.chalk.red(message));
+    }
+    info(message) {
+        console.log(this.chalk.blue('ℹ'), message);
+    }
+    log(message) {
+        console.log(message);
+    }
+    success(message) {
+        console.log(this.chalk.green('✓'), message);
+    }
+    warn(message) {
+        console.warn(this.chalk.yellow(message));
+    }
+    section(message) {
+        if (config.color) {
+            console.log(this.chalk.bold.magenta(`\n${message}`));
+        }
+        else {
+            console.log(`\n=== ${message} ===`);
+        }
+    }
+}
+export const logger = new Logger();

package/dist/utils/spinner.d.ts

@@ -0,0 +1,4 @@
+import { Options } from 'ora';
+export declare function spin<T>(action: PromiseLike<T>, message: string, options?: Options & {
+    ignoreError?: boolean;
+}): Promise<T | undefined>;