@dineug/erd-editor 4.2.0 → 5.0.0

package/dist/r-html/dist/template/vCSSStyleSheet.js

@@ -0,0 +1,162 @@
+//#region ../r-html/dist/template/vCSSStyleSheet.js
+var cssSharedContext = {
+	vCSSStyleSheetMap: /* @__PURE__ */ new Map(),
+	hostContextMap: /* @__PURE__ */ new Map(),
+	globalOrder: [],
+	orderedSheets: null
+};
+var supportsAdoptingStyleSheets = globalThis.ShadowRoot && "adoptedStyleSheets" in Document.prototype && "replace" in CSSStyleSheet.prototype;
+var hostSheetsMap = /* @__PURE__ */ new WeakMap();
+var rootOfElement = /* @__PURE__ */ new WeakMap();
+var mutableAdoptedStyleSheets = null;
+function supportsMutatingAdoptedStyleSheets() {
+	if (mutableAdoptedStyleSheets === null) mutableAdoptedStyleSheets = detectMutableAdoptedStyleSheets();
+	return mutableAdoptedStyleSheets;
+}
+function detectMutableAdoptedStyleSheets() {
+	try {
+		const probe = document.createElement("div").attachShadow({ mode: "open" });
+		const sheet = new CSSStyleSheet();
+		probe.adoptedStyleSheets.push(sheet);
+		return probe.adoptedStyleSheets.length === 1 && probe.adoptedStyleSheets[0] === sheet;
+	} catch {
+		return false;
+	}
+}
+function getCSSSharedContext() {
+	return cssSharedContext;
+}
+function setGlobalStyleOrder(order) {
+	const ctx = getCSSSharedContext();
+	ctx.globalOrder = order.map(String);
+	ctx.orderedSheets = null;
+	updateSheets();
+	if (supportsAdoptingStyleSheets && ctx.hostContextMap.size > 0) invalidateGlobalRules(ctx);
+}
+function invalidateGlobalRules(ctx) {
+	ctx.vCSSStyleSheetMap.forEach(({ mode, sheet, cssText }) => {
+		if (mode === "global" && sheet) sheet.replaceSync(cssText);
+	});
+}
+function vRender(compiled) {
+	const ctx = getCSSSharedContext();
+	const { identifier, cssText, mode } = compiled;
+	if (!cssText || ctx.vCSSStyleSheetMap.has(identifier)) return identifier;
+	const sheet = supportsAdoptingStyleSheets ? new CSSStyleSheet() : null;
+	const styleElement = supportsAdoptingStyleSheets ? null : document.createElement("style");
+	if (sheet) sheet.replaceSync(cssText);
+	else if (styleElement) styleElement.textContent = cssText;
+	const vCSSStyleSheet = {
+		identifier,
+		cssText,
+		mode,
+		sheet,
+		styleElement
+	};
+	ctx.vCSSStyleSheetMap.set(identifier, vCSSStyleSheet);
+	addSheet(vCSSStyleSheet);
+	return identifier;
+}
+function orderedVSheets(ctx) {
+	const globals = [];
+	const components = [];
+	for (const vCSSStyleSheet of ctx.vCSSStyleSheetMap.values()) (vCSSStyleSheet.mode === "global" ? globals : components).push(vCSSStyleSheet);
+	if (ctx.globalOrder.length > 0) {
+		const rankOf = ({ identifier }) => {
+			const index = ctx.globalOrder.indexOf(identifier);
+			return index === -1 ? ctx.globalOrder.length : index;
+		};
+		globals.sort((a, b) => rankOf(a) - rankOf(b));
+	}
+	return [...globals, ...components];
+}
+function getOrderedSheets(ctx) {
+	if (!ctx.orderedSheets) ctx.orderedSheets = orderedVSheets(ctx).map(({ sheet }) => sheet).filter(Boolean);
+	return ctx.orderedSheets;
+}
+function adoptInto(host, sheets) {
+	host.adoptedStyleSheets = [...hostSheetsMap.get(host) ?? [], ...sheets];
+}
+function canAdoptStyleSheets() {
+	return Boolean(supportsAdoptingStyleSheets);
+}
+function adoptHostSheet(element, sheet) {
+	const host = rootOfElement.get(element);
+	if (!supportsAdoptingStyleSheets || !host) return null;
+	const ctx = getCSSSharedContext();
+	const readopt = () => {
+		if (ctx.hostContextMap.has(host)) adoptInto(host, getOrderedSheets(ctx));
+	};
+	hostSheetsMap.set(host, [...hostSheetsMap.get(host) ?? [], sheet]);
+	readopt();
+	return () => {
+		const own = (hostSheetsMap.get(host) ?? []).filter((item) => item !== sheet);
+		own.length ? hostSheetsMap.set(host, own) : hostSheetsMap.delete(host);
+		readopt();
+	};
+}
+function updateSheets() {
+	supportsAdoptingStyleSheets ? updateStyleSheets() : updateStyleElements();
+}
+function updateStyleSheets() {
+	const ctx = getCSSSharedContext();
+	const sheets = getOrderedSheets(ctx);
+	ctx.hostContextMap.forEach((_, host) => adoptInto(host, sheets));
+}
+function addSheet(vCSSStyleSheet) {
+	if (!supportsAdoptingStyleSheets) {
+		updateStyleElements();
+		return;
+	}
+	const ctx = getCSSSharedContext();
+	const { mode, sheet } = vCSSStyleSheet;
+	const sheets = ctx.orderedSheets;
+	if (!sheet || mode === "global" || !sheets) {
+		ctx.orderedSheets = null;
+		updateStyleSheets();
+		return;
+	}
+	sheets.push(sheet);
+	if (!supportsMutatingAdoptedStyleSheets()) {
+		updateStyleSheets();
+		return;
+	}
+	ctx.hostContextMap.forEach((_, host) => host.adoptedStyleSheets.push(sheet));
+}
+function updateStyleElements() {
+	const ctx = getCSSSharedContext();
+	const ordered = orderedVSheets(ctx);
+	Array.from(ctx.hostContextMap).forEach(([host, { styleElements }]) => {
+		ordered.forEach((vCSSStyleSheet, index) => {
+			if (styleElements.has(vCSSStyleSheet) || !vCSSStyleSheet.styleElement) return;
+			const styleElement = document.importNode(vCSSStyleSheet.styleElement, true);
+			const before = nextMountedElement(ordered, index + 1, styleElements);
+			before ? host.insertBefore(styleElement, before) : host.appendChild(styleElement);
+			styleElements.set(vCSSStyleSheet, styleElement);
+		});
+	});
+}
+function nextMountedElement(ordered, start, styleElements) {
+	for (let i = start; i < ordered.length; i++) {
+		const styleElement = styleElements.get(ordered[i]);
+		if (styleElement) return styleElement;
+	}
+	return null;
+}
+function addCSSHost(host) {
+	const ctx = getCSSSharedContext();
+	if (ctx.hostContextMap.has(host)) return;
+	ctx.hostContextMap.set(host, { styleElements: /* @__PURE__ */ new Map() });
+	rootOfElement.set(host.host, host);
+	supportsAdoptingStyleSheets ? adoptInto(host, getOrderedSheets(ctx)) : updateStyleElements();
+}
+function removeCSSHost(host) {
+	const ctx = getCSSSharedContext();
+	const hostContext = ctx.hostContextMap.get(host);
+	if (!hostContext) return;
+	if (supportsAdoptingStyleSheets) host.adoptedStyleSheets = [];
+	else hostContext.styleElements.forEach((styleElement) => host.removeChild(styleElement));
+	ctx.hostContextMap.delete(host);
+}
+//#endregion
+export { addCSSHost, adoptHostSheet, canAdoptStyleSheets, removeCSSHost, setGlobalStyleOrder, vRender };

