@dineug/erd-editor 4.2.0 → 5.0.0

package/dist/utils/calcTable.js

@@ -0,0 +1,220 @@
+import { COLUMN_ALTERNATE_KEY_CHAR_WIDTH, VIEW_TABLE_HEADER_FONT_SCALE, VIEW_TABLE_HEADER_WEIGHT_SCALE } from "../constants/layout.js";
+import { query } from "../erd-editor-schema/dist/query/index.js";
+import { Show } from "../constants/schema.js";
+import { textInRange } from "./validation.js";
+import { observable } from "../r-html/dist/observable/index.js";
+import { getLiveDomainName } from "../engine/modules/dictionary/membership.js";
+import { FocusType } from "../engine/modules/editor/state.js";
+import { bHas } from "./bit.js";
+import { drawsDomainInTypeCell, drawsNameForLogicalName, getTableFocusTypes, isBothNameView, isLogicalNameView, sceneNameSettings } from "../engine/modules/editor/utils/nameView.js";
+import { getAlternateKeyMarks } from "./tableKeys.js";
+//#region src/utils/calcTable.ts
+var widthGeneration = 0;
+var widthSignal = observable({ generation: 0 });
+function getWidthGeneration() {
+	return widthGeneration;
+}
+function trackTableWidths() {
+	return widthSignal.generation;
+}
+function invalidateTableWidths() {
+	widthGeneration++;
+	widthSignal.generation = widthGeneration;
+}
+function calcAlternateKeyWidth(table, state) {
+	if (!bHas(state.settings.show, Show.columnAlternateKey)) return 0;
+	return Object.values(getAlternateKeyMarks(state, table)).reduce((width, mark) => Math.max(width, Math.ceil(mark.length * COLUMN_ALTERNATE_KEY_CHAR_WIDTH)), 0);
+}
+function headerCellWidth(state, table, focusType) {
+	const { settings } = state;
+	switch (focusType) {
+		case FocusType.tableComment: return settings.maxWidthComment === -1 || settings.maxWidthComment >= table.ui.widthComment ? table.ui.widthComment : settings.maxWidthComment;
+		case FocusType.tableLogicalName: return drawsNameForLogicalName(settings, table) ? table.ui.widthName : table.ui.widthLogicalName;
+		default: return table.ui.widthName;
+	}
+}
+function calcTableWidths(table, state) {
+	const { settings, collections } = state;
+	let width = getTableFocusTypes(settings).reduce((acc, focusType) => acc + headerCellWidth(state, table, focusType) + 8, 20);
+	width += 28;
+	const alternateKey = calcAlternateKeyWidth(table, state);
+	const defaultWidthColumns = calcDefaultWidthColumns(settings) + (alternateKey ? alternateKey + 8 : 0);
+	if (width < defaultWidthColumns) width = defaultWidthColumns;
+	const maxWidthColumn = calcMaxWidthColumn(query(collections).collection("tableColumnEntities").selectByIds(table.columnIds), state, alternateKey);
+	if (width < maxWidthColumn.width) width = maxWidthColumn.width;
+	return {
+		...maxWidthColumn,
+		width: 9 + width + 8 + 1
+	};
+}
+var DEFAULT_WIDTH_COLUMNS = [
+	{
+		key: Show.columnComment,
+		width: 60
+	},
+	{
+		key: Show.columnDataType,
+		width: 60
+	},
+	{
+		key: Show.columnDomain,
+		width: 60
+	},
+	{
+		key: Show.columnDefault,
+		width: 60
+	},
+	{
+		key: Show.columnNotNull,
+		width: 35
+	},
+	{
+		key: Show.columnAutoIncrement,
+		width: 15
+	},
+	{
+		key: Show.columnUnique,
+		width: 22
+	}
+];
+function calcDefaultWidthColumns(settings) {
+	const shown = DEFAULT_WIDTH_COLUMNS.reduce((acc, { key, width }) => bHas(settings.show, key) ? acc + width + 8 : acc, 100);
+	return isBothNameView(settings) ? shown + 60 + 8 : shown;
+}
+function createColumnWidth() {
+	return {
+		width: 0,
+		alternateKey: 0,
+		name: 0,
+		logicalName: 0,
+		comment: 0,
+		dataType: 0,
+		domain: 0,
+		default: 0,
+		notNull: 0,
+		autoIncrement: 0,
+		unique: 0
+	};
+}
+function calcMaxWidthColumn(columns, state, alternateKey) {
+	const { settings } = state;
+	const { show, maxWidthComment } = settings;
+	const logical = isLogicalNameView(settings);
+	const both = isBothNameView(settings);
+	const columnWidth = createColumnWidth();
+	columnWidth.alternateKey = alternateKey;
+	for (const column of columns) {
+		const widthName = logical && !drawsNameForLogicalName(settings, column) ? column.ui.widthLogicalName : column.ui.widthName;
+		if (columnWidth.name < widthName) columnWidth.name = widthName;
+		if (both && columnWidth.logicalName < column.ui.widthLogicalName) columnWidth.logicalName = column.ui.widthLogicalName;
+		if (bHas(show, Show.columnComment) && columnWidth.comment < column.ui.widthComment) columnWidth.comment = maxWidthComment === -1 ? column.ui.widthComment : maxWidthComment < column.ui.widthComment ? maxWidthComment : column.ui.widthComment;
+		if (bHas(show, Show.columnDataType)) {
+			const widthDataType = drawsDomainInTypeCell(state, column) ? column.ui.widthDomain : column.ui.widthDataType;
+			if (columnWidth.dataType < widthDataType) columnWidth.dataType = widthDataType;
+		}
+		if (bHas(show, Show.columnDomain) && columnWidth.domain < column.ui.widthDomain) columnWidth.domain = column.ui.widthDomain;
+		if (bHas(show, Show.columnDefault) && columnWidth.default < column.ui.widthDefault) columnWidth.default = column.ui.widthDefault;
+	}
+	if (bHas(show, Show.columnNotNull)) columnWidth.notNull = 35;
+	if (bHas(show, Show.columnAutoIncrement)) columnWidth.autoIncrement = 15;
+	if (bHas(show, Show.columnUnique)) columnWidth.unique = 22;
+	columnWidth.width = Object.entries(columnWidth).reduce((acc, [key, width]) => {
+		if (key === "width" || width === 0) return acc;
+		return acc + width + 8;
+	}, 32);
+	return columnWidth;
+}
+function calcViewTableWidths(table, state, columnIds) {
+	const { settings } = state;
+	const logical = isLogicalNameView(settings);
+	const both = isBothNameView(settings);
+	const columnWidth = createColumnWidth();
+	const columns = query(state.collections).collection("tableColumnEntities").selectByIds(columnIds);
+	for (const column of columns) {
+		columnWidth.name = Math.max(columnWidth.name, logical && !drawsNameForLogicalName(settings, column) ? column.ui.widthLogicalName : column.ui.widthName);
+		columnWidth.dataType = Math.max(columnWidth.dataType, drawsDomainInTypeCell(state, column, "flow") ? column.ui.widthDomain : column.ui.widthDataType);
+		if (both) {
+			columnWidth.logicalName = Math.max(columnWidth.logicalName, column.ui.widthLogicalName);
+			columnWidth.domain = Math.max(columnWidth.domain, column.ui.widthDomain);
+		}
+	}
+	const cells = both ? [
+		columnWidth.logicalName,
+		columnWidth.name,
+		columnWidth.domain,
+		columnWidth.dataType
+	] : [columnWidth.name, columnWidth.dataType];
+	const rowWidth = columns.length ? cells.reduce((acc, width) => acc + 8 + width, 14) : 0;
+	const chrome = 18;
+	const content = Math.max(viewHeaderWidth(table, state), rowWidth, 154);
+	if (columns.length) columnWidth.name += content - rowWidth;
+	columnWidth.width = chrome + content;
+	return columnWidth;
+}
+function viewHeaderNameWidth(widthName) {
+	return Math.ceil(widthName * VIEW_TABLE_HEADER_FONT_SCALE * VIEW_TABLE_HEADER_WEIGHT_SCALE);
+}
+function viewHeaderWidth(table, state) {
+	return getTableFocusTypes(sceneNameSettings(state.settings, "flow")).reduce((acc, focusType) => acc + viewHeaderNameWidth(headerCellWidth(state, table, focusType)) + 8, 20) + 28;
+}
+function tableHeaderHeight(source = "document") {
+	return source === "document" ? 20 : 24;
+}
+function tableRowHeight(source = "document") {
+	return source === "document" ? 24 : 32;
+}
+function calcTableHeight(table, rowCount = table.columnIds.length, source = "document") {
+	return 9 + tableHeaderHeight(source) + rowCount * tableRowHeight(source) + 1;
+}
+var tableTextWidths = (table, toWidth) => ({
+	widthName: textInRange(toWidth(table.name)),
+	widthLogicalName: textInRange(toWidth(table.logicalName)),
+	widthComment: textInRange(toWidth(table.comment))
+});
+var columnTextWidths = (state, column, toWidth) => ({
+	widthName: textInRange(toWidth(column.name)),
+	widthLogicalName: textInRange(toWidth(column.logicalName)),
+	widthDataType: textInRange(toWidth(column.dataType)),
+	widthDomain: textInRange(toWidth(getLiveDomainName(state, column.domainId))),
+	widthDefault: textInRange(toWidth(column.default)),
+	widthComment: textInRange(toWidth(column.comment))
+});
+function recalculateTableWidth(state, { toWidth }) {
+	const { doc: { tableIds }, collections } = state;
+	invalidateTableWidths();
+	const tables = query(collections).collection("tableEntities").selectByIds(tableIds);
+	const columnCollection = query(collections).collection("tableColumnEntities");
+	for (const table of tables) {
+		Object.assign(table.ui, tableTextWidths(table, toWidth));
+		const columns = columnCollection.selectByIds(table.columnIds);
+		for (const column of columns) Object.assign(column.ui, columnTextWidths(state, column, toWidth));
+	}
+}
+function measureTableSize(table, state, toWidth) {
+	const columns = query(state.collections).collection("tableColumnEntities").selectByIds(table.columnIds).map((column) => ({
+		...column,
+		ui: {
+			...column.ui,
+			...columnTextWidths(state, column, toWidth)
+		}
+	}));
+	const measured = {
+		...table,
+		ui: {
+			...table.ui,
+			...tableTextWidths(table, toWidth)
+		}
+	};
+	return {
+		width: calcTableWidths(measured, {
+			...state,
+			collections: {
+				...state.collections,
+				tableColumnEntities: Object.fromEntries(columns.map((column) => [column.id, column]))
+			}
+		}).width,
+		height: calcTableHeight(measured)
+	};
+}
+//#endregion
+export { calcAlternateKeyWidth, calcTableHeight, calcTableWidths, calcViewTableWidths, getWidthGeneration, headerCellWidth, invalidateTableWidths, measureTableSize, recalculateTableWidth, tableHeaderHeight, tableRowHeight, trackTableWidths, viewHeaderNameWidth };

