texditor 2.0.0

package/dist/src/core/ui/virtual-selection.mjs

@@ -0,0 +1,205 @@
+import { Q as e, S as t, Z as n, b as r, g as i, ie as a, m as o, w as s, x as c, y as l } from "../../../node_modules/snappykit/dist/snappykit.mjs";
+/* empty css                                  */
+//#region src/core/ui/virtual-selection.ts
+var u = class {
+	constructor(e) {
+		this.blocks = [], this.isDragging = !1, this.isLassoActive = !1, this.hasMoved = !1, this.isTouchScrolling = !1, this.startedInContentEditable = !1, this.contentEditableStartPoint = {
+			x: 0,
+			y: 0
+		}, this.startPointInDocument = {
+			x: 0,
+			y: 0
+		}, this.currentPointInDocument = {
+			x: 0,
+			y: 0
+		}, this.selectedIndices = /* @__PURE__ */ new Set(), this.selectionRect = null, this.eventId = "slUi_" + o(8), this.autoScrollInterval = null, this.startBlock = null, this.touchDelayTimeout = null, this.pendingLassoActivation = !1, this.rafId = null, this.needsUpdate = !1, this.cachedLassoRect = null, this.cachedSelectedIndices = /* @__PURE__ */ new Set(), this.options = {
+			blocksContainer: e.blocksContainer,
+			blockSelector: e.blockSelector,
+			selectionZone: e.selectionZone || document.body,
+			selectedBlockClass: e.selectedBlockClass || "tex-ui-vs-selected",
+			exitTolerance: e.exitTolerance || 12,
+			autoScrollSpeed: e.autoScrollSpeed || 20,
+			autoScrollEdgeThreshold: e.autoScrollEdgeThreshold || 60,
+			touchActivationDelay: e.touchActivationDelay || 200,
+			onSelectionChange: e.onSelectionChange || (() => {}),
+			onLassoStart: e.onLassoStart || (() => {}),
+			onLassoEnd: e.onLassoEnd || (() => {})
+		}, this.init();
+	}
+	setTouchAction(e) {
+		i(this.options.selectionZone, "touch-action", e);
+	}
+	init() {
+		this.refreshBlocks(), this.createElements(), this.attachEvents(), this.setTouchAction("pan-y");
+	}
+	isInsideContentEditable(e) {
+		let t = e;
+		for (; t && t !== this.options.selectionZone;) {
+			if (t.contentEditable === "true") return !0;
+			t = t.parentElement;
+		}
+		return !1;
+	}
+	getFullBlockRect(e) {
+		let t = e.getBoundingClientRect(), n = window.getComputedStyle(e), r = parseFloat(n.marginTop), i = parseFloat(n.marginRight), a = parseFloat(n.marginBottom), o = parseFloat(n.marginLeft);
+		return new DOMRect(t.left + window.scrollX - o, t.top + window.scrollY - r, t.width + o + i, t.height + r + a);
+	}
+	hasExitedBlockBoundaries(e, t) {
+		let n = this.getFullBlockRect(t), r = {
+			left: e.x - n.left,
+			right: n.right - e.x,
+			top: e.y - n.top,
+			bottom: n.bottom - e.y
+		}, i = Math.min(Math.abs(r.left), Math.abs(r.right), Math.abs(r.top), Math.abs(r.bottom));
+		return (e.x < n.left || e.x > n.right || e.y < n.top || e.y > n.bottom) && i >= this.options.exitTolerance;
+	}
+	refreshBlocks() {
+		this.blocks.length = 0, t(this.options.blockSelector, (e) => {
+			this.blocks.push(e);
+		}, this.options.blocksContainer), this.updateBlocksVisuals(!0);
+	}
+	createElements() {
+		this.selectionRect &&= (this.selectionRect.parentNode && c(this.selectionRect), null), this.selectionRect = a("div", (e) => {
+			l(e, "tex-ui-vs-rect"), i(e, { display: "none" });
+		}), s(document.body, this.selectionRect);
+	}
+	attachEvents() {
+		let e = this.eventId, t = this.options.selectionZone;
+		n(t, "mousedown." + e, (e) => this.onMouseDown(e)), n(window, "mousemove." + e, (e) => this.onMouseMove(e)), n(window, "mouseup." + e, () => this.onMouseUp()), n(t, "touchstart." + e, (e) => this.onTouchStart(e), { passive: !1 }), n(t, "touchmove." + e, (e) => this.onTouchMove(e), { passive: !1 }), n(window, "touchend." + e, () => this.onTouchEnd());
+	}
+	viewportToDocument(e, t) {
+		return {
+			x: e + window.scrollX,
+			y: t + window.scrollY
+		};
+	}
+	documentToViewport(e, t) {
+		return {
+			x: e - window.scrollX,
+			y: t - window.scrollY
+		};
+	}
+	getBlockAtPoint(e, t) {
+		for (let n of this.blocks) {
+			let r = this.getFullBlockRect(n);
+			if (e >= r.left && e <= r.right && t >= r.top && t <= r.bottom) return n;
+		}
+		return null;
+	}
+	startAutoScroll() {
+		this.autoScrollInterval ||= window.setInterval(() => {
+			if (!this.isLassoActive || !this.isDragging) return;
+			let e = this.currentPointInDocument.y - window.scrollY, t = this.options.autoScrollEdgeThreshold, n = 0;
+			e < t ? n = -this.options.autoScrollSpeed : e > window.innerHeight - t && (n = this.options.autoScrollSpeed), n !== 0 && (window.scrollBy(0, n), this.currentPointInDocument.y += n, this.scheduleUpdate());
+		}, 16);
+	}
+	stopAutoScroll() {
+		this.autoScrollInterval &&= (clearInterval(this.autoScrollInterval), null);
+	}
+	startLassoMode() {
+		if (this.isLassoActive) return;
+		this.isLassoActive = !0, this.startAutoScroll();
+		let e = window.getSelection();
+		e && e.removeAllRanges(), this.options.onLassoStart();
+	}
+	stopLassoMode() {
+		this.isLassoActive && (this.isLassoActive = !1, this.stopAutoScroll(), this.cancelRAF(), this.options.onLassoEnd(), this.selectionRect && i(this.selectionRect, "display", "none"), this.cachedLassoRect = null, this.cachedSelectedIndices.clear());
+	}
+	scheduleUpdate() {
+		this.needsUpdate || (this.needsUpdate = !0, this.rafId === null && (this.rafId = requestAnimationFrame(() => {
+			this.rafId = null, this.needsUpdate = !1, this.performUpdate();
+		})));
+	}
+	performUpdate() {
+		if (!this.isLassoActive) return;
+		this.cachedLassoRect ||= new DOMRect();
+		let e = this.cachedLassoRect;
+		e.x = Math.min(this.startPointInDocument.x, this.currentPointInDocument.x), e.y = Math.min(this.startPointInDocument.y, this.currentPointInDocument.y), e.width = Math.abs(this.currentPointInDocument.x - this.startPointInDocument.x), e.height = Math.abs(this.currentPointInDocument.y - this.startPointInDocument.y), this.cachedSelectedIndices.clear(), this.blocks.forEach((t, n) => {
+			let r = this.getFullBlockRect(t);
+			e.right < r.left || e.left > r.right || e.bottom < r.top || e.top > r.bottom || this.cachedSelectedIndices.add(n);
+		}), this.areSetsEqual(this.selectedIndices, this.cachedSelectedIndices) || (this.selectedIndices = new Set(this.cachedSelectedIndices), this.updateBlocksVisuals()), this.updateSelectionRect();
+	}
+	areSetsEqual(e, t) {
+		if (e.size !== t.size) return !1;
+		for (let n of e) if (!t.has(n)) return !1;
+		return !0;
+	}
+	cancelRAF() {
+		this.rafId !== null && (cancelAnimationFrame(this.rafId), this.rafId = null), this.needsUpdate = !1;
+	}
+	updateSelectionRect() {
+		if (!this.selectionRect || !this.isLassoActive) return;
+		let e = this.documentToViewport(this.startPointInDocument.x, this.startPointInDocument.y), t = this.documentToViewport(this.currentPointInDocument.x, this.currentPointInDocument.y);
+		i(this.selectionRect, {
+			display: "block",
+			left: Math.min(e.x, t.x) + "px",
+			top: Math.min(e.y, t.y) + "px",
+			width: Math.abs(t.x - e.x) + "px",
+			height: Math.abs(t.y - e.y) + "px"
+		});
+	}
+	updateLassoSelection() {
+		this.isLassoActive && this.scheduleUpdate();
+	}
+	updateBlocksVisuals(e = !1) {
+		let t = this.options.selectedBlockClass;
+		this.blocks.forEach((e, n) => {
+			this.selectedIndices.has(n) ? e.classList.contains(t) || l(e, t) : e.classList.contains(t) && r(e, t);
+		}), e || this.options.onSelectionChange(Array.from(this.selectedIndices), this.getSelectedBlocks());
+	}
+	onMouseDown(e) {
+		if (e.button !== 0) return;
+		let t = e.target, n = this.viewportToDocument(e.clientX, e.clientY);
+		this.startPointInDocument = n, this.currentPointInDocument = n, this.isDragging = !0, this.hasMoved = !1, this.startedInContentEditable = this.isInsideContentEditable(t), this.contentEditableStartPoint = n, this.startBlock = this.getBlockAtPoint(n.x, n.y);
+	}
+	onMouseMove(e) {
+		if (!this.isDragging) return;
+		let t = this.viewportToDocument(e.clientX, e.clientY);
+		this.currentPointInDocument = t;
+		let n = t.x - this.startPointInDocument.x, r = t.y - this.startPointInDocument.y;
+		(Math.abs(n) > 2 || Math.abs(r) > 2) && (this.hasMoved = !0), !this.isLassoActive && this.hasMoved && !this.startBlock && this.startLassoMode(), !this.isLassoActive && this.hasMoved && this.startBlock && this.hasExitedBlockBoundaries(t, this.startBlock) && (this.startLassoMode(), e.preventDefault()), this.isLassoActive && (this.updateLassoSelection(), e.preventDefault());
+	}
+	onMouseUp() {
+		this.isDragging && (this.isLassoActive && (this.updateLassoSelection(), this.stopLassoMode()), this.isDragging = !1, this.startedInContentEditable = !1, this.pendingLassoActivation = !1, this.startBlock = null, this.touchDelayTimeout &&= (clearTimeout(this.touchDelayTimeout), null), this.cancelRAF());
+	}
+	onTouchStart(e) {
+		let t = e.touches[0];
+		if (!t) return;
+		let n = e.target, r = this.viewportToDocument(t.clientX, t.clientY);
+		this.startPointInDocument = r, this.currentPointInDocument = r, this.isDragging = !0, this.hasMoved = !1, this.startedInContentEditable = this.isInsideContentEditable(n), this.contentEditableStartPoint = r, this.isTouchScrolling = !1, this.pendingLassoActivation = !1, this.startBlock = this.getBlockAtPoint(r.x, r.y), this.touchDelayTimeout &&= (clearTimeout(this.touchDelayTimeout), null), this.setTouchAction("none");
+	}
+	onTouchMove(e) {
+		if (!this.isDragging) return;
+		let t = e.touches[0];
+		if (!t) return;
+		let n = this.viewportToDocument(t.clientX, t.clientY);
+		this.currentPointInDocument = n;
+		let r = n.x - this.startPointInDocument.x, i = n.y - this.startPointInDocument.y, a = Math.abs(r), o = Math.abs(i);
+		if (!this.isLassoActive && o > a && o > 10) {
+			this.isTouchScrolling = !0, this.setTouchAction("pan-y"), this.touchDelayTimeout &&= (clearTimeout(this.touchDelayTimeout), null), this.pendingLassoActivation = !1;
+			return;
+		}
+		!this.isLassoActive && !this.isTouchScrolling && (a > 5 || o > 5) && !this.pendingLassoActivation && !this.touchDelayTimeout && (this.pendingLassoActivation = !0, this.touchDelayTimeout = window.setTimeout(() => {
+			this.isDragging && !this.isLassoActive && !this.isTouchScrolling && (this.startBlock ? this.startBlock && this.hasExitedBlockBoundaries(this.currentPointInDocument, this.startBlock) && (this.startLassoMode(), e.preventDefault()) : (this.startLassoMode(), e.preventDefault())), this.touchDelayTimeout = null, this.pendingLassoActivation = !1;
+		}, this.options.touchActivationDelay)), a < 3 && o < 3 && this.pendingLassoActivation && this.touchDelayTimeout && (clearTimeout(this.touchDelayTimeout), this.touchDelayTimeout = null, this.pendingLassoActivation = !1), this.isLassoActive && (this.updateLassoSelection(), e.preventDefault()), (this.pendingLassoActivation || this.isLassoActive) && e.preventDefault();
+	}
+	onTouchEnd() {
+		this.touchDelayTimeout &&= (clearTimeout(this.touchDelayTimeout), null), this.pendingLassoActivation = !1, this.isDragging && (this.isLassoActive && (this.updateLassoSelection(), this.stopLassoMode()), this.isDragging = !1, this.startedInContentEditable = !1, this.isTouchScrolling = !1, this.startBlock = null, this.setTouchAction("pan-y"), this.cancelRAF());
+	}
+	getSelectedIndices() {
+		return Array.from(this.selectedIndices);
+	}
+	getSelectedBlocks() {
+		return Array.from(this.selectedIndices).map((e) => this.blocks[e]).filter(Boolean);
+	}
+	clearSelection() {
+		this.selectedIndices.clear(), this.updateBlocksVisuals(!0);
+	}
+	destroy() {
+		this.stopAutoScroll(), this.cancelRAF(), this.touchDelayTimeout &&= (clearTimeout(this.touchDelayTimeout), null);
+		let t = this.eventId, n = this.options.selectionZone;
+		e(n, "mousedown." + t), e(window, "mousemove." + t), e(window, "mouseup." + t), e(n, "touchstart." + t), e(n, "touchmove." + t), e(window, "touchend." + t), this.selectionRect?.parentNode && this.selectionRect.parentNode.removeChild(this.selectionRect), this.selectionRect = null, this.blocks.length = 0, this.selectedIndices.clear(), this.cachedSelectedIndices.clear(), this.cachedLassoRect = null, this.startBlock = null, this.setTouchAction("pan-y");
+	}
+};
+//#endregion
+export { u as default };