package/dist/r-html-konva/dist/batchDraw.js

@@ -0,0 +1,90 @@
+import { DD } from "konva/lib/DragAndDrop";
+import { Konva } from "konva/lib/Global";
+import { Stage } from "konva/lib/Stage";
+//#region ../r-html-konva/dist/batchDraw.js
+Konva.autoDrawEnabled = false;
+Reflect.set(Konva, "DD", DD);
+var dirty = /* @__PURE__ */ new Set();
+var deferred = /* @__PURE__ */ new Set();
+var animating = /* @__PURE__ */ new Map();
+var waiters = [];
+var endWaiters = [];
+var listeners = /* @__PURE__ */ new Set();
+var armed = false;
+var dirtySinceHop = false;
+var epoch = 0;
+function currentEpoch() {
+	return epoch;
+}
+function flush() {
+	epoch += 1;
+	try {
+		listeners.forEach((listener) => listener());
+	} finally {
+		armed = false;
+		dirtySinceHop = false;
+		for (const layer of dirty) {
+			if (animating.has(layer)) {
+				deferred.add(layer);
+				continue;
+			}
+			if (layer.getStage() instanceof Stage) layer.batchDraw();
+		}
+		dirty.clear();
+		waiters.splice(0).forEach((resolve) => resolve());
+	}
+}
+function onBeforeFlush(listener) {
+	listeners.add(listener);
+	return () => {
+		listeners.delete(listener);
+	};
+}
+function hop() {
+	queueMicrotask(() => {
+		if (dirtySinceHop) {
+			dirtySinceHop = false;
+			hop();
+			return;
+		}
+		flush();
+	});
+}
+function requestFlush() {
+	dirtySinceHop = true;
+	if (armed) return;
+	armed = true;
+	hop();
+}
+function markDirty(layer) {
+	if (animating.has(layer)) {
+		deferred.add(layer);
+		return;
+	}
+	dirty.add(layer);
+	requestFlush();
+}
+function beginAnimation(layer) {
+	animating.set(layer, (animating.get(layer) ?? 0) + 1);
+}
+function endAnimation(layer) {
+	const open = (animating.get(layer) ?? 0) - 1;
+	if (open > 0) animating.set(layer, open);
+	else animating.delete(layer);
+	endWaiters.splice(0).forEach((resolve) => resolve());
+	if (open <= 0 && deferred.delete(layer)) markDirty(layer);
+}
+function nextEndAnimation() {
+	return new Promise((resolve) => {
+		endWaiters.push(resolve);
+	});
+}
+function whenDrawn() {
+	if (animating.size) return nextEndAnimation().then(whenDrawn);
+	if (!armed) return Promise.resolve();
+	return new Promise((resolve) => {
+		waiters.push(resolve);
+	});
+}
+//#endregion
+export { beginAnimation, currentEpoch, endAnimation, markDirty, onBeforeFlush, requestFlush, whenDrawn };