package/dist/utils/clickGesture.js

@@ -0,0 +1,33 @@
+import { isMod } from "./keyboard-shortcut/index.js";
+import { isMainButtonPress, isMouseEvent, isMultiTouch } from "./domEvent.js";
+import { moveEnd$ } from "./globalEventObservable.js";
+import { take } from "rxjs";
+function pointOf(evt) {
+	if (isMouseEvent(evt)) return {
+		x: evt.clientX,
+		y: evt.clientY
+	};
+	const { touches, changedTouches } = evt;
+	const touch = touches?.[0] ?? changedTouches?.[0];
+	return touch ? {
+		x: touch.clientX,
+		y: touch.clientY
+	} : null;
+}
+var isLift = (evt) => evt.type === "mouseup" || evt.type === "touchend" && !evt.touches?.length;
+function isClick(from, to) {
+	return Math.abs(to.x - from.x) <= 4 && Math.abs(to.y - from.y) <= 4;
+}
+function isPlainPress(evt) {
+	return !isMod(evt) && isMainButtonPress(evt);
+}
+function onClickRelease(evt, done) {
+	const from = pointOf(evt);
+	if (!from || isMultiTouch(evt)) return;
+	moveEnd$.pipe(take(1)).subscribe((end) => {
+		const to = isLift(end) ? pointOf(end) : null;
+		if (to && isClick(from, to)) done();
+	});
+}
+//#endregion
+export { isClick, isPlainPress, onClickRelease, pointOf };

