durcno 1.0.0-alpha.0

package/dist/src/sql.mjs

@@ -0,0 +1,36 @@
+import { isCol } from "./entity.mjs";
+//#region src/sql.ts
+var Sql = class {
+	#string;
+	constructor(sql) {
+		this.#string = sql;
+	}
+	get string() {
+		return this.#string;
+	}
+	toSQL() {
+		return this.#string;
+	}
+	toQuery(query) {
+		query.sql += this.#string;
+	}
+};
+function sql(strings, ...params) {
+	let s = "";
+	strings.forEach((str, i) => {
+		s += str;
+		const param = params[i];
+		if (param !== void 0) s += toSqlValue(param);
+	});
+	return new Sql(s);
+}
+function toSqlValue(value) {
+	if (value === null || value === void 0) return "NULL";
+	else if (typeof value === "string") return `'${value.replace(/'/g, "''")}'`;
+	else if (typeof value === "number" || typeof value === "bigint") return value.toString();
+	else if (typeof value === "boolean") return value ? "'1'" : "'0'";
+	else if (isCol(value)) return value.fullName;
+	else return "NULL";
+}
+//#endregion
+export { Sql, sql };

package/dist/src/symbols.d.mts

@@ -0,0 +1,4 @@
+//#region src/symbols.d.ts
+declare const entityType: unique symbol;
+//#endregion
+export { entityType };

package/dist/src/symbols.mjs

@@ -0,0 +1,4 @@
+//#region src/symbols.ts
+const entityType = Symbol.for("durcno:entityType");
+//#endregion
+export { entityType };

package/dist/src/table.d.mts

