@travetto/web 6.0.0 → 6.0.2

package/src/registry/types.ts

@@ -5,7 +5,7 @@ import type { WebInterceptor } from '../types/interceptor.ts';
 import type { WebChainedFilter, WebFilter } from '../types/filter.ts';
 import { HttpMethod } from '../types/core.ts';
 import { WebHeaders } from '../types/headers.ts';
-import { WebResponse } from '../types/response.ts';
+import { WebResponse, WebResponseContext } from '../types/response.ts';
 import { WebRequest } from '../types/request.ts';
 
 export type EndpointFunction = TypedFunction<Any, unknown>;
@@ -78,6 +78,10 @@ interface CoreConfig {
    * Response headers
    */
   responseHeaders?: Record<string, string>;
+  /**
+   * Partial response context
+   */
+  responseContext?: Partial<WebResponseContext>;
 }
 
 /**
@@ -167,14 +171,14 @@ export interface EndpointConfig extends CoreConfig, DescribableConfig {
    * Full path including controller
    */
   fullPath: string;
-  /**
-   * Response header map
-   */
-  responseHeaderMap: WebHeaders;
   /**
    * Response finalizer
    */
   responseFinalizer?: (res: WebResponse) => WebResponse;
+  /**
+   * Response headers finalized
+   */
+  finalizedResponseHeaders: WebHeaders;
 }
 
 /**

package/src/types/cookie.ts

@@ -9,7 +9,7 @@ export type Cookie = {
   priority?: 'low' | 'medium' | 'high';
   sameSite?: 'strict' | 'lax' | 'none';
   secure?: boolean;
-  httpOnly?: boolean;
+  httponly?: boolean;
   partitioned?: boolean;
   response?: boolean;
 };

package/src/types/headers.ts

@@ -1,19 +1,14 @@
-import { Any, ByteRange, castTo } from '@travetto/runtime';
-import { MimeType, MimeUtil } from '../util/mime.ts';
+import { Any, castTo } from '@travetto/runtime';
 
 type Prim = number | boolean | string;
 type HeaderValue = Prim | Prim[] | readonly Prim[];
 export type WebHeadersInit = Headers | Record<string, undefined | null | HeaderValue> | [string, HeaderValue][];
 
-const FILENAME_EXTRACT = /filename[*]?=["]?([^";]*)["]?/;
-
 /**
  * Simple Headers wrapper with additional logic for common patterns
  */
 export class WebHeaders extends Headers {
 
-  #parsedType?: MimeType;
-
   constructor(o?: WebHeadersInit) {
     const passed = (o instanceof Headers);
     super(passed ? o : undefined);
@@ -56,42 +51,6 @@ export class WebHeaders extends Headers {
     }
   }
 
-  /**
-   * Vary a value
-   */
-  vary(value: string): void {
-    this.append('Vary', value);
-  }
-
-  /**
-   * Get the fully parsed content type
-   */
-  getContentType(): MimeType | undefined {
-    return this.#parsedType ??= MimeUtil.parse(this.get('Content-Type')!);
-  }
-
-  /**
-   * Read the filename from the content disposition
-   */
-  getFilename(): string | undefined {
-    const [, match] = (this.get('Content-Disposition') ?? '').match(FILENAME_EXTRACT) ?? [];
-    return match;
-  }
-
-  /**
-   * Get requested byte range for a given request
-   */
-  getRange(chunkSize: number = 100 * 1024): ByteRange | undefined {
-    const rangeHeader = this.get('Range');
-    if (rangeHeader) {
-      const [start, end] = rangeHeader.replace(/bytes=/, '').split('-')
-        .map(x => x ? parseInt(x, 10) : undefined);
-      if (start !== undefined) {
-        return { start, end: end ?? (start + chunkSize) };
-      }
-    }
-  }
-
   /**
    * Set header value with a prefix
    */

package/src/types/response.ts

@@ -2,6 +2,8 @@ import { BaseWebMessage } from './message.ts';
 
 export interface WebResponseContext {
   httpStatusCode?: number;
+  isPrivate?: boolean;
+  cacheableAge?: number;
 }
 
 /**

package/src/util/body.ts

@@ -1,6 +1,5 @@
 import { TextDecoder } from 'node:util';
 import { Readable } from 'node:stream';
-import { buffer as toBuffer } from 'node:stream/consumers';
 
 import { Any, BinaryUtil, castTo, hasToJSON, Util } from '@travetto/runtime';
 
@@ -15,20 +14,6 @@ const WebRawStreamSymbol = Symbol();
  */
 export class WebBodyUtil {
 
-  /**
-   * Convert a node binary input to a buffer
-   */
-  static async toBuffer(src: WebBinaryBody): Promise<Buffer> {
-    return Buffer.isBuffer(src) ? src : toBuffer(src);
-  }
-
-  /**
-   * Convert a node binary input to a readable
-   */
-  static toReadable(src: WebBinaryBody): Readable {
-    return Buffer.isBuffer(src) ? Readable.from(src) : src;
-  }
-
   /**
    * Generate multipart body
    */

package/src/util/common.ts

@@ -1,17 +1,15 @@
-import { AppError, ErrorCategory, TimeSpan, TimeUtil } from '@travetto/runtime';
+import { AppError, ErrorCategory, Util } from '@travetto/runtime';
 
 import { WebResponse } from '../types/response.ts';
 import { WebRequest } from '../types/request.ts';
+import { WebError } from '../types/error.ts';
 
 type List<T> = T[] | readonly T[];
 type OrderedState<T> = { after?: List<T>, before?: List<T>, key: T };
 
 const WebRequestParamsSymbol = Symbol();
 
-export type CacheControlFlag =
-  'must-revalidate' | 'public' | 'private' | 'no-cache' |
-  'no-store' | 'no-transform' | 'proxy-revalidate' | 'immutable' |
-  'must-understand' | 'stale-if-error' | 'stale-while-revalidate';
+export type ByteSizeInput = `${number}${'mb' | 'kb' | 'gb' | 'b' | ''}` | number;
 
 /**
  * Mapping from error category to standard http error codes
@@ -33,6 +31,12 @@ export class WebCommonUtil {
     gb: 2 ** 30,
   };
 
+  static #convert(rule: string): RegExp {
+    const core = (rule.endsWith('/*') || !rule.includes('/')) ?
+      `${rule.replace(/[/].{0,20}$/, '')}\/.*` : rule;
+    return new RegExp(`^${core}[ ]{0,10}(;|$)`);
+  }
+
   static #buildEdgeMap<T, U extends OrderedState<T>>(items: List<U>): Map<T, Set<T>> {
     const edgeMap = new Map(items.map(x => [x.key, new Set(x.after ?? [])]));
 
@@ -51,6 +55,19 @@ export class WebCommonUtil {
     return edgeMap;
   }
 
+
+  /**
+   * Build matcher
+   */
+  static mimeTypeMatcher(rules: string[] | string = []): (contentType: string) => boolean {
+    return Util.allowDeny<RegExp, [string]>(
+      rules,
+      this.#convert.bind(this),
+      (regex, mime) => regex.test(mime),
+      k => k
+    );
+  }
+
   /**
    * Produces a satisfied ordering for a list of orderable elements
    */
@@ -103,7 +120,7 @@ export class WebCommonUtil {
         new AppError(err.message, { details: err }) :
         new AppError(`${err}`);
 
-    const error: Error & { category?: ErrorCategory, details?: { statusCode: number } } = body;
+    const error: Error & Partial<WebError> = body;
     const statusCode = error.details?.statusCode ?? ERROR_CATEGORY_STATUS[error.category!] ?? 500;
 
     return new WebResponse({ body, context: { httpStatusCode: statusCode } });
@@ -123,19 +140,13 @@ export class WebCommonUtil {
     request[WebRequestParamsSymbol] ??= params;
   }
 
-  /**
-   * Get a cache control value
-   */
-  static getCacheControlValue(value: number | TimeSpan, flags: CacheControlFlag[] = []): string {
-    const delta = TimeUtil.asSeconds(value);
-    const finalFlags = delta === 0 ? ['no-cache'] : flags;
-    return [...finalFlags, `max-age=${delta}`].join(',');
-  }
-
   /**
    * Parse byte size
    */
-  static parseByteSize(input: `${number}${'mb' | 'kb' | 'gb' | 'b' | ''}`): number {
+  static parseByteSize(input: ByteSizeInput): number {
+    if (typeof input === 'number') {
+      return input;
+    }
     const [, num, unit] = input.toLowerCase().split(/(\d+)/);
     return parseInt(num, 10) * (this.#unitMapping[unit] ?? 1);
   }

package/src/util/cookie.ts

@@ -1,7 +1,8 @@
-import keygrip from 'keygrip';
-import { AppError, castKey, castTo } from '@travetto/runtime';
+import { AppError } from '@travetto/runtime';
 
 import { Cookie, CookieGetOptions, CookieSetOptions } from '../types/cookie.ts';
+import { KeyGrip } from './keygrip.ts';
+import { WebHeaderUtil } from './header.ts';
 
 const pairText = (c: Cookie): string => `${c.name}=${c.value}`;
 const pair = (k: string, v: unknown): string => `${k}=${v}`;
@@ -10,55 +11,13 @@ type CookieJarOptions = { keys?: string[] } & CookieSetOptions;
 
 export class CookieJar {
 
-  static parseCookieHeader(header: string): Cookie[] {
-    return header.split(/\s{0,4};\s{0,4}/g)
-      .map(x => x.trim())
-      .filter(x => !!x)
-      .map(item => {
-        const kv = item.split(/\s{0,4}=\s{0,4}/);
-        return { name: kv[0], value: kv[1] };
-      });
-  }
-
-  static parseSetCookieHeader(header: string): Cookie {
-    const parts = header.split(/\s{0,4};\s{0,4}/g);
-    const [name, value] = parts[0].split(/\s{0,4}=\s{0,4}/);
-    const c: Cookie = { name, value };
-    for (const p of parts.slice(1)) {
-      // eslint-disable-next-line prefer-const
-      let [k, v = ''] = p.split(/\s{0,4}=\s{0,4}/);
-      if (v[0] === '"') {
-        v = v.slice(1, -1);
-      }
-      if (k === 'expires') {
-        c[k] = new Date(v);
-      } else {
-        c[castKey(k)] = castTo(v || true);
-      }
-    }
-    return c;
-  }
-
-  static responseSuffix(c: Cookie): string[] {
-    const parts = [];
-    if (c.path) { parts.push(pair('path', c.path)); }
-    if (c.expires) { parts.push(pair('expires', c.expires.toUTCString())); }
-    if (c.domain) { parts.push(pair('domain', c.domain)); }
-    if (c.priority) { parts.push(pair('priority', c.priority.toLowerCase())); }
-    if (c.sameSite) { parts.push(pair('samesite', c.sameSite.toLowerCase())); }
-    if (c.secure) { parts.push('secure'); }
-    if (c.httpOnly) { parts.push('httponly'); }
-    if (c.partitioned) { parts.push('partitioned'); }
-    return parts;
-  }
-
-  #grip?: keygrip;
+  #grip?: KeyGrip;
   #cookies: Record<string, Cookie> = {};
   #setOptions: CookieSetOptions = {};
   #deleteOptions: CookieSetOptions = { maxAge: 0, expires: undefined };
 
   constructor({ keys, ...options }: CookieJarOptions = {}) {
-    this.#grip = keys?.length ? new keygrip(keys) : undefined;
+    this.#grip = keys?.length ? new KeyGrip(keys) : undefined;
     this.#setOptions = {
       secure: false,
       path: '/',
@@ -68,7 +27,7 @@ export class CookieJar {
   }
 
   #exportCookie(cookie: Cookie, response?: boolean): string[] {
-    const suffix = response ? CookieJar.responseSuffix(cookie) : null;
+    const suffix = response ? WebHeaderUtil.buildCookieSuffix(cookie) : null;
     const payload = pairText(cookie);
     const out = suffix ? [[payload, ...suffix].join(';')] : [payload];
     if (cookie.signed) {
@@ -144,11 +103,11 @@ export class CookieJar {
   }
 
   importCookieHeader(header: string | null | undefined): this {
-    return this.import(CookieJar.parseCookieHeader(header ?? ''));
+    return this.import(WebHeaderUtil.parseCookieHeader(header ?? ''));
   }
 
   importSetCookieHeader(headers: string[] | null | undefined): this {
-    return this.import(headers?.map(CookieJar.parseSetCookieHeader) ?? []);
+    return this.import(headers?.map(WebHeaderUtil.parseSetCookieHeader) ?? []);
   }
 
   exportCookieHeader(): string {

package/src/util/endpoint.ts

@@ -143,10 +143,15 @@ export class EndpointUtil {
     try {
       const params = await this.extractParameters(endpoint, request);
       const body = await endpoint.endpoint.apply(endpoint.instance, params);
-      const headers = endpoint.responseHeaderMap;
-      const response = body instanceof WebResponse ? body : new WebResponse({ body, headers });
-      if (response === body) {
-        for (const [k, v] of headers) { response.headers.setIfAbsent(k, v); }
+      const headers = endpoint.finalizedResponseHeaders;
+      let response: WebResponse;
+      if (body instanceof WebResponse) {
+        for (const [k, v] of headers) { body.headers.setIfAbsent(k, v); }
+        // Rewrite context
+        Object.assign(body.context, { ...endpoint.responseContext, ...body.context });
+        response = body;
+      } else {
+        response = new WebResponse({ body, headers, context: { ...endpoint.responseContext } });
       }
       return endpoint.responseFinalizer?.(response) ?? response;
     } catch (err) {

package/src/util/header.ts

@@ -0,0 +1,161 @@
+import { ByteRange, castKey, castTo } from '@travetto/runtime';
+
+import { type Cookie } from '../types/cookie.ts';
+import { WebHeaders } from '../types/headers.ts';
+
+export type WebParsedHeader = { value: string, parameters: Record<string, string>, q?: number };
+
+const SPLIT_EQ = /[ ]{0,10}=[ ]{0,10}/g;
+const SPLIT_COMMA = /[ ]{0,10},[ ]{0,10}/g;
+const SPLIT_SEMI = /[ ]{0,10};[ ]{0,10}/g;
+const QUOTE = '"'.charCodeAt(0);
+
+/**
+ * Web header utils
+ */
+export class WebHeaderUtil {
+
+  /**
+   * Parse cookie header
+   */
+  static parseCookieHeader(header: string): Cookie[] {
+    const val = header.trim();
+    return !val ? [] : val.split(SPLIT_SEMI).map(item => {
+      const [name, value] = item.split(SPLIT_EQ);
+      return { name, value };
+    });
+  }
+
+  /**
+   * Parse cookie set header
+   */
+  static parseSetCookieHeader(header: string): Cookie {
+    const parts = header.split(SPLIT_SEMI);
+    const [name, value] = parts[0].split(SPLIT_EQ);
+    const c: Cookie = { name, value };
+    for (const p of parts.slice(1)) {
+      const [k, pv = ''] = p.toLowerCase().split(SPLIT_EQ);
+      const v = pv.charCodeAt(0) === QUOTE ? pv.slice(1, -1) : pv;
+      if (k === 'expires') {
+        c[k] = new Date(v);
+      } else {
+        c[castKey(k)] = castTo(v || true);
+      }
+    }
+    return c;
+  }
+
+  /**
+   * Parse header segment
+   * @input input
+   */
+  static parseHeaderSegment(input: string | null | undefined): WebParsedHeader {
+    if (!input) {
+      return { value: '', parameters: {} };
+    }
+    const [rv, ...parts] = input.split(SPLIT_SEMI);
+    const item: WebParsedHeader = { value: '', parameters: {} };
+    const value = rv.charCodeAt(0) === QUOTE ? rv.slice(1, -1) : rv;
+    if (value.includes('=')) {
+      parts.unshift(value);
+    } else {
+      item.value = value;
+    }
+    for (const part of parts) {
+      const [k, pv = ''] = part.split(SPLIT_EQ);
+      const v = (pv.charCodeAt(0) === QUOTE) ? pv.slice(1, -1) : pv;
+      item.parameters[k] = v;
+      if (k === 'q') {
+        item.q = parseFloat(v);
+      }
+    }
+    return item;
+  }
+
+  /**
+   * Parse full header
+   */
+  static parseHeader(input: string): WebParsedHeader[] {
+    const v = input.trim();
+    if (!input) { return []; }
+    return v.split(SPLIT_COMMA).map(x => this.parseHeaderSegment(x));
+  }
+
+  /**
+   * Build cookie suffix
+   */
+  static buildCookieSuffix(c: Cookie): string[] {
+    const parts = [];
+    if (c.path) { parts.push(`path=${c.path}`); }
+    if (c.expires) { parts.push(`expires=${c.expires.toUTCString()}`); }
+    if (c.domain) { parts.push(`domain=${c.domain}`); }
+    if (c.priority) { parts.push(`priority=${c.priority.toLowerCase()}`); }
+    if (c.sameSite) { parts.push(`samesite=${c.sameSite.toLowerCase()}`); }
+    if (c.secure) { parts.push('secure'); }
+    if (c.httponly) { parts.push('httponly'); }
+    if (c.partitioned) { parts.push('partitioned'); }
+    return parts;
+  }
+
+  /**
+   * Negotiate header
+   */
+  static negotiateHeader<K extends string>(header: string, values: K[]): K | undefined {
+    if (header === '*' || header === '*/*') {
+      return values[0];
+    }
+    const sorted = this.parseHeader(header.toLowerCase()).filter(x => (x.q ?? 1) > 0).toSorted((a, b) => (b.q ?? 1) - (a.q ?? 1));
+    const set = new Set(values);
+    for (const { value } of sorted) {
+      const vk: K = castKey(value);
+      if (value === '*') {
+        return values[0];
+      } else if (set.has(vk)) {
+        return vk;
+      }
+    }
+    return undefined;
+  }
+
+  /**
+   * Get requested byte range for a given request
+   */
+  static getRange(headers: WebHeaders, chunkSize: number = 100 * 1024): ByteRange | undefined {
+    if (!headers.has('Range')) {
+      return;
+    }
+    const { parameters } = this.parseHeaderSegment(headers.get('Range'));
+    if ('bytes' in parameters) {
+      const [start, end] = parameters.bytes.split('-')
+        .map(x => x ? parseInt(x, 10) : undefined);
+      if (start !== undefined) {
+        return { start, end: end ?? (start + chunkSize) };
+      }
+    }
+  }
+
+  /**
+   * Check freshness of the response using request and response headers.
+   */
+  static isFresh(req: WebHeaders, res: WebHeaders): boolean {
+    const cacheControl = req.get('Cache-Control');
+    if (cacheControl?.includes('no-cache')) {
+      return false;
+    }
+
+    const noneMatch = req.get('If-None-Match');
+    if (noneMatch) {
+      const etag = res.get('ETag');
+      const validTag = (v: string): boolean => v === etag || v === `W/${etag}` || `W/${v}` === etag;
+      return noneMatch === '*' || (!!etag && noneMatch.split(SPLIT_COMMA).some(validTag));
+    } else {
+      const modifiedSince = req.get('If-Modified-Since');
+      const lastModified = res.get('Last-Modified');
+      if (!modifiedSince || !lastModified) {
+        return false;
+      }
+      const [a, b] = [Date.parse(lastModified), Date.parse(modifiedSince)];
+      return !(Number.isNaN(a) || Number.isNaN(b)) && a >= b;
+    }
+  }
+}

package/src/util/keygrip.ts

@@ -0,0 +1,43 @@
+import crypto, { BinaryToTextEncoding } from 'node:crypto';
+import { AppError, castKey } from '@travetto/runtime';
+
+const CHAR_MAPPING = { '/': '_', '+': '-', '=': '' };
+
+function timeSafeCompare(a: string, b: string): boolean {
+  const key = crypto.randomBytes(32);
+  const ah = crypto.createHmac('sha256', key).update(a).digest();
+  const bh = crypto.createHmac('sha256', key).update(b).digest();
+  return ah.length === bh.length && crypto.timingSafeEqual(ah, bh);
+}
+
+export class KeyGrip {
+
+  #keys: string[];
+  #algorithm: string;
+  #encoding: BinaryToTextEncoding;
+
+  constructor(keys: string[], algorithm = 'sha1', encoding: BinaryToTextEncoding = 'base64') {
+    if (!keys.length) {
+      throw new AppError('Keys must be defined');
+    }
+    this.#keys = keys;
+    this.#algorithm = algorithm;
+    this.#encoding = encoding;
+  }
+
+  sign(data: string, key?: string): string {
+    return crypto
+      .createHmac(this.#algorithm, key ?? this.#keys[0])
+      .update(data)
+      .digest(this.#encoding)
+      .replace(/[/+=]/g, x => CHAR_MAPPING[castKey(x)]);
+  }
+
+  verify(data: string, digest: string): boolean {
+    return this.index(data, digest) > -1;
+  }
+
+  index(data: string, digest: string): number {
+    return this.#keys.findIndex(key => timeSafeCompare(digest, this.sign(data, key)));
+  }
+}

package/support/test/dispatch-util.ts

@@ -1,4 +1,5 @@
-import { buffer as toBuffer } from 'node:stream/consumers';
+import { buffer } from 'node:stream/consumers';
+import { Readable } from 'node:stream';
 
 import { AppError, BinaryUtil, castTo } from '@travetto/runtime';
 import { BindUtil } from '@travetto/schema';
@@ -9,6 +10,8 @@ import { DecompressInterceptor } from '../../src/interceptor/decompress.ts';
 import { WebBodyUtil } from '../../src/util/body.ts';
 import { WebCommonUtil } from '../../src/util/common.ts';
 
+const toBuffer = (src: Buffer | Readable) => Buffer.isBuffer(src) ? src : buffer(src);
+
 /**
  * Utilities for supporting custom test dispatchers
  */
@@ -18,7 +21,7 @@ export class WebTestDispatchUtil {
     if (request.body !== undefined) {
       const sample = WebBodyUtil.toBinaryMessage(request);
       sample.headers.forEach((v, k) => request.headers.set(k, Array.isArray(v) ? v.join(',') : v));
-      request.body = WebBodyUtil.markRaw(await WebBodyUtil.toBuffer(sample.body!));
+      request.body = WebBodyUtil.markRaw(await toBuffer(sample.body!));
     }
     Object.assign(request.context, { httpQuery: BindUtil.flattenPaths(request.context.httpQuery ?? {}) });
     return request;
@@ -31,7 +34,7 @@ export class WebTestDispatchUtil {
 
     if (decompress) {
       if (Buffer.isBuffer(result) || BinaryUtil.isReadable(result)) {
-        const bufferResult = result = await WebBodyUtil.toBuffer(result);
+        const bufferResult = result = await toBuffer(result);
         if (bufferResult.length) {
           try {
             result = await DecompressInterceptor.decompress(
@@ -74,7 +77,7 @@ export class WebTestDispatchUtil {
 
     const body: RequestInit['body'] =
       WebBodyUtil.isRaw(request.body) ?
-        Buffer.isBuffer(request.body) ? request.body : await toBuffer(request.body) :
+        await toBuffer(request.body) :
         castTo(request.body);
 
     return { path: finalPath, init: { headers, method, body } };

package/support/test/suite/base.ts

@@ -20,6 +20,9 @@ export class WebTestConfig implements ConfigSource {
           http: {
             ssl: { active: false },
             port: -1,
+          },
+          etag: {
+            minimumSize: 1
           }
         }
       },

package/src/interceptor/response-cache.ts

@@ -1,47 +0,0 @@
-import { Injectable, Inject } from '@travetto/di';
-import { Config } from '@travetto/config';
-
-import { WebChainedContext } from '../types/filter.ts';
-import { WebInterceptor, WebInterceptorContext } from '../types/interceptor.ts';
-import { WebInterceptorCategory } from '../types/core.ts';
-import { WebResponse } from '../types/response.ts';
-
-import { WebCommonUtil } from '../util/common.ts';
-
-import { EtagInterceptor } from './etag.ts';
-
-@Config('web.cache')
-export class ResponseCacheConfig {
-  /**
-   * Generate response cache headers
-   */
-  applies = true;
-
-  /**
-   * Determines how we cache
-   */
-  mode: 'allow' | 'deny' = 'deny';
-}
-
-/**
- * Determines if we should cache all get requests
- */
-@Injectable()
-export class ResponseCacheInterceptor implements WebInterceptor {
-
-  category: WebInterceptorCategory = 'response';
-  dependsOn = [EtagInterceptor];
-
-  @Inject()
-  config: ResponseCacheConfig;
-
-  applies({ config, endpoint }: WebInterceptorContext<ResponseCacheConfig>): boolean {
-    return !!endpoint.cacheable && config.applies && config.mode === 'deny';
-  }
-
-  async filter({ next }: WebChainedContext<ResponseCacheConfig>): Promise<WebResponse> {
-    const response = await next();
-    response.headers.setIfAbsent('Cache-Control', WebCommonUtil.getCacheControlValue(0));
-    return response;
-  }
-}