package/dist/utils/clipboard.js

@@ -0,0 +1,45 @@
+//#region src/utils/clipboard.ts
+function fallbackCopyTextToClipboard(value) {
+	return new Promise((resolve, reject) => {
+		const textarea = document.createElement("textarea");
+		textarea.style.fontSize = "12pt";
+		textarea.style.border = "0";
+		textarea.style.padding = "0";
+		textarea.style.margin = "0";
+		textarea.style.position = "fixed";
+		textarea.style.left = "-9999px";
+		textarea.style.top = "-9999px";
+		textarea.setAttribute("readonly", "");
+		textarea.value = value;
+		document.body.appendChild(textarea);
+		textarea.select();
+		textarea.setSelectionRange(0, 99999);
+		try {
+			document.execCommand("copy") ? resolve() : reject(/* @__PURE__ */ new Error("the browser refused to copy"));
+		} catch (error) {
+			reject(error);
+		}
+		textarea.setSelectionRange(0, 0);
+		document.body.removeChild(textarea);
+	});
+}
+async function copyToClipboard(value) {
+	if (!navigator.clipboard) return fallbackCopyTextToClipboard(value);
+	try {
+		await navigator.clipboard.writeText(value);
+	} catch (error) {
+		return fallbackCopyTextToClipboard(value);
+	}
+}
+function copyImageToClipboard(createPng) {
+	if (typeof ClipboardItem === "undefined" || !navigator.clipboard?.write) return Promise.reject(/* @__PURE__ */ new Error("[clipboard] this host puts no image on the clipboard"));
+	const png = createPng();
+	try {
+		return navigator.clipboard.write([new ClipboardItem({ "image/png": png })]);
+	} catch (error) {
+		png.catch(() => {});
+		return Promise.reject(error);
+	}
+}
+//#endregion
+export { copyImageToClipboard, copyToClipboard };