@@ -0,0 +1,144 @@
+import { entityType } from "./symbols.mjs";
+import { Column } from "./columns/common.mjs";
+import { Check, CheckBuilder, CheckExpr } from "./constraints/check.mjs";
+import { PrimaryKeyConstraint, PrimaryKeyConstraintFn } from "./constraints/primary-key.mjs";
+import { UniqueConstraint, UniqueConstraintFn } from "./constraints/unique.mjs";
+import { Index } from "./indexes.mjs";
+import { CamelToSnake } from "./types.mjs";
+import { Config } from "./index.mjs";
+
+//#region src/table.d.ts
+type AnyColumn = Column<any, any>;
+type InferTColArgs<TColumns extends Record<string, unknown>> = { [ColName in keyof TColumns]: TColumns[ColName] extends TableColumn<infer TTSchema, infer TTName, infer TCName, infer TColumn> ? [TTSchema, TTName, TCName, TColumn] : never };
+type TColsToLeftRight<TColumns extends Record<string, AnyTableColumn>> = { [ColName in keyof TColumns]: TColumns[ColName] extends TableColumn<infer UTSchema, infer UTName, infer UCName, infer UColumn> ? {
+  left: [UTSchema, UTName, UCName, UColumn];
+  right: InferTColArgs<Omit<TColumns, UCName>>;
+} : never };
+type TableExtra<TSchema extends string, TName extends string, TColumns extends Record<string, AnyColumn>> = {
+  indexes?: (...args: [TableWithColumns<TSchema, TName, TColumns>]) => Index<TColumns[keyof TColumns]>[];
+  primaryKeyConstraint?: (table: TableWithColumns<TSchema, TName, TColumns>, primaryKey: PrimaryKeyConstraintFn) => PrimaryKeyConstraint;
+  uniqueConstraints?: (table: TableWithColumns<TSchema, TName, TColumns>, unique: UniqueConstraintFn) => UniqueConstraint[];
+  checkConstraints?: (table: TableWithColumns<TSchema, TName, TColumns>, check: (name: string, expr: CheckExpr) => Check, c: CheckBuilder) => Check[];
+};
+type TableConfig<TSchema extends string, TName extends string, TColumns extends Record<string, AnyColumn>> = {
+  readonly name: TName;
+  readonly schema: TSchema;
+  readonly fullName: `"${TSchema}"."${TName}"`;
+  readonly cols: TColumns;
+  readonly columns: { [ColName in keyof TColumns]: TableColumn<TSchema, TName, ColName, TColumns[ColName]> };
+  readonly extra: TableExtra<TSchema, TName, TColumns>;
+  config?: Config;
+};
+type TableColumn<TTSchema extends string, TTName extends string, TName extends Key, TColumn extends AnyColumn> = TColumn & {
+  table: StdTable;
+  name: TName;
+  nameSnake: CamelToSnake<Extract<TName, string>>;
+  tableName: TTName;
+  schemaName: TTSchema;
+};
+type StdTableColumn = TableColumn<string, string, Key, AnyColumn>;
+type AnyTableColumn = TableColumn<any, any, any, any>;
+type TableColumnArgs = [string, string, Key, AnyColumn];
+type BuildScmTblColumns<TSchema extends string, TName extends string, TColumns extends Record<string, AnyColumn>> = { [ColName in keyof TColumns & string as `${TSchema}_${TName}_${ColName}`]: TableColumn<TSchema, TName, ColName, TColumns[ColName]> };
+declare class Table<TSchema extends string, TName extends string, TColumns extends Record<string, AnyColumn>> {
+  static readonly [entityType] = "Table";
+  readonly $: {
+    inferSelect: { [ColName in keyof TColumns]: TColumns[ColName]["ValTypeSelect"] };
+    _: {
+      scmTblColumns: BuildScmTblColumns<TSchema, TName, TColumns>;
+    };
+  };
+  _: TableConfig<TSchema, TName, TColumns>;
+  constructor(schema: TSchema, name: TName, columns: TColumns, extra: TableExtra<TSchema, TName, TColumns>);
+}
+type StdTable = Table<string, string, Record<string, AnyColumn>>;
+type TableWithColumns<TTSchema extends string, TTName extends string, TColumns extends Record<string, AnyColumn>> = Table<TTSchema, TTName, TColumns> & Table<TTSchema, TTName, TColumns>["_"]["columns"];
+type AnyTableWithColumns = TableWithColumns<any, any, any>;
+type TableWCorNever<T> = T extends TableWithColumns<infer TTSchema, infer TTName, infer TColumns> ? TColumns extends Record<string, AnyColumn> ? TableWithColumns<TTSchema, TTName, TColumns> : never : never;
+type IsTableWC<T> = T extends TableWithColumns<any, any, any> ? true : false;
+/**
+ * Creates a typed table definition with column accessors.
+ *
+ * @example
+ * ```ts
+ * import { table, pk, varchar } from "durcno";
+ *
+ * export const Users = table("public", "users", {
+ *   id: pk(),
+ *   email: varchar({ length: 255 }),
+ * });
+ * ```
+ */
+declare function table<TSchema extends string, TName extends string, TColumns extends Record<string, AnyColumn>>(schema: TSchema, name: TName, columns: TColumns, extra?: TableExtra<TSchema, TName, TColumns>): TableWithColumns<TSchema, TName, TColumns>;
+declare class One<TTSchema extends string, TTName extends string, TTColumns extends Record<string, AnyColumn>, TCol extends TableWithColumns<TTSchema, TTName, TTColumns>[keyof TTColumns]> {
+  readonly t: "One";
+  readonly table: TableWithColumns<TTSchema, TTName, TTColumns>;
+  readonly col: TCol;
+  constructor(table: TableWithColumns<TTSchema, TTName, TTColumns>, col: TCol);
+}
+/**
+ * Defines a one-to-one relation where the foreign key is on the **related** table.
+ *
+ * @param table - The related table that holds the foreign key column
+ * @param col - The foreign key column on the related table
+ *
+ * @example
+ * ```ts
+ * export const UsersRelations = relations(Users, () => ({
+ *   profile: one(UserProfiles, UserProfiles.userId),
+ * }));
+ * ```
+ */
+declare function one<TTSchema extends string, TTName extends string, TTColumns extends Record<string, AnyColumn>, TCol extends TableWithColumns<TTSchema, TTName, TTColumns>[keyof TTColumns]>(table: TableWithColumns<TTSchema, TTName, TTColumns>, col: TCol): One<TTSchema, TTName, TTColumns, TCol>;
+declare class Many<TTSchema extends string, TTName extends string, TTColumns extends Record<string, AnyColumn>, TCol extends TableWithColumns<TTSchema, TTName, TTColumns>[keyof TTColumns]> {
+  readonly t: "Many";
+  readonly table: TableWithColumns<TTSchema, TTName, TTColumns>;
+  readonly col: TCol;
+  constructor(table: TableWithColumns<TTSchema, TTName, TTColumns>, col: TCol);
+}
+/**
+ * Defines a one-to-many relation where the foreign key is on the **target** table.
+ *
+ * @param table - The target table that contains the foreign key
+ * @param col - The foreign key column on the target table referencing this table
+ *
+ * @example
+ * ```ts
+ * export const UsersRelations = relations(Users, () => ({
+ *   posts: many(Posts, Posts.userId),
+ * }));
+ * ```
+ */
+declare function many<TTSchema extends string, TTName extends string, TTColumns extends Record<string, AnyColumn>, TCol extends TableWithColumns<TTSchema, TTName, TTColumns>[keyof TTColumns]>(table: TableWithColumns<TTSchema, TTName, TTColumns>, col: TCol): Many<TTSchema, TTName, TTColumns, TCol>;
+declare class Fk<TTSchema extends string, TTName extends string, TTColumns extends Record<string, AnyColumn>, TCol extends TableColumn<any, any, any, AnyColumn>> {
+  readonly t: "Fk";
+  readonly col: TCol;
+  readonly table: TableWithColumns<TTSchema, TTName, TTColumns>;
+  constructor(col: TCol, table: TableWithColumns<TTSchema, TTName, TTColumns>);
+}
+/**
+ * Defines a many-to-one relation where the foreign key is on the **current** table.
+ *
+ * @param col - The foreign key column on the current table
+ * @param table - The referenced table that the foreign key points to
+ *
+ * @example
+ * ```ts
+ * export const PostsRelations = relations(Posts, () => ({
+ *   author: fk(Posts.userId, Users),
+ * }));
+ * ```
+ */
+declare function fk<TTSchema extends string, TTName extends string, TTColumns extends Record<string, AnyColumn>, TCol extends TableColumn<any, any, any, AnyColumn>>(col: TCol, table: TableWithColumns<TTSchema, TTName, TTColumns>): Fk<TTSchema, TTName, TTColumns, TCol>;
+type AnyRelation = Many<any, any, any, any> | One<any, any, any, any> | Fk<any, any, any, any>;
+declare class Relations<TTSchema extends string, TTName extends string, TTColumns extends Record<string, AnyColumn>, TRelations extends Record<string, AnyRelation>> {
+  static readonly [entityType] = "Relation";
+  readonly table: TableWithColumns<TTSchema, TTName, TTColumns>;
+  readonly map: TRelations;
+  constructor(table: TableWithColumns<TTSchema, TTName, TTColumns>, relations: TRelations);
+}
+type StdRelations = Relations<string, string, Record<string, AnyColumn>, Record<string, Many<string, string, Record<string, AnyColumn>, StdTableColumn> | One<string, string, Record<string, AnyColumn>, StdTableColumn> | Fk<string, string, Record<string, AnyColumn>, StdTableColumn>>>;
+type AnyRelations = Relations<any, any, Record<any, any>, Record<any, any>>;
+declare function relations<TTSchema extends string, TTName extends string, TColumns extends Record<string, AnyColumn>, TRelations extends Record<string, AnyRelation>>(table: TableWithColumns<TTSchema, TTName, TColumns>, relations: () => TRelations): () => Relations<TTSchema, TTName, TColumns, TRelations>;
+//#endregion
+export { AnyColumn, AnyRelation, AnyRelations, AnyTableColumn, AnyTableWithColumns, BuildScmTblColumns, Fk, IsTableWC, Many, Relations, StdRelations, StdTable, StdTableColumn, TColsToLeftRight, Table, TableColumn, TableColumnArgs, TableWCorNever, TableWithColumns, fk, many, one, relations, table };

