miqro 6.1.2 → 6.1.3

package/src/common/jsx.ts

@@ -0,0 +1,512 @@
+import { Runtime } from "@miqro/jsx";
+import { createNodeRuntime } from "@miqro/jsx-node";
+import { basename, dirname, relative, resolve } from "node:path";
+import { randomUUID } from "node:crypto";
+import { mkdirSync, readFileSync, rmdirSync, unlinkSync, writeFileSync } from "node:fs";
+import { Request, Response, CORSOptions, Logger, APIRoute } from "@miqro/core";
+import { Parser, Schema } from "@miqro/parser";
+import { APIRouteSchema, SessionHandlerOptionsSchema } from "@miqro/core";
+import { cwd } from "node:process";
+
+import { esBuild } from "./esbuild.js";
+import { assertGlobalTampered, browserJSXGlobals } from "../services/globals.js";
+import { APIOptions, ServerConfig, WSConfig, AuthConfig, DBConfig, LogConfig, MiddlewareConfig, ErrorConfig, DocConfig } from "../types.js";
+import { getJSXJSPath, JSX_TMP_DIR } from "./paths.js";
+import { CLEAR_JSX_CACHE } from "./constants.js";
+import { getAsset, initAsset, validateAsset } from "./assets.js";
+import { calculateChecksumFromBuffer } from "./checksum.js";
+import { HandlerWithOptionsSchema, RouteOptionsSchema } from "@miqro/core/build/types.js";
+import { Migration } from "@miqro/query";
+
+let jsxJSBuffer: null | Buffer = null; // Buffer.from(getAsset("jsx.dom.js"));
+let jsxJSBufferChecksumPromise: null | Promise<string> = null; // calculateChecksumFromBuffer(jsxJSBuffer);
+
+export async function initJSXJS(logger: Logger) {
+  jsxJSBuffer = jsxJSBuffer ? jsxJSBuffer : Buffer.from(getAsset("jsx.dom.js"));
+  jsxJSBufferChecksumPromise = jsxJSBufferChecksumPromise ? jsxJSBufferChecksumPromise : calculateChecksumFromBuffer(jsxJSBuffer);
+  return initAsset(logger, getJSXJSPath(), jsxJSBuffer, true, jsxJSBufferChecksumPromise, false);
+}
+
+export async function validateJSXJS(logger: Logger) {
+  const checksum = await jsxJSBufferChecksumPromise;
+  if (!checksum) {
+    throw new Error("error calculating checksum");
+  }
+  return validateAsset(logger, getJSXJSPath(), checksum);
+}
+
+export interface Dict<T> {
+  [key: string]: T | Dict<T>;
+}
+
+const parser = new Parser();
+
+export interface InflateError {
+  filePath: string;
+  error: Error;
+}
+
+export interface InflateOptions {
+  embemedJSX: boolean;
+  minify: boolean;
+  useExport: boolean;
+  logger?: Logger | Console;
+}
+
+const DEFAULT_ESOPTION = {
+  platform: "neutral",
+  bundle: true,
+  jsxFactory: "JSX.createElement",
+  jsxFragment: "JSX.Fragment"
+};
+
+export async function inflateJSX(inFile: string, options: InflateOptions): Promise<string> {
+  const tmpBuildDir = resolve(JSX_TMP_DIR, String(process.pid), "build", Date.now() + "-" + randomUUID());
+  const inFileTmp = resolve(tmpBuildDir, basename(inFile) + ".mjs");
+  const jsxJSPath = getJSXJSPath();//resolve(tmpBuildDir, "jsx.js");
+  const logger = options.logger; //getLogger(`${SERVER_IDENTIFIER}_JSX`);
+
+  try {
+
+    if (!options.embemedJSX) {
+      mkdirSync(tmpBuildDir, {
+        recursive: true
+      });
+      writeFileSync(inFileTmp, browserJSXGlobals(inFile, false, options.useExport));
+      //writeFileSync(inFileTmp, browserJSXGlobals(relative(tmpBuildDir, inFile), false));
+      logger?.trace("inflating [%s] from [%s]. to change the import folder set JSX_TMP", relative(cwd(), inFile), dirname(relative(JSX_TMP_DIR, inFileTmp)));
+      const { outputFiles: [{ contents }] } = await esBuild({
+        ...DEFAULT_ESOPTION,
+        entryPoints: [inFileTmp],
+        minify: options.minify
+      });
+      if (CLEAR_JSX_CACHE) {
+        logger?.trace("clearing cache at [%s] to change this behaivor set CLEAR_JSX_CACHE to 0", tmpBuildDir);
+        unlinkSync(inFileTmp);
+        rmdirSync(tmpBuildDir);
+      }
+      return contents;
+    } else {
+      mkdirSync(tmpBuildDir, {
+        recursive: true
+      });
+      //writeFileSync(jsxJSPath, Buffer.from(getAsset("jsx-dom-bundle")));
+      writeFileSync(inFileTmp, browserJSXGlobals(inFile, jsxJSPath));
+      //writeFileSync(inFileTmp, browserJSXGlobals(relative(tmpBuildDir, inFile), relative(tmpBuildDir, jsxJSPath)));
+      logger?.trace("inflating [%s] from [%s] with jsx.js embedded. to change the import folder set JSX_TMP", relative(cwd(), inFile), dirname(relative(JSX_TMP_DIR, inFileTmp)));
+      const { outputFiles: [{ contents }] } = await esBuild({
+        ...DEFAULT_ESOPTION,
+        entryPoints: [inFileTmp],
+        minify: options.minify
+      });
+      if (CLEAR_JSX_CACHE) {
+        logger?.trace("clearing cache at [%s] to change this behaivor set CLEAR_JSX_CACHE to 0", tmpBuildDir);
+        unlinkSync(inFileTmp);
+        //unlinkSync(jsxJSPath);
+        rmdirSync(tmpBuildDir);
+      }
+      return contents;
+    }
+  } catch (e) {
+    logger?.error("error with: " + inFile);
+    logger?.error(e);
+    if (options.embemedJSX) {
+      if (CLEAR_JSX_CACHE) {
+        logger?.trace("clearing cache at [%s] to change this behaivor set CLEAR_JSX_CACHE to 0", tmpBuildDir);
+        unlinkSync(inFileTmp);
+        //unlinkSync(jsxJSPath);
+        rmdirSync(tmpBuildDir);
+      } else {
+        //console.error("errors on: " + tmpBuildDir);
+        logger?.error("error with: %s", inFileTmp);
+        logger?.trace("NOT clearing cache. to change this behaivor set CLEAR_JSX_CACHE to 1", tmpBuildDir);
+      }
+    }
+    throw e;
+  }
+}
+
+export const APIOptionsSchema: Schema<APIOptions> = {
+  type: "object?",
+  properties: {
+    basePath: "string?",
+    path: "string?|string[]?",
+    method: "string?|string[]?",
+    parser: {
+      type: "object?",
+      properties: {
+        parse: "function"
+      },
+      mode: "add_extra"
+    },
+    middleware: "function[]!?",
+    session: {
+      type: "object?|function?",
+      properties: SessionHandlerOptionsSchema.properties
+    },
+    ...RouteOptionsSchema.properties
+  },
+  //mode:"add_extra"
+};
+
+export interface HTMLModule {
+  default: JSX.Element | ((req: Request | null, res: Response | null) => (Promise<JSX.Element> | JSX.Element));
+  apiOptions?: APIOptions;
+}
+
+export const HTMLModuleSchema: Schema<HTMLModule> = {
+  type: "object",
+  properties: {
+    default: {
+      type: "function|object"
+    },
+    apiOptions: APIOptionsSchema
+  },
+  //mode:"add_extra"
+}
+
+export type JSONModuleValue = string | object;
+
+export interface JSONModule {
+  default: JSONModuleValue | ((req: Request | null, res: Response | null) => (Promise<JSONModuleValue> | JSONModuleValue));
+  apiOptions?: APIOptions;
+}
+
+export const JSONModuleSchema: Schema<JSONModule> = {
+  type: "object",
+  properties: {
+    default: {
+      type: "function|object|string"
+    },
+    apiOptions: APIOptionsSchema
+  },
+  //mode:"add_extra"
+}
+
+export const MigrationSchema: Schema<Migration> = {
+  type: "object",
+  properties: {
+    up: "function",
+    down: "function"
+  },
+  mode: "add_extra"
+}
+
+export const CORSOptionsSchema: Schema<CORSOptions> = {
+  type: "object",
+  properties: {
+    origins: "string[]?|string?",
+    validate: "function?",
+    methods: "string?",
+    preflightContinue: "boolean?"
+  },
+  //mode:"add_extra"
+}
+
+export const WSConfigSchema: Schema<WSConfig> = {
+  type: "object",
+  properties: {
+    path: "string",
+    disabled: "boolean?",
+    maxConnections: "number?",
+    validate: "function?",
+    onConnection: "function?",
+    onMessage: "function?",
+    onDisconnect: "function?"
+  },
+  //mode:"add_extra"
+};
+
+export const DBConfigSchema: Schema<DBConfig> = {
+  type: "object",
+  properties: {
+    url: "string?",
+    disabled: "boolean?",
+    storage: "string?",
+    dialect: "string?",
+    name: "string"
+  },
+  //mode:"add_extra"
+}
+
+export const ServerConfigSchema: Schema<ServerConfig> = {
+  type: "object",
+  properties: {
+    preload: "function?",
+    unload: "function?",
+    stop: "function?",
+    start: "function?",
+    load: "function?"
+  },
+  //mode:"add_extra"
+};
+
+export const LogConfigSchema: Schema<LogConfig> = {
+  type: "object",
+  properties: {
+    level: {
+      type: "enum?",
+      enumValues: ["error", "warn", "info", "debug", "trace", "none"]
+    },
+    replaceConsoleTransport: "boolean?",
+    replaceFileTransport: "boolean?",
+    write: "function"
+  },
+  //mode:"add_extra"
+};
+
+export const AuthConfigSchema: Schema<AuthConfig> = {
+  type: "object",
+  properties: {
+    ...SessionHandlerOptionsSchema.properties
+  },
+  //mode:"add_extra"
+}
+
+export const MiddlewareConfigSchema: Schema<MiddlewareConfig> = {
+  type: "object",
+  properties: {
+    middleware: {
+      type: "Array",
+      arrayType: "function|object",
+      required: false,
+      properties: {
+        ...HandlerWithOptionsSchema.properties
+      }
+    },
+    post: {
+      type: "Array",
+      arrayType: "function|object",
+      required: false,
+      properties: {
+        ...HandlerWithOptionsSchema.properties
+      }
+    }
+  },
+}
+
+export const ErrorConfigSchema: Schema<ErrorConfig> = {
+  type: "object",
+  properties: {
+    catch: {
+      type: "Array",
+      required: false,
+      arrayType: "function"
+    }
+  },
+}
+
+export const DocConfigSchema: Schema<DocConfig> = {
+  type: "object",
+  properties: {
+    publish: {
+      type: "dict?",
+      dictType: "object",
+      properties: {
+        type: {
+          type: "enum?",
+          enumValues: ["HTML", "MD", "JSON"]
+        },
+        all: "boolean?"
+      }
+    }
+  }
+}
+
+export async function importAPIRoute(inFile: string, logger?: Logger) {
+  const mod = (await importJSXFile(inFile, logger)).default;
+  const module = typeof mod === "function" ? { handler: mod } : parser.parse(mod, APIRouteSchema, basename(inFile));
+  if (module !== undefined) {
+    return module as APIRoute;
+  } else {
+    throw new Error(`error with module [${inFile}] undefined`);
+  }
+}
+
+export async function importMigrationModule(inFile: string, logger?: Logger) {
+  const module = parser.parse((await importJSXFile(inFile, logger)).default, MigrationSchema, basename(inFile));
+  if (module !== undefined) {
+    return module;
+  } else {
+    throw new Error(`error with module [${inFile}] undefined`);
+  }
+}
+
+export async function importHTMLModule(inFile: string, logger?: Logger) {
+  const module = (await importJSXFile(inFile, logger));
+  parser.parse(module.default, HTMLModuleSchema.properties.default, `${basename(inFile)}.default`);
+  parser.parse(module.apiOptions, APIOptionsSchema, `${basename(inFile)}.apiOptions`);
+  if (module !== undefined) {
+    return module;
+  } else {
+    throw new Error(`error with module [${inFile}] undefined`);
+  }
+}
+
+export async function importJSONModule(inFile: string, logger?: Logger) {
+  const module = (await importJSXFile(inFile, logger));
+  parser.parse(module.default, JSONModuleSchema.properties.default, `${basename(inFile)}.default`);
+  parser.parse(module.apiOptions, APIOptionsSchema, `${basename(inFile)}.apiOptions`);
+  if (module !== undefined) {
+    return module;
+  } else {
+    throw new Error(`error with module [${inFile}] undefined`);
+  }
+}
+
+export async function importAuthModule(inFile: string, logger?: Logger) {
+  const module = parser.parse((await importJSXFile(inFile, logger)).default, AuthConfigSchema, basename(inFile));
+  if (module !== undefined) {
+    return module;
+  } else {
+    throw new Error(`error with module [${inFile}] undefined`);
+  }
+}
+
+export async function importMiddlewareConfigModule(inFile: string, logger?: Logger) {
+  const module = parser.parse((await importJSXFile(inFile, logger)).default, MiddlewareConfigSchema, basename(inFile));
+  if (module !== undefined) {
+    return module;
+  } else {
+    throw new Error(`error with module [${inFile}] undefined`);
+  }
+}
+
+export async function importErrorConfigModule(inFile: string, logger?: Logger) {
+  const module = parser.parse((await importJSXFile(inFile, logger)).default, ErrorConfigSchema, basename(inFile));
+  if (module !== undefined) {
+    return module;
+  } else {
+    throw new Error(`error with module [${inFile}] undefined`);
+  }
+}
+
+export async function importDocConfigModule(inFile: string, logger?: Logger) {
+  const module = parser.parse((await importJSXFile(inFile, logger)).default, DocConfigSchema, basename(inFile));
+  if (module !== undefined) {
+    return module;
+  } else {
+    throw new Error(`error with module [${inFile}] undefined`);
+  }
+}
+
+export async function importConfigConfigModule(inFile: string, logger?: Logger) {
+  const module = parser.parse((await importJSXFile(inFile, logger)).default, MiddlewareConfigSchema, basename(inFile));
+  if (module !== undefined) {
+    return module;
+  } else {
+    throw new Error(`error with module [${inFile}] undefined`);
+  }
+}
+
+export async function importCORSModule(inFile: string, logger?: Logger) {
+  const module = parser.parse((await importJSXFile(inFile, logger)).default, CORSOptionsSchema, basename(inFile));
+  if (module !== undefined) {
+    return module;
+  } else {
+    throw new Error(`error with module [${inFile}] undefined`);
+  }
+}
+
+export async function importWSConfigModule(inFile: string, logger?: Logger) {
+  const module = parser.parse((await importJSXFile(inFile, logger)).default, WSConfigSchema, basename(inFile));
+  if (module !== undefined) {
+    return module;
+  } else {
+    throw new Error(`error with module [${inFile}] undefined`);
+  }
+}
+
+export async function importDBConfigModule(inFile: string, logger?: Logger) {
+  const module = parser.parse((await importJSXFile(inFile, logger)).default, DBConfigSchema, basename(inFile));
+  if (module !== undefined) {
+    return module;
+  } else {
+    throw new Error(`error with module [${inFile}] undefined`);
+  }
+}
+
+export async function importLogConfigModule(inFile: string, logger?: Logger) {
+  const module = parser.parse((await importJSXFile(inFile, logger)).default, LogConfigSchema, basename(inFile));
+  if (module !== undefined) {
+    return module;
+  } else {
+    throw new Error(`error with module [${inFile}] undefined`);
+  }
+}
+
+export async function importServerConfigModule(inFile: string, logger?: Logger) {
+  const module = parser.parse((await importJSXFile(inFile, logger)).default, ServerConfigSchema, basename(inFile));
+  if (module !== undefined) {
+    return module;
+  } else {
+    throw new Error(`error with module [${inFile}] undefined`);
+  }
+}
+
+export async function importJSXFile(inFile: string, logger?: Logger | Console): Promise<any> {
+  const inflatedCode = await inflateJSX(inFile, {
+    embemedJSX: false,
+    minify: false,
+    useExport: true,
+    logger
+  });
+  const tmpBuildDir = resolve(JSX_TMP_DIR, String(process.pid), "import", Date.now() + "-" + randomUUID());
+  const inFileTmp = resolve(tmpBuildDir, basename(inFile) + ".mjs");
+  //const logger = getLogger(`${SERVER_IDENTIFIER}_JSX`);
+  mkdirSync(tmpBuildDir, {
+    recursive: true
+  });
+  try {
+    writeFileSync(inFileTmp, inflatedCode);
+    assertGlobalTampered();
+    logger?.trace("importing [%s] from [%s]. to change the import folder set JSX_TMP", relative(cwd(), inFile), dirname(relative(JSX_TMP_DIR, inFileTmp)));
+    logger?.debug("importing [%s]", relative(cwd(), inFile));
+    const module = await import(inFileTmp);
+    assertGlobalTampered();
+    if (CLEAR_JSX_CACHE) {
+      logger?.trace("clearing cache at [%s]. to change this behaivor set CLEAR_JSX_CACHE to 0", tmpBuildDir);
+      unlinkSync(inFileTmp);
+      rmdirSync(tmpBuildDir);
+    }
+    return module;
+  } catch (e) {
+    logger?.error(e);
+    logger?.error("error with: " + inFile);
+    if (CLEAR_JSX_CACHE) {
+      logger?.trace("clearing cache at [%s] to change this behaivor set CLEAR_JSX_CACHE to 0", tmpBuildDir);
+      unlinkSync(inFileTmp);
+      rmdirSync(tmpBuildDir);
+    } else {
+      //console.error("errors on: " + tmpBuildDir);
+      logger?.error("error with: %s", inFileTmp);
+      logger?.trace("NOT clearing cache. to change this behaivor set CLEAR_JSX_CACHE to 1", tmpBuildDir);
+    }
+    throw e;
+  }
+}
+
+export function jsx2HTML(out: JSX.Element, runtime?: Runtime): string {
+  runtime = runtime ? runtime : createNodeRuntime();
+  const element = runtime.createElement("root");
+  const container = runtime.createContainer(element, {
+    shadowInit: false, runtimeOptions: {
+      disableEffects: true,
+      disableEvents: true,
+      disableRefListener: true,
+      disableRefresh: true
+    }
+  });
+  container.render(out);
+  //console.log("jsx2HTML [%s]", element);
+  let HTML = "";
+  for (let i = 0; i < element.childNodes.length; i++) {
+    const child = element.childNodes[i];
+    //console.log("jsx2HTML child [%s]", child);
+    //console.log("jsx2HTML child [%s]", (child as any).toString("  ", -1));
+    HTML += (child as any).toString("  ", -1);
+  }
+  container.disconnect();
+  //console.log("jsx2HTML [%s]", HTML);
+  return HTML;
+}

