@visulima/pail 4.0.0-alpha.1 → 4.0.0-alpha.10

package/dist/middleware/shared/create-middleware-logger.d.ts

@@ -0,0 +1,82 @@
+import type { PailBrowserImpl } from "../../pail.d.ts";
+import type { DefaultLogTypes, LoggerFunction } from "../../types.d.ts";
+import type { WideEventFinishOptions } from "../../wide-event.d.ts";
+import { WideEvent } from "../../wide-event.d.ts";
+import type { RouteConfig } from "./routes.d.ts";
+/**
+ * A pail instance with dynamically generated log methods.
+ */
+type PailLike<T extends string = string> = PailBrowserImpl<T> & Record<DefaultLogTypes | T, LoggerFunction>;
+/**
+ * Base options shared by all framework middleware adapters.
+ * @template T - Custom logger type names from the pail instance
+ */
+export interface PailMiddlewareOptions<T extends string = string> {
+    /**
+     * Glob patterns for paths to exclude from logging.
+     * Exclusions take precedence over inclusions.
+     * @example ["/health", "/api/_internal/**"]
+     */
+    exclude?: string[];
+    /**
+     * Glob patterns for paths to include in logging.
+     * If not set, all non-excluded paths are logged.
+     * @example ["/api/**"]
+     */
+    include?: string[];
+    /**
+     * The pail logger instance to use for wide event emission.
+     */
+    pail: PailLike<T>;
+    /**
+     * Route-specific configuration. Maps glob patterns to config.
+     * First matching route wins.
+     * @example { "/api/auth/**": { service: "auth-service" } }
+     */
+    routes?: Record<string, RouteConfig>;
+    /**
+     * Default service name for all wide events.
+     * Can be overridden per-route via `routes`.
+     */
+    service?: string;
+}
+/**
+ * Result of creating a middleware logger for a request.
+ */
+export interface MiddlewareLoggerResult {
+    /**
+     * Finalize and emit the wide event. Sets status/error before emitting.
+     * Safe to call multiple times — only the first call emits.
+     */
+    finish: (options?: WideEventFinishOptions) => void;
+    /**
+     * The request-scoped WideEvent logger.
+     * Use `set()`, `info()`, `warn()`, `error()`, `debug()` to accumulate context.
+     */
+    logger: WideEvent;
+    /**
+     * Whether this request was skipped (excluded from logging).
+     * When true, `logger` and `finish` should not be used.
+     */
+    skipped: boolean;
+}
+/**
+ * Core factory function used by all framework middleware adapters.
+ *
+ * Creates a WideEvent for the given request, checks route inclusion/exclusion,
+ * resolves the service name, and returns a logger + finish callback.
+ * @param options Middleware options including pail instance and route config
+ * @param request Request metadata for the current HTTP request
+ * @param request.headers Safe headers extracted from the request
+ * @param request.method The HTTP method (GET, POST, etc.)
+ * @param request.path The URL path of the request
+ * @param request.requestId A unique identifier for this request
+ * @returns A result object with logger, finish callback, and skipped flag
+ */
+export declare const createMiddlewareLogger: <T extends string = string>(options: PailMiddlewareOptions<T>, request: {
+    headers?: Record<string, string>;
+    method: string;
+    path: string;
+    requestId: string;
+}) => MiddlewareLoggerResult;
+export {};

package/dist/middleware/shared/headers.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Extract safe headers from a Web API Headers object, filtering out
+ * sensitive headers like Authorization, Cookie, and API keys.
+ * @param headers Web API Headers object
+ * @returns Plain object of safe header key-value pairs
+ */
+export declare const extractSafeHeaders: (headers: Headers) => Record<string, string>;
+/**
+ * Extract safe headers from a Node.js IncomingHttpHeaders object,
+ * filtering out sensitive headers.
+ * @param headers Node.js IncomingHttpHeaders-like object
+ * @returns Plain object of safe header key-value pairs
+ */
+export declare const extractSafeNodeHeaders: (headers: Record<string, string | string[] | undefined>) => Record<string, string>;