package/dist/src/table.mjs

@@ -0,0 +1,134 @@
+import { entityType } from "./symbols.mjs";
+//#region src/table.ts
+function bindNameNTable(table, columns) {
+	for (const [ColName, col] of Object.entries(columns)) {
+		col._.setName(ColName);
+		col._.setTable(table);
+	}
+	return columns;
+}
+var Table = class {
+	static [entityType] = "Table";
+	$;
+	_;
+	constructor(schema, name, columns, extra) {
+		bindNameNTable(this, columns);
+		this._ = {
+			schema,
+			name,
+			fullName: `"${schema}"."${name}"`,
+			cols: columns,
+			columns,
+			extra
+		};
+	}
+};
+/**
+* Creates a typed table definition with column accessors.
+*
+* @example
+* ```ts
+* import { table, pk, varchar } from "durcno";
+*
+* export const Users = table("public", "users", {
+*   id: pk(),
+*   email: varchar({ length: 255 }),
+* });
+* ```
+*/
+function table(schema, name, columns, extra) {
+	const table = new Table(schema, name, columns, extra ?? {});
+	for (const colName in table._.columns) Object.defineProperty(table, colName, { get() {
+		return table._.columns[colName];
+	} });
+	return table;
+}
+var One = class {
+	t = "One";
+	table;
+	col;
+	constructor(table, col) {
+		this.table = table;
+		this.col = col;
+	}
+};
+/**
+* Defines a one-to-one relation where the foreign key is on the **related** table.
+*
+* @param table - The related table that holds the foreign key column
+* @param col - The foreign key column on the related table
+*
+* @example
+* ```ts
+* export const UsersRelations = relations(Users, () => ({
+*   profile: one(UserProfiles, UserProfiles.userId),
+* }));
+* ```
+*/
+function one(table, col) {
+	return new One(table, col);
+}
+var Many = class {
+	t = "Many";
+	table;
+	col;
+	constructor(table, col) {
+		this.table = table;
+		this.col = col;
+	}
+};
+/**
+* Defines a one-to-many relation where the foreign key is on the **target** table.
+*
+* @param table - The target table that contains the foreign key
+* @param col - The foreign key column on the target table referencing this table
+*
+* @example
+* ```ts
+* export const UsersRelations = relations(Users, () => ({
+*   posts: many(Posts, Posts.userId),
+* }));
+* ```
+*/
+function many(table, col) {
+	return new Many(table, col);
+}
+var Fk = class {
+	t = "Fk";
+	col;
+	table;
+	constructor(col, table) {
+		this.col = col;
+		this.table = table;
+	}
+};
+/**
+* Defines a many-to-one relation where the foreign key is on the **current** table.
+*
+* @param col - The foreign key column on the current table
+* @param table - The referenced table that the foreign key points to
+*
+* @example
+* ```ts
+* export const PostsRelations = relations(Posts, () => ({
+*   author: fk(Posts.userId, Users),
+* }));
+* ```
+*/
+function fk(col, table) {
+	return new Fk(col, table);
+}
+var Relations = class {
+	static [entityType] = "Relation";
+	table;
+	map;
+	constructor(table, relations) {
+		this.table = table;
+		this.map = relations;
+	}
+};
+function relations(table, relations) {
+	return () => new Relations(table, relations());
+}
+//#endregion
+export { Relations, Table, fk, many, one, relations, table };