package/dist/r-html-konva/dist/host.js

@@ -0,0 +1,336 @@
+import { createHostTemplate } from "../../r-html/dist/render/hostTemplate.js";
+import { currentEpoch, markDirty, onBeforeFlush, requestFlush } from "./batchDraw.js";
+import { Stage } from "konva/lib/Stage";
+import { Container } from "konva/lib/Container";
+import { Group } from "konva/lib/Group";
+import { Layer } from "konva/lib/Layer";
+import { Node } from "konva/lib/Node";
+import { Shape } from "konva/lib/Shape";
+import { Circle } from "konva/lib/shapes/Circle";
+import { Line } from "konva/lib/shapes/Line";
+import { Path } from "konva/lib/shapes/Path";
+import { Rect } from "konva/lib/shapes/Rect";
+import { Text } from "konva/lib/shapes/Text";
+//#region ../r-html-konva/dist/host.js
+var SLOT = Symbol("r-html/konva-slot");
+var LEDGER = Symbol("r-html/konva-ledger");
+var VIRTUAL = Symbol("r-html/konva-virtual");
+var FRAGMENT = Symbol("r-html/konva-fragment");
+var MINIMAP_STAGE_NAME = "minimap";
+var BANNED_ATTRIBUTES = /* @__PURE__ */ new Set([
+	"class",
+	"style",
+	"zIndex"
+]);
+var hostStats = {
+	reconcile: 0,
+	scan: 0,
+	attach: 0,
+	drop: 0,
+	order: 0,
+	setZIndex: 0
+};
+var KONVA_TAG_FACTORY = {
+	"k-layer": () => new Layer(),
+	"k-group": () => new Group(),
+	"k-rect": () => new Rect(),
+	"k-text": () => new Text(),
+	"k-path": () => new Path(),
+	"k-line": () => new Line(),
+	"k-circle": () => new Circle(),
+	"k-shape": () => new Shape({})
+};
+function noValidate() {}
+function domOnly() {
+	throw new Error("[konva-host] a DOM-only directive reached the konva host. innerHTML and vCSSStyleSheet read the DOM through the module helpers, which a konva node has nothing to answer with");
+}
+function createVirtual(kind, data = "") {
+	const node = {
+		kind,
+		data
+	};
+	Reflect.set(node, VIRTUAL, kind);
+	Object.defineProperty(node, "nextSibling", { get: domOnly });
+	Object.defineProperty(node, "parentNode", { get: domOnly });
+	return node;
+}
+var virtualKindOf = (value) => value && typeof value === "object" ? Reflect.get(value, VIRTUAL) ?? null : null;
+var isKonva = (value) => value instanceof Node;
+var isFragmentNode = (value) => isKonva(value) && Reflect.get(value, FRAGMENT) === true;
+var peekSlot = (node) => Reflect.get(node, SLOT);
+function slotOf(node) {
+	const existing = peekSlot(node);
+	if (existing) return existing;
+	const slot = {
+		node,
+		parent: null,
+		prev: null,
+		next: null,
+		doomed: false
+	};
+	Reflect.set(node, SLOT, slot);
+	return slot;
+}
+function ledgerOf(parent) {
+	const existing = Reflect.get(parent, LEDGER);
+	if (existing) return existing;
+	const ledger = {
+		first: null,
+		last: null,
+		dirty: false,
+		reconciledAt: -1
+	};
+	Reflect.set(parent, LEDGER, ledger);
+	return ledger;
+}
+var parentOf = (node) => peekSlot(node)?.parent ?? null;
+var nextSiblingOf = (node) => peekSlot(node)?.next?.node ?? null;
+var pending = /* @__PURE__ */ new Set();
+var bridges = /* @__PURE__ */ new WeakMap();
+function layerOf(node) {
+	let current = node;
+	while (current) {
+		if (current instanceof Layer) return current;
+		current = parentOf(current);
+	}
+	return null;
+}
+function markLayer(node) {
+	const layer = layerOf(node);
+	if (layer) markDirty(layer);
+}
+function markStructural(parent) {
+	ledgerOf(parent).dirty = true;
+	pending.add(parent);
+	markLayer(parent);
+	requestFlush();
+}
+function unlink(slot) {
+	const parent = slot.parent;
+	if (!parent) return;
+	const ledger = ledgerOf(parent);
+	slot.prev ? slot.prev.next = slot.next : ledger.first = slot.next;
+	slot.next ? slot.next.prev = slot.prev : ledger.last = slot.prev;
+	slot.parent = null;
+	slot.prev = null;
+	slot.next = null;
+	markStructural(parent);
+}
+function link(parent, slot, before) {
+	unlink(slot);
+	const ledger = ledgerOf(parent);
+	slot.parent = parent;
+	slot.doomed = false;
+	slot.prev = before ? before.prev : ledger.last;
+	slot.next = before;
+	slot.prev ? slot.prev.next = slot : ledger.first = slot;
+	slot.next ? slot.next.prev = slot : ledger.last = slot;
+	markStructural(parent);
+}
+function assertPlacement(parent, node) {
+	if (!isKonva(node) || isFragmentNode(parent)) return;
+	if (parent instanceof Stage) {
+		if (!(node instanceof Layer)) throw new Error(`[konva-host] a Stage holds layers only, so ${node.getClassName()} cannot sit at a template root. Make k-layer the root`);
+		return;
+	}
+	if (node instanceof Layer) throw new Error("[konva-host] k-layer nests in nothing but a Stage");
+	if (isKonva(parent) && !(parent instanceof Container)) throw new Error(`[konva-host] ${parent.getClassName()} is a shape and holds no children`);
+}
+function insertInto(parent, newChild, before) {
+	if (newChild === before) return;
+	const beforeSlot = before ? slotOf(before) : null;
+	if (!isFragmentNode(newChild)) {
+		assertPlacement(parent, newChild);
+		link(parent, slotOf(newChild), beforeSlot);
+		return;
+	}
+	const moving = [];
+	for (let slot = ledgerOf(newChild).first; slot; slot = slot.next) moving.push(slot);
+	for (const slot of moving) {
+		assertPlacement(parent, slot.node);
+		link(parent, slot, beforeSlot);
+	}
+}
+function destroyNode(node) {
+	pending.delete(node);
+	Reflect.deleteProperty(node, SLOT);
+	Reflect.deleteProperty(node, LEDGER);
+	node.destroy();
+}
+function attach(parent, node) {
+	const owner = node.getParent();
+	if (owner === parent) return;
+	if (owner && pending.has(owner)) ensureReconciled(owner);
+	hostStats.attach += 1;
+	parent.add(node);
+}
+function sameOrder(children, desired) {
+	if (children.length !== desired.length) return false;
+	for (let index = 0; index < desired.length; index++) if (children[index] !== desired[index]) return false;
+	return true;
+}
+function orderLayers(stage, desired) {
+	for (let index = 0; index < desired.length; index++) {
+		const node = desired[index];
+		if (stage.children[index] === node) continue;
+		hostStats.setZIndex += 1;
+		node.setZIndex(index);
+	}
+}
+function orderChildren(parent, desired) {
+	const children = parent.children;
+	children.length = 0;
+	for (let index = 0; index < desired.length; index++) {
+		const node = desired[index];
+		children.push(node);
+		node.index = index;
+	}
+}
+function reconcile(parent) {
+	hostStats.reconcile += 1;
+	if (!(parent instanceof Container)) return;
+	const desired = [];
+	for (let slot = ledgerOf(parent).first; slot; slot = slot.next) {
+		hostStats.scan += 1;
+		if (isKonva(slot.node)) desired.push(slot.node);
+	}
+	for (const node of desired) attach(parent, node);
+	const keep = new Set(desired);
+	const dropped = parent.children.filter((child) => !keep.has(child));
+	if (!dropped.length && sameOrder(parent.children, desired)) return;
+	hostStats.order += 1;
+	if (parent instanceof Stage) {
+		for (const node of dropped) node.remove();
+		orderLayers(parent, desired);
+	} else {
+		for (const node of dropped) {
+			node.parent = null;
+			node.index = 0;
+			node.remove();
+		}
+		orderChildren(parent, desired);
+	}
+	for (const node of dropped) {
+		hostStats.drop += 1;
+		if (slotOf(node).doomed) destroyNode(node);
+	}
+}
+function ensureReconciled(parent) {
+	const ledger = ledgerOf(parent);
+	if (!ledger.dirty && ledger.reconciledAt === currentEpoch()) return;
+	ledger.dirty = false;
+	ledger.reconciledAt = currentEpoch();
+	reconcile(parent);
+}
+onBeforeFlush(() => {
+	for (const parent of pending) ensureReconciled(parent);
+	pending.clear();
+});
+function rootOf(node) {
+	let current = node;
+	let parent = parentOf(current);
+	while (parent) {
+		current = parent;
+		parent = parentOf(current);
+	}
+	return bridges.get(current) ?? current;
+}
+function assertIdConvention(node, value) {
+	if (!value) return;
+	const root = rootOf(node);
+	if (isKonva(root) && root.hasName("minimap")) throw new Error(`[konva-host] id "${value}" is not the minimap's to carry. Locate a minimap node by name plus a tableId attr`);
+}
+var konvaAdapter = {
+	createElement(name) {
+		const factory = KONVA_TAG_FACTORY[name.toLowerCase()];
+		if (!factory) throw new Error(`[konva-host] unknown konva tag <${name}>`);
+		return factory();
+	},
+	createText: (value) => createVirtual("text", value),
+	createMarker: (value) => createVirtual("marker", value),
+	createFragment() {
+		const fragment = new Group();
+		Reflect.set(fragment, FRAGMENT, true);
+		Reflect.set(fragment, "_validateAdd", noValidate);
+		return fragment;
+	},
+	createEventBus: () => new EventTarget(),
+	insertBefore(newChild, refChild) {
+		const parent = parentOf(refChild);
+		if (!parent) return;
+		insertInto(parent, newChild, refChild);
+	},
+	appendChild(parent, newChild) {
+		insertInto(parent, newChild, null);
+	},
+	prependChild(parent, newChild) {
+		insertInto(parent, newChild, ledgerOf(parent).first?.node ?? null);
+	},
+	removeChild(node) {
+		const slot = slotOf(node);
+		unlink(slot);
+		if (!isKonva(node)) return;
+		slot.doomed = true;
+		if (!node.getParent()) destroyNode(node);
+	},
+	parentOf,
+	nextSiblingOf,
+	setText(node, value) {
+		if (virtualKindOf(node) !== "text") throw new Error("[konva-host] a konva tree has no text node to write");
+		node.data = value;
+	},
+	setAttribute(node, name, value, isSingleMarker) {
+		if (!isKonva(node)) return;
+		if (BANNED_ATTRIBUTES.has(name)) throw new Error(`[konva-host] "${name}" is not a konva attribute a template may write`);
+		const next = isSingleMarker ? value : String(value);
+		if (name === "id") assertIdConvention(node, next);
+		if (node.attrs[name] === next) return;
+		node.setAttrs({ [name]: next });
+		markLayer(node);
+	},
+	removeAttribute(node, name) {
+		if (!isKonva(node) || node.attrs[name] === void 0) return;
+		node.setAttrs({ [name]: void 0 });
+		markLayer(node);
+	},
+	isHostNode: (value) => isKonva(value) || virtualKindOf(value) !== null,
+	isMarker: (value) => virtualKindOf(value) === "marker",
+	isText: (value) => virtualKindOf(value) === "text",
+	isElement: (value) => isKonva(value) && !isFragmentNode(value),
+	isFragment: (value) => isFragmentNode(value),
+	addEventListener(node, type, listener, options) {
+		if (isKonva(node)) node.on(`${type}.rhtml`, listener);
+		else node.addEventListener(type, listener, options);
+	},
+	removeEventListener(node, type, listener, options) {
+		if (isKonva(node)) node.off(`${type}.rhtml`, listener);
+		else node.removeEventListener(type, listener, options);
+	},
+	getRoot: rootOf,
+	createComponentContext(startNode, eventBus) {
+		return {
+			get host() {
+				const root = rootOf(startNode);
+				return root instanceof Stage ? root.container() : eventBus;
+			},
+			get parentElement() {
+				return null;
+			},
+			dispatchEvent: (event) => eventBus.dispatchEvent(event)
+		};
+	},
+	bridgeFragment(fragment, root) {
+		bridges.set(fragment, root);
+		return () => {
+			bridges.delete(fragment);
+		};
+	}
+};
+var konvaTemplate = createHostTemplate(konvaAdapter);
+var konva = konvaTemplate.html;
+function renderKonva(stage, templateLiterals) {
+	if (!(stage instanceof Stage)) throw new Error("[konva-host] a konva template renders into a Stage");
+	konvaTemplate.render(stage, templateLiterals);
+}
+//#endregion
+export { MINIMAP_STAGE_NAME, hostStats, konva, konvaAdapter, renderKonva };