package/dist/utils/collection/domain.entity.js

@@ -0,0 +1,13 @@
+import { uuid25 } from "../../uuid/dist/uuid25.js";
+import { deepMerge } from "../deepMerge.js";
+//#region src/utils/collection/domain.entity.ts
+var createDomain = (value) => deepMerge({
+	id: uuid25(),
+	name: "",
+	category: "",
+	dataType: "",
+	description: "",
+	order: ""
+}, value ?? {});
+//#endregion
+export { createDomain };

package/dist/utils/collection/index.entity.js

@@ -0,0 +1,13 @@
+import { uuid25 } from "../../uuid/dist/uuid25.js";
+import { deepMerge } from "../deepMerge.js";
+//#region src/utils/collection/index.entity.ts
+var createIndex = (value) => deepMerge({
+	id: uuid25(),
+	name: "",
+	tableId: "",
+	indexColumnIds: [],
+	seqIndexColumnIds: [],
+	unique: false
+}, value ?? {});
+//#endregion
+export { createIndex };

package/dist/utils/collection/indexColumn.entity.js

@@ -0,0 +1,12 @@
+import { uuid25 } from "../../uuid/dist/uuid25.js";
+import { OrderType } from "../../constants/schema.js";
+import { deepMerge } from "../deepMerge.js";
+//#region src/utils/collection/indexColumn.entity.ts
+var createIndexColumn = (value) => deepMerge({
+	id: uuid25(),
+	indexId: "",
+	columnId: "",
+	orderType: OrderType.ASC
+}, value ?? {});
+//#endregion
+export { createIndexColumn };