package/dist/src/types.d.mts

@@ -0,0 +1,4 @@
+//#region src/types.d.ts
+type CamelToSnake<S extends string> = S extends `${infer Head}${infer Tail}` ? Head extends Uppercase<Head> ? `_${Lowercase<Head>}${CamelToSnake<Tail>}` : `${Head}${CamelToSnake<Tail>}` : S;
+//#endregion
+export { CamelToSnake };

package/dist/src/utils.mjs

@@ -0,0 +1,10 @@
+//#region src/utils.ts
+/** biome-ignore-all lint/suspicious/noExplicitAny: <> */
+function camelToSnake(str) {
+	return str.replace(/([A-Z]+)([A-Z][a-z])/g, "$1_$2").replace(/([a-z])([A-Z])/g, "$1_$2").toLowerCase();
+}
+function snakeToCamel(str) {
+	return str.replace(/_([a-z])/g, (_, c) => c.toUpperCase());
+}
+//#endregion
+export { camelToSnake, snakeToCamel };

package/dist/src/validators/zod.d.mts

@@ -0,0 +1,23 @@
+import { AnyColumn, TableWithColumns } from "../table.mjs";
+import * as z from "zod";
+
+//#region src/validators/zod.d.ts
+type BuildZodRefine<TColumns extends Record<string, AnyColumn>> = { [K in keyof TColumns]?: (...args: [TColumns[K]["zodType"]]) => z.ZodType };
+type InferColInsertZodType<TColumn extends AnyColumn, ZType extends z.ZodType> = TColumn extends {
+  generated: "ALWAYS";
+} ? never : TColumn extends {
+  generated: "BY DEFAULT";
+} ? z.ZodOptional<ZType> : TColumn extends {
+  hasDefault: true;
+} ? z.ZodOptional<ZType> : TColumn extends {
+  hasDefaultFn: true;
+} ? z.ZodOptional<ZType> : TColumn extends {
+  isNotNull: true;
+} ? ZType : z.ZodOptional<ZType>;
+type InferInsertZodShape<TColumns extends Record<string, AnyColumn>, TRefine extends BuildZodRefine<TColumns> | undefined> = { [K in keyof TColumns]: TRefine extends {} ? TRefine[K] extends ((...args: any[]) => infer U) ? U extends z.ZodType ? InferColInsertZodType<TColumns[K], U> : never : InferColInsertZodType<TColumns[K], TColumns[K]["zodType"]> : InferColInsertZodType<TColumns[K], TColumns[K]["zodType"]> } extends infer U ? { [K in keyof U as U[K] extends never ? never : K]: U[K] } : never;
+declare function createInsertSchema<TTSchema extends string, TTName extends string, TColumns extends Record<string, AnyColumn>, TRefine extends BuildZodRefine<TColumns>>(table: TableWithColumns<TTSchema, TTName, TColumns>, refine?: TRefine): z.ZodObject<InferInsertZodShape<TColumns, TRefine>>;
+type InferColUpdateZodType<TColumn extends AnyColumn, ZType extends z.ZodType> = TColumn["isPrimaryKey"] extends true ? never : TColumn["isNotNull"] extends true ? z.ZodOptional<ZType> : z.ZodOptional<z.ZodNullable<ZType>>;
+type InferUpdateZodShape<TColumns extends Record<string, AnyColumn>, TRefine extends BuildZodRefine<TColumns> | undefined> = { [K in keyof TColumns]: TRefine extends {} ? TRefine[K] extends ((...args: any[]) => infer U) ? U extends z.ZodType ? InferColUpdateZodType<TColumns[K], U> : never : InferColUpdateZodType<TColumns[K], TColumns[K]["zodType"]> : InferColUpdateZodType<TColumns[K], TColumns[K]["zodType"]> } extends infer U ? { [K in keyof U as U[K] extends never ? never : K]: U[K] } : never;
+declare function createUpdateSchema<TTSchema extends string, TTName extends string, TColumns extends Record<string, AnyColumn>, TRefine extends BuildZodRefine<TColumns>>(table: TableWithColumns<TTSchema, TTName, TColumns>, refine?: TRefine): z.ZodObject<InferUpdateZodShape<TColumns, TRefine>>;
+//#endregion
+export { BuildZodRefine, createInsertSchema, createUpdateSchema };