package/dist/middleware/shared/routes.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Check if a path matches a glob pattern.
+ */
+export declare const matchesPattern: (path: string, pattern: string) => boolean;
+/**
+ * Route configuration for a specific path pattern.
+ */
+export interface RouteConfig {
+    /** Override the service name for requests matching this route. */
+    service?: string;
+}
+/**
+ * Determine whether a request path should be logged based on include/exclude patterns.
+ *
+ * - Exclusions take precedence over inclusions.
+ * - If no include patterns are provided, all non-excluded paths are logged.
+ * @param path The request path
+ * @param include Glob patterns of paths to include
+ * @param exclude Glob patterns of paths to exclude
+ * @returns Whether the path should be logged
+ */
+export declare const shouldLog: (path: string, include?: string[], exclude?: string[]) => boolean;
+/**
+ * Get the service name override for a given path based on route configuration.
+ * Returns the first matching route's service name, or undefined if no match.
+ * @param path The request path
+ * @param routes Route configuration map (pattern → config)
+ * @returns The service name override, or undefined
+ */
+export declare const getServiceForPath: (path: string, routes?: Record<string, RouteConfig>) => string | undefined;

package/dist/middleware/shared/storage.d.ts

@@ -0,0 +1,29 @@
+import { AsyncLocalStorage } from "node:async_hooks";
+import type { WideEvent } from "../../wide-event.d.ts";
+/**
+ * Create an isolated AsyncLocalStorage instance and a `useLogger` accessor
+ * for retrieving the request-scoped WideEvent from anywhere in the call stack.
+ *
+ * Each framework adapter should call this once at module level to get its own
+ * isolated storage instance.
+ * @param contextHint A description of the expected context, used in the
+ * error message when `useLogger` is called outside of a request scope.
+ * @returns An object with `storage` and `useLogger`
+ * @example
+ * ```typescript
+ * const { storage, useLogger } = createLoggerStorage(
+ *   "Express middleware context. Make sure evlog middleware is registered."
+ * );
+ *
+ * // In middleware:
+ * storage.run(wideEvent, () => next());
+ *
+ * // In handler:
+ * const log = useLogger();
+ * log.set({ user: { id: 1 } });
+ * ```
+ */
+export declare const createLoggerStorage: (contextHint: string) => {
+    storage: AsyncLocalStorage<WideEvent>;
+    useLogger: () => WideEvent;
+};

package/dist/middleware/sveltekit.d.ts