package/dist/src/entities/actions/convert-action.mjs

@@ -0,0 +1,43 @@
+import { Te as e, ie as t, se as n, w as r, y as i } from "../../../node_modules/snappykit/dist/snappykit.mjs";
+import { IconConvert as a } from "../../icons/index.mjs";
+import { renderIcon as o } from "../../utils/icon.mjs";
+import s from "../../core/models/action-model.mjs";
+//#region src/entities/actions/convert-action.ts
+var c = class extends s {
+	configure() {
+		return {
+			name: "convertAction",
+			icon: a,
+			translation: "convert",
+			dropdown: !0
+		};
+	}
+	dropdown() {
+		let { blockManager: a } = this.editor, s = this.getBlockElement(), c = a.getSchemas();
+		return t("div", (l) => {
+			r(l, t("h4", (e) => {
+				e.textContent = this.getTranslation() || this.getName();
+			})), c.forEach((c) => {
+				let u = c.model;
+				u.isConvertible() && s?.baseModel.getName() !== u.getName() && r(l, t("div", (c) => {
+					i(c, "tex-actions-content-dropdown-item");
+					let l = u.getIcon();
+					l && r(c, t("span", (e) => n(e, o(l, {
+						width: u.getIconWidth(),
+						height: u.getIconHeight()
+					})))), r(c, t("span", (e) => {
+						n(e, u.getTranslation() || u.getName());
+					})), e(c, "click.am", () => {
+						s && a.convert(s, u);
+					});
+				}));
+			});
+		});
+	}
+	isVisible() {
+		let e = this.getBlockElement()?.baseModel;
+		return e ? e.isConvertible() : !1;
+	}
+};
+//#endregion
+export { c as default };