package/dist/schema-sql-parser/dist/parser/dataType/Databricks.js

@@ -0,0 +1,50 @@
+//#region ../schema-sql-parser/dist/parser/dataType/Databricks.js
+var DatabricksTypes = [
+	"ARRAY",
+	"BIGINT",
+	"BINARY",
+	"BOOLEAN",
+	"BYTE",
+	"CHAR",
+	"DATE",
+	"DEC",
+	"DECIMAL",
+	"DOUBLE",
+	"FLOAT",
+	"GEOGRAPHY",
+	"GEOMETRY",
+	"INT",
+	"INTEGER",
+	"INTERVAL DAY TO HOUR",
+	"INTERVAL DAY TO MINUTE",
+	"INTERVAL DAY TO SECOND",
+	"INTERVAL DAY",
+	"INTERVAL HOUR TO MINUTE",
+	"INTERVAL HOUR TO SECOND",
+	"INTERVAL HOUR",
+	"INTERVAL MINUTE TO SECOND",
+	"INTERVAL MINUTE",
+	"INTERVAL MONTH",
+	"INTERVAL SECOND",
+	"INTERVAL YEAR TO MONTH",
+	"INTERVAL YEAR",
+	"INTERVAL",
+	"LONG",
+	"MAP",
+	"NUMERIC",
+	"OBJECT",
+	"REAL",
+	"SHORT",
+	"SMALLINT",
+	"STRING",
+	"STRUCT",
+	"TIMESTAMP_LTZ",
+	"TIMESTAMP_NTZ",
+	"TIMESTAMP",
+	"TINYINT",
+	"VARCHAR",
+	"VARIANT",
+	"VOID"
+];
+//#endregion
+export { DatabricksTypes };