package/src/common/paths.ts

@@ -0,0 +1,158 @@
+import { checkEnvVariable } from "@miqro/core";
+import { randomUUID } from "node:crypto";
+import { existsSync, statSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { resolve } from "node:path";
+import { cwd, platform } from "node:process";
+
+export const JSX_TMP_DIR = checkEnvVariable(`JSX_TMP`, resolve(tmpdir(), "jsx_tmp"));
+
+export const TEST_SOCKET = resolve(JSX_TMP_DIR, `test.${randomUUID()}.sock`);
+
+export function getServicePath(service: string) {
+  return resolve(cwd(), service);
+}
+
+export function getLogConfigPath(servicePath: string) {
+  const logConfigPath = resolve(servicePath, "log.ts");
+  const logConfigPathJS = resolve(servicePath, "log.js");
+  if (existsSync(logConfigPath) && !statSync(logConfigPath).isDirectory()) {
+    return logConfigPath;
+  } else if (existsSync(logConfigPathJS) && !statSync(logConfigPathJS).isDirectory()) {
+    return logConfigPathJS;
+  }
+  return false;
+}
+
+export function getCORSConfigPath(servicePath: string) {
+  const corsPath = resolve(servicePath, "cors.ts");
+  const corsPathJS = resolve(servicePath, "cors.js");
+  if (existsSync(corsPath) && !statSync(corsPath).isDirectory()) {
+    return corsPath;
+  } else if (existsSync(corsPathJS) && !statSync(corsPathJS).isDirectory()) {
+    return corsPathJS;
+  }
+  return false;
+}
+
+export function getServerConfigPath(servicePath: string) {
+  const serverPath = resolve(servicePath, "server.ts");
+  const serverPathJS = resolve(servicePath, "server.js");
+  if (existsSync(serverPath)) {
+    return serverPath;
+  } else if (existsSync(serverPathJS)) {
+    return serverPathJS;
+  }
+  return false;
+}
+
+export function getWSConfigPath(servicePath: string) {
+  const wsPath = resolve(servicePath, "ws.ts");
+  const wsPathJS = resolve(servicePath, "ws.js");
+  if (existsSync(wsPath)) {
+    return wsPath;
+  } else if (existsSync(wsPathJS)) {
+    return wsPathJS;
+  }
+  return false;
+}
+
+export function getDBConfigPath(servicePath: string) {
+  const dbPath = resolve(servicePath, "db.ts");
+  const dbPathJS = resolve(servicePath, "db.js");
+  if (existsSync(dbPath)) {
+    return dbPath;
+  } else if (existsSync(dbPathJS)) {
+    return dbPathJS;
+  }
+  return false;
+}
+
+export function getStaticFilesPath(servicePath: string) {
+  const staticFilesPath = resolve(servicePath, "static");
+  if (existsSync(staticFilesPath) && statSync(staticFilesPath).isDirectory()) {
+    return staticFilesPath;
+  }
+  return false;
+}
+
+export function getMiddlewareConfigPath(servicePath: string) {
+  const middlewarePath = resolve(servicePath, "middleware.ts");
+  const middlewarePathJS = resolve(servicePath, "middleware.js");
+  if (existsSync(middlewarePath) && !statSync(middlewarePath).isDirectory()) {
+    return middlewarePath;
+  } else if (existsSync(middlewarePathJS) && !statSync(middlewarePathJS).isDirectory()) {
+    return middlewarePathJS;
+  }
+  return false;
+}
+
+export function getErrorConfigPath(servicePath: string) {
+  const errorPath = resolve(servicePath, "catch.ts");
+  const errorPathJS = resolve(servicePath, "catch.js");
+  if (existsSync(errorPath) && !statSync(errorPath).isDirectory()) {
+    return errorPath;
+  } else if (existsSync(errorPathJS) && !statSync(errorPathJS).isDirectory()) {
+    return errorPathJS;
+  }
+  return false;
+}
+
+export function getDocConfigPath(servicePath: string) {
+  const docPath = resolve(servicePath, "doc.ts");
+  const docPathJS = resolve(servicePath, "doc.js");
+  if (existsSync(docPath) && !statSync(docPath).isDirectory()) {
+    return docPath;
+  } else if (existsSync(docPathJS) && !statSync(docPathJS).isDirectory()) {
+    return docPathJS;
+  }
+  return false;
+}
+
+export function getMiqroJSONPath() {
+  const miqroRCPath = resolve(cwd(), "miqro.json");
+  if (existsSync(miqroRCPath) && !statSync(miqroRCPath).isDirectory()) {
+    return miqroRCPath;
+  }
+  return false;
+}
+
+export function getAuthConfigPath(servicePath: string) {
+  const authPath = resolve(servicePath, "auth.ts");
+  const authPathJS = resolve(servicePath, "auth.js");
+  if (existsSync(authPath) && !statSync(authPath).isDirectory()) {
+    return authPath;
+  } else if (existsSync(authPathJS) && !statSync(authPathJS).isDirectory()) {
+    return authPathJS;
+  }
+  return false;
+}
+
+export function getHTTPRouterPath(servicePath: string) {
+  const apiRouterPath = resolve(servicePath, "http");
+  if (existsSync(apiRouterPath) && statSync(apiRouterPath).isDirectory()) {
+    return apiRouterPath;
+  }
+  return false;
+}
+
+export function getMigrationsPath(servicePath: string) {
+  const migrationsFolderPath = resolve(servicePath, "migration");
+  if (existsSync(migrationsFolderPath) && statSync(migrationsFolderPath).isDirectory()) {
+    return migrationsFolderPath;
+  }
+  return false;
+}
+
+export function getESBuildBinaryPath() {
+  if (platform === "win32") {
+    return resolve(JSX_TMP_DIR, String(process.pid), "esbuild.exe");
+  } else {
+    return resolve(JSX_TMP_DIR, String(process.pid), "esbuild");
+  }
+}
+
+export function getJSXJSPath() {
+  return resolve(JSX_TMP_DIR, String(process.pid), "jsx.js");
+}
+