rwsdk 1.0.0-alpha.6 → 1.0.0-alpha.7

package/dist/lib/e2e/tarball.mjs

@@ -0,0 +1,189 @@
+import { $ } from "execa";
+import fs from "node:fs";
+import path from "node:path";
+import os from "node:os";
+import crypto from "node:crypto";
+const log = (message) => console.log(message);
+/**
+ * Copies wrangler cache from monorepo to temp directory for deployment tests
+ */
+async function copyWranglerCache(targetDir, sdkRoot) {
+    try {
+        // Find the monorepo root by starting from the SDK root directory
+        // and walking up to find the monorepo root
+        let currentDir = path.resolve(sdkRoot);
+        let monorepoRoot = null;
+        // Walk up the directory tree to find the monorepo root
+        while (currentDir !== path.dirname(currentDir)) {
+            const nodeModulesPath = path.join(currentDir, "node_modules");
+            const packageJsonPath = path.join(currentDir, "package.json");
+            if (fs.existsSync(nodeModulesPath) && fs.existsSync(packageJsonPath)) {
+                try {
+                    const packageJson = JSON.parse(await fs.promises.readFile(packageJsonPath, "utf8"));
+                    // Check if this looks like our monorepo root
+                    if (packageJson.name === "rw-sdk-monorepo" ||
+                        packageJson.private === true) {
+                        monorepoRoot = currentDir;
+                        break;
+                    }
+                }
+                catch {
+                    // Continue searching if we can't read the package.json
+                }
+            }
+            currentDir = path.dirname(currentDir);
+        }
+        if (!monorepoRoot) {
+            log(`  ⚠️ Could not find monorepo root, skipping wrangler cache copy`);
+            return;
+        }
+        const sourceCachePath = path.join(monorepoRoot, "node_modules/.cache/wrangler");
+        const targetCachePath = path.join(targetDir, "node_modules/.cache/wrangler");
+        if (fs.existsSync(sourceCachePath)) {
+            log(`  🔐 Copying wrangler cache from monorepo to temp directory...`);
+            // Ensure the target cache directory exists
+            await fs.promises.mkdir(path.dirname(targetCachePath), {
+                recursive: true,
+            });
+            // Copy the entire wrangler cache directory
+            await $ `cp -r ${sourceCachePath} ${path.dirname(targetCachePath)}`;
+            log(`  ✅ Wrangler cache copied successfully`);
+        }
+        else {
+            log(`  ⚠️ No wrangler cache found in monorepo, deployment tests may require authentication`);
+        }
+    }
+    catch (error) {
+        log(`  ⚠️ Failed to copy wrangler cache: ${error.message}`);
+        // Don't throw - this is not a fatal error, deployment tests will just need manual auth
+    }
+}
+/**
+ * Creates a tarball-based test environment similar to the release script approach
+ */
+export async function setupTarballEnvironment({ projectDir, packageManager = "pnpm", }) {
+    // Generate unique temp directory name
+    const randomId = crypto.randomBytes(4).toString("hex");
+    const projectName = path.basename(projectDir);
+    const tempDirName = `${projectName}-e2e-test-${randomId}`;
+    const targetDir = path.join(os.tmpdir(), tempDirName);
+    log(`📁 Creating temp directory: ${targetDir}`);
+    // Create temp directory
+    await fs.promises.mkdir(targetDir, { recursive: true });
+    try {
+        // Copy project to temp directory
+        log(`📋 Copying project from ${projectDir} to ${targetDir}`);
+        await $ `cp -a ${projectDir}/. ${targetDir}/`;
+        // Configure temp project to not use frozen lockfile
+        log(`⚙️  Configuring temp project to not use frozen lockfile...`);
+        const npmrcPath = path.join(targetDir, ".npmrc");
+        await fs.promises.writeFile(npmrcPath, "frozen-lockfile=false\n");
+        // Replace workspace:* dependencies with placeholder versions
+        log(`🔄 Replacing workspace dependencies...`);
+        const packageJsonPath = path.join(targetDir, "package.json");
+        const packageJsonContent = await fs.promises.readFile(packageJsonPath, "utf8");
+        const packageJson = JSON.parse(packageJsonContent);
+        // Replace workspace:* dependencies with a placeholder version
+        const replaceWorkspaceDeps = (deps) => {
+            if (!deps)
+                return;
+            for (const [name, version] of Object.entries(deps)) {
+                if (version === "workspace:*") {
+                    deps[name] = "0.0.80"; // Use a placeholder version that exists on npm
+                }
+            }
+        };
+        replaceWorkspaceDeps(packageJson.dependencies);
+        replaceWorkspaceDeps(packageJson.devDependencies);
+        replaceWorkspaceDeps(packageJson.peerDependencies);
+        await fs.promises.writeFile(packageJsonPath, JSON.stringify(packageJson, null, 2));
+        // Find SDK root directory (relative to current working directory)
+        const currentDir = process.cwd();
+        const sdkRoot = currentDir.includes("/playground")
+            ? path.join(currentDir, "../sdk")
+            : currentDir;
+        // Pack the SDK
+        log(`📦 Packing SDK from ${sdkRoot}...`);
+        const packResult = await $({ cwd: sdkRoot }) `npm pack`;
+        const tarballName = packResult.stdout.trim();
+        const tarballPath = path.join(sdkRoot, tarballName);
+        // Install the tarball in the temp project
+        log(`💿 Installing tarball ${tarballName} in ${targetDir}...`);
+        if (packageManager === "pnpm") {
+            await $({ cwd: targetDir }) `pnpm add ${tarballPath}`;
+        }
+        else if (packageManager === "npm") {
+            await $({ cwd: targetDir }) `npm install ${tarballPath}`;
+        }
+        else if (packageManager === "yarn") {
+            await $({ cwd: targetDir }) `yarn add ${tarballPath}`;
+        }
+        else {
+            throw new Error(`Unsupported package manager: ${packageManager}`);
+        }
+        // Verify installation
+        const sdkPackageJson = JSON.parse(await fs.promises.readFile(path.join(sdkRoot, "package.json"), "utf8"));
+        const packageName = sdkPackageJson.name;
+        const installedDistPath = path.join(targetDir, "node_modules", packageName, "dist");
+        log(`🔍 Verifying installed package contents...`);
+        if (!fs.existsSync(installedDistPath)) {
+            throw new Error(`dist/ directory not found in installed package at ${installedDistPath}`);
+        }
+        // Compare checksums like the release script does
+        const originalDistPath = path.join(sdkRoot, "dist");
+        if (fs.existsSync(originalDistPath)) {
+            const getDistChecksum = async (distPath) => {
+                const findResult = await $({ cwd: distPath }) `find . -type f`;
+                const sortedFiles = findResult.stdout
+                    .trim()
+                    .split("\n")
+                    .sort()
+                    .join("\n");
+                return crypto.createHash("md5").update(sortedFiles).digest("hex");
+            };
+            const originalChecksum = await getDistChecksum(originalDistPath);
+            const installedChecksum = await getDistChecksum(installedDistPath);
+            log(`  - Original dist checksum: ${originalChecksum}`);
+            log(`  - Installed dist checksum: ${installedChecksum}`);
+            if (originalChecksum !== installedChecksum) {
+                throw new Error("File list in installed dist/ does not match original dist/");
+            }
+            log(`  ✅ Installed package contents match the local build`);
+        }
+        // Copy wrangler cache from monorepo to temp directory for deployment tests
+        await copyWranglerCache(targetDir, sdkRoot);
+        // Cleanup function
+        const cleanup = async () => {
+            try {
+                // Remove tarball
+                if (fs.existsSync(tarballPath)) {
+                    await fs.promises.unlink(tarballPath);
+                }
+                // Remove temp directory
+                if (fs.existsSync(targetDir)) {
+                    await fs.promises.rm(targetDir, { recursive: true, force: true });
+                }
+            }
+            catch (error) {
+                console.warn(`Warning: Failed to cleanup temp files: ${error.message}`);
+            }
+        };
+        return {
+            targetDir,
+            cleanup,
+            tarballPath,
+        };
+    }
+    catch (error) {
+        // Cleanup on error
+        try {
+            if (fs.existsSync(targetDir)) {
+                await fs.promises.rm(targetDir, { recursive: true, force: true });
+            }
+        }
+        catch (cleanupError) {
+            console.warn(`Warning: Failed to cleanup after error: ${cleanupError.message}`);
+        }
+        throw error;
+    }
+}