package/dist/utils/collection/memo.entity.js

@@ -0,0 +1,18 @@
+import "../../constants/layout.js";
+import { uuid25 } from "../../uuid/dist/uuid25.js";
+import { deepMerge } from "../deepMerge.js";
+//#region src/utils/collection/memo.entity.ts
+var createMemo = (value) => deepMerge({
+	id: uuid25(),
+	value: "",
+	ui: {
+		x: 200,
+		y: 100,
+		zIndex: 2,
+		width: 116,
+		height: 100,
+		color: ""
+	}
+}, value ?? {});
+//#endregion
+export { createMemo };

package/dist/utils/collection/relationship.entity.js

@@ -0,0 +1,28 @@
+import { uuid25 } from "../../uuid/dist/uuid25.js";
+import { Direction, ReferentialAction, RelationshipType, StartRelationshipType } from "../../constants/schema.js";
+import { deepMerge } from "../deepMerge.js";
+//#region src/utils/collection/relationship.entity.ts
+var createRelationship = (value) => deepMerge({
+	id: uuid25(),
+	identification: false,
+	relationshipType: RelationshipType.ZeroN,
+	startRelationshipType: StartRelationshipType.dash,
+	onDelete: ReferentialAction.none,
+	onUpdate: ReferentialAction.none,
+	start: {
+		tableId: "",
+		columnIds: [],
+		x: 0,
+		y: 0,
+		direction: Direction.bottom
+	},
+	end: {
+		tableId: "",
+		columnIds: [],
+		x: 0,
+		y: 0,
+		direction: Direction.bottom
+	}
+}, value ?? {});
+//#endregion
+export { createRelationship };

package/dist/utils/collection/sequence.js

@@ -0,0 +1,21 @@
+import { arrayHas } from "../arrayHas.js";
+//#region src/utils/collection/sequence.ts
+function addAndSort(ids, seqIds, id) {
+	if (arrayHas(seqIds)(id)) {
+		const idIndices = seqIds.reduce((acc, cur, index) => {
+			acc[cur] = index;
+			return acc;
+		}, {});
+		ids.push(id);
+		ids.sort((a, b) => {
+			const indexA = idIndices[a];
+			const indexB = idIndices[b];
+			return indexA === void 0 ? 1 : indexB === void 0 ? -1 : indexA - indexB;
+		});
+	} else {
+		ids.push(id);
+		seqIds.push(id);
+	}
+}
+//#endregion
+export { addAndSort };

package/dist/utils/collection/table.entity.js

@@ -0,0 +1,24 @@
+import { uuid25 } from "../../uuid/dist/uuid25.js";
+import { deepMerge } from "../deepMerge.js";
+//#region src/utils/collection/table.entity.ts
+var createTable = (value) => deepMerge({
+	id: uuid25(),
+	name: "",
+	logicalName: "",
+	comment: "",
+	columnIds: [],
+	seqColumnIds: [],
+	groupId: "",
+	nameDerived: false,
+	ui: {
+		x: 200,
+		y: 100,
+		zIndex: 2,
+		widthName: 60,
+		widthLogicalName: 60,
+		widthComment: 60,
+		color: ""
+	}
+}, value ?? {});
+//#endregion
+export { createTable };

package/dist/utils/collection/tableColumn.entity.js