package/dist/src/validators/zod.mjs

@@ -0,0 +1,27 @@
+import * as z from "zod";
+//#region src/validators/zod.ts
+function createInsertSchema(table, refine) {
+	const shape = {};
+	for (const [columnName, column] of Object.entries(table._.columns)) {
+		if (column.generated === "ALWAYS") continue;
+		let zodSchema = column.zodType;
+		if (refine?.[columnName]) zodSchema = refine[columnName](column.zodType);
+		if (column.generated === "BY DEFAULT" || !column.isNotNull || column.hasDefault || column.hasInsertFn) zodSchema = zodSchema.optional();
+		shape[columnName] = zodSchema;
+	}
+	return z.object(shape);
+}
+function createUpdateSchema(table, refine) {
+	const shape = {};
+	for (const [columnName, column] of Object.entries(table._.columns)) {
+		if (column.isPrimaryKey) continue;
+		let zodSchema = column.zodType;
+		if (refine?.[columnName]) zodSchema = refine[columnName](column.zodType);
+		if (!column.isNotNull) zodSchema = zodSchema.nullable();
+		zodSchema = zodSchema.optional();
+		shape[columnName] = zodSchema;
+	}
+	return z.object(shape);
+}
+//#endregion
+export { createInsertSchema, createUpdateSchema };

