@deterministic-code/datasources-postgres 0.0.0-stage → 0.1.1

package/dist/PostgresBulkUpdateStatementTextRenderer.d.ts

@@ -0,0 +1,4 @@
+import { BulkUpdateStatementTextRenderer, type Cell } from "@datasources/core";
+export declare class PostgresBulkUpdateStatementTextRenderer extends BulkUpdateStatementTextRenderer {
+    protected cell: (column: string, index: number, value: Cell) => string;
+}

package/dist/PostgresCreateTableStatementRenderer.d.ts

@@ -0,0 +1,6 @@
+import { CreateTableStatementTextRenderer, type Column } from "@datasources/core";
+export declare class PostgresCreateTableStatementRenderer extends CreateTableStatementTextRenderer {
+    protected typeName(column: Column): string;
+    protected columnDefault(column: Column): string;
+    protected identity(column: Column): string;
+}

package/dist/PostgresDriver.d.ts

@@ -0,0 +1,12 @@
+import { StatementTextRenderer, type Cell, type DatasourceOptions, type ICommand, type IConnection, type IDriver, type Information, type ITransaction, type IsolationLevel, type TypeConverter } from "@datasources/core";
+import { columnTypes } from "./columnTypes.js";
+export { columnTypes };
+export declare class PostgresDriver implements IDriver {
+    readonly statementRenderer: StatementTextRenderer;
+    readonly information: Information;
+    rowTypeConverters: Record<string, TypeConverter<Cell, Cell>>;
+    columnType: (name: string) => string;
+    connection: (options?: DatasourceOptions) => IConnection;
+    command: (connection: IConnection) => ICommand;
+    transaction: (connection: IConnection, isolation?: IsolationLevel) => ITransaction;
+}

package/dist/PostgresStatementRenderer.d.ts

@@ -0,0 +1,7 @@
+import { BulkUpdateStatement, CreateTableStatement, SelectInsertedIdStatement, StatementRenderer, type StatementTextRenderer } from "@datasources/core";
+export declare class PostgresStatementRenderer extends StatementRenderer {
+    constructor(text: StatementTextRenderer);
+    protected visitSelectInsertedId(inserted: SelectInsertedIdStatement): string;
+    protected visitCreateTable(create: CreateTableStatement): string;
+    protected visitBulkUpdate(update: BulkUpdateStatement): string;
+}

package/dist/bind.d.ts

@@ -0,0 +1,7 @@
+import { type Parameter } from "@datasources/core";
+import type { Scalar, Wire } from "./scalar.js";
+export declare const toPostgres: (sql: string, params?: Record<string, Scalar>) => {
+    text: string;
+    values: Wire[];
+};
+export declare const bindParameters: (parameters?: Parameter[] | null) => Record<string, Scalar>;

package/dist/columnTypes.d.ts

@@ -0,0 +1 @@
+export declare const columnTypes: Record<string, string>;

package/dist/command.d.ts

@@ -0,0 +1,14 @@
+import { CommandMiddlewareHost, Native, StatementTextRenderer, Response, type Cells, type ICommand, type IReader, type IStatement, type Parameter } from "@datasources/core";
+import type { PostgresConnection } from "./connection.js";
+export declare class PostgresCommand extends CommandMiddlewareHost implements ICommand {
+    readonly connection: PostgresConnection;
+    private readonly statements;
+    constructor(connection: PostgresConnection, statements?: StatementTextRenderer);
+    executeReaderNative(text: Native, parameters?: Parameter[]): Promise<IReader<Cells>>;
+    executeReaderStatement(statement: IStatement, parameters?: Parameter[]): Promise<IReader<Cells>>;
+    executeStatement(statement: IStatement, parameters?: Parameter[]): Promise<Response>;
+    private firstCell;
+    executeNative(text: Native, parameters?: Parameter[]): Promise<Response>;
+    private runSql;
+    private query;
+}

package/dist/connection-options.d.ts

@@ -0,0 +1,6 @@
+import type { PgClientCtor } from "./i-postgres-driver.js";
+export interface PostgresConnectionOptions {
+    url?: string;
+    schema?: string;
+    Client?: PgClientCtor;
+}

package/dist/connection.d.ts