package/dist/src/entities/actions/create-action.mjs

@@ -0,0 +1,39 @@
+import { Te as e, ie as t, se as n, w as r, y as i } from "../../../node_modules/snappykit/dist/snappykit.mjs";
+import { IconPlus as a } from "../../icons/index.mjs";
+import { renderIcon as o } from "../../utils/icon.mjs";
+import s from "../../core/models/action-model.mjs";
+//#region src/entities/actions/create-action.ts
+var c = class extends s {
+	configure() {
+		return {
+			name: "createAction",
+			translation: "createAction",
+			icon: a,
+			dropdown: !0
+		};
+	}
+	dropdown() {
+		let { blockManager: a } = this.editor, s = a.getSchemas();
+		return t("div", (c) => {
+			r(c, t("h4", (e) => {
+				e.textContent = this.getTranslation() || this.getName();
+			})), s.forEach((s) => {
+				let l = s.model;
+				r(c, t("div", (s) => {
+					i(s, "tex-actions-content-dropdown-item");
+					let c = l.getIcon();
+					c && r(s, t("span", (e) => n(e, o(c, {
+						width: l.getIconWidth(),
+						height: l.getIconHeight()
+					})))), r(s, t("span", (e) => {
+						n(e, l.getTranslation() || l.getName());
+					})), e(s, "click.am", () => {
+						a.createBlock(l.getName());
+					});
+				}));
+			});
+		});
+	}
+};
+//#endregion
+export { c as default };