package/dist/schema-sql-parser/dist/parser/dataType/MSSQL.js

@@ -0,0 +1,53 @@
+//#region ../schema-sql-parser/dist/parser/dataType/MSSQL.js
+var MSSQLTypes = [
+	"BIGINT",
+	"BINARY VARYING",
+	"BINARY",
+	"BIT",
+	"CHAR VARYING",
+	"CHAR",
+	"CHARACTER VARYING",
+	"CHARACTER",
+	"DATE",
+	"DATETIME",
+	"DATETIME2",
+	"DATETIMEOFFSET",
+	"DEC",
+	"DECIMAL",
+	"DOUBLE PRECISION",
+	"FLOAT",
+	"GEOGRAPHY",
+	"GEOMETRY",
+	"HIERARCHYID",
+	"IMAGE",
+	"INT",
+	"INTEGER",
+	"JSON",
+	"MONEY",
+	"NATIONAL CHAR VARYING",
+	"NATIONAL CHAR",
+	"NATIONAL CHARACTER VARYING",
+	"NATIONAL CHARACTER",
+	"NATIONAL TEXT",
+	"NCHAR",
+	"NTEXT",
+	"NUMERIC",
+	"NVARCHAR",
+	"REAL",
+	"ROWVERSION",
+	"SMALLDATETIME",
+	"SMALLINT",
+	"SMALLMONEY",
+	"SQL_VARIANT",
+	"TEXT",
+	"TIME",
+	"TIMESTAMP",
+	"TINYINT",
+	"UNIQUEIDENTIFIER",
+	"VARBINARY",
+	"VARCHAR",
+	"VECTOR",
+	"XML"
+];
+//#endregion
+export { MSSQLTypes };