@@ -0,0 +1,25 @@
+import { uuid25 } from "../../uuid/dist/uuid25.js";
+import { deepMerge } from "../deepMerge.js";
+//#region src/utils/collection/tableColumn.entity.ts
+var createColumn = (value) => deepMerge({
+	id: uuid25(),
+	tableId: "",
+	name: "",
+	comment: "",
+	dataType: "",
+	default: "",
+	options: 0,
+	logicalName: "",
+	domainId: "",
+	ui: {
+		keys: 0,
+		widthName: 60,
+		widthLogicalName: 60,
+		widthComment: 60,
+		widthDataType: 60,
+		widthDomain: 60,
+		widthDefault: 60
+	}
+}, value ?? {});
+//#endregion
+export { createColumn };

package/dist/utils/collection/tableGroup.entity.js

@@ -0,0 +1,17 @@
+import { uuid25 } from "../../uuid/dist/uuid25.js";
+import { deepMerge } from "../deepMerge.js";
+//#region src/utils/collection/tableGroup.entity.ts
+var createTableGroup = (value) => deepMerge({
+	id: uuid25(),
+	name: "",
+	color: "",
+	ui: {
+		x: 200,
+		y: 100,
+		width: 400,
+		height: 300,
+		zIndex: 1
+	}
+}, value ?? {});
+//#endregion
+export { createTableGroup };

package/dist/utils/collection/term.entity.js

@@ -0,0 +1,14 @@
+import { uuid25 } from "../../uuid/dist/uuid25.js";
+import { deepMerge } from "../deepMerge.js";
+//#region src/utils/collection/term.entity.ts
+var createTerm = (value) => deepMerge({
+	id: uuid25(),
+	name: "",
+	physicalName: "",
+	domainId: "",
+	description: "",
+	synonyms: "",
+	order: ""
+}, value ?? {});
+//#endregion
+export { createTerm };

package/dist/utils/collection/word.entity.js

@@ -0,0 +1,15 @@
+import { uuid25 } from "../../uuid/dist/uuid25.js";
+import { deepMerge } from "../deepMerge.js";
+//#region src/utils/collection/word.entity.ts
+var createWord = (value) => deepMerge({
+	id: uuid25(),
+	name: "",
+	abbreviation: "",
+	englishName: "",
+	description: "",
+	synonyms: "",
+	forbiddenWords: "",
+	order: ""
+}, value ?? {});
+//#endregion
+export { createWord };

package/dist/utils/contrastText.js

@@ -0,0 +1,26 @@
+import { toLinear, toOpaqueHex } from "./tableColor.js";
+//#region src/utils/contrastText.ts
+var CONTRAST_BLACK = "#000000";
+var CONTRAST_WHITE = "#ffffff";
+function relativeLuminance(color) {
+	const hex = toOpaqueHex(color);
+	if (!hex) return null;
+	const [r, g, b] = [
+		1,
+		3,
+		5
+	].map((offset) => toLinear(parseInt(hex.slice(offset, offset + 2), 16)));
+	return .2126 * r + .7152 * g + .0722 * b;
+}
+function contrastRatio(a, b) {
+	return (Math.max(a, b) + .05) / (Math.min(a, b) + .05);
+}
+var BLACK_MIN_LEAD = 4;
+function contrastTextColor(background) {
+	const luminance = relativeLuminance(background);
+	if (luminance === null) return null;
+	const white = contrastRatio(luminance, 1);
+	return contrastRatio(luminance, 0) - white > BLACK_MIN_LEAD ? CONTRAST_BLACK : CONTRAST_WHITE;
+}
+//#endregion
+export { CONTRAST_BLACK, CONTRAST_WHITE, contrastRatio, contrastTextColor, relativeLuminance };

package/dist/utils/deepMerge.js