package/dist/src/entities/actions/delete-action.mjs

@@ -0,0 +1,19 @@
+import { IconTrash as e } from "../../icons/index.mjs";
+import t from "../../core/models/action-model.mjs";
+//#region src/entities/actions/delete-action.ts
+var n = class extends t {
+	configure() {
+		return {
+			name: "deleteAction",
+			translation: "deleteAction",
+			icon: e,
+			confirm: !0
+		};
+	}
+	onClick() {
+		let { blockManager: e } = this.editor;
+		e.removeBlock();
+	}
+};
+//#endregion
+export { n as default };

package/dist/src/entities/actions/move-down-action.mjs

@@ -0,0 +1,22 @@
+import { IconArrowDown as e } from "../../icons/index.mjs";
+import t from "../../core/models/action-model.mjs";
+//#region src/entities/actions/move-down-action.ts
+var n = class extends t {
+	configure() {
+		return {
+			name: "moveDownAction",
+			translation: "moveDownAction",
+			icon: e
+		};
+	}
+	onClick() {
+		let { blockManager: e } = this.editor, t = e.getIndex(), n = this.getBlockElement()?.baseModel;
+		e.moveBlock(t, t + 1), n && n.showActions();
+	}
+	isVisible() {
+		let { blockManager: e } = this.editor;
+		return e.getIndex() + 1 != e.count();
+	}
+};
+//#endregion
+export { n as default };