@@ -0,0 +1,21 @@
+import { type DatasourceOptions, type ICommand, type IConnection, type IsolationLevelName, type ITransaction } from "@datasources/core";
+import type { PostgresConnectionOptions } from "./connection-options.js";
+import { type IPgClient } from "./i-postgres-driver.js";
+export declare class PostgresConnection implements IConnection {
+    readonly provider = "postgres";
+    url: string;
+    schema?: string;
+    isOpen: boolean;
+    private client?;
+    private readonly Client?;
+    static from: (options?: DatasourceOptions) => PostgresConnection;
+    constructor(options?: PostgresConnectionOptions);
+    createCommand: () => ICommand;
+    open(): Promise<void>;
+    close(): Promise<void>;
+    [Symbol.asyncDispose]: () => Promise<void>;
+    startTransaction(isolation?: IsolationLevelName): Promise<ITransaction>;
+    ensureOpen(): void;
+    require(): IPgClient;
+    exec(sql: string): Promise<void>;
+}

package/dist/converters/BinaryConverter.d.ts

@@ -0,0 +1,6 @@
+import { TypeConverter, type Cell } from "@datasources/core";
+export declare const isBase64: (value: string) => boolean;
+export declare class BinaryConverter extends TypeConverter<Cell, Cell> {
+    convert: (from: Cell) => Cell;
+    reverseConvert: (to: Cell) => Cell;
+}

package/dist/converters/BoolConverter.d.ts

@@ -0,0 +1,5 @@
+import { TypeConverter, type Cell } from "@datasources/core";
+export declare class BoolConverter extends TypeConverter<Cell, Cell> {
+    convert: (from: Cell) => Cell;
+    reverseConvert: (to: Cell) => Cell;
+}

package/dist/converters/DateTimeConverter.d.ts

@@ -0,0 +1,6 @@
+import { TypeConverter, type Cell } from "@datasources/core";
+export declare const isIsoDate: (value: string) => boolean;
+export declare class DateTimeConverter extends TypeConverter<Cell, Cell> {
+    convert: (from: Cell) => Cell;
+    reverseConvert: (to: Cell) => Cell;
+}

package/dist/converters/DecimalConverter.d.ts

@@ -0,0 +1,5 @@
+import { TypeConverter, type Cell } from "@datasources/core";
+export declare class DecimalConverter extends TypeConverter<Cell, Cell> {
+    convert: (from: Cell) => Cell;
+    reverseConvert: (to: Cell) => Cell;
+}

package/dist/converters/PostgresRowTypeConverters.d.ts

@@ -0,0 +1,3 @@
+import { type Cell, type TypeConverter } from "@datasources/core";
+export declare const PostgresRowTypeConverters: Record<string, TypeConverter<Cell, Cell>>;
+export declare const reverse: (value: Cell) => Cell;

package/dist/converters/UuidConverter.d.ts

@@ -0,0 +1,5 @@
+import { TypeConverter, type Cell } from "@datasources/core";
+export declare class UuidConverter extends TypeConverter<Cell, Cell> {
+    convert: (from: Cell) => Cell;
+    reverseConvert: (to: Cell) => Cell;
+}

package/dist/i-postgres-driver.d.ts

@@ -0,0 +1,38 @@
+import type { Parameter } from "@datasources/core";
+import QueryStream from "pg-query-stream";
+import type { Cells, Scalar, Wire } from "./scalar.js";
+export interface PostgresExecuteResult {
+    rowsAffected: number;
+    result?: Scalar;
+    parameters?: Parameter[];
+}
+export interface PgQueryResult {
+    rowCount: number | null;
+    rows: Cells[];
+}
+export interface IPgClient {
+    connect(): Promise<void>;
+    query(text: string, values?: Wire[]): Promise<PgQueryResult>;
+    rows(text: string, values?: Wire[]): AsyncIterable<Cells>;
+    end(): Promise<void>;
+}
+interface PgNativeClient {
+    connect(): Promise<void>;
+    query(text: string, values?: Wire[]): Promise<PgQueryResult>;
+    query(query: QueryStream): AsyncIterable<Cells>;
+    end(): Promise<void>;
+}
+export type PgClientCtor = new (options: {
+    connectionString: string;
+}) => IPgClient;
+type PgNativeCtor = new (options: {
+    connectionString: string;
+}) => PgNativeClient;
+export type PgModule = {
+    Client: PgNativeCtor;
+    default?: {
+        Client: PgNativeCtor;
+    };
+};
+export declare const pgClient: (imported: PgModule) => PgClientCtor;
+export {};