@@ -0,0 +1,24 @@
+//#region src/utils/deepMerge.ts
+var isMergeable = (value) => typeof value === "object" && value !== null;
+var hasKey = (target, key) => isMergeable(target) && key in target;
+var isUnsafeKey = (target, key) => hasKey(target, key) && !Object.prototype.propertyIsEnumerable.call(target, key);
+var clone = (value) => isMergeable(value) ? merge(Array.isArray(value) ? [] : {}, value) : value;
+function mergeObject(target, source) {
+	const destination = {};
+	if (isMergeable(target)) for (const key of Object.keys(target)) destination[key] = clone(target[key]);
+	for (const key of Object.keys(source)) {
+		if (isUnsafeKey(target, key)) continue;
+		destination[key] = hasKey(target, key) && isMergeable(source[key]) ? merge(target[key], source[key]) : clone(source[key]);
+	}
+	return destination;
+}
+function merge(target, source) {
+	const sourceIsArray = Array.isArray(source);
+	if (sourceIsArray !== Array.isArray(target)) return clone(source);
+	return sourceIsArray ? target.concat(source).map(clone) : mergeObject(target, source);
+}
+function deepMerge(target, source) {
+	return merge(target, source);
+}
+//#endregion
+export { deepMerge };

package/dist/utils/device-detect/index.js

@@ -0,0 +1,6 @@
+//#region src/utils/device-detect/index.ts
+var readPlatform = () => typeof navigator === "object" ? navigator.platform : "";
+var hasAppleDevice = () => /Mac|iPod|iPhone|iPad/.test(readPlatform());
+var hasWindows = () => readPlatform() === "Win32";
+//#endregion
+export { hasAppleDevice, hasWindows };

package/dist/utils/dictionary-csv/csv.js

@@ -0,0 +1,61 @@
+//#region src/utils/dictionary-csv/csv.ts
+var QUOTE = 34;
+var COMMA = 44;
+var LF = 10;
+var CR = 13;
+var BOM = 65279;
+var NEEDS_QUOTES = /[",\r\n]/;
+function parseCsv(text) {
+	const records = [];
+	const end = text.length;
+	let index = text.charCodeAt(0) === BOM ? 1 : 0;
+	let record = [];
+	while (index < end) {
+		let value = "";
+		if (text.charCodeAt(index) === QUOTE) {
+			index++;
+			for (;;) {
+				const close = text.indexOf("\"", index);
+				if (close === -1) {
+					value += text.slice(index);
+					index = end;
+					break;
+				}
+				value += text.slice(index, close);
+				index = close + 1;
+				if (text.charCodeAt(index) !== QUOTE) break;
+				value += "\"";
+				index++;
+			}
+		}
+		let stop = index;
+		while (stop < end) {
+			const code = text.charCodeAt(stop);
+			if (code === COMMA || code === LF || code === CR) break;
+			stop++;
+		}
+		record.push(value + text.slice(index, stop));
+		index = stop;
+		if (text.charCodeAt(index) === COMMA) {
+			index++;
+			if (index === end) record.push("");
+			continue;
+		}
+		const crlf = text.charCodeAt(index) === CR && text.charCodeAt(index + 1) === LF;
+		index += crlf ? 2 : 1;
+		if (record.length > 1 || record[0] !== "") records.push(record);
+		record = [];
+	}
+	if (record.length) records.push(record);
+	return records;
+}
+function serializeCsv(records) {
+	let text = String.fromCharCode(BOM);
+	for (const record of records) text += `${record.map(quoteField).join(",")}\r\n`;
+	return text;
+}
+function quoteField(value) {
+	return NEEDS_QUOTES.test(value) ? `"${value.replaceAll("\"", "\"\"")}"` : value;
+}
+//#endregion
+export { parseCsv, serializeCsv };

package/dist/utils/dictionary-csv/decode.js

@@ -0,0 +1,10 @@
+//#region src/utils/dictionary-csv/decode.ts
+function decodeCsvBytes(bytes) {
+	try {
+		return new TextDecoder("utf-8", { fatal: true }).decode(bytes);
+	} catch {
+		return new TextDecoder("euc-kr").decode(bytes);
+	}
+}
+//#endregion
+export { decodeCsvBytes };