package/dist/lib/e2e/testHarness.d.mts

@@ -0,0 +1,98 @@
+import type { Browser, Page } from "puppeteer-core";
+interface PlaygroundEnvironment {
+    projectDir: string;
+    cleanup: () => Promise<void>;
+}
+interface DevServerInstance {
+    url: string;
+    stopDev: () => Promise<void>;
+}
+interface DeploymentInstance {
+    url: string;
+    workerName: string;
+    resourceUniqueKey: string;
+}
+/**
+ * Sets up a playground environment for the entire test suite.
+ * Automatically registers beforeAll and afterAll hooks.
+ *
+ * @param sourceProjectDir - Explicit path to playground directory, or import.meta.url to auto-detect
+ */
+export declare function setupPlaygroundEnvironment(sourceProjectDir?: string): void;
+/**
+ * Gets the current playground environment.
+ * Throws if no environment has been set up.
+ */
+export declare function getPlaygroundEnvironment(): PlaygroundEnvironment;
+/**
+ * Creates a dev server instance using the shared playground environment.
+ * Automatically registers cleanup to run after the test.
+ */
+export declare function createDevServer(): Promise<DevServerInstance>;
+/**
+ * Creates a deployment instance using the shared playground environment.
+ * Automatically registers cleanup to run after the test.
+ */
+export declare function createDeployment(): Promise<DeploymentInstance>;
+/**
+ * Manually cleans up a deployment instance (deletes worker and D1 database).
+ * This is optional since cleanup happens automatically after each test.
+ */
+export declare function cleanupDeployment(deployment: DeploymentInstance): Promise<void>;
+/**
+ * Creates a browser instance for testing.
+ * Automatically registers cleanup to run after the test.
+ */
+export declare function createBrowser(): Promise<Browser>;
+/**
+ * High-level test wrapper for dev server tests.
+ * Automatically skips if RWSDK_SKIP_DEV=1
+ */
+export declare function testDev(name: string, testFn: (context: {
+    devServer: DevServerInstance;
+    browser: Browser;
+    page: Page;
+    url: string;
+}) => Promise<void>): void;
+export declare namespace testDev {
+    var skip: (name: string, testFn?: any) => void;
+}
+/**
+ * High-level test wrapper for deployment tests.
+ * Automatically skips if RWSDK_SKIP_DEPLOY=1
+ */
+export declare function testDeploy(name: string, testFn: (context: {
+    deployment: DeploymentInstance;
+    browser: Browser;
+    page: Page;
+    url: string;
+}) => Promise<void>): void;
+export declare namespace testDeploy {
+    var skip: (name: string, testFn?: any) => void;
+}
+/**
+ * Unified test function that runs the same test against both dev server and deployment.
+ * Automatically skips based on environment variables.
+ */
+export declare function testDevAndDeploy(name: string, testFn: (context: {
+    devServer?: DevServerInstance;
+    deployment?: DeploymentInstance;
+    browser: Browser;
+    page: Page;
+    url: string;
+}) => Promise<void>): void;
+export declare namespace testDevAndDeploy {
+    var skip: (name: string, testFn?: any) => void;
+    var only: (name: string, testFn: (context: {
+        devServer?: DevServerInstance;
+        deployment?: DeploymentInstance;
+        browser: Browser;
+        page: Page;
+        url: string;
+    }) => Promise<void>) => void;
+}
+/**
+ * Utility function for polling/retrying assertions
+ */
+export declare function poll(fn: () => Promise<boolean>, timeout?: number, interval?: number): Promise<void>;
+export {};