package/dist/src/wkx/binaryreader.mjs

@@ -0,0 +1,56 @@
+//#region src/wkx/binaryreader.ts
+var BinaryReader = class {
+	buffer;
+	position;
+	isBigEndian;
+	constructor(buffer, isBigEndian = false) {
+		this.buffer = buffer;
+		this.position = 0;
+		this.isBigEndian = isBigEndian;
+	}
+	_read(readLE, readBE, size) {
+		let value;
+		if (this.isBigEndian) value = readBE.call(this.buffer, this.position);
+		else value = readLE.call(this.buffer, this.position);
+		this.position += size;
+		return value;
+	}
+	readUInt8() {
+		return this._read(Buffer.prototype.readUInt8, Buffer.prototype.readUInt8, 1);
+	}
+	readUInt16() {
+		return this._read(Buffer.prototype.readUInt16LE, Buffer.prototype.readUInt16BE, 2);
+	}
+	readUInt32() {
+		return this._read(Buffer.prototype.readUInt32LE, Buffer.prototype.readUInt32BE, 4);
+	}
+	readInt8() {
+		return this._read(Buffer.prototype.readInt8, Buffer.prototype.readInt8, 1);
+	}
+	readInt16() {
+		return this._read(Buffer.prototype.readInt16LE, Buffer.prototype.readInt16BE, 2);
+	}
+	readInt32() {
+		return this._read(Buffer.prototype.readInt32LE, Buffer.prototype.readInt32BE, 4);
+	}
+	readFloat() {
+		return this._read(Buffer.prototype.readFloatLE, Buffer.prototype.readFloatBE, 4);
+	}
+	readDouble() {
+		return this._read(Buffer.prototype.readDoubleLE, Buffer.prototype.readDoubleBE, 8);
+	}
+	readVarInt() {
+		let nextByte;
+		let result = 0;
+		let bytesRead = 0;
+		do {
+			nextByte = this.buffer[this.position + bytesRead];
+			result += (nextByte & 127) << 7 * bytesRead;
+			bytesRead++;
+		} while (nextByte >= 128);
+		this.position += bytesRead;
+		return result;
+	}
+};
+//#endregion
+export { BinaryReader };

package/dist/src/wkx/binarywriter.mjs