@@ -0,0 +1,123 @@
+import type { WideEvent } from "../wide-event.d.ts";
+import type { PailMiddlewareOptions } from "./shared/create-middleware-logger.d.ts";
+/**
+ * A SvelteKit-like event object with access to the pail logger via `locals.log`.
+ * @example
+ * ```typescript
+ * // In a SvelteKit load function or action:
+ * import type { PailSvelteKitEvent } from "@visulima/pail/middleware/sveltekit";
+ *
+ * export const load = async (event: PailSvelteKitEvent) => {
+ *   event.locals.log?.set({ user: { id: 1 } });
+ * };
+ * ```
+ */
+interface PailSvelteKitEvent {
+    [key: string]: unknown;
+    locals: Record<string, unknown> & {
+        log?: WideEvent;
+    };
+    request: Request;
+    url: URL;
+}
+/**
+ * Options passed to SvelteKit's resolve function.
+ */
+interface PailSvelteKitResolveOptions {
+    filterSerializedResponseHeaders?: (name: string) => boolean;
+    preload?: (input: {
+        type: string;
+    }) => boolean;
+    transformPageChunk?: (input: {
+        html: string;
+    }) => string;
+}
+/**
+ * SvelteKit resolve function type.
+ */
+type PailSvelteKitResolve = (event: PailSvelteKitEvent, options?: PailSvelteKitResolveOptions) => Promise<Response>;
+/**
+ * Input for the SvelteKit handle hook.
+ */
+interface PailSvelteKitHandleInput {
+    event: PailSvelteKitEvent;
+    resolve: PailSvelteKitResolve;
+}
+/**
+ * SvelteKit handle hook function type returned by `pailHandle()`.
+ */
+type PailSvelteKitHandle = (input: PailSvelteKitHandleInput) => Promise<Response>;
+/**
+ * Input for the SvelteKit handleError hook.
+ */
+interface PailSvelteKitHandleErrorInput {
+    error: unknown;
+    event: PailSvelteKitEvent;
+    message: string;
+    status: number;
+}
+/**
+ * SvelteKit handleError hook function type returned by `pailHandleError()`.
+ */
+type PailSvelteKitHandleError = (input: PailSvelteKitHandleErrorInput) => void;
+/**
+ * Retrieve the request-scoped WideEvent logger from AsyncLocalStorage.
+ * Must be called within a request handled by the pail SvelteKit handle hook.
+ * @returns The request-scoped WideEvent logger
+ * @throws Error if called outside of the hook context
+ */
+declare const useLogger: () => WideEvent;
+type SvelteKitHandleOptions<T extends string = string> = PailMiddlewareOptions<T>;
+/**
+ * Create a SvelteKit `handle` hook that attaches a WideEvent logger to each request.
+ *
+ * The logger is available via:
+ * - `event.locals.log` in server load functions and actions
+ * - `useLogger()` from anywhere in the async call stack
+ *
+ * The wide event is automatically emitted when the response is sent or an error occurs.
+ * @param options Hook configuration
+ * @returns SvelteKit handle hook function
+ * @example
+ * ```typescript
+ * // src/hooks.server.ts
+ * import { createPail } from "@visulima/pail";
+ * import { pailHandle, pailHandleError } from "@visulima/pail/middleware/sveltekit";
+ *
+ * const logger = createPail();
+ *
+ * export const handle = pailHandle({ pail: logger });
+ * export const handleError = pailHandleError();
+ * ```
+ */
+export declare const pailHandle: <T extends string = string>(options: SvelteKitHandleOptions<T>) => PailSvelteKitHandle;
+/**
+ * Create a SvelteKit `handleError` hook that captures errors into the WideEvent logger.
+ *
+ * Should be used alongside `pailHandle` to ensure errors are recorded in the wide event.
+ * @returns SvelteKit handleError hook function
+ */
+export declare const pailHandleError: () => PailSvelteKitHandleError;
+/**
+ * Convenience function that returns both handle and handleError hooks.
+ * @param options Hook configuration
+ * @returns Object with `handle` and `handleError` hooks
+ * @example
+ * ```typescript
+ * // src/hooks.server.ts
+ * import { createPail } from "@visulima/pail";
+ * import { createPailHooks } from "@visulima/pail/middleware/sveltekit";
+ *
+ * const logger = createPail();
+ * const { handle, handleError } = createPailHooks({ pail: logger });
+ *
+ * export { handle, handleError };
+ * ```
+ */
+export declare const createPailHooks: <T extends string = string>(options: SvelteKitHandleOptions<T>) => {
+    handle: PailSvelteKitHandle;
+    handleError: PailSvelteKitHandleError;
+};
+export { useLogger };
+export type { PailSvelteKitEvent, PailSvelteKitHandle, PailSvelteKitHandleError, PailSvelteKitHandleErrorInput, PailSvelteKitHandleInput, PailSvelteKitResolve, PailSvelteKitResolveOptions, SvelteKitHandleOptions, };
+export type { WideEvent } from "../wide-event.d.ts";

package/dist/middleware/sveltekit.js

@@ -0,0 +1,43 @@
+import { a as extractSafeHeaders, c as createMiddlewareLogger } from '../packem_shared/headers-BxHWM6KI.js';
+import { c as createLoggerStorage } from '../packem_shared/storage-D0vqz8OX.js';
+
+const loggerStorage = createLoggerStorage("SvelteKit handle hook context. Make sure pailHandle is added to your hooks.server.ts.");
+const useLogger = () => loggerStorage.useLogger();
+const pailHandle = (options) => async ({ event, resolve }) => {
+  const requestId = event.request.headers.get("x-request-id") ?? crypto.randomUUID();
+  const safeHeaders = extractSafeHeaders(event.request.headers);
+  const { finish, logger, skipped } = createMiddlewareLogger(options, {
+    headers: safeHeaders,
+    method: event.request.method,
+    path: event.url.pathname,
+    requestId
+  });
+  if (skipped) {
+    return resolve(event);
+  }
+  event.locals.log = logger;
+  return loggerStorage.storage.run(logger, async () => {
+    try {
+      const response = await resolve(event);
+      finish({ status: response.status });
+      return response;
+    } catch (error) {
+      finish({ error: error instanceof Error ? error : new Error(String(error)) });
+      throw error;
+    }
+  });
+};
+const pailHandleError = () => ({ error, event }) => {
+  const logger = event.locals.log;
+  if (logger && error instanceof Error) {
+    logger.error(error.message, error);
+  }
+};
+const createPailHooks = (options) => {
+  return {
+    handle: pailHandle(options),
+    handleError: pailHandleError()
+  };
+};
+
+export { createPailHooks, pailHandle, pailHandleError, useLogger };