package/dist/lib/e2e/testHarness.mjs

@@ -0,0 +1,393 @@
+import { test, beforeAll, afterAll, afterEach, } from "vitest";
+import { setupTarballEnvironment } from "./tarball.mjs";
+import { runDevServer } from "./dev.mjs";
+import { runRelease, deleteWorker, deleteD1Database, isRelatedToTest, } from "./release.mjs";
+import { launchBrowser } from "./browser.mjs";
+// Environment variable flags for skipping tests
+const SKIP_DEV_SERVER_TESTS = process.env.RWSDK_SKIP_DEV === "1";
+const SKIP_DEPLOYMENT_TESTS = process.env.RWSDK_SKIP_DEPLOY === "1";
+// Global test environment state
+let globalPlaygroundEnv = null;
+const cleanupTasks = [];
+let hooksRegistered = false;
+/**
+ * Registers global cleanup hooks automatically
+ */
+function ensureHooksRegistered() {
+    if (hooksRegistered)
+        return;
+    // Register global afterEach to clean up resources created during tests
+    afterEach(async () => {
+        const tasksToCleanup = [...cleanupTasks];
+        cleanupTasks.length = 0; // Clear the array
+        for (const task of tasksToCleanup) {
+            try {
+                await task.cleanup();
+            }
+            catch (error) {
+                console.warn(`Failed to cleanup ${task.type} ${task.id}:`, error);
+            }
+        }
+    });
+    // Register global afterAll to clean up the playground environment
+    afterAll(async () => {
+        if (globalPlaygroundEnv) {
+            try {
+                await globalPlaygroundEnv.cleanup();
+                globalPlaygroundEnv = null;
+            }
+            catch (error) {
+                console.warn("Failed to cleanup playground environment:", error);
+            }
+        }
+    });
+    hooksRegistered = true;
+}
+/**
+ * Registers a cleanup task to be executed automatically
+ */
+function registerCleanupTask(task) {
+    ensureHooksRegistered();
+    cleanupTasks.push(task);
+}
+/**
+ * Removes a cleanup task from the registry (when manually cleaned up)
+ */
+function unregisterCleanupTask(id) {
+    const index = cleanupTasks.findIndex((task) => task.id === id);
+    if (index !== -1) {
+        cleanupTasks.splice(index, 1);
+    }
+}
+/**
+ * Get the project directory for the current test by looking at the call stack
+ */
+function getProjectDirectory() {
+    // For now, let's hardcode this to '../playground/hello-world' since we only have one project
+    // TODO: Make this more dynamic when we have multiple playground projects
+    return "../playground/hello-world";
+}
+/**
+ * Derive the playground directory from import.meta.url
+ */
+function getPlaygroundDirFromImportMeta(importMetaUrl) {
+    const url = new URL(importMetaUrl);
+    const testFilePath = url.pathname;
+    // Extract playground name from path like: /path/to/playground/PLAYGROUND_NAME/__tests__/e2e.test.mts
+    const playgroundMatch = testFilePath.match(/\/playground\/([^\/]+)\/__tests__\//);
+    if (playgroundMatch) {
+        const playgroundName = playgroundMatch[1];
+        // Return the absolute path to the playground directory
+        const playgroundPath = testFilePath.replace(/\/__tests__\/.*$/, "");
+        return playgroundPath;
+    }
+    throw new Error(`Could not determine playground directory from import.meta.url: ${importMetaUrl}`);
+}
+/**
+ * Sets up a playground environment for the entire test suite.
+ * Automatically registers beforeAll and afterAll hooks.
+ *
+ * @param sourceProjectDir - Explicit path to playground directory, or import.meta.url to auto-detect
+ */
+export function setupPlaygroundEnvironment(sourceProjectDir) {
+    ensureHooksRegistered();
+    beforeAll(async () => {
+        let projectDir;
+        if (!sourceProjectDir) {
+            projectDir = getProjectDirectory();
+        }
+        else if (sourceProjectDir.startsWith("file://")) {
+            // This is import.meta.url, derive the playground directory
+            projectDir = getPlaygroundDirFromImportMeta(sourceProjectDir);
+        }
+        else {
+            // This is an explicit path
+            projectDir = sourceProjectDir;
+        }
+        console.log(`Setting up playground environment from ${projectDir}...`);
+        const tarballEnv = await setupTarballEnvironment({
+            projectDir,
+            packageManager: "pnpm",
+        });
+        globalPlaygroundEnv = {
+            projectDir: tarballEnv.targetDir,
+            cleanup: tarballEnv.cleanup,
+        };
+    });
+}
+/**
+ * Gets the current playground environment.
+ * Throws if no environment has been set up.
+ */
+export function getPlaygroundEnvironment() {
+    if (!globalPlaygroundEnv) {
+        throw new Error("No playground environment set up. Call setupPlaygroundEnvironment() in beforeAll()");
+    }
+    return globalPlaygroundEnv;
+}
+/**
+ * Creates a dev server instance using the shared playground environment.
+ * Automatically registers cleanup to run after the test.
+ */
+export async function createDevServer() {
+    if (SKIP_DEV_SERVER_TESTS) {
+        throw new Error("Dev server tests are skipped via RWSDK_SKIP_DEV=1");
+    }
+    const env = getPlaygroundEnvironment();
+    const devResult = await runDevServer("pnpm", env.projectDir);
+    const serverId = `devServer-${Date.now()}-${Math.random()
+        .toString(36)
+        .substring(2, 9)}`;
+    // Register automatic cleanup
+    registerCleanupTask({
+        id: serverId,
+        type: "devServer",
+        cleanup: devResult.stopDev,
+    });
+    return {
+        url: devResult.url,
+        stopDev: async () => {
+            await devResult.stopDev();
+            unregisterCleanupTask(serverId); // Remove from auto-cleanup since manually cleaned
+        },
+    };
+}
+/**
+ * Creates a deployment instance using the shared playground environment.
+ * Automatically registers cleanup to run after the test.
+ */
+export async function createDeployment() {
+    if (SKIP_DEPLOYMENT_TESTS) {
+        throw new Error("Deployment tests are skipped via RWSDK_SKIP_DEPLOY=1");
+    }
+    const env = getPlaygroundEnvironment();
+    const resourceUniqueKey = Math.random().toString(36).substring(2, 15);
+    const deployResult = await runRelease(env.projectDir, env.projectDir, resourceUniqueKey);
+    const deploymentId = `deployment-${Date.now()}-${Math.random()
+        .toString(36)
+        .substring(2, 9)}`;
+    // Register automatic cleanup (non-blocking for deployments)
+    registerCleanupTask({
+        id: deploymentId,
+        type: "deployment",
+        cleanup: async () => {
+            // Run deployment cleanup in background without blocking
+            const performCleanup = async () => {
+                if (isRelatedToTest(deployResult.workerName, resourceUniqueKey)) {
+                    await deleteWorker(deployResult.workerName, env.projectDir, resourceUniqueKey);
+                }
+                await deleteD1Database(resourceUniqueKey, env.projectDir, resourceUniqueKey);
+            };
+            // Start cleanup in background and return immediately
+            performCleanup().catch((error) => {
+                console.warn(`Warning: Background deployment cleanup failed: ${error.message}`);
+            });
+            return Promise.resolve();
+        },
+    });
+    return {
+        url: deployResult.url,
+        workerName: deployResult.workerName,
+        resourceUniqueKey,
+    };
+}
+/**
+ * Manually cleans up a deployment instance (deletes worker and D1 database).
+ * This is optional since cleanup happens automatically after each test.
+ */
+export async function cleanupDeployment(deployment) {
+    const env = getPlaygroundEnvironment();
+    if (isRelatedToTest(deployment.workerName, deployment.resourceUniqueKey)) {
+        await deleteWorker(deployment.workerName, env.projectDir, deployment.resourceUniqueKey);
+    }
+    await deleteD1Database(deployment.resourceUniqueKey, env.projectDir, deployment.resourceUniqueKey);
+    // Remove from auto-cleanup registry since manually cleaned
+    const deploymentId = cleanupTasks.find((task) => task.type === "deployment" &&
+        task.id.includes(deployment.resourceUniqueKey))?.id;
+    if (deploymentId) {
+        unregisterCleanupTask(deploymentId);
+    }
+}
+/**
+ * Creates a browser instance for testing.
+ * Automatically registers cleanup to run after the test.
+ */
+export async function createBrowser() {
+    // Check if we should run in headed mode for debugging
+    const headless = process.env.RWSDK_HEADLESS !== "false";
+    const browser = await launchBrowser(undefined, headless);
+    const browserId = `browser-${Date.now()}-${Math.random().toString(36).substring(2, 9)}`;
+    // Register automatic cleanup
+    registerCleanupTask({
+        id: browserId,
+        type: "browser",
+        cleanup: async () => {
+            try {
+                await browser.close();
+            }
+            catch (error) {
+                // Browser might already be closed, ignore the error
+            }
+        },
+    });
+    // Wrap the close method to handle cleanup registration
+    const originalClose = browser.close.bind(browser);
+    browser.close = async () => {
+        await originalClose();
+        unregisterCleanupTask(browserId); // Remove from auto-cleanup since manually closed
+    };
+    return browser;
+}
+/**
+ * High-level test wrapper for dev server tests.
+ * Automatically skips if RWSDK_SKIP_DEV=1
+ */
+export function testDev(name, testFn) {
+    if (SKIP_DEV_SERVER_TESTS) {
+        test.skip(name, () => { });
+        return;
+    }
+    test(name, async () => {
+        const devServer = await createDevServer();
+        const browser = await createBrowser();
+        const page = await browser.newPage();
+        await testFn({
+            devServer,
+            browser,
+            page,
+            url: devServer.url,
+        });
+        // Automatic cleanup handled by afterEach hooks
+    });
+}
+/**
+ * Skip version of testDev
+ */
+testDev.skip = (name, testFn) => {
+    test.skip(name, testFn || (() => { }));
+};
+/**
+ * High-level test wrapper for deployment tests.
+ * Automatically skips if RWSDK_SKIP_DEPLOY=1
+ */
+export function testDeploy(name, testFn) {
+    if (SKIP_DEPLOYMENT_TESTS) {
+        test.skip(name, () => { });
+        return;
+    }
+    test(name, async () => {
+        const deployment = await createDeployment();
+        const browser = await createBrowser();
+        const page = await browser.newPage();
+        await testFn({
+            deployment,
+            browser,
+            page,
+            url: deployment.url,
+        });
+        // Automatic cleanup handled by afterEach hooks
+    });
+}
+/**
+ * Skip version of testDeploy
+ */
+testDeploy.skip = (name, testFn) => {
+    test.skip(name, testFn || (() => { }));
+};
+/**
+ * Unified test function that runs the same test against both dev server and deployment.
+ * Automatically skips based on environment variables.
+ */
+export function testDevAndDeploy(name, testFn) {
+    if (SKIP_DEV_SERVER_TESTS) {
+        test.skip(`${name} (dev)`, () => { });
+    }
+    else {
+        test(`${name} (dev)`, async () => {
+            const devServer = await createDevServer();
+            const browser = await createBrowser();
+            const page = await browser.newPage();
+            await testFn({
+                devServer,
+                browser,
+                page,
+                url: devServer.url,
+            });
+            // Automatic cleanup handled by afterEach hooks
+        });
+    }
+    if (SKIP_DEPLOYMENT_TESTS) {
+        test.skip(`${name} (deployment)`, () => { });
+    }
+    else {
+        test(`${name} (deployment)`, async () => {
+            const deployment = await createDeployment();
+            const browser = await createBrowser();
+            const page = await browser.newPage();
+            await testFn({
+                deployment,
+                browser,
+                page,
+                url: deployment.url,
+            });
+            // Automatic cleanup handled by afterEach hooks
+        });
+    }
+}
+/**
+ * Skip version of testDevAndDeploy
+ */
+testDevAndDeploy.skip = (name, testFn) => {
+    test.skip(`${name} (dev)`, testFn || (() => { }));
+    test.skip(`${name} (deployment)`, testFn || (() => { }));
+};
+/**
+ * Only version of testDevAndDeploy
+ */
+testDevAndDeploy.only = (name, testFn) => {
+    if (!SKIP_DEV_SERVER_TESTS) {
+        test.only(`${name} (dev)`, async () => {
+            const devServer = await createDevServer();
+            const browser = await createBrowser();
+            const page = await browser.newPage();
+            await testFn({
+                devServer,
+                browser,
+                page,
+                url: devServer.url,
+            });
+        });
+    }
+    if (!SKIP_DEPLOYMENT_TESTS) {
+        test.only(`${name} (deployment)`, async () => {
+            const deployment = await createDeployment();
+            const browser = await createBrowser();
+            const page = await browser.newPage();
+            await testFn({
+                deployment,
+                browser,
+                page,
+                url: deployment.url,
+            });
+        });
+    }
+};
+/**
+ * Utility function for polling/retrying assertions
+ */
+export async function poll(fn, timeout = 5000, interval = 100) {
+    const startTime = Date.now();
+    while (Date.now() - startTime < timeout) {
+        try {
+            const result = await fn();
+            if (result) {
+                return;
+            }
+        }
+        catch (error) {
+            // Continue polling on errors
+        }
+        await new Promise((resolve) => setTimeout(resolve, interval));
+    }
+    throw new Error(`Polling timed out after ${timeout}ms`);
+}