package/dist/index.d.ts

@@ -0,0 +1 @@
+export { PostgresDriver } from "./PostgresDriver.js";

package/dist/scalar.d.ts

@@ -0,0 +1,3 @@
+export type Scalar = string | number | boolean | bigint | null;
+export type Wire = Scalar | Date | Uint8Array;
+export type Cells = Record<string, Scalar>;

package/dist/transaction.d.ts

@@ -0,0 +1,9 @@
+import { type ITransaction, type IsolationLevelName } from "@datasources/core";
+import type { PostgresConnection } from "./connection.js";
+export declare class PostgresTransaction implements ITransaction {
+    readonly connection: PostgresConnection;
+    readonly isolation: IsolationLevelName;
+    constructor(connection: PostgresConnection, isolation?: IsolationLevelName);
+    commit(): Promise<void>;
+    abort(): Promise<void>;
+}

package/package.json

@@ -1,6 +1,27 @@
 {
   "name": "@deterministic-code/datasources-postgres",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.1.1",
+  "type": "module",
+  "main": "./src/index.ts",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./src/index.ts",
+      "default": "./src/index.ts"
+    }
+  },
+  "files": [
+    "dist",
+    "src"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "@types/pg": "^8.15.5",
+    "pg": "^8.16.0",
+    "pg-query-stream": "^4.17.0",
+    "@deterministic-code/datasources": "^0.1.1"
+  }
+}

package/src/PostgresBulkUpdateStatementTextRenderer.ts

@@ -0,0 +1,27 @@
+import { BulkUpdateStatementTextRenderer, type Cell } from "@datasources/core";
+import { columnTypes } from "./columnTypes.ts";
+import { isBase64 } from "./converters/BinaryConverter.ts";
+import { isIsoDate } from "./converters/DateTimeConverter.ts";
+
+const logical = (value: Cell): string | undefined =>
+  value === null
+    ? undefined
+    : typeof value === "boolean"
+      ? "bool"
+      : typeof value === "bigint" || (typeof value === "number" && Number.isInteger(value))
+        ? "int"
+        : typeof value === "number"
+          ? "float"
+          : value instanceof Date || (typeof value === "string" && isIsoDate(value))
+            ? "datetime"
+            : value instanceof Uint8Array || (typeof value === "string" && isBase64(value))
+              ? "binary"
+              : "string";
+
+export class PostgresBulkUpdateStatementTextRenderer extends BulkUpdateStatementTextRenderer {
+  protected override cell = (column: string, index: number, value: Cell): string => {
+    const type = logical(value);
+    const sql = type ? columnTypes[type] : undefined;
+    return sql ? `$${column}__${index}::${sql} AS ${column}` : `$${column}__${index} AS ${column}`;
+  };
+}

package/src/PostgresCreateTableStatementRenderer.ts

@@ -0,0 +1,33 @@
+import {
+  ColumnDefault,
+  CreateTableStatementTextRenderer,
+  type Column,
+} from "@datasources/core";
+import { PostgresRowTypeConverters } from "./converters/PostgresRowTypeConverters.ts";
+import { columnTypes } from "./columnTypes.ts";
+
+export class PostgresCreateTableStatementRenderer extends CreateTableStatementTextRenderer {
+  protected typeName(column: Column): string {
+    return columnTypes[column.type] ?? column.type;
+  }
+
+  protected columnDefault(column: Column): string {
+    const literal = sqlLiteral(column);
+    const value = column.default;
+    return value == null || literal == null
+      ? super.columnDefault(column)
+      : super.columnDefault({ ...column, default: new ColumnDefault(literal, value.name) });
+  }
+
+  protected identity(column: Column): string {
+    return column.identity ? " GENERATED BY DEFAULT AS IDENTITY" : "";
+  }
+}
+
+function sqlLiteral(column: Column): string | undefined {
+  const raw = column.default?.value;
+  const converter = PostgresRowTypeConverters[column.type];
+  if (raw == null || !converter || !/^-?\d+$/.test(raw)) return undefined;
+  const converted = converter.convert(Number(raw));
+  return converted === true ? "TRUE" : converted === false ? "FALSE" : undefined;
+}