@@ -0,0 +1,110 @@
+import { __esmMin } from "../_virtual/_rolldown/runtime.mjs";
+//#region src/wkx/binarywriter.ts
+var BinaryWriter;
+var init_binarywriter = __esmMin((() => {
+	BinaryWriter = class {
+		buffer;
+		position;
+		allowResize;
+		constructor(size, allowResize = false) {
+			this.buffer = Buffer.alloc(size);
+			this.position = 0;
+			this.allowResize = allowResize;
+		}
+		ensureSize(size) {
+			if (this.buffer.length < this.position + size) if (this.allowResize) {
+				const tempBuffer = Buffer.alloc(this.position + size);
+				this.buffer.copy(tempBuffer, 0, 0, this.buffer.length);
+				this.buffer = tempBuffer;
+			} else throw new RangeError("index out of range");
+		}
+		writeUInt8(value) {
+			this.ensureSize(1);
+			this.buffer.writeUInt8(value, this.position);
+			this.position += 1;
+		}
+		writeUInt16LE(value) {
+			this.ensureSize(2);
+			this.buffer.writeUInt16LE(value, this.position);
+			this.position += 2;
+		}
+		writeUInt16BE(value) {
+			this.ensureSize(2);
+			this.buffer.writeUInt16BE(value, this.position);
+			this.position += 2;
+		}
+		writeUInt32LE(value, noAssert) {
+			this.ensureSize(4);
+			this.buffer.writeUInt32LE(value, this.position);
+			this.position += 4;
+		}
+		writeUInt32BE(value) {
+			this.ensureSize(4);
+			this.buffer.writeUInt32BE(value, this.position);
+			this.position += 4;
+		}
+		writeInt8(value) {
+			this.ensureSize(1);
+			this.buffer.writeInt8(value, this.position);
+			this.position += 1;
+		}
+		writeInt16LE(value) {
+			this.ensureSize(2);
+			this.buffer.writeInt16LE(value, this.position);
+			this.position += 2;
+		}
+		writeInt16BE(value) {
+			this.ensureSize(2);
+			this.buffer.writeInt16BE(value, this.position);
+			this.position += 2;
+		}
+		writeInt32LE(value) {
+			this.ensureSize(4);
+			this.buffer.writeInt32LE(value, this.position);
+			this.position += 4;
+		}
+		writeInt32BE(value) {
+			this.ensureSize(4);
+			this.buffer.writeInt32BE(value, this.position);
+			this.position += 4;
+		}
+		writeFloatLE(value) {
+			this.ensureSize(4);
+			this.buffer.writeFloatLE(value, this.position);
+			this.position += 4;
+		}
+		writeFloatBE(value) {
+			this.ensureSize(4);
+			this.buffer.writeFloatBE(value, this.position);
+			this.position += 4;
+		}
+		writeDoubleLE(value) {
+			this.ensureSize(8);
+			this.buffer.writeDoubleLE(value, this.position);
+			this.position += 8;
+		}
+		writeDoubleBE(value) {
+			this.ensureSize(8);
+			this.buffer.writeDoubleBE(value, this.position);
+			this.position += 8;
+		}
+		writeBuffer(buffer) {
+			this.ensureSize(buffer.length);
+			buffer.copy(this.buffer, this.position, 0, buffer.length);
+			this.position += buffer.length;
+		}
+		writeVarInt(value) {
+			let length = 1;
+			while ((value & 4294967168) !== 0) {
+				this.writeUInt8(value & 127 | 128);
+				value >>>= 7;
+				length++;
+			}
+			this.writeUInt8(value & 127);
+			return length;
+		}
+	};
+}));
+//#endregion
+init_binarywriter();
+export { BinaryWriter, init_binarywriter };

package/dist/src/wkx/geometry.mjs

