@dineug/erd-editor 4.2.0 → 5.0.1

package/dist/utils/generator-code/aml.js

@@ -0,0 +1,199 @@
+import { query } from "../../erd-editor-schema/dist/query/index.js";
+import { ColumnOption } from "../../constants/schema.js";
+import { bHas } from "../bit.js";
+import { autoName, orderByNameASC } from "../tableName.js";
+import { toAMLColor } from "../tableColor.js";
+import { hasNRelationship, hasOneRelationship, referentialActionEntries } from "./utils.js";
+//#region src/utils/generator-code/aml.ts
+var BARE_IDENTIFIER = /^[A-Za-z_][0-9A-Za-z_]*$/;
+var AML_KEYWORD = /^(as|check|false|fk|index|namespace|null|nullable|pk|rel|true|type|unique)$/i;
+var NUMERIC_LITERAL = /^-?(0|[1-9][0-9]*)(\.[0-9]+)?$/;
+var KEYWORD_LITERAL = /^(true|false|null)$/i;
+var QUOTED_LITERAL = /^'([^']|'')*'$/;
+var ESCAPED_QUOTE = /''/g;
+var IDENTIFIER_ESCAPE = /["\\]/g;
+var HAS_LINE_TERMINATOR = /[\n\r]/;
+var LINE_TERMINATOR = /\r\n|[\n\r]/g;
+var HASH = /#/g;
+function createCode(state) {
+	const { doc: { tableIds }, collections } = state;
+	const stringBuffer = [""];
+	const context = createAMLContext(state);
+	query(collections).collection("tableEntities").selectByIds(tableIds).sort(orderByNameASC).forEach((table) => {
+		formatAMLTable(state, {
+			buffer: stringBuffer,
+			table
+		}, context);
+		stringBuffer.push("");
+	});
+	if (context.relationLines.length !== 0) {
+		context.relationLines.forEach((line) => stringBuffer.push(line));
+		stringBuffer.push("");
+	}
+	return stringBuffer.join("\n");
+}
+function formatTable(state, { buffer, table }) {
+	formatAMLTable(state, {
+		buffer,
+		table
+	}, createAMLContext(state, false));
+}
+function formatAMLTable(state, { buffer, table }, context) {
+	const { collections } = state;
+	const name = context.tableNames.get(table.id);
+	if (name === void 0) return;
+	const doc = formatDoc(table.comment, "");
+	buffer.push(`${quoteIdentifier(name)}${formatEntityProperties(table)}${doc}`);
+	const indexes = formatIndexes(state, table, context, name);
+	query(collections).collection("tableColumnEntities").selectByIds(table.columnIds).forEach((column) => {
+		const columnName = context.columnNames.get(column.id);
+		if (columnName === void 0) return;
+		buffer.push(`  ${formatAttribute(column, columnName, indexes.get(column.id) ?? "", context.inlineRelations.get(column.id) ?? "")}`);
+	});
+}
+function formatEntityProperties(table) {
+	const color = toAMLColor(table.ui.color);
+	return color === null ? "" : ` {color: ${color}}`;
+}
+function formatAttribute(column, name, indexes, relations) {
+	const dataType = formatDataType(column.dataType);
+	const defaultValue = dataType === "" ? "" : formatDefault(column.default);
+	const nullable = bHas(column.options, ColumnOption.notNull) ? "" : " nullable";
+	const primaryKey = bHas(column.options, ColumnOption.primaryKey) ? " pk" : "";
+	const props = bHas(column.options, ColumnOption.autoIncrement) ? " {autoIncrement}" : "";
+	return `${quoteIdentifier(name)}${dataType}${defaultValue}${nullable}${primaryKey}${indexes}${relations}${props}${formatDoc(column.comment, "  ")}`;
+}
+function formatIndexes({ doc: { indexIds }, collections }, table, context, tableName) {
+	const columnCollection = query(collections).collection("tableColumnEntities");
+	const indexColumnCollection = query(collections).collection("indexColumnEntities");
+	const result = /* @__PURE__ */ new Map();
+	const names = [];
+	const append = (columnId, value) => result.set(columnId, `${result.get(columnId) ?? ""}${value}`);
+	columnCollection.selectByIds(table.columnIds).forEach((column) => {
+		if (context.columnNames.has(column.id) && bHas(column.options, ColumnOption.unique)) append(column.id, " unique");
+	});
+	query(collections).collection("indexEntities").selectByIds(indexIds).filter((index) => index.tableId === table.id).forEach((index, position) => {
+		const columnIds = [];
+		indexColumnCollection.selectByIds(index.indexColumnIds).forEach((indexColumn) => {
+			const column = columnCollection.selectById(indexColumn.columnId);
+			if (!column || column.tableId !== table.id || !context.columnNames.has(column.id)) return;
+			columnIds.push(column.id);
+		});
+		if (columnIds.length === 0) return;
+		const wanted = index.name.trim() === "" ? columnIds.length === 1 ? "" : `${tableName}_idx_${position + 1}` : index.name.trim();
+		const name = wanted === "" ? "" : autoName(names, index.id, wanted);
+		names.push({
+			id: index.id,
+			name
+		});
+		const constraint = ` ${index.unique ? "unique" : "index"}${name === "" ? "" : `=${quoteIdentifier(name)}`}`;
+		columnIds.forEach((columnId) => append(columnId, constraint));
+	});
+	return result;
+}
+function createAMLContext(state, actions = true) {
+	const { doc: { tableIds, relationshipIds }, collections } = state;
+	const context = {
+		tableNames: /* @__PURE__ */ new Map(),
+		columnNames: /* @__PURE__ */ new Map(),
+		inlineRelations: /* @__PURE__ */ new Map(),
+		relationLines: []
+	};
+	const columnCollection = query(collections).collection("tableColumnEntities");
+	const usedTableNames = /* @__PURE__ */ new Set();
+	query(collections).collection("tableEntities").selectByIds(tableIds).sort(orderByNameASC).forEach((table) => {
+		const usedColumnNames = /* @__PURE__ */ new Set();
+		columnCollection.selectByIds(table.columnIds).forEach((column) => {
+			if (usedColumnNames.has(column.name)) return;
+			usedColumnNames.add(column.name);
+			context.columnNames.set(column.id, column.name);
+		});
+		context.tableNames.set(table.id, uniqueName(usedTableNames, table.name));
+	});
+	const resolveEndpoint = (point) => {
+		const table = context.tableNames.get(point.tableId);
+		if (table === void 0 || point.columnIds.length === 0) return null;
+		const columns = [];
+		for (const columnId of point.columnIds) {
+			const column = columnCollection.selectById(columnId);
+			const name = context.columnNames.get(columnId);
+			if (!column || column.tableId !== point.tableId || name === void 0) return null;
+			columns.push(name);
+		}
+		return {
+			table,
+			columns
+		};
+	};
+	const used = /* @__PURE__ */ new Set();
+	query(collections).collection("relationshipEntities").selectByIds(relationshipIds).forEach((relationship) => {
+		const arrow = relationshipArrow(relationship);
+		const parent = resolveEndpoint(relationship.start);
+		const child = resolveEndpoint(relationship.end);
+		if (arrow === "" || parent === null || child === null || parent.columns.length !== child.columns.length) return;
+		const parentText = formatEndpoint(parent);
+		const childText = formatEndpoint(child);
+		const key = [parentText, childText].sort().join(" ");
+		if (used.has(key)) return;
+		used.add(key);
+		const properties = actions ? formatRelationProperties(relationship) : "";
+		if (child.columns.length === 1 && properties === "") {
+			const [columnId] = relationship.end.columnIds;
+			context.inlineRelations.set(columnId, `${context.inlineRelations.get(columnId) ?? ""} ${arrow} ${parentText}`);
+			return;
+		}
+		context.relationLines.push(`rel ${childText} ${arrow} ${parentText}${properties}`);
+	});
+	return context;
+}
+function formatEndpoint({ table, columns }) {
+	return `${quoteIdentifier(table)}(${columns.map(quoteIdentifier).join(", ")})`;
+}
+function formatRelationProperties(relationship) {
+	const properties = referentialActionEntries(relationship).map(({ key, sql }) => `${key}: ${quoteIdentifier(sql.toLowerCase())}`);
+	return properties.length ? ` {${properties.join(", ")}}` : "";
+}
+function relationshipArrow(relationship) {
+	if (hasNRelationship(relationship.relationshipType)) return "->";
+	if (hasOneRelationship(relationship.relationshipType)) return "--";
+	return "";
+}
+function formatDataType(dataType) {
+	const value = dataType.trim();
+	return value === "" ? "" : ` ${quoteIdentifier(value)}`;
+}
+function formatDefault(value) {
+	const trimmed = value.trim();
+	return trimmed === "" ? "" : `=${formatValue(trimmed)}`;
+}
+function formatValue(value) {
+	if (NUMERIC_LITERAL.test(value)) return value;
+	if (KEYWORD_LITERAL.test(value)) return value.toLocaleLowerCase();
+	if (QUOTED_LITERAL.test(value)) return quoteIdentifier(value.slice(1, -1).replace(ESCAPED_QUOTE, "'"));
+	if (value.includes("`")) return quoteIdentifier(value);
+	return `\`${value}\``;
+}
+function formatDoc(comment, indent) {
+	const value = comment.trim();
+	if (value === "") return "";
+	if (HAS_LINE_TERMINATOR.test(value) && !value.includes("|||")) return ` |||\n${value.split(LINE_TERMINATOR).map((line) => `${indent}  ${line}\n`).join("")}${indent}|||`;
+	return ` | ${value.replace(LINE_TERMINATOR, " ").replace(HASH, "\\#")}`;
+}
+function quoteIdentifier(value) {
+	return BARE_IDENTIFIER.test(value) && !AML_KEYWORD.test(value) ? value : `"${escapeIdentifier(value)}"`;
+}
+function escapeIdentifier(value) {
+	return value.replace(IDENTIFIER_ESCAPE, (char) => `\\${char}`).replace(LINE_TERMINATOR, "\\n");
+}
+function uniqueName(used, name) {
+	let result = name;
+	let index = 2;
+	while (used.has(result)) {
+		result = `${name}${index}`;
+		index += 1;
+	}
+	used.add(result);
+	return result;
+}
+//#endregion
+export { createCode, formatTable };

package/dist/utils/generator-code/columnTypes.js

@@ -0,0 +1,369 @@
+import { Database } from "../../constants/schema.js";
+import { baseTypeName, findDataTypeHint, fractionalNumber, getPrimitiveType } from "./utils.js";
+//#region src/utils/generator-code/columnTypes.ts
+var BINARY_TYPES = /* @__PURE__ */ new Set([
+	"bfile",
+	"binary",
+	"binary varying",
+	"blob",
+	"bytea",
+	"char byte",
+	"image",
+	"long raw",
+	"long varbinary",
+	"longblob",
+	"mediumblob",
+	"raw",
+	"tinyblob",
+	"varbinary"
+]);
+var UUID_TYPES = /* @__PURE__ */ new Set(["uniqueidentifier", "uuid"]);
+var JSON_TYPES = /* @__PURE__ */ new Set(["json", "jsonb"]);
+var TIMESTAMP_TZ_TYPES = /* @__PURE__ */ new Set([
+	"datetimeoffset",
+	"timestamp with time zone",
+	"timestamp_tz",
+	"timestamptz"
+]);
+var TIMESTAMP_LTZ_TYPES = /* @__PURE__ */ new Set([
+	"timestamp with local time zone",
+	"timestamp_ltz",
+	"timestampltz"
+]);
+var MONEY_TYPES = /* @__PURE__ */ new Set(["money", "smallmoney"]);
+var POSTGRES_BIT_TYPES = /* @__PURE__ */ new Set([
+	"bit",
+	"bit varying",
+	"varbit"
+]);
+var POSTGRES_TIME_TZ_TYPES = /* @__PURE__ */ new Set(["time with time zone", "timetz"]);
+var POSTGRES_OBJECT_ID_TYPES = /* @__PURE__ */ new Set([
+	"cid",
+	"oid",
+	"xid",
+	"xid8"
+]);
+var POSTGRES_TEXT_INTEGER_TYPES = /* @__PURE__ */ new Set([
+	"cid",
+	"xid",
+	"xid8"
+]);
+var POSTGRES_SERIAL_TYPES = /* @__PURE__ */ new Set([
+	"bigserial",
+	"serial",
+	"serial2",
+	"serial4",
+	"serial8",
+	"smallserial"
+]);
+var CHARACTER_TYPES = /* @__PURE__ */ new Set([
+	"bpchar",
+	"char",
+	"char varying",
+	"character",
+	"character varying",
+	"national char",
+	"national char varying",
+	"national character",
+	"national character varying",
+	"national varchar",
+	"national varcharacter",
+	"native character",
+	"nchar",
+	"nchar varchar",
+	"nchar varcharacter",
+	"nchar varying",
+	"nvarchar",
+	"nvarchar2",
+	"varchar",
+	"varchar2",
+	"varcharacter",
+	"varying character"
+]);
+var SNOWFLAKE_CHARACTER_TYPES = /* @__PURE__ */ new Set(["string", "text"]);
+var SCALARS = {
+	int: "i32",
+	long: "i64",
+	float: "f32",
+	double: "f64",
+	decimal: "decimal",
+	boolean: "bool",
+	string: "string",
+	lob: "string",
+	date: "date",
+	dateTime: "dateTime",
+	time: "time"
+};
+var WIDE_INTEGER_DATABASES = /* @__PURE__ */ new Set([
+	Database.Oracle,
+	Database.Snowflake,
+	Database.SQLite
+]);
+var INTEGER_BITS = {
+	i8: 8,
+	i16: 16,
+	i32: 32,
+	i64: 64,
+	u8: 8,
+	u16: 16,
+	u32: 32,
+	u64: 64
+};
+var smallintTypes = /* @__PURE__ */ new Set([
+	"int2",
+	"serial2",
+	"short",
+	"smallint",
+	"smallserial"
+]);
+var tinyintTypes = /* @__PURE__ */ new Set([
+	"byte",
+	"int1",
+	"tinyint"
+]);
+var mediumintTypes = /* @__PURE__ */ new Set([
+	"int3",
+	"mediumint",
+	"middleint"
+]);
+var unsignedTypes = /* @__PURE__ */ new Map([
+	["bigint", "u64"],
+	["int", "u32"],
+	["int1", "u8"],
+	["int2", "u16"],
+	["int3", "u32"],
+	["int4", "u32"],
+	["int8", "u64"],
+	["integer", "u32"],
+	["mediumint", "u32"],
+	["middleint", "u32"],
+	["smallint", "u16"],
+	["tinyint", "u8"]
+]);
+var yearTypes = /* @__PURE__ */ new Set(["sql_tsi_year", "year"]);
+var mssqlTypes = /* @__PURE__ */ new Map([
+	["bit", "bool"],
+	["numeric", "decimal"],
+	["rowversion", "bytes"],
+	["timestamp", "bytes"],
+	["tinyint", "u8"]
+]);
+var mariadbNetworkTypes = /* @__PURE__ */ new Map([["inet4", "ipv4"], ["inet6", "ipv6"]]);
+var postgresNetworkTypes = /* @__PURE__ */ new Map([
+	["cidr", "cidr"],
+	["inet", "inet"],
+	["macaddr", "macaddr"],
+	["macaddr8", "macaddr8"]
+]);
+var INTERVAL = /^interval\b/;
+var DAY_TIME_FIELD = /\b(day|hour|minute|second)\b/;
+var SEMI_STRUCTURED = /^(array|map|object|struct|variant)(?![0-9a-z_])/;
+var UNSIGNED = /(^|[^0-9a-z_])unsigned([^0-9a-z_]|$)/;
+var ZEROFILL = /(^|[^0-9a-z_])zerofill([^0-9a-z_]|$)/;
+var SIGNED = /(^|[^0-9a-z_])signed([^0-9a-z_]|$)/;
+var WHITESPACE = /\s+/g;
+var TYPE_ARGUMENTS = /\(\s*([^)]*)\)/;
+var DIGITS = /^[0-9]+$/;
+var CHARACTER_LENGTH = /^[^(]*\(\s*(\d+)(?:\s+(?:byte|char))?\s*\)/i;
+var NUMERIC_ARGUMENTS = /^[^(]*\(\s*(\*|\d+)\s*(?:,\s*(-?\d+)\s*)?\)/;
+var ENUM_HEAD = /^\s*enum\s*\(/i;
+var SET_HEAD = /^\s*set\s*\(/i;
+var MEMBER_SEPARATOR = /[\s,]/;
+var ARRAY_KEYWORD = /\s+array\s*(?:\[\s*\d*\s*\])?\s*$/i;
+var ARRAY_BOUND = /\[\s*\d*\s*\]\s*$/;
+var NUMERIC_TYPES = /* @__PURE__ */ new Set([
+	"dec",
+	"decimal",
+	"fixed",
+	"number",
+	"numeric"
+]);
+var mysqlEscapes = /* @__PURE__ */ new Map([
+	["0", String.fromCharCode(0)],
+	["b", "\b"],
+	["n", "\n"],
+	["r", "\r"],
+	["t", "	"],
+	["Z", String.fromCharCode(26)]
+]);
+function getColumnType(dataType, database) {
+	const [element, arrayDepth] = splitPostgresArray(dataType, database);
+	const typeName = baseTypeName(element);
+	const isMySQL = isMySQLFamily(database);
+	const unsigned = isMySQL && isUnsignedTypeName(typeName);
+	const base = isMySQL ? typeName.replace(UNSIGNED, "$1$2").replace(ZEROFILL, "$1$2").replace(SIGNED, "$1$2").replace(WHITESPACE, " ").trim() : typeName;
+	const args = typeArguments(element);
+	const scalar = storedScalar(columnScalar(element, base, args, database, unsigned), database);
+	const isCharacter = scalar === "string" && (CHARACTER_TYPES.has(base) || database === Database.Snowflake && SNOWFLAKE_CHARACTER_TYPES.has(base));
+	const [precision, scale] = NUMERIC_TYPES.has(base) ? numericArguments(element) : [null, null];
+	return {
+		scalar,
+		element,
+		base,
+		args,
+		arrayDepth,
+		bits: integerBits(scalar, base, database),
+		isListed: findDataTypeHint(element, database) !== void 0,
+		isUnsigned: unsigned,
+		isSerial: database === Database.PostgreSQL && POSTGRES_SERIAL_TYPES.has(base) || isMySQL && base === "serial",
+		isFloat: scalar === "f32" || scalar === "f64",
+		isMoney: MONEY_TYPES.has(base),
+		isGuid: base === "uniqueidentifier",
+		isRowVersion: database === Database.MSSQL && (base === "rowversion" || base === "timestamp"),
+		isSemiStructured: isSemiStructured(base, database),
+		isBitString: database === Database.PostgreSQL && POSTGRES_BIT_TYPES.has(base),
+		isTextInteger: database === Database.PostgreSQL && POSTGRES_TEXT_INTEGER_TYPES.has(base),
+		isNullOnly: database === Database.Databricks && base === "void",
+		length: isCharacter ? characterLength(element) : null,
+		precision,
+		scale,
+		interval: scalar === "interval" ? intervalFields(base) : null,
+		network: networkType(base, database),
+		enumMembers: ENUM_HEAD.test(element) ? listMembers(element) : null,
+		setMembers: SET_HEAD.test(element) ? listMembers(element) : null
+	};
+}
+function isUnsigned(dataType, database) {
+	return isMySQLFamily(database) && isUnsignedTypeName(baseTypeName(dataType));
+}
+function enumMembers(dataType) {
+	return ENUM_HEAD.test(dataType) || SET_HEAD.test(dataType) ? listMembers(dataType) : null;
+}
+function splitPostgresArray(dataType, database) {
+	if (database !== Database.PostgreSQL) return [dataType, 0];
+	if (ARRAY_KEYWORD.test(dataType)) return [dataType.replace(ARRAY_KEYWORD, ""), 1];
+	let element = dataType;
+	let depth = 0;
+	while (ARRAY_BOUND.test(element)) {
+		element = element.replace(ARRAY_BOUND, "");
+		depth++;
+	}
+	return [element, depth];
+}
+function typeArguments(dataType) {
+	const matched = TYPE_ARGUMENTS.exec(dataType);
+	if (!matched) return [];
+	const values = matched[1].split(",").map((value) => value.trim());
+	return values.every((value) => DIGITS.test(value)) ? values.map(Number) : [];
+}
+function isMySQLFamily(database) {
+	return database === Database.MySQL || database === Database.MariaDB;
+}
+function columnScalar(element, base, args, database, isUnsigned, primitiveOf = getPrimitiveType) {
+	if (isMySQLFamily(database)) {
+		const unsigned = isUnsigned ? unsignedTypes.get(base) : void 0;
+		if (unsigned) return unsigned;
+		if (base === "serial") return "u64";
+		if (base === "bit") return args.length === 1 && args[0] > 1 ? "u64" : "bool";
+		if (yearTypes.has(base)) return "u16";
+		if (base === "timestamp") return "dateTimeUtc";
+		if (base === "float" && args.length === 1 && args[0] > 24) return "f64";
+	}
+	if (database === Database.MariaDB && base === "number" && args.length === 0) return "f64";
+	if (database === Database.PostgreSQL) {
+		if (POSTGRES_BIT_TYPES.has(base)) return "string";
+		if (POSTGRES_TIME_TZ_TYPES.has(base)) return "timeTz";
+		if (POSTGRES_OBJECT_ID_TYPES.has(base)) return base === "xid8" ? "u64" : "u32";
+		if (base === "float" && args.length === 1 && args[0] <= 24) return "f32";
+	}
+	if (database === Database.MSSQL) {
+		const mssqlType = mssqlTypes.get(base);
+		if (mssqlType) return mssqlType;
+		if (base === "float" && args.length === 1 && args[0] <= 24) return "f32";
+	}
+	if (database === Database.Oracle) {
+		if (base === "date") return "dateTime";
+		if (base === "real") return "f64";
+	}
+	if (database === Database.Databricks && base === "timestamp") return "dateTimeUtc";
+	if (isSemiStructured(base, database)) return "json";
+	if (fractionalNumber(element, database)) return "decimal";
+	if (BINARY_TYPES.has(base)) return "bytes";
+	if (UUID_TYPES.has(base)) return "uuid";
+	if (JSON_TYPES.has(base)) return "json";
+	if (TIMESTAMP_TZ_TYPES.has(base)) return "dateTimeOffset";
+	if (TIMESTAMP_LTZ_TYPES.has(base)) return "dateTimeUtc";
+	if (MONEY_TYPES.has(base)) return "decimal";
+	if (INTERVAL.test(base)) return "interval";
+	if (base === "pg_lsn") return "string";
+	if (database !== Database.Oracle && database !== Database.Snowflake) {
+		if (smallintTypes.has(base)) return "i16";
+		if (tinyintTypes.has(base)) return "i8";
+	}
+	return SCALARS[primitiveOf(element, database)];
+}
+function storedScalar(scalar, database) {
+	return WIDE_INTEGER_DATABASES.has(database) && INTEGER_BITS[scalar] !== void 0 ? "i64" : scalar;
+}
+function isUnsignedTypeName(typeName) {
+	return UNSIGNED.test(typeName) || ZEROFILL.test(typeName) || typeName === "serial";
+}
+function isSemiStructured(base, database) {
+	return (database === Database.Snowflake || database === Database.Databricks) && SEMI_STRUCTURED.test(base);
+}
+function integerBits(scalar, base, database) {
+	const bits = INTEGER_BITS[scalar];
+	if (bits === void 0) return null;
+	return isMySQLFamily(database) && mediumintTypes.has(base) ? 24 : bits;
+}
+function characterLength(element) {
+	const matched = CHARACTER_LENGTH.exec(element);
+	return matched ? Number(matched[1]) : null;
+}
+function numericArguments(element) {
+	const matched = NUMERIC_ARGUMENTS.exec(element);
+	if (!matched) return [null, null];
+	const [, precision, scale] = matched;
+	return [precision === "*" ? 38 : Number(precision), scale === void 0 ? null : Number(scale)];
+}
+function intervalFields(base) {
+	const fields = base.slice(8).trim();
+	if (fields === "") return "mixed";
+	return DAY_TIME_FIELD.test(fields) ? "dayTime" : "yearMonth";
+}
+function networkType(base, database) {
+	if (database === Database.MariaDB) return mariadbNetworkTypes.get(base) ?? null;
+	if (database === Database.PostgreSQL) return postgresNetworkTypes.get(base) ?? null;
+	return null;
+}
+function listMembers(dataType) {
+	const start = dataType.indexOf("(");
+	const source = dataType.slice(start + 1, dataType.lastIndexOf(")"));
+	const members = [];
+	let index = 0;
+	while (index < source.length) {
+		if (MEMBER_SEPARATOR.test(source[index])) {
+			index += 1;
+			continue;
+		}
+		const quote = source[index];
+		if (quote !== "'" && quote !== "\"") return null;
+		let member = "";
+		let closed = false;
+		index += 1;
+		while (index < source.length && !closed) {
+			const char = source[index];
+			if (char === "\\" && index + 1 < source.length) {
+				member += unescapeMySQL(source[index + 1]);
+				index += 2;
+			} else if (char !== quote) {
+				member += char;
+				index += 1;
+			} else if (source[index + 1] === quote) {
+				member += quote;
+				index += 2;
+			} else {
+				closed = true;
+				index += 1;
+			}
+		}
+		if (!closed) return null;
+		members.push(member);
+	}
+	return members.length === 0 ? null : members;
+}
+function unescapeMySQL(char) {
+	return char === "%" || char === "_" ? `\\${char}` : mysqlEscapes.get(char) ?? char;
+}
+//#endregion
+export { BINARY_TYPES, CHARACTER_TYPES, JSON_TYPES, MONEY_TYPES, POSTGRES_BIT_TYPES, POSTGRES_OBJECT_ID_TYPES, POSTGRES_SERIAL_TYPES, POSTGRES_TIME_TZ_TYPES, TIMESTAMP_LTZ_TYPES, TIMESTAMP_TZ_TYPES, UUID_TYPES, columnScalar, enumMembers, getColumnType, isMySQLFamily, isUnsigned, splitPostgresArray, typeArguments };