package/src/PostgresDriver.ts

@@ -0,0 +1,55 @@
+import {
+  DatasourceError,
+  StatementTextRenderer,
+  type Cell,
+  type DatasourceOptions,
+  type ICommand,
+  type IConnection,
+  type IDriver,
+  type Information,
+  type ITransaction,
+  type IsolationLevel,
+  type TypeConverter,
+} from "@datasources/core";
+import { PostgresConnection } from "./connection.ts";
+import { PostgresCommand } from "./command.ts";
+import { PostgresTransaction } from "./transaction.ts";
+import { PostgresRowTypeConverters } from "./converters/PostgresRowTypeConverters.ts";
+import { PostgresStatementRenderer } from "./PostgresStatementRenderer.ts";
+import { columnTypes } from "./columnTypes.ts";
+
+export { columnTypes };
+
+const statements = new StatementTextRenderer(t => new PostgresStatementRenderer(t));
+
+export class PostgresDriver implements IDriver {
+  readonly statementRenderer = statements;
+  readonly information: Information = {
+    descriptions: [
+      "PostgreSQL server driver.",
+      "Full connection, command, transaction, and repository support.",
+    ],
+    overrides: [
+      "Overrides SelectInsertedIdStatement to SELECT lastval() AS {column}",
+      "Overrides CreateTableStatement identity to GENERATED BY DEFAULT AS IDENTITY",
+      "Overrides CreateTableStatement boolean defaults (0/1 → TRUE/FALSE)",
+      "Overrides CreateTableStatement type mapping (int→INTEGER, uuid→UUID, string→TEXT, bool→BOOLEAN, decimal→NUMERIC, float→DOUBLE PRECISION, datetime→TIMESTAMPTZ, binary→BYTEA)",
+    ],
+    changeLogs: [],
+  };
+  rowTypeConverters: Record<string, TypeConverter<Cell, Cell>> = PostgresRowTypeConverters;
+  columnType = (name: string): string =>
+    columnTypes[name] ??
+    (() => {
+      throw new DatasourceError(`Unknown postgres type "${name}"`);
+    })();
+  connection = (options?: DatasourceOptions): IConnection =>
+    PostgresConnection.from(options);
+  command = (connection: IConnection): ICommand =>
+    new PostgresCommand(connection as PostgresConnection, statements);
+  transaction = (
+    connection: IConnection,
+    isolation: IsolationLevel = "readCommitted",
+  ): ITransaction =>
+    new PostgresTransaction(connection as PostgresConnection, isolation);
+}

package/src/PostgresStatementRenderer.test.ts