@@ -0,0 +1,101 @@
+import { __esmMin } from "../_virtual/_rolldown/runtime.mjs";
+import { BinaryWriter, init_binarywriter } from "./binarywriter.mjs";
+import { ZigZag, init_zigzag } from "./zigzag.mjs";
+//#region src/wkx/geometry.ts
+var Geometry;
+var init_geometry = __esmMin((() => {
+	init_binarywriter();
+	init_zigzag();
+	Geometry = class {
+		srid;
+		hasZ = false;
+		hasM = false;
+		static parse;
+		static parseTwkb;
+		static parseGeoJSON;
+		static _parseWkt;
+		static _parseWkb;
+		static _parseGeoJSON;
+		toEwkt() {
+			return "SRID=" + this.srid + ";" + this.toWkt();
+		}
+		toEwkb() {
+			const ewkb = new BinaryWriter(this._getWkbSize() + 4);
+			const wkb = this.toWkb();
+			ewkb.writeInt8(1);
+			ewkb.writeUInt32LE((wkb.slice(1, 5).readUInt32LE(0) | 536870912) >>> 0, true);
+			ewkb.writeUInt32LE(this.srid || 0);
+			ewkb.writeBuffer(wkb.slice(5));
+			return ewkb.buffer;
+		}
+		_getWktType(wktType, isEmpty) {
+			let wkt = wktType;
+			if (this.hasZ && this.hasM) wkt += " ZM ";
+			else if (this.hasZ) wkt += " Z ";
+			else if (this.hasM) wkt += " M ";
+			if (isEmpty && !this.hasZ && !this.hasM) wkt += " ";
+			if (isEmpty) wkt += "EMPTY";
+			return wkt;
+		}
+		_getWktCoordinate(point) {
+			let coordinates = point.x + " " + point.y;
+			if (this.hasZ) coordinates += " " + point.z;
+			if (this.hasM) coordinates += " " + point.m;
+			return coordinates;
+		}
+		_writeWkbType(wkb, geometryType, parentOptions) {
+			let dimensionType = 0;
+			if (typeof this.srid === "undefined" && (!parentOptions || typeof parentOptions.srid === "undefined")) {
+				if (this.hasZ && this.hasM) dimensionType += 3e3;
+				else if (this.hasZ) dimensionType += 1e3;
+				else if (this.hasM) dimensionType += 2e3;
+			} else {
+				if (this.hasZ) dimensionType |= 2147483648;
+				if (this.hasM) dimensionType |= 1073741824;
+			}
+			wkb.writeUInt32LE(dimensionType + geometryType >>> 0, true);
+		}
+		static getTwkbPrecision(xyPrecision, zPrecision, mPrecision) {
+			return {
+				xy: xyPrecision,
+				z: zPrecision,
+				m: mPrecision,
+				xyFactor: 10 ** xyPrecision,
+				zFactor: 10 ** zPrecision,
+				mFactor: 10 ** mPrecision
+			};
+		}
+		_writeTwkbHeader(twkb, geometryType, precision, isEmpty) {
+			const type = (ZigZag.encode(precision.xy) << 4) + geometryType;
+			let metadataHeader = (this.hasZ || this.hasM ? 1 : 0) << 3;
+			metadataHeader += (isEmpty ? 1 : 0) << 4;
+			twkb.writeUInt8(type);
+			twkb.writeUInt8(metadataHeader);
+			if (this.hasZ || this.hasM) {
+				let extendedPrecision = 0;
+				if (this.hasZ) extendedPrecision |= 1;
+				if (this.hasM) extendedPrecision |= 2;
+				twkb.writeUInt8(extendedPrecision);
+			}
+		}
+		toGeoJSON(options) {
+			const geoJSON = {};
+			if (this.srid) {
+				if (options) {
+					if (options.shortCrs) geoJSON.crs = {
+						type: "name",
+						properties: { name: "EPSG:" + this.srid }
+					};
+					else if (options.longCrs) geoJSON.crs = {
+						type: "name",
+						properties: { name: "urn:ogc:def:crs:EPSG::" + this.srid }
+					};
+				}
+			}
+			return geoJSON;
+		}
+	};
+}));
+//#endregion
+init_geometry();
+export { Geometry, init_geometry };