@dineug/erd-editor 4.2.0 → 5.0.0

package/dist/utils/table-clipboard/copy.js

@@ -0,0 +1,208 @@
+import { query } from "../../erd-editor-schema/dist/query/index.js";
+import { ColumnOption, ColumnType } from "../../constants/schema.js";
+import { arrayHas } from "../arrayHas.js";
+import { getLiveDomainName } from "../../engine/modules/dictionary/membership.js";
+import { SelectType } from "../../engine/modules/editor/state.js";
+import { bHas } from "../bit.js";
+import { drawsDomainInTypeCell } from "../../engine/modules/editor/utils/nameView.js";
+import { CLIPBOARD_HTML_ATTR, CLIPBOARD_HTML_TRUNCATED_ATTR, PayloadKind, createPayload } from "./payload.js";
+import { CellType, getShowColumnOrder } from "./index.js";
+//#region src/utils/table-clipboard/copy.ts
+function tableCopyToText(state) {
+	return getTableData(state).map((row) => row.map(([, value]) => value).join("	")).join("\n");
+}
+function tableCopyToHtml(state) {
+	return rowsToHtmlTable(getTableData(state));
+}
+function getTableData(state) {
+	const { editor: { focusTable }, settings: { show, columnOrder, nameViewMode }, collections } = state;
+	const rows = [];
+	if (!focusTable || focusTable.edit || focusTable.selectColumnIds.length === 0) return rows;
+	const table = query(collections).collection("tableEntities").selectById(focusTable.tableId);
+	if (!table) return rows;
+	const hasColumnIds = arrayHas(focusTable.selectColumnIds);
+	const columns = query(collections).collection("tableColumnEntities").selectByIds(table.columnIds).filter((column) => hasColumnIds(column.id));
+	const showColumnOrder = getShowColumnOrder(show, columnOrder, nameViewMode);
+	return columns.map((column) => showColumnOrder.map((columnType) => toCell(state, column, columnType)));
+}
+function entitiesCopyToPayload(state) {
+	const { editor: { selectedMap }, collections } = state;
+	const tableIds = [];
+	const memoIds = [];
+	for (const [id, selectType] of Object.entries(selectedMap)) if (selectType === SelectType.table) tableIds.push(id);
+	else if (selectType === SelectType.memo) memoIds.push(id);
+	const tables = query(collections).collection("tableEntities").selectByIds(tableIds);
+	const memos = query(collections).collection("memoEntities").selectByIds(memoIds);
+	if (tables.length === 0 && memos.length === 0) return null;
+	const columns = tables.flatMap((table) => query(collections).collection("tableColumnEntities").selectByIds(table.columnIds));
+	const copiedTableIds = tables.map(({ id }) => id);
+	return createPayload({
+		kind: PayloadKind.tables,
+		tables: tables.map(toClipboardTable),
+		columns: columns.map(toClipboardColumn),
+		memos: memos.map(toClipboardMemo),
+		relationships: toClipboardRelationships(state, copiedTableIds),
+		indexes: toClipboardIndexes(state, copiedTableIds)
+	});
+}
+function toClipboardRelationships({ doc, collections }, tableIds) {
+	const hasTableId = arrayHas(tableIds);
+	return query(collections).collection("relationshipEntities").selectByIds(doc.relationshipIds).filter(({ start, end }) => hasTableId(start.tableId) && hasTableId(end.tableId)).map(({ relationshipType, onDelete, onUpdate, start, end }) => ({
+		relationshipType,
+		onDelete,
+		onUpdate,
+		start: {
+			tableId: start.tableId,
+			columnIds: [...start.columnIds]
+		},
+		end: {
+			tableId: end.tableId,
+			columnIds: [...end.columnIds]
+		}
+	}));
+}
+function toClipboardIndexes({ doc, collections }, tableIds) {
+	const hasTableId = arrayHas(tableIds);
+	const indexColumnCollection = query(collections).collection("indexColumnEntities");
+	const clipboardIndexes = [];
+	for (const index of query(collections).collection("indexEntities").selectByIds(doc.indexIds)) {
+		if (!hasTableId(index.tableId)) continue;
+		const indexColumns = [];
+		let resolved = true;
+		for (const indexColumnId of index.indexColumnIds) {
+			const indexColumn = indexColumnCollection.selectById(indexColumnId);
+			if (!indexColumn) {
+				resolved = false;
+				break;
+			}
+			indexColumns.push({
+				columnId: indexColumn.columnId,
+				orderType: indexColumn.orderType
+			});
+		}
+		if (!resolved) continue;
+		clipboardIndexes.push({
+			tableId: index.tableId,
+			name: index.name,
+			unique: index.unique,
+			indexColumns
+		});
+	}
+	return clipboardIndexes;
+}
+function columnsCopyToPayload({ editor: { focusTable }, collections }) {
+	if (!focusTable || focusTable.edit || focusTable.selectColumnIds.length === 0) return null;
+	const table = query(collections).collection("tableEntities").selectById(focusTable.tableId);
+	const hasColumnIds = arrayHas(focusTable.selectColumnIds);
+	const columns = table ? query(collections).collection("tableColumnEntities").selectByIds(table.columnIds).filter((column) => hasColumnIds(column.id)) : [];
+	return createPayload({
+		kind: PayloadKind.columns,
+		columns: columns.map(toClipboardColumn)
+	});
+}
+function entitiesToTsv(payload, state) {
+	return payload.tables.length === 0 ? payload.memos.map(({ value }) => value).join("\n\n") : toEntityRows(payload, state).map((row) => row.map(([, value]) => value).join("	")).join("\n");
+}
+function entitiesToHtmlTable(payload, state) {
+	return rowsToHtmlTable(toEntityRows(payload, state));
+}
+function payloadToHtml(payload, tableHtml) {
+	const json = escapeHtml(JSON.stringify(payload));
+	return byteLength(json) > 1e6 ? `<span ${CLIPBOARD_HTML_TRUNCATED_ATTR}="1">${tableHtml}</span>` : `<span ${CLIPBOARD_HTML_ATTR}="${json}">${tableHtml}</span>`;
+}
+function toClipboardTable(table) {
+	return {
+		sourceId: table.id,
+		name: table.name,
+		logicalName: table.logicalName,
+		comment: table.comment,
+		columnIds: [...table.columnIds],
+		nameDerived: table.nameDerived,
+		ui: {
+			x: table.ui.x,
+			y: table.ui.y,
+			zIndex: table.ui.zIndex,
+			widthName: table.ui.widthName,
+			widthComment: table.ui.widthComment,
+			color: table.ui.color
+		}
+	};
+}
+function toClipboardColumn(column) {
+	return {
+		sourceId: column.id,
+		tableId: column.tableId,
+		name: column.name,
+		comment: column.comment,
+		dataType: column.dataType,
+		default: column.default,
+		options: column.options,
+		logicalName: column.logicalName,
+		domainId: column.domainId,
+		ui: {
+			keys: column.ui.keys,
+			widthName: column.ui.widthName,
+			widthComment: column.ui.widthComment,
+			widthDataType: column.ui.widthDataType,
+			widthDefault: column.ui.widthDefault
+		}
+	};
+}
+function toClipboardMemo(memo) {
+	return {
+		sourceId: memo.id,
+		value: memo.value,
+		ui: {
+			x: memo.ui.x,
+			y: memo.ui.y,
+			width: memo.ui.width,
+			height: memo.ui.height,
+			zIndex: memo.ui.zIndex,
+			color: memo.ui.color
+		}
+	};
+}
+function rowsToHtmlTable(rows) {
+	if (rows.length === 0) return "";
+	return `<table><tbody>${rows.map((row) => `<tr>${row.map(cellToHtml).join("")}</tr>`).join("")}</tbody></table>`;
+}
+function cellToHtml([type, value]) {
+	return `<td data-type="${escapeHtml(type)}">${escapeHtml(value)}</td>`;
+}
+function toEntityRows(payload, state) {
+	const { show, columnOrder, nameViewMode } = state.settings;
+	const showColumnOrder = getShowColumnOrder(show, columnOrder, nameViewMode);
+	const columnMap = new Map(payload.columns.map((column) => [column.sourceId, column]));
+	return payload.tables.flatMap((table) => table.columnIds.map((columnId) => columnMap.get(columnId)).filter((column) => Boolean(column)).map((column) => showColumnOrder.map((columnType) => toCell(state, column, columnType))));
+}
+function toCell(state, column, columnType) {
+	const domainId = column.domainId ?? "";
+	switch (columnType) {
+		case ColumnType.columnName: return [CellType.columnName, column.name];
+		case ColumnType.columnLogicalName: return [CellType.columnLogicalName, column.logicalName ?? ""];
+		case ColumnType.columnDataType: return drawsDomainInTypeCell(state, { domainId }) ? [CellType.columnDomain, getLiveDomainName(state, domainId)] : [CellType.columnDataType, column.dataType];
+		case ColumnType.columnDomain: return [CellType.columnDomain, getLiveDomainName(state, domainId)];
+		case ColumnType.columnDefault: return [CellType.columnDefault, column.default];
+		case ColumnType.columnComment: return [CellType.columnComment, column.comment];
+		case ColumnType.columnAutoIncrement: return [CellType.columnAutoIncrement, bHas(column.options, ColumnOption.autoIncrement) ? "TRUE" : "FALSE"];
+		case ColumnType.columnUnique: return [CellType.columnUnique, bHas(column.options, ColumnOption.unique) ? "TRUE" : "FALSE"];
+		case ColumnType.columnNotNull: return [CellType.columnNotNull, bHas(column.options, ColumnOption.notNull) ? "NOT NULL" : "NULL"];
+		default: return ["", ""];
+	}
+}
+var HTML_ESCAPE_MAP = {
+	"&": "&amp;",
+	"<": "&lt;",
+	">": "&gt;",
+	"\"": "&quot;",
+	"'": "&#39;"
+};
+function escapeHtml(value) {
+	return value.replace(/[&<>"']/g, (char) => HTML_ESCAPE_MAP[char]);
+}
+var textEncoder = new TextEncoder();
+function byteLength(value) {
+	return textEncoder.encode(value).length;
+}
+//#endregion
+export { columnsCopyToPayload, entitiesCopyToPayload, entitiesToHtmlTable, entitiesToTsv, payloadToHtml, tableCopyToHtml, tableCopyToText, toClipboardIndexes, toClipboardRelationships };

package/dist/utils/table-clipboard/index.js

@@ -0,0 +1,28 @@
+import { ColumnType } from "../../constants/schema.js";
+import { arrayHas } from "../arrayHas.js";
+import { ColumnTypeShown, isLogicalNameView } from "../../engine/modules/editor/utils/nameView.js";
+import { CLIPBOARD_FORMAT, CLIPBOARD_HTML_ATTR, CLIPBOARD_HTML_TRUNCATED_ATTR, CLIPBOARD_MIME, HTML_PAYLOAD_MAX_BYTES, PayloadKind, createPayload, migratePayload, parsePayload } from "./payload.js";
+import { resolvePlacement } from "./placement.js";
+//#region src/utils/table-clipboard/index.ts
+var CellType = {
+	columnName: "columnName",
+	columnDataType: "columnDataType",
+	columnNotNull: "columnNotNull",
+	columnUnique: "columnUnique",
+	columnAutoIncrement: "columnAutoIncrement",
+	columnDefault: "columnDefault",
+	columnComment: "columnComment",
+	columnLogicalName: "columnLogicalName",
+	columnDomain: "columnDomain"
+};
+var hasCellType = arrayHas(Object.values(CellType));
+function getShowColumnOrder(show, columnOrder, nameViewMode) {
+	const settings = {
+		show,
+		nameViewMode
+	};
+	const logical = isLogicalNameView(settings);
+	return columnOrder.filter((columnType) => ColumnTypeShown[columnType]?.(settings) === true).map((columnType) => logical && columnType === ColumnType.columnName ? ColumnType.columnLogicalName : columnType);
+}
+//#endregion
+export { CLIPBOARD_FORMAT, CLIPBOARD_HTML_ATTR, CLIPBOARD_HTML_TRUNCATED_ATTR, CLIPBOARD_MIME, CellType, HTML_PAYLOAD_MAX_BYTES, PayloadKind, createPayload, getShowColumnOrder, hasCellType, migratePayload, parsePayload, resolvePlacement };

package/dist/utils/table-clipboard/paste.js

@@ -0,0 +1,154 @@
+import { ColumnOption, ColumnType } from "../../constants/schema.js";
+import { arrayHas } from "../arrayHas.js";
+import { createColumn } from "../collection/tableColumn.entity.js";
+import { findDomain } from "../../engine/modules/dictionary/dictionaryIndex.js";
+import { isDomainInTypeCell } from "../../engine/modules/editor/utils/nameView.js";
+import { CLIPBOARD_HTML_ATTR, CLIPBOARD_MIME, parsePayload } from "./payload.js";
+import { CellType, getShowColumnOrder, hasCellType } from "./index.js";
+import { last } from "es-toolkit";
+//#region src/utils/table-clipboard/paste.ts
+var hasTruthy = arrayHas([
+	"true",
+	"1",
+	"yes",
+	"y"
+]);
+var hasNotNullTruthy = arrayHas([
+	"true",
+	"1",
+	"yes",
+	"y",
+	"not null"
+]);
+var CellTypeOf = {
+	[ColumnType.columnName]: CellType.columnName,
+	[ColumnType.columnLogicalName]: CellType.columnLogicalName,
+	[ColumnType.columnDataType]: CellType.columnDataType,
+	[ColumnType.columnDomain]: CellType.columnDomain,
+	[ColumnType.columnNotNull]: CellType.columnNotNull,
+	[ColumnType.columnUnique]: CellType.columnUnique,
+	[ColumnType.columnAutoIncrement]: CellType.columnAutoIncrement,
+	[ColumnType.columnDefault]: CellType.columnDefault,
+	[ColumnType.columnComment]: CellType.columnComment
+};
+var createPastedRow = () => ({
+	column: createColumn(),
+	domainName: null,
+	typed: false
+});
+function cellTypeAt(state, columnType, value) {
+	if (columnType === ColumnType.columnDataType && isDomainInTypeCell(state.settings)) return findDomain(state, value) ? CellType.columnDomain : CellType.columnDataType;
+	return CellTypeOf[columnType] ?? "";
+}
+function toPastedColumn(state, { column, domainName, typed }) {
+	if (domainName === null) return column;
+	const domain = findDomain(state, domainName);
+	column.domainId = domain?.id ?? "";
+	if (domain && !typed) column.dataType = domain.dataType;
+	return column;
+}
+function tablePasteFromTextToColumns(state, text) {
+	const { show, columnOrder, nameViewMode } = state.settings;
+	const lines = text.split(/\r?\n/);
+	if (lines.length > 1 && last(lines) === "") lines.pop();
+	const rows = lines.map((line) => line.split("	"));
+	const showColumnOrder = getShowColumnOrder(show, columnOrder, nameViewMode);
+	return rows.map((cells) => {
+		const row = createPastedRow();
+		showColumnOrder.forEach((columnType, index) => {
+			const value = cells[index];
+			if (!value) return;
+			const newValue = value.trim();
+			assignCell(row, newValue, cellTypeAt(state, columnType, newValue));
+		});
+		return toPastedColumn(state, row);
+	});
+}
+function tablePasteFromHtmlToColumns(state, html) {
+	const { show, columnOrder, nameViewMode } = state.settings;
+	const showColumnOrder = getShowColumnOrder(show, columnOrder, nameViewMode);
+	const template = document.createElement("template");
+	template.innerHTML = html;
+	const fragment = template.content;
+	return Array.from(fragment.querySelectorAll("tr")).map((row) => Array.from(row.querySelectorAll("td,th")).map((cell) => [cell.dataset?.type ?? "", cell.textContent ?? ""])).map((cells) => {
+		const row = createPastedRow();
+		showColumnOrder.forEach((columnType, index) => {
+			const cell = cells[index];
+			if (!cell) return;
+			const [type, value] = cell;
+			const newValue = value.trim();
+			assignCell(row, newValue, hasCellType(type) ? type : cellTypeAt(state, columnType, newValue));
+		});
+		cells.filter(([type]) => hasCellType(type)).forEach(([type, value]) => {
+			assignCell(row, value.trim(), type);
+		});
+		return toPastedColumn(state, row);
+	});
+}
+function readClipboardPayload(dataTransfer) {
+	const json = dataTransfer.getData(CLIPBOARD_MIME);
+	if (json) {
+		const result = parsePayload(json);
+		if (result.status !== "foreign") return result;
+	}
+	const html = dataTransfer.getData("text/html");
+	if (!html) return { status: "foreign" };
+	const template = document.createElement("template");
+	template.innerHTML = html;
+	const fragment = template.content;
+	const hidden = fragment.querySelector(`[${CLIPBOARD_HTML_ATTR}]`)?.getAttribute(CLIPBOARD_HTML_ATTR);
+	if (hidden) {
+		const result = parsePayload(hidden);
+		if (result.status !== "foreign") return result;
+	}
+	if (fragment.querySelector(`[data-erd-editor-truncated]`)) return {
+		status: "unsupported",
+		version: NaN
+	};
+	return { status: "foreign" };
+}
+function payloadToColumns({ columns }) {
+	return columns.map(({ sourceId, tableId, ui, ...rest }) => createColumn({
+		...rest,
+		ui: {
+			...ui,
+			keys: 0
+		}
+	}));
+}
+function assignCell(row, value, cellType) {
+	const { column } = row;
+	switch (cellType) {
+		case CellType.columnName:
+			column.name = value;
+			break;
+		case CellType.columnLogicalName:
+			column.logicalName = value;
+			break;
+		case CellType.columnDataType:
+			column.dataType = value;
+			row.typed = true;
+			break;
+		case CellType.columnDomain:
+			row.domainName = value;
+			break;
+		case CellType.columnDefault:
+			column.default = value;
+			break;
+		case CellType.columnComment:
+			column.comment = value;
+			break;
+		case CellType.columnAutoIncrement:
+			if (isTruthy(value)) column.options |= ColumnOption.autoIncrement;
+			break;
+		case CellType.columnUnique:
+			if (isTruthy(value)) column.options |= ColumnOption.unique;
+			break;
+		case CellType.columnNotNull: if (hasNotNullTruthy(value.trim().toLowerCase())) column.options |= ColumnOption.notNull;
+	}
+}
+function isTruthy(value) {
+	return hasTruthy(value.trim().toLowerCase());
+}
+//#endregion
+export { payloadToColumns, readClipboardPayload, tablePasteFromHtmlToColumns, tablePasteFromTextToColumns };

package/dist/utils/table-clipboard/payload.js

@@ -0,0 +1,73 @@
+import { uuid25 } from "../../uuid/dist/uuid25.js";
+import { arrayHas } from "../arrayHas.js";
+import { isNil, isNumber, isPlainObject, isString } from "es-toolkit";
+//#region src/utils/table-clipboard/payload.ts
+var CLIPBOARD_MIME = "application/x-erd-editor";
+var CLIPBOARD_FORMAT = "erd-editor-clipboard";
+var CLIPBOARD_HTML_ATTR = "data-erd-editor";
+var CLIPBOARD_HTML_TRUNCATED_ATTR = "data-erd-editor-truncated";
+var HTML_PAYLOAD_MAX_BYTES = 1e6;
+var PayloadKind = {
+	tables: "tables",
+	columns: "columns"
+};
+var hasPayloadKind = arrayHas(Object.values(PayloadKind));
+function createPayload({ kind, copyId = uuid25(), tables = [], columns = [], memos = [], relationships = [], indexes = [] }) {
+	return {
+		format: CLIPBOARD_FORMAT,
+		version: 1,
+		copyId,
+		kind,
+		tables,
+		columns,
+		memos,
+		relationships,
+		indexes
+	};
+}
+function parsePayload(json) {
+	let raw;
+	try {
+		raw = JSON.parse(json);
+	} catch {
+		return { status: "foreign" };
+	}
+	if (!isPlainObject(raw)) return { status: "foreign" };
+	if (raw.format !== "erd-editor-clipboard") return { status: "foreign" };
+	const version = isNumber(raw.version) ? raw.version : NaN;
+	if (!Number.isInteger(version)) return {
+		status: "unsupported",
+		version
+	};
+	if (version > 1) return {
+		status: "unsupported",
+		version
+	};
+	if (!isSupportedStructure(raw)) return {
+		status: "unsupported",
+		version
+	};
+	return {
+		status: "ok",
+		payload: migratePayload(raw)
+	};
+}
+function isSupportedStructure(raw) {
+	return isString(raw.kind) && hasPayloadKind(raw.kind) && Array.isArray(raw.tables) && Array.isArray(raw.columns) && Array.isArray(raw.memos) && isOptionalArray(raw.relationships) && isOptionalArray(raw.indexes);
+}
+function isOptionalArray(value) {
+	return isNil(value) || Array.isArray(value);
+}
+function migratePayload(payload) {
+	let next = payload;
+	while (next.version < 1) {
+		const from = next.version;
+		next = {
+			...next,
+			version: from + 1
+		};
+	}
+	return next;
+}
+//#endregion
+export { CLIPBOARD_FORMAT, CLIPBOARD_HTML_ATTR, CLIPBOARD_HTML_TRUNCATED_ATTR, CLIPBOARD_MIME, HTML_PAYLOAD_MAX_BYTES, PayloadKind, createPayload, migratePayload, parsePayload };

package/dist/utils/table-clipboard/placement.js

@@ -0,0 +1,54 @@
+import { nextPoint, nextZIndex } from "../index.js";
+//#region src/utils/table-clipboard/placement.ts
+var toKey = ({ x, y }) => `${x},${y}`;
+var compareId = (a, b) => a < b ? -1 : a > b ? 1 : 0;
+var kindRank = ({ kind }) => kind === "memo" ? 1 : 0;
+var toZIndex = (entity) => entity.ui.zIndex ?? 0;
+function resolvePlacement({ entities, offset, escapeCollision, settings, tables, memos, findSource }) {
+	const placement = /* @__PURE__ */ new Map();
+	if (entities.length === 0) return placement;
+	const taken = new Set([...tables, ...memos].map(({ ui }) => toKey(ui)));
+	const points = /* @__PURE__ */ new Map();
+	const absent = [];
+	for (const entity of entities) {
+		const source = findSource(entity.sourceId);
+		if (source) points.set(entity.sourceId, {
+			x: source.ui.x + offset.x,
+			y: source.ui.y + offset.y
+		});
+		else absent.push(entity);
+	}
+	if (absent.length !== 0) {
+		const anchor = nextPoint(settings, tables, memos);
+		const originRef = absent.reduce((acc, entity) => entity.ui.x < acc.ui.x || entity.ui.x === acc.ui.x && entity.ui.y < acc.ui.y ? entity : acc);
+		for (const entity of absent) points.set(entity.sourceId, {
+			x: anchor.x + (entity.ui.x - originRef.ui.x),
+			y: anchor.y + (entity.ui.y - originRef.ui.y)
+		});
+	}
+	if (escapeCollision) {
+		const ordered = [...entities].sort((a, b) => compareId(a.sourceId, b.sourceId));
+		for (const { sourceId } of ordered) {
+			const point = points.get(sourceId);
+			if (!point) continue;
+			while (taken.has(toKey(point))) {
+				point.x += 50;
+				point.y += 50;
+			}
+			taken.add(toKey(point));
+		}
+	}
+	const baseZIndex = nextZIndex(tables, memos);
+	[...entities].sort((a, b) => toZIndex(a) - toZIndex(b) || kindRank(a) - kindRank(b) || compareId(a.sourceId, b.sourceId)).forEach(({ sourceId }, index) => {
+		const point = points.get(sourceId);
+		if (!point) return;
+		placement.set(sourceId, {
+			x: point.x,
+			y: point.y,
+			zIndex: baseZIndex + index
+		});
+	});
+	return placement;
+}
+//#endregion
+export { resolvePlacement };

package/dist/utils/tableColor.js

@@ -0,0 +1,139 @@
+//#region src/utils/tableColor.ts
+var AML_COLORS = {
+	red: "#ef4444",
+	orange: "#f97316",
+	amber: "#f59e0b",
+	yellow: "#eab308",
+	lime: "#84cc16",
+	green: "#22c55e",
+	emerald: "#10b981",
+	teal: "#14b8a6",
+	cyan: "#06b6d4",
+	sky: "#0ea5e9",
+	blue: "#3b82f6",
+	indigo: "#6366f1",
+	violet: "#8b5cf6",
+	purple: "#a855f7",
+	fuchsia: "#d946ef",
+	pink: "#ec4899",
+	rose: "#f43f5e",
+	gray: "#6b7280"
+};
+var DBML_HEX = /^#(?:[0-9a-f]{3}|[0-9a-f]{6})$/i;
+var AML_HEX = /^#(?:[0-9a-f]{3}|[0-9a-f]{6}|[0-9a-f]{8})$/i;
+var ANY_HEX = /^#(?:[0-9a-f]{3,4}|[0-9a-f]{6}|[0-9a-f]{8})$/i;
+var COLOR_FUNCTION = /^(rgba?|hsla?)\(([^()]*)\)$/i;
+var ARGUMENT_SEPARATOR = /\s*[,/]\s*|\s+/;
+var NUMBER = /^[+-]?(?:\d+\.?\d*|\.\d+)(?:e[+-]?\d+)?$/i;
+var ANGLE_UNIT = /deg$/i;
+var PERCENT = /%$/;
+var AML_COLOR_BY_NAME = new Map(Object.entries(AML_COLORS));
+var GRAY_CHROMA = .04;
+function fromDBMLColor(value) {
+	return DBML_HEX.test(value) ? value : "";
+}
+function fromAMLColor(value) {
+	return AML_COLOR_BY_NAME.get(value.toLowerCase()) ?? (AML_HEX.test(value) ? value : "");
+}
+function toDBMLColor(color) {
+	const value = color.trim();
+	if (ANY_HEX.test(value)) return value.length - 1 === 4 ? value.slice(0, 4) : value.slice(0, 7);
+	const channels = channelsOf(value);
+	return channels ? toHex(channels) : null;
+}
+function toAMLColor(color) {
+	const channels = channelsOf(color.trim());
+	if (!channels) return null;
+	const [, a, b] = oklabOf(channels);
+	if (Math.hypot(a, b) < GRAY_CHROMA) return "gray";
+	const hue = Math.atan2(b, a);
+	let nearest = null;
+	let nearestDistance = Infinity;
+	for (const [name, hex] of AML_COLOR_BY_NAME) {
+		if (name === "gray") continue;
+		const [, namedA, namedB] = oklabOf(hexChannels(hex.slice(1)));
+		const turn = Math.abs(hue - Math.atan2(namedB, namedA));
+		const distance = Math.min(turn, 2 * Math.PI - turn);
+		if (distance < nearestDistance) {
+			nearest = name;
+			nearestDistance = distance;
+		}
+	}
+	return nearest;
+}
+function toOpaqueHex(color) {
+	const channels = channelsOf(color.trim());
+	return channels ? toHex(channels) : null;
+}
+function channelsOf(value) {
+	if (ANY_HEX.test(value)) return hexChannels(value.slice(1));
+	const match = COLOR_FUNCTION.exec(value);
+	if (!match) return null;
+	const args = match[2].trim().split(ARGUMENT_SEPARATOR);
+	if (args.length < 3) return null;
+	return match[1].toLowerCase().startsWith("rgb") ? rgbChannels(args) : hslChannels(args);
+}
+function hexChannels(digits) {
+	const full = digits.length <= 4 ? [...digits].map((digit) => `${digit}${digit}`).join("") : digits;
+	return [
+		0,
+		2,
+		4
+	].map((offset) => parseInt(full.slice(offset, offset + 2), 16));
+}
+function rgbChannels(args) {
+	const channels = [];
+	for (const arg of args.slice(0, 3)) {
+		const percent = arg.endsWith("%");
+		const value = numberOf(percent ? arg.slice(0, -1) : arg);
+		if (value === null) return null;
+		channels.push(clampChannel(percent ? value * 2.55 : value));
+	}
+	return channels;
+}
+function hslChannels(args) {
+	const hue = numberOf(args[0].replace(ANGLE_UNIT, ""));
+	const saturation = numberOf(args[1].replace(PERCENT, ""));
+	const lightness = numberOf(args[2].replace(PERCENT, ""));
+	if (hue === null || saturation === null || lightness === null) return null;
+	if (!Number.isFinite(hue)) return null;
+	const h = (hue % 360 + 360) % 360;
+	const s = Math.min(Math.max(saturation, 0), 100) / 100;
+	const l = Math.min(Math.max(lightness, 0), 100) / 100;
+	const a = s * Math.min(l, 1 - l);
+	const f = (n) => {
+		const k = (n + h / 30) % 12;
+		return l - a * Math.max(-1, Math.min(k - 3, 9 - k, 1));
+	};
+	return [
+		f(0),
+		f(8),
+		f(4)
+	].map((value) => clampChannel(value * 255));
+}
+function oklabOf(channels) {
+	const [r, g, b] = channels.map(toLinear);
+	const l = Math.cbrt(.4122214708 * r + .5363325363 * g + .0514459929 * b);
+	const m = Math.cbrt(.2119034982 * r + .6806995451 * g + .1073969566 * b);
+	const s = Math.cbrt(.0883024619 * r + .2817188376 * g + .6299787005 * b);
+	return [
+		.2104542553 * l + .793617785 * m - .0040720468 * s,
+		1.9779984951 * l - 2.428592205 * m + .4505937099 * s,
+		.0259040371 * l + .7827717662 * m - .808675766 * s
+	];
+}
+function toLinear(channel) {
+	const value = channel / 255;
+	return value <= .04045 ? value / 12.92 : ((value + .055) / 1.055) ** 2.4;
+}
+function numberOf(text) {
+	return NUMBER.test(text) ? Number(text) : null;
+}
+function clampChannel(value) {
+	return Math.round(Math.min(Math.max(value, 0), 255));
+}
+function toHex(channels) {
+	return `#${channels.map((value) => value.toString(16).padStart(2, "0")).join("")}`;
+}
+//#endregion
+export { AML_COLORS, fromAMLColor, fromDBMLColor, toAMLColor, toDBMLColor, toLinear, toOpaqueHex };