@@ -0,0 +1,105 @@
+import {
+  BulkUpdateStatement,
+  type Cell,
+  ColumnDefault,
+  CreateTableStatement,
+  DefaultStatementTextRenderer,
+  ForeignKey,
+  SelectInsertedIdStatement,
+  NotNull,
+  PrimaryKey,
+  ReferentialAction,
+  SelectStatement,
+  StatementTextRenderer,
+} from "@datasources/core";
+import { describe, expect, it } from "vitest";
+import { PostgresCreateTableStatementRenderer } from "./PostgresCreateTableStatementRenderer.ts";
+import { PostgresStatementRenderer } from "./PostgresStatementRenderer.ts";
+
+describe("PostgresStatementRenderer", () => {
+  const renderer = new StatementTextRenderer(t => new PostgresStatementRenderer(t));
+
+  it("renders inserted id and create table", () => {
+    expect(renderer.render(new SelectInsertedIdStatement("users", "id"))).toBe(
+      "SELECT lastval() AS id",
+    );
+
+    const create = new CreateTableStatement(
+      "orders",
+      [
+        { name: "id", type: "INTEGER", default: new ColumnDefault("0", "df_id"), notNull: new NotNull("nn_id") },
+        { name: "user_id", type: "INTEGER" },
+      ],
+      [
+        new PrimaryKey("pk_orders", ["id"]),
+        new ForeignKey("fk_orders_user", ["user_id"], "users", ["id"], ReferentialAction.Cascade),
+      ],
+    );
+    expect(renderer.render(create)).toBe(new PostgresCreateTableStatementRenderer().render(create));
+    expect(renderer.render(new SelectStatement({ table: "users", fields: ["id"] }))).toBe(
+      "SELECT id FROM users",
+    );
+  });
+
+  it("renders type default and identity", () => {
+    const create = new CreateTableStatement("users", [
+      { name: "id", type: "int", identity: true },
+      { name: "is_enabled", type: "bool", default: new ColumnDefault("1") },
+      { name: "is_disabled", type: "bool", default: new ColumnDefault("0", "df_off") },
+      { name: "amount", type: "decimal", default: new ColumnDefault("1") },
+      { name: "flag", type: "bool", default: new ColumnDefault("true") },
+    ]);
+    expect(renderer.render(create)).toBe(
+      "CREATE TABLE users (id INTEGER GENERATED BY DEFAULT AS IDENTITY, is_enabled BOOLEAN DEFAULT TRUE, is_disabled BOOLEAN CONSTRAINT df_off DEFAULT FALSE, amount NUMERIC DEFAULT 1, flag BOOLEAN DEFAULT true)",
+    );
+    expect(DefaultStatementTextRenderer.instance.render(create)).toBe(
+      "CREATE TABLE users (id int, is_enabled bool DEFAULT 1, is_disabled bool CONSTRAINT df_off DEFAULT 0, amount decimal DEFAULT 1, flag bool DEFAULT true)",
+    );
+  });
+
+  it("renders bulk update with column types", () => {
+    const update = new BulkUpdateStatement("parents", ["label"], ["id"], [
+      { fields: [{ name: "label", value: "a" }], ids: [{ name: "id", value: 1 }] },
+      { fields: [{ name: "label", value: "b" }], ids: [{ name: "id", value: 2 }] },
+    ]);
+    expect(renderer.render(update)).toBe(
+      "UPDATE parents SET label = data.label FROM (SELECT $label__0::TEXT AS label, $id__0::INTEGER AS id UNION ALL SELECT $label__1::TEXT AS label, $id__1::INTEGER AS id) AS data WHERE parents.id = data.id",
+    );
+  });
+
+  it("renders bulk update cell types", () => {
+    const update = new BulkUpdateStatement("t", ["flag", "n", "at", "blob", "x"], ["id"], [
+      {
+        fields: [
+          { name: "flag", value: true },
+          { name: "n", value: 1.5 },
+          { name: "at", value: new Date("2020-01-02T03:04:05.000Z") },
+          { name: "blob", value: new Uint8Array([1]) },
+          { name: "x", value: null },
+        ] as { name: string; value: Cell }[],
+        ids: [{ name: "id", value: 1n }],
+      },
+    ]);
+    expect(renderer.render(update)).toBe(
+      "UPDATE t SET flag = data.flag, n = data.n, at = data.at, blob = data.blob, x = data.x FROM (SELECT $flag__0::BOOLEAN AS flag, $n__0::DOUBLE PRECISION AS n, $at__0::TIMESTAMPTZ AS at, $blob__0::BYTEA AS blob, $x__0 AS x, $id__0::INTEGER AS id) AS data WHERE t.id = data.id",
+    );
+  });
+
+  it("renders bulk update iso created as timestamptz", () => {
+    const update = new BulkUpdateStatement("contacts", ["created"], ["id"], [
+      { fields: [{ name: "created", value: "2020-01-02T03:04:05.000Z" }], ids: [{ name: "id", value: 1 }] },
+    ]);
+    expect(renderer.render(update)).toBe(
+      "UPDATE contacts SET created = data.created FROM (SELECT $created__0::TIMESTAMPTZ AS created, $id__0::INTEGER AS id) AS data WHERE contacts.id = data.id",
+    );
+  });
+
+  it("renders bulk update base64 version as bytea", () => {
+    const update = new BulkUpdateStatement("contacts", ["version"], ["id"], [
+      { fields: [{ name: "version", value: "AA==" }], ids: [{ name: "id", value: 1 }] },
+    ]);
+    expect(renderer.render(update)).toBe(
+      "UPDATE contacts SET version = data.version FROM (SELECT $version__0::BYTEA AS version, $id__0::INTEGER AS id) AS data WHERE contacts.id = data.id",
+    );
+  });
+});

package/src/PostgresStatementRenderer.ts

@@ -0,0 +1,34 @@
+import {
+  BulkUpdateStatement,
+  CreateTableStatement,
+  SelectInsertedIdStatement,
+  SelectInsertedIdStatementTextRenderer,
+  StatementRenderer,
+  type StatementTextRenderer,
+} from "@datasources/core";
+import { PostgresBulkUpdateStatementTextRenderer } from "./PostgresBulkUpdateStatementTextRenderer.ts";
+import { PostgresCreateTableStatementRenderer } from "./PostgresCreateTableStatementRenderer.ts";
+
+class PostgresSelectInsertedIdStatementTextRenderer extends SelectInsertedIdStatementTextRenderer {
+  override render(statement: SelectInsertedIdStatement): string {
+    return `SELECT lastval() AS ${statement.column}`;
+  }
+}
+
+export class PostgresStatementRenderer extends StatementRenderer {
+  constructor(text: StatementTextRenderer) {
+    super(text);
+  }
+
+  protected override visitSelectInsertedId(inserted: SelectInsertedIdStatement): string {
+    return new PostgresSelectInsertedIdStatementTextRenderer().render(inserted);
+  }
+
+  protected override visitCreateTable(create: CreateTableStatement): string {
+    return new PostgresCreateTableStatementRenderer().render(create);
+  }
+
+  protected override visitBulkUpdate(update: BulkUpdateStatement): string {
+    return new PostgresBulkUpdateStatementTextRenderer().render(update);
+  }
+}

package/src/bind.ts

@@ -0,0 +1,50 @@
+import { parametersToRecord, type Cell, type Parameter } from "@datasources/core";
+import { isBase64 } from "./converters/BinaryConverter.ts";
+import { isIsoDate } from "./converters/DateTimeConverter.ts";
+import { reverse } from "./converters/PostgresRowTypeConverters.ts";
+import type { Scalar, Wire } from "./scalar.ts";
+
+const NAME = /\$([A-Za-z_][A-Za-z0-9_]*)/g;
+
+const quoteMixedCase = (sql: string): string =>
+  sql.replace(/\$[A-Za-z_][A-Za-z0-9_]*|'[^']*'|"[^"]*"|`[^`]*`|\b[A-Za-z_][A-Za-z0-9_]*\b/g, (token) =>
+    token.startsWith("$") || token.startsWith("'") || token.startsWith("\"") || token.startsWith("`")
+      || !/[A-Z]/.test(token) || !/[a-z]/.test(token)
+      ? token
+      : `"${token}"`,
+  );
+
+const wire = (value: Scalar): Wire =>
+  typeof value !== "string"
+    ? value
+    : isIsoDate(value)
+      ? new Date(value)
+      : isBase64(value)
+        ? Uint8Array.from(Buffer.from(value, "base64"))
+        : value;
+
+export const toPostgres = (
+  sql: string,
+  params?: Record<string, Scalar>,
+): { text: string; values: Wire[] } => {
+  const names: string[] = [];
+  const text = quoteMixedCase(sql).replace(NAME, (_match, name: string) => {
+    let index = names.indexOf(name);
+    if (index < 0) {
+      names.push(name);
+      index = names.length - 1;
+    }
+    return `$${index + 1}`;
+  });
+  return { text, values: names.map((name) => wire(params?.[name] ?? null)) };
+};
+
+export const bindParameters = (
+  parameters?: Parameter[] | null,
+): Record<string, Scalar> => {
+  const record = parametersToRecord(parameters);
+  const bound: Record<string, Scalar> = {};
+  for (const [name, value] of Object.entries(record))
+    bound[name] = reverse(value as Cell) as Scalar;
+  return bound;
+};

package/src/columnTypes.ts

@@ -0,0 +1,10 @@
+export const columnTypes: Record<string, string> = {
+  int: "INTEGER",
+  uuid: "UUID",
+  string: "TEXT",
+  bool: "BOOLEAN",
+  decimal: "NUMERIC",
+  float: "DOUBLE PRECISION",
+  datetime: "TIMESTAMPTZ",
+  binary: "BYTEA",
+};