package/dist/src/entities/actions/move-up-action.mjs

@@ -0,0 +1,22 @@
+import { IconArrowUp as e } from "../../icons/index.mjs";
+import t from "../../core/models/action-model.mjs";
+//#region src/entities/actions/move-up-action.ts
+var n = class extends t {
+	configure() {
+		return {
+			name: "moveUpAction",
+			translation: "moveUpAction",
+			icon: e
+		};
+	}
+	onClick() {
+		let { blockManager: e } = this.editor, t = e.getIndex(), n = this.getBlockElement()?.baseModel;
+		e.moveBlock(t, t - 1), n && n.showActions();
+	}
+	isVisible() {
+		let { blockManager: e } = this.editor;
+		return e.getIndex() > 0 && e.count() !== 0;
+	}
+};
+//#endregion
+export { n as default };

package/dist/src/entities/blocks/code/index.mjs

@@ -0,0 +1,144 @@
+import { A as e, N as t, O as n, Q as r, S as i, T as a, Z as o, c as s, g as c, ie as l, le as u, n as d, se as f, ue as p, w as m, y as h } from "../../../../node_modules/snappykit/dist/snappykit.mjs";
+import { IconArrowDown as g, IconCode as _, IconCornerUpRight as v } from "../../../icons/index.mjs";
+import { renderIcon as y } from "../../../utils/icon.mjs";
+import b from "../../../core/models/block-model.mjs";
+import x from "./languages.mjs";
+/* empty css                                        */
+//#region src/entities/blocks/code/index.ts
+var S = class extends b {
+	configure() {
+		return {
+			name: "code",
+			tagName: "pre",
+			translation: "code",
+			groupCode: "code",
+			className: "tex-code",
+			autoParse: !1,
+			autoMerge: !0,
+			icon: _,
+			placeholder: this.editor.i18n.get("codePlaceholder", "Enter your code"),
+			editable: !0,
+			emptyDetect: !0,
+			sanitizer: !1,
+			raw: !0,
+			enterCreate: !1,
+			convertible: !0,
+			languages: x,
+			showLanguages: !0,
+			customSave: !0,
+			search: !0,
+			lineBreakInfoMessage: "Ctrl + Enter"
+		};
+	}
+	onCompose() {
+		let e = this.getElement();
+		this.init(e);
+	}
+	init(t) {
+		if (!t) return;
+		let { events: d, i18n: _ } = this.editor;
+		if (this.getConfig("showLanguages", !0)) {
+			let v = _.get("notSpecified", "Not specified");
+			if (t) {
+				let b = this.getConfig("languages", {}), x = (e) => b[e] || v, S = (e = v) => {
+					i(".tex-code-lang-link-name", (t) => {
+						t.textContent = e;
+					}, t);
+				};
+				a(t, l("div", (a) => {
+					h(a, "tex-code-lang");
+					let C = l("div", (r) => {
+						h(r, "tex-code-menu tex-animate-fadeIn"), this.getConfig("search", !0) && m(r, l("div", (r) => {
+							h(r, "tex-code-menu-search"), m(r, l("input", (r) => {
+								h(r, "tex-input"), n(r, "type", "text"), n(r, "placeholder", _.get("search", "Search")), o(r, "input.codeLang", (n) => {
+									n.preventDefault(), p(r);
+									let a = s(p(r)).trim();
+									i(".tex-code-menu-item", (t) => {
+										if (a) {
+											let n = t.textContent?.toLowerCase() || "", r = e(t, "langKey") || "";
+											!n.includes(a) && !r.includes(a) ? c(t, "display", "none") : c(t, "display", "");
+										} else c(t, "display", "");
+									}, t);
+								});
+							}));
+						})), m(r, l("div", (e) => {
+							h(e, "tex-code-menu-item"), n(e, "data-lang-key", ""), f(e, v), o(e, "click.rmLang", () => {
+								this.removeOption("lang"), S(), T(), d.change({
+									modelCode: this.getModelCode(),
+									type: "codeClearLanguage",
+									blockElement: t
+								});
+							});
+						}));
+						for (let [e, i] of Object.entries(b)) m(r, l("div", (r) => {
+							h(r, "tex-code-menu-item"), n(r, "data-lang-key", e), f(r, i), o(r, "click.chLang", () => {
+								this.setOption("lang", e), S(i), T(), d.change({
+									modelCode: this.getModelCode(),
+									type: "codeChangeLanguage",
+									blockElement: t,
+									lang: e
+								});
+							});
+						}));
+					}), w = this.getEventId(), T = () => {
+						r(document, "click.codeMenu" + w), c(C, "display", "");
+					};
+					m(a, [l("a", (e) => {
+						h(e, "tex-code-lang-link"), m(e, [l("span", (e) => {
+							h(e, "tex-code-lang-link-name"), e.textContent = x(this.getOption("lang", "") || "");
+						}), l("span", (e) => {
+							f(e, y(g, {
+								width: 12,
+								height: 12
+							}));
+						})]), o(e, "click.codeLink", () => {
+							c(C, "display", "block"), o(document, "click.codeMenu" + w, (e) => {
+								u(e.target, C) || T();
+							}, !0);
+						});
+					}), C]);
+				}));
+			}
+		}
+		let b = this.getConfig("lineBreakInfoMessage", "");
+		b && m(t, l("div", (e) => {
+			h(e, "tex-code-line-break-info"), m(e, [l("span", (e) => {
+				f(e, b);
+			}), l("span", (e) => {
+				f(e, y(v, {
+					width: 12,
+					height: 12
+				}));
+			})]);
+		}));
+	}
+	onKeyDown(e) {
+		let { blockManager: t } = this.editor;
+		return e.ctrlKey && e.key === "Enter" ? (t.createDefaultBlock(), e.preventDefault(), !1) : !0;
+	}
+	save(e, n) {
+		let { blockManager: r } = this.editor, i = r.getContentElement(n);
+		if (i && !d(t(i))) {
+			e.data = [t(i)];
+			let n = this.getOption("lang", "");
+			n && (e.lang = n);
+		}
+		return e;
+	}
+	parse(e) {
+		let t = this.getConfig("languages", {}), n = e?.lang || "";
+		return n && !t[n] && (n = ""), {
+			lang: n,
+			data: typeof e.data[0] == "string" ? e.data[0] : ""
+		};
+	}
+	afterConvert(e) {
+		return this.init(e), e;
+	}
+	destroy() {
+		let e = this.getEventId();
+		r(document, "click.codeMenu" + e);
+	}
+};
+//#endregion
+export { S as default };