package/dist/object-tree.d.ts

@@ -16,7 +16,7 @@ export type TreeSortFunction = (a: string, b: string) => number;
  */
 export interface ObjectTreeOptions {
     /** Text to display for circular references (default: " (circular ref.)") */
-    breakCircularWith?: string | null | undefined;
+    breakCircularWith?: string | null;
     /** Whether to return as single string or array of lines (default: true) */
     joined?: boolean;
     /** Connector for neighbor keys (default: "├─ ") */
@@ -28,7 +28,7 @@ export interface ObjectTreeOptions {
     /** Separator between key and value (default: ": ") */
     separator?: string;
     /** Function to sort object keys (default: natural order) */
-    sortFn?: TreeSortFunction | undefined;
+    sortFn?: TreeSortFunction;
     /** Spacer for neighbor branches (default: "│  ") */
     spacerNeighbour?: string;
     /** Spacer for non-neighbor branches (default: "   ") */

package/dist/object-tree.js

@@ -50,22 +50,22 @@ const renderObjectTree = (tree, options) => {
   const result = [];
   const rootRendered = context.renderFn(tree);
   if (rootRendered !== void 0) {
-    result.push(String(rootRendered));
+    result.push(rootRendered);
   }
   const sort = (input) => {
     if (context.sortFn === void 0) {
       return input;
     }
-    return input.toSorted((a, b) => context?.sortFn?.(b, a) ?? 0);
+    return input.toSorted((a, b) => context.sortFn?.(b, a) ?? 0);
   };
   const neighbours = [];
   const keys = sort(Object.keys(tree)).map((k) => [k]);
   const lookup = [tree];
   while (keys.length > 0) {
     const key = keys.pop() ?? [];
-    const node = lookup[key.length - 1][key[key.length - 1] ?? ""];
+    const node = lookup[key.length - 1][key.at(-1) ?? ""];
     const isCircular = context.breakCircularWith !== null && lookup.slice(0, key.length).includes(node);
-    neighbours[key.length - 1] = keys.length > 0 && (keys[keys.length - 1]?.length ?? 0) === key.length;
+    neighbours[key.length - 1] = keys.length > 0 && (keys.at(-1)?.length ?? 0) === key.length;
     const indent = neighbours.slice(0, key.length - 1).map((n) => {
       if (n) {
         return context.spacerNeighbour;
@@ -73,17 +73,17 @@ const renderObjectTree = (tree, options) => {
       return context.spacerNoNeighbour;
     }).join("");
     const connector = neighbours[key.length - 1] ? context.keyNeighbour : context.keyNoNeighbour;
-    const keyName = key[key.length - 1];
+    const keyName = key.at(-1) ?? "";
     const nodeRendered = context.renderFn(node);
     const value = nodeRendered === void 0 ? "" : `${context.separator}${nodeRendered}`;
-    const circular = isCircular ? context.breakCircularWith : "";
+    const circular = isCircular ? context.breakCircularWith ?? "" : "";
     result.push(`${indent}${connector}${keyName}${value}${circular}`);
     if (node !== null && typeof node === "object" && !Array.isArray(node) && !isCircular) {
       keys.push(...sort(Object.keys(node)).map((k) => [...key, k]));
       lookup[key.length] = node;
     }
   }
-  return context.joined === true ? result.join("\n") : result;
+  return context.joined ? result.join("\n") : result;
 };
 
 export { renderObjectTree as default, renderObjectTree };

package/dist/packem_shared/AbstractJsonReporter-CjtVgHbU.js

@@ -0,0 +1,288 @@
+import { E as EMPTY_SYMBOL } from './constants-B1RjD_ps.js';
+
+function isPlainObject(value) {
+  if (typeof value !== "object" || value === null) {
+    return false;
+  }
+  const prototype = Object.getPrototypeOf(value);
+  return (prototype === null || prototype === Object.prototype || Object.getPrototypeOf(prototype) === null) && !(Symbol.toStringTag in value) && !(Symbol.iterator in value);
+}
+
+const ErrorProto = Object.create(
+  {},
+  {
+    cause: {
+      enumerable: false,
+      value: void 0,
+      writable: true
+    },
+    code: {
+      enumerable: true,
+      value: void 0,
+      writable: true
+    },
+    errors: {
+      enumerable: false,
+      value: void 0,
+      writable: true
+    },
+    message: {
+      enumerable: false,
+      value: void 0,
+      writable: true
+    },
+    name: {
+      enumerable: false,
+      value: void 0,
+      writable: true
+    },
+    stack: {
+      enumerable: false,
+      value: void 0,
+      writable: true
+    }
+  }
+);
+const toJsonWasCalled = /* @__PURE__ */ new WeakSet();
+const makePropertiesEnumerable = (object) => {
+  const props = Object.getOwnPropertyNames(object);
+  for (const prop of props) {
+    const descriptor = Object.getOwnPropertyDescriptor(object, prop);
+    if (descriptor) {
+      if (!descriptor.enumerable) {
+        Object.defineProperty(object, prop, {
+          ...descriptor,
+          enumerable: true
+        });
+      }
+      if (descriptor.value && typeof descriptor.value === "object" && !Array.isArray(descriptor.value) && (Object.getPrototypeOf(descriptor.value) === Object.prototype || Object.getPrototypeOf(descriptor.value) === null)) {
+        makePropertiesEnumerable(descriptor.value);
+      }
+    }
+  }
+};
+const toJSON = (from) => {
+  toJsonWasCalled.add(from);
+  const json = from.toJSON();
+  toJsonWasCalled.delete(from);
+  if (
+    // Only make properties enumerable if the object is extensible
+    // Non-extensible objects (like when toJSON returns 'this') should preserve original enumerability
+    Object.isExtensible(json)
+  ) {
+    makePropertiesEnumerable(json);
+  }
+  return json;
+};
+const serializeValue = (value, seen, depth, options) => {
+  if (value && value instanceof Uint8Array && value.constructor.name === "Buffer") {
+    return "[object Buffer]";
+  }
+  if (value !== null && typeof value === "object" && "pipe" in value && typeof value.pipe === "function") {
+    return "[object Stream]";
+  }
+  if (value instanceof Error) {
+    if (seen.has(value)) {
+      return "[Circular]";
+    }
+    depth += 1;
+    return _serialize(value, options, seen, depth);
+  }
+  if (options.useToJSON && value !== null && typeof value === "object" && "toJSON" in value && typeof value.toJSON === "function") {
+    return value.toJSON();
+  }
+  if (value instanceof Date) {
+    return value.toISOString();
+  }
+  if (typeof value === "function") {
+    return `[Function: ${value.name || "anonymous"}]`;
+  }
+  if (typeof value === "bigint") {
+    return `${String(value)}n`;
+  }
+  if (isPlainObject(value)) {
+    if (options.maxDepth !== void 0 && options.maxDepth !== Number.POSITIVE_INFINITY && depth + 1 >= options.maxDepth) {
+      return {};
+    }
+    depth += 1;
+    const plainObject = {};
+    for (const key in value) {
+      plainObject[key] = serializeValue(value[key], seen, depth, options);
+    }
+    return plainObject;
+  }
+  try {
+    return value;
+  } catch {
+    return "[Not Available]";
+  }
+};
+const _serialize = (error, options, seen, depth) => {
+  seen.add(error);
+  if (options.maxDepth === 0) {
+    return {};
+  }
+  if (options.useToJSON && typeof error.toJSON === "function" && !toJsonWasCalled.has(error)) {
+    return toJSON(error);
+  }
+  const protoError = Object.create(ErrorProto);
+  Object.defineProperty(protoError, "name", {
+    configurable: true,
+    enumerable: true,
+    value: Object.prototype.toString.call(error.constructor) === "[object Function]" ? error.constructor.name : error.name,
+    writable: true
+  });
+  Object.defineProperty(protoError, "message", {
+    configurable: true,
+    enumerable: true,
+    value: error.message,
+    writable: true
+  });
+  Object.defineProperty(protoError, "stack", {
+    configurable: true,
+    enumerable: true,
+    value: error.stack,
+    writable: true
+  });
+  if (Array.isArray(error.errors)) {
+    const aggregateErrors = [];
+    for (const aggregateError of error.errors) {
+      if (!(aggregateError instanceof Error)) {
+        throw new TypeError("All errors in the 'errors' property must be instances of Error");
+      }
+      if (seen.has(aggregateError)) {
+        Object.defineProperty(protoError, "errors", {
+          configurable: true,
+          enumerable: true,
+          value: [],
+          writable: true
+        });
+        return protoError;
+      }
+      aggregateErrors.push(_serialize(aggregateError, options, seen, depth));
+    }
+    Object.defineProperty(protoError, "errors", {
+      configurable: true,
+      enumerable: true,
+      value: aggregateErrors,
+      writable: true
+    });
+  }
+  const causeValue = error.cause;
+  if (causeValue !== void 0 && causeValue !== null) {
+    if (causeValue instanceof Error) {
+      if (seen.has(causeValue)) {
+        Object.defineProperty(protoError, "cause", {
+          configurable: true,
+          enumerable: true,
+          value: "[Circular]",
+          writable: true
+        });
+      } else {
+        Object.defineProperty(protoError, "cause", {
+          configurable: true,
+          enumerable: true,
+          value: _serialize(causeValue, options, seen, depth),
+          writable: true
+        });
+      }
+    } else {
+      const serializedCause = serializeValue(causeValue, seen, depth, options);
+      Object.defineProperty(protoError, "cause", {
+        configurable: true,
+        enumerable: true,
+        value: serializedCause,
+        writable: true
+      });
+    }
+  }
+  for (const key in error) {
+    if (key === "name" || key === "message" || key === "stack" || key === "cause" || key === "errors") {
+      continue;
+    }
+    const value = error[key];
+    const serializedValue = serializeValue(value, seen, depth, options);
+    Object.defineProperty(protoError, key, {
+      configurable: true,
+      enumerable: true,
+      value: serializedValue,
+      writable: true
+    });
+  }
+  if (Array.isArray(options.exclude) && options.exclude.length > 0) {
+    for (const key of options.exclude) {
+      try {
+        delete protoError[key];
+      } catch {
+      }
+    }
+  }
+  return protoError;
+};
+const serialize = (error, options = {}) => _serialize(
+  error,
+  {
+    exclude: options.exclude ?? [],
+    maxDepth: options.maxDepth ?? Number.POSITIVE_INFINITY,
+    useToJSON: options.useToJSON ?? false
+  },
+  /* @__PURE__ */ new Set(),
+  0
+);
+
+class AbstractJsonReporter {
+  /** Custom stringify function for object serialization */
+  stringify;
+  /** Error serialization options */
+  errorOptions;
+  /**
+   * Creates a new AbstractJsonReporter instance.
+   * @param options Configuration options for JSON formatting and error handling
+   */
+  constructor(options = {}) {
+    this.errorOptions = options.error ?? {};
+  }
+  /**
+   * Sets a custom stringify function for object serialization.
+   * @param function_ The stringify function to use for serialization
+   */
+  setStringify(function_) {
+    this.stringify = function_;
+  }
+  // eslint-disable-next-line sonarjs/cognitive-complexity
+  log(meta) {
+    const { context, error, file, message, type, ...rest } = meta;
+    if (rest.label) {
+      rest.label = rest.label.trim();
+    }
+    if (file) {
+      rest.file = `${file.name ?? ""}:${String(file.line)}${file.column ? `:${String(file.column)}` : ""}`;
+    }
+    if (message === EMPTY_SYMBOL) {
+      rest.message = void 0;
+    } else {
+      rest.message = message;
+    }
+    if (error) {
+      rest.error = serialize(error, this.errorOptions);
+    }
+    if (context) {
+      const newContext = [];
+      for (let i = 0; i < context.length; i += 1) {
+        const item = context[i];
+        if (item === EMPTY_SYMBOL) {
+          continue;
+        }
+        if (item instanceof Error) {
+          newContext.push(serialize(item, this.errorOptions));
+        } else {
+          newContext.push(item);
+        }
+      }
+      rest.context = newContext;
+    }
+    this._log(this.stringify(rest), type.level);
+  }
+}
+
+export { AbstractJsonReporter };