heroku 10.13.2 → 11.0.0-alpha.2

package/lib/lib/ci/pipelines.js

@@ -1,58 +1,76 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getPipeline = exports.disambiguatePipeline = void 0;
-const inquirer_1 = require("inquirer");
-const validator_1 = require("validator");
-const core_1 = require("@oclif/core");
-async function disambiguatePipeline(pipelineIDOrName, herokuAPI) {
-    const headers = { Accept: 'application/vnd.heroku+json; version=3.pipelines' };
-    if ((0, validator_1.isUUID)(pipelineIDOrName)) {
-        const { body: pipeline } = await herokuAPI.get(`/pipelines/${pipelineIDOrName}`, { headers });
-        return pipeline;
-    }
-    const { body: pipelines } = await herokuAPI.get(`/pipelines?eq[name]=${pipelineIDOrName}`, { headers });
-    let choices;
-    let questions;
-    switch (pipelines.length) {
-        case 0:
-            core_1.ux.error('Pipeline not found');
-            break;
-        case 1:
-            return pipelines[0];
-        default:
-            choices = pipelines.map(function (x) {
-                return { name: new Date(x.created_at), value: x };
-            });
-            questions = [{
-                    type: 'list',
-                    name: 'pipeline',
-                    message: `Which ${pipelineIDOrName} pipeline?`,
-                    choices,
-                }];
-            return (0, inquirer_1.prompt)(questions);
+import inquirer from 'inquirer';
+import { ux } from '@oclif/core';
+import { uuidValidate } from '../utils/uuid-validate.js';
+export class PipelineService {
+    herokuAPI;
+    // eslint-disable-next-line no-useless-constructor
+    constructor(herokuAPI) {
+        this.herokuAPI = herokuAPI;
+        // Constructor required to inject herokuAPI dependency
     }
-}
-exports.disambiguatePipeline = disambiguatePipeline;
-async function getPipeline(flags, herokuAPI) {
-    let pipeline;
-    if ((!flags.pipeline) && (!flags.app)) {
-        core_1.ux.error('Required flag:  --pipeline PIPELINE or --app APP');
+    promptForPipeline(pipelineIDOrName, choices) {
+        const questions = [{
+                type: 'list',
+                name: 'pipeline',
+                message: `Which ${pipelineIDOrName} pipeline?`,
+                choices,
+            }];
+        return inquirer.prompt(questions);
     }
-    if (flags && flags.pipeline) {
-        pipeline = await disambiguatePipeline(flags.pipeline, herokuAPI);
-        if (pipeline.pipeline) {
-            pipeline = pipeline.pipeline;
-        } // in case prompt returns an object like { pipeline: { ... } }
+    async disambiguatePipeline(pipelineIDOrName) {
+        const headers = { Accept: 'application/vnd.heroku+json; version=3.pipelines' };
+        if (uuidValidate(pipelineIDOrName)) {
+            const { body: pipeline } = await this.herokuAPI.get(`/pipelines/${pipelineIDOrName}`, { headers });
+            return pipeline;
+        }
+        const { body: pipelines } = await this.herokuAPI.get(`/pipelines?eq[name]=${pipelineIDOrName}`, { headers });
+        let choices;
+        switch (pipelines.length) {
+            case 0:
+                ux.error('Pipeline not found');
+                break;
+            case 1:
+                return pipelines[0];
+            default:
+                choices = pipelines.map(function (x) {
+                    return { name: new Date(x.created_at), value: x };
+                });
+                return this.promptForPipeline(pipelineIDOrName, choices);
+        }
     }
-    else {
-        const { body: coupling } = await herokuAPI.get(`/apps/${flags.app}/pipeline-couplings`);
-        if ((coupling) && (coupling.pipeline)) {
-            pipeline = coupling.pipeline;
+    async getPipeline(flags) {
+        let pipeline;
+        if ((!flags.pipeline) && (!flags.app)) {
+            ux.error('Required flag:  --pipeline PIPELINE or --app APP');
+        }
+        if (flags && flags.pipeline) {
+            pipeline = await this.disambiguatePipeline(flags.pipeline);
+            if (pipeline.pipeline) {
+                pipeline = pipeline.pipeline;
+            } // in case prompt returns an object like { pipeline: { ... } }
         }
         else {
-            core_1.ux.error(`No pipeline found with application ${flags.app}`);
+            const { body: coupling } = await this.herokuAPI.get(`/apps/${flags.app}/pipeline-couplings`);
+            if ((coupling) && (coupling.pipeline)) {
+                pipeline = coupling.pipeline;
+            }
+            else {
+                ux.error(`No pipeline found with application ${flags.app}`);
+            }
         }
+        return pipeline;
     }
-    return pipeline;
 }
-exports.getPipeline = getPipeline;
+// Export standalone functions for backward compatibility
+export function promptForPipeline(pipelineIDOrName, choices) {
+    const service = new PipelineService({});
+    return service.promptForPipeline(pipelineIDOrName, choices);
+}
+export async function disambiguatePipeline(pipelineIDOrName, herokuAPI) {
+    const service = new PipelineService(herokuAPI);
+    return service.disambiguatePipeline(pipelineIDOrName);
+}
+export async function getPipeline(flags, herokuAPI) {
+    const service = new PipelineService(herokuAPI);
+    return service.getPipeline(flags);
+}

package/lib/lib/ci/source.js

@@ -1,18 +1,16 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createSourceBlob = void 0;
-const fs = require("async-file");
-const git = require("./git");
-const got_1 = require("got");
-const debug_1 = require("debug");
-const ciDebug = (0, debug_1.default)('ci');
+import { promises as fs } from 'fs';
+import { createReadStream } from 'fs';
+import * as git from './git.js';
+import { got } from 'got';
+import debug from 'debug';
+const ciDebug = debug('ci');
 async function uploadArchive(url, filePath) {
-    const request = got_1.default.stream.put(url, {
+    const request = got.stream.put(url, {
         headers: {
             'content-length': (await fs.stat(filePath)).size.toString(),
         },
     });
-    fs.createReadStream(filePath).pipe(request);
+    createReadStream(filePath).pipe(request);
     return new Promise((resolve, reject) => {
         request.on('error', reject);
         request.on('response', resolve);
@@ -24,7 +22,7 @@ async function prepareSource(ref, command) {
     await uploadArchive(source.source_blob.put_url, filePath);
     return Promise.resolve(source);
 }
-async function createSourceBlob(ref, command) {
+export async function createSourceBlob(ref, command) {
     try {
         const githubRepository = await git.githubRepository();
         const { user, repo } = githubRepository;
@@ -40,4 +38,3 @@ async function createSourceBlob(ref, command) {
     const sourceBlob = await prepareSource(ref, command);
     return sourceBlob.source_blob.get_url;
 }
-exports.createSourceBlob = createSourceBlob;

package/lib/lib/ci/test-run.js

@@ -1,19 +1,17 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.displayTestRunInfo = exports.displayAndExit = exports.waitForStates = exports.renderList = void 0;
-const color_1 = require("@heroku-cli/color");
-const core_1 = require("@oclif/core");
-const heroku_cli_util_1 = require("@heroku/heroku-cli-util");
-const https_1 = require("https");
-const node_crypto_1 = require("node:crypto");
-const phoenix_1 = require("phoenix");
-const util_1 = require("util");
-const WebSocket = require("ws");
-const debug = require('debug')('ci');
-const ansiEscapes = require('ansi-escapes');
+import { color } from '@heroku-cli/color';
+import { ux } from '@oclif/core';
+import { hux } from '@heroku/heroku-cli-util';
+import { get } from 'https';
+import { randomUUID } from 'node:crypto';
+import { Socket } from 'phoenix';
+import { inspect } from 'util';
+import WebSocket from 'ws';
+import debug from 'debug';
+import ansiEscapes from 'ansi-escapes';
+const ciDebug = debug('ci');
 const HEROKU_CI_WEBSOCKET_URL = process.env.HEROKU_CI_WEBSOCKET_URL || 'wss://particleboard.heroku.com/socket';
 function logStream(url, fn) {
-    return (0, https_1.get)(url, fn);
+    return get(url, fn);
 }
 function stream(url) {
     return new Promise((resolve, reject) => {
@@ -32,25 +30,31 @@ function stream(url) {
 }
 function statusIcon({ status }) {
     if (!status) {
-        return color_1.default.yellow('-');
+        return color.yellow('-');
     }
     switch (status) {
         case 'pending':
         case 'creating':
         case 'building':
         case 'running':
-        case 'debugging':
-            return color_1.default.yellow('-');
-        case 'errored':
-            return color_1.default.red('!');
-        case 'failed':
-            return color_1.default.red('✗');
-        case 'succeeded':
-            return color_1.default.green('✓');
-        case 'cancelled':
-            return color_1.default.yellow('!');
-        default:
-            return color_1.default.yellow('?');
+        case 'debugging': {
+            return color.yellow('-');
+        }
+        case 'errored': {
+            return color.red('!');
+        }
+        case 'failed': {
+            return color.red('✗');
+        }
+        case 'succeeded': {
+            return color.green('✓');
+        }
+        case 'cancelled': {
+            return color.yellow('!');
+        }
+        default: {
+            return color.yellow('?');
+        }
     }
 }
 const BUILDING = 'building';
@@ -88,7 +92,7 @@ function sort(testRuns) {
 function draw(testRuns, watchOption = false, jsonOption = false, count = 15) {
     const latestTestRuns = sort(testRuns).slice(0, count);
     if (jsonOption) {
-        heroku_cli_util_1.hux.styledJSON(latestTestRuns);
+        hux.styledJSON(latestTestRuns);
         return;
     }
     if (watchOption) {
@@ -104,38 +108,38 @@ function draw(testRuns, watchOption = false, jsonOption = false, count = 15) {
             status: testRun.status,
         });
     });
-    heroku_cli_util_1.hux.table(data, {
+    hux.table(data, {
         iconStatus: {
-            minWidth: 1, header: '', // header '' is to make sure that width is 1 character
+            header: ' ', // header '' is to make sure that width is 1 character
         },
         number: {
-            header: '', // header '' is to make sure that width is 1 character
+            header: ' ', // header '' is to make sure that width is 1 character
         },
         branch: {},
         sha: {},
         status: {},
-    }, { printHeader: undefined });
+    });
     if (watchOption) {
         process.stdout.write(ansiEscapes.cursorUp(latestTestRuns.length));
     }
 }
-async function renderList(command, testRuns, pipeline, watchOption, jsonOption) {
+export async function renderList(command, testRuns, pipeline, watchOption, jsonOption) {
     const watchable = (Boolean(watchOption && !jsonOption));
     if (!jsonOption) {
         const header = `${watchOption ? 'Watching' : 'Showing'} latest test runs for the ${pipeline.name} pipeline`;
-        heroku_cli_util_1.hux.styledHeader(header);
+        hux.styledHeader(header);
     }
     draw(testRuns, watchOption, jsonOption);
     if (!watchable) {
         return;
     }
-    const socket = new phoenix_1.Socket(HEROKU_CI_WEBSOCKET_URL, {
+    const socket = new Socket(HEROKU_CI_WEBSOCKET_URL, {
         transport: WebSocket,
         params: {
             token: command.heroku.auth,
-            tab_id: `heroku-cli-${(0, node_crypto_1.randomUUID)()}`,
+            tab_id: `heroku-cli-${randomUUID()}`,
         },
-        logger: (kind, msg, data) => debug(`${kind}: ${msg}\n${(0, util_1.inspect)(data)}`),
+        logger: (kind, msg, data) => ciDebug(`${kind}: ${msg}\n${inspect(data)}`),
     });
     socket.connect();
     const channel = socket.channel(`events:pipelines/${pipeline.id}/test-runs`, {});
@@ -150,7 +154,6 @@ async function renderList(command, testRuns, pipeline, watchOption, jsonOption)
     // eslint-disable-next-line unicorn/require-array-join-separator
     channel.join();
 }
-exports.renderList = renderList;
 async function renderNodeOutput(command, testRun, testNode) {
     if (!testNode) {
         command.error(`Test run ${testRun.number} was ${testRun.status}. No Heroku CI runs found for this pipeline.`);
@@ -160,7 +163,7 @@ async function renderNodeOutput(command, testRun, testNode) {
     command.log();
     command.log(printLine(testRun));
 }
-async function waitForStates(states, testRun, command) {
+export async function waitForStates(states, testRun, command) {
     let newTestRun = testRun;
     while (!states.includes(newTestRun.status.toString())) {
         const { body: bodyTestRun } = await command.heroku.get(`/pipelines/${testRun.pipeline.id}/test-runs/${testRun.number}`);
@@ -168,13 +171,12 @@ async function waitForStates(states, testRun, command) {
     }
     return newTestRun;
 }
-exports.waitForStates = waitForStates;
 async function display(pipeline, number, command) {
     let { body: testRun } = await command.heroku.get(`/pipelines/${pipeline.id}/test-runs/${number}`);
     if (testRun) {
-        core_1.ux.action.start('Waiting for build to start');
+        ux.action.start('Waiting for build to start');
         testRun = await waitForStates(BUILDING_STATES, testRun, command);
-        core_1.ux.action.stop();
+        ux.action.stop();
         const { body: testNodes } = await command.heroku.get(`/test-runs/${testRun.id}/test-nodes`);
         let firstTestNode = testNodes[0];
         if (firstTestNode) {
@@ -200,12 +202,11 @@ async function display(pipeline, number, command) {
         return firstTestNode;
     }
 }
-async function displayAndExit(pipeline, number, command) {
+export async function displayAndExit(pipeline, number, command) {
     const testNode = await display(pipeline, number, command);
-    testNode ? processExitCode(command, testNode) : command.exit(1);
+    testNode ? processExitCode(command, testNode) : ux.exit(1);
 }
-exports.displayAndExit = displayAndExit;
-async function displayTestRunInfo(command, testRun, testNodes, nodeArg) {
+export async function displayTestRunInfo(command, testRun, testNodes, nodeArg) {
     let testNode;
     if (nodeArg) {
         const nodeIndex = Number.parseInt(nodeArg, 2);
@@ -231,4 +232,3 @@ async function displayTestRunInfo(command, testRun, testNodes, nodeArg) {
         processExitCode(command, testNode);
     }
 }
-exports.displayTestRunInfo = displayTestRunInfo;

package/lib/lib/ci/validate.d.ts

@@ -1,2 +1,2 @@
-import { ParserOutput } from '@oclif/core/lib/interfaces/parser';
-export declare const validateArgvPresent: (argv: ParserOutput['argv'], isUnset?: boolean) => void;
+import { Interfaces } from '@oclif/core';
+export declare const validateArgvPresent: (argv: Interfaces.ParserOutput['argv'], isUnset?: boolean) => void;

package/lib/lib/ci/validate.js

@@ -1,10 +1,6 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.validateArgvPresent = void 0;
-const core_1 = require("@oclif/core");
-const validateArgvPresent = (argv, isUnset = false) => {
+import { ux } from '@oclif/core';
+export const validateArgvPresent = (argv, isUnset = false) => {
     if (argv.length === 0) {
-        core_1.ux.error(`Usage: heroku ci:config:${isUnset ? 'unset' : 'set'} KEY1 [KEY2 ...]\nMust specify KEY to ${isUnset ? 'unset' : 'set'}.`, { exit: 1 });
+        ux.error(`Usage: heroku ci:config:${isUnset ? 'unset' : 'set'} KEY1 [KEY2 ...]\nMust specify KEY to ${isUnset ? 'unset' : 'set'}.`, { exit: 1 });
     }
 };
-exports.validateArgvPresent = validateArgvPresent;

package/lib/lib/clients/clients.js

@@ -1,7 +1,5 @@
 'use strict';
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.validateURL = void 0;
-const url_1 = require("url");
+import { URL } from 'url';
 function insecureURL(uri) {
     if (uri.protocol === 'https:')
         return false;
@@ -14,12 +12,11 @@ function insecureURL(uri) {
         return false;
     return true;
 }
-function validateURL(uri) {
-    const u = new url_1.URL(uri);
+export function validateURL(uri) {
+    const u = new URL(uri);
     if (!u.protocol)
         throw new Error('Invalid URL');
     if (insecureURL(u))
         throw new Error('Unsupported callback URL. Clients have to use HTTPS for non-local addresses.');
     return uri;
 }
-exports.validateURL = validateURL;

package/lib/lib/config/quote.js

@@ -1,9 +1,6 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.parse = exports.quote = void 0;
-const shell = require('shell-quote');
+import shell from 'shell-quote';
 // slightly modified form of shell-quote to default to using single-quotes over backslashes
-function quote(s) {
+export function quote(s) {
     // eslint-disable-next-line no-useless-escape
     if (/["\s#!$&'()*,:;<=>?@\[\\\]^`{|}]/.test(s)) {
         if (/['\n]/.test(s))
@@ -16,8 +13,7 @@ function quote(s) {
     }
     return s;
 }
-exports.quote = quote;
-function parse(a) {
+export function parse(a) {
     if (a.startsWith('"')) {
         a = a.replace(/\\n/g, '\n');
     }
@@ -27,7 +23,10 @@ function parse(a) {
     const parsed = shell.parse(a);
     if (parsed.length > 1)
         throw new Error(`Invalid token: ${a}`);
-    return parsed[0];
-    // return parsed[0].replace(/\\\\n/g, '\n')
+    if (parsed.length === 0)
+        return '';
+    const result = parsed[0];
+    if (typeof result !== 'string')
+        throw new Error(`Invalid token: ${a}`);
+    return result;
 }
-exports.parse = parse;

package/lib/lib/config/util.d.ts

@@ -1,3 +1,3 @@
 export declare class Editor {
-    edit(input: string, options?: {}): any;
+    edit(input: string, options?: {}): Promise<string>;
 }

package/lib/lib/config/util.js

@@ -1,12 +1,29 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Editor = void 0;
-const edit = require('edit-string');
-// This indirection exists to give tests
-// a way to stub calls to `edit(...)`
-class Editor {
-    edit(input, options = {}) {
-        return edit(input, options);
+import tmp from 'tmp';
+import fs from 'fs-extra';
+import { spawn } from 'node:child_process';
+export class Editor {
+    async edit(input, options = {}) {
+        // Create a temporary file
+        const tmpFile = tmp.fileSync(options);
+        // Write the input to the temporary file
+        await fs.writeFile(tmpFile.name, input);
+        // Get the editor from environment variables
+        const editor = process.env.VISUAL || process.env.EDITOR || 'vim';
+        // Spawn the editor process
+        const child = spawn(editor, [tmpFile.name], { stdio: 'inherit' });
+        // Wait for the editor to close
+        await new Promise((resolve, reject) => {
+            child.on('exit', code => {
+                if (code === 0)
+                    resolve(null);
+                else
+                    reject(new Error(`Editor exited with code ${code}`));
+            });
+        });
+        // Read the edited file
+        const result = await fs.readFile(tmpFile.name, 'utf8');
+        // Clean up the temporary file
+        tmpFile.removeCallback();
+        return result;
     }
 }
-exports.Editor = Editor;

package/lib/lib/confirmCommand.d.ts

@@ -1 +1,3 @@
-export default function confirmCommand(app: string, confirm?: string, message?: string): Promise<void>;
+export default class ConfirmCommand {
+    confirm(app: string, confirm?: string, message?: string): Promise<void>;
+}

package/lib/lib/confirmCommand.js

@@ -1,24 +1,23 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const color_1 = require("@heroku-cli/color");
-const core_1 = require("@oclif/core");
-const heroku_cli_util_1 = require("@heroku/heroku-cli-util");
-async function confirmCommand(app, confirm, message) {
-    if (confirm) {
-        if (confirm === app)
+import { color } from '@heroku-cli/color';
+import { ux } from '@oclif/core';
+import { hux } from '@heroku/heroku-cli-util';
+export default class ConfirmCommand {
+    async confirm(app, confirm, message) {
+        if (confirm) {
+            if (confirm === app)
+                return;
+            throw new Error(`Confirmation ${color.bold.red(confirm)} did not match ${color.bold.red(app)}. Aborted.`);
+        }
+        if (!message) {
+            message = `WARNING: Destructive Action
+This command will affect the app ${color.bold.red(app)}`;
+        }
+        ux.warn(message);
+        console.error();
+        const entered = await hux.prompt(`To proceed, type ${color.bold.red(app)} or re-run this command with ${color.bold.red('--confirm', app)}`, { required: true });
+        if (entered === app) {
             return;
-        throw new Error(`Confirmation ${color_1.default.bold.red(confirm)} did not match ${color_1.default.bold.red(app)}. Aborted.`);
+        }
+        throw new Error(`Confirmation did not match ${color.bold.red(app)}. Aborted.`);
     }
-    if (!message) {
-        message = `WARNING: Destructive Action
-This command will affect the app ${color_1.default.bold.red(app)}`;
-    }
-    core_1.ux.warn(message);
-    console.error();
-    const entered = await heroku_cli_util_1.hux.prompt(`To proceed, type ${color_1.default.bold.red(app)} or re-run this command with ${color_1.default.bold.red('--confirm', app)}`, { required: true });
-    if (entered === app) {
-        return;
-    }
-    throw new Error(`Confirmation did not match ${color_1.default.bold.red(app)}. Aborted.`);
 }
-exports.default = confirmCommand;

package/lib/lib/container/debug.d.ts

@@ -1,2 +1,2 @@
-import * as logger from 'debug';
-export declare const debug: logger.Debugger;
+import debugModule from 'debug';
+export declare const debug: debugModule.Debugger;

package/lib/lib/container/debug.js

@@ -1,5 +1,2 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.debug = void 0;
-const logger = require("debug");
-exports.debug = logger('heroku-container-registry');
+import debugModule from 'debug';
+export const debug = debugModule('heroku-container-registry');

package/lib/lib/container/docker_helper.d.ts

@@ -1,24 +1,17 @@
-export declare type cmdOptions = {
+export declare type CmdOptions = {
     output?: boolean;
     input?: string;
 };
-export declare const cmd: (cmd: string, args: string[], options?: cmdOptions) => Promise<string>;
-export declare const version: () => Promise<number[]>;
-export declare const pullImage: (resource: string) => Promise<string>;
-export declare const getDockerfiles: (rootdir: string, recursive: boolean) => string[];
-export declare type dockerJob = {
+export declare type DockerJob = {
     name: string;
     resource: string;
     dockerfile: string;
     postfix: number;
     depth: number;
 };
-export declare type groupedDockerJobs = {
-    [processType: string]: dockerJob[];
+export declare type GroupedDockerJobs = {
+    [processType: string]: DockerJob[];
 };
-export declare const getJobs: (resourceRoot: string, dockerfiles: string[]) => groupedDockerJobs;
-export declare const filterByProcessType: (jobs: groupedDockerJobs, processTypes: string[]) => groupedDockerJobs;
-export declare const chooseJobs: (jobs: groupedDockerJobs) => Promise<dockerJob[]>;
 declare type BuildImageParams = {
     dockerfile: string;
     resource: string;
@@ -26,7 +19,16 @@ declare type BuildImageParams = {
     path?: string;
     arch?: string;
 };
-export declare const buildImage: ({ dockerfile, resource, buildArgs, path, arch }: BuildImageParams) => Promise<string>;
-export declare const pushImage: (resource: string, arch: string) => Promise<string>;
-export declare const runImage: (resource: string, command: string, port: number) => Promise<string>;
+export declare class DockerHelper {
+    cmd(cmd: string, args: string[], options?: CmdOptions): Promise<string>;
+    version(): Promise<[number, number]>;
+    pullImage(resource: string): Promise<string>;
+    getDockerfiles(rootdir: string, recursive: boolean): string[];
+    getJobs(resourceRoot: string, dockerfiles: string[]): GroupedDockerJobs;
+    filterByProcessType(jobs: GroupedDockerJobs, processTypes: string[]): GroupedDockerJobs;
+    chooseJobs(jobs: GroupedDockerJobs): Promise<DockerJob[]>;
+    buildImage({ dockerfile, resource, buildArgs, path, arch }: BuildImageParams): Promise<string>;
+    pushImage(resource: string, arch: string): Promise<string>;
+    runImage(resource: string, command: string, port: number): Promise<string>;
+}
 export {};