package/dist/src/entities/blocks/code/languages.mjs

@@ -0,0 +1,54 @@
+//#region src/entities/blocks/code/languages.ts
+var e = {
+	bash: "Bash",
+	c: "C",
+	clojure: "Clojure",
+	cmake: "CMake",
+	cpp: "C++",
+	csharp: "C#",
+	css: "CSS",
+	dart: "Dart",
+	dockerfile: "Dockerfile",
+	elixir: "Elixir",
+	erlang: "Erlang",
+	fsharp: "F#",
+	go: "Go",
+	graphql: "GraphQL",
+	groovy: "Groovy",
+	haskell: "Haskell",
+	html: "HTML",
+	java: "Java",
+	javascript: "JavaScript",
+	json: "JSON",
+	julia: "Julia",
+	kotlin: "Kotlin",
+	less: "Less",
+	lua: "Lua",
+	makefile: "Makefile",
+	markdown: "Markdown",
+	matlab: "MATLAB",
+	nginx: "Nginx",
+	objectivec: "Objective-C",
+	perl: "Perl",
+	php: "PHP",
+	plaintext: "Plain Text",
+	powershell: "PowerShell",
+	python: "Python",
+	r: "R",
+	ruby: "Ruby",
+	rust: "Rust",
+	scala: "Scala",
+	scss: "SCSS",
+	shell: "Shell",
+	sql: "SQL",
+	swift: "Swift",
+	svelte: "Svelte",
+	toml: "TOML",
+	typescript: "TypeScript",
+	vim: "Vim script",
+	wasm: "WebAssembly",
+	xml: "XML",
+	yaml: "YAML"
+};
+//#endregion
+export { e as default };

package/dist/src/entities/blocks/files/actions/DeleteFileAction.mjs

@@ -0,0 +1,21 @@
+import { IconTrash as e } from "../../../../icons/index.mjs";
+import t from "../../../../core/models/file-action-model.mjs";
+//#region src/entities/blocks/files/actions/DeleteFileAction.ts
+var n = class extends t {
+	configure() {
+		return {
+			name: "delete",
+			icon: e,
+			translation: "delete"
+		};
+	}
+	onClick(e) {
+		let { blockManager: t } = this.editor, n = this.getBlockElement(), r = n?.baseModel, i = this.getItemElement();
+		if (n && r && i) {
+			let e = r.getItemIndex(i), n = t.getIndex();
+			r.removeItem(e), r.isEmpty() ? t.removeBlock() : t.focus(n);
+		}
+	}
+};
+//#endregion
+export { n as default };

package/dist/src/entities/blocks/files/actions/DownloadFileAction.mjs

@@ -0,0 +1,44 @@
+import { O as e } from "../../../../../node_modules/snappykit/dist/snappykit.mjs";
+import { IconDownload as t } from "../../../../icons/index.mjs";
+import n from "../../../../core/models/file-action-model.mjs";
+//#region src/entities/blocks/files/actions/DownloadFileAction.ts
+var r = class extends n {
+	configure() {
+		return {
+			name: "download",
+			icon: t,
+			elementTagName: "a",
+			translation: "downloadFile"
+		};
+	}
+	onClick() {
+		let { events: e } = this.editor, t = this.getBlockElement(), n = t?.baseModel;
+		if (t && n) {
+			let r = this.getItemElement();
+			if (r) {
+				let i = n.getContentElement(), a = n.getItemIndex(r);
+				e.change({
+					modelCode: this.getModelCode(),
+					type: "download",
+					contentElement: i,
+					blockElement: t,
+					item: r,
+					index: a
+				});
+			}
+		}
+	}
+	onMount(t) {
+		let n = this.getItemElement();
+		if (n) {
+			let r = n.fileUrl, i = n.fileName || "";
+			r && e(t, {
+				href: r,
+				target: "_blank",
+				download: i || r.split("/").pop() || ""
+			});
+		}
+	}
+};
+//#endregion
+export { r as default };