hexagon-editor 0.1.0-alpha.0

package/dist/heading-specs-D7Bj4aIM.js

@@ -0,0 +1,489 @@
+import { d as I } from "./index-uerphigI.js";
+const f = "blockquote", q = {
+  content: "block+",
+  defining: !0,
+  group: "block",
+  parseDOM: [{ tag: "blockquote" }],
+  selectable: !0,
+  selectAll: "node",
+  toDOM: () => ["blockquote", 0]
+}, G = { block: f }, W = (e, t) => {
+  e.wrapBlock("> ", null, t, () => e.renderContent(t));
+}, ze = (e) => {
+  e.addNodeSpec(f, () => q).addMarkdownTokenParserSpec(f, () => G).addNodeSerializerSpec(f, () => W);
+}, b = "strong", d = { Markup: "data-markup" }, y = "**", j = {
+  attrs: { [d.Markup]: { default: y } },
+  parseDOM: [
+    { tag: "b" },
+    { getAttrs: (e) => ({ [d.Markup]: e.getAttribute(d.Markup) }), tag: "strong" },
+    { getAttrs: (e) => /^(bold(er)?|[5-9]\d{2,})$/.test(e) && null, style: "font-weight" }
+  ],
+  toDOM: (e) => ["strong", e.attrs]
+}, E = { getAttrs: (e) => ({ [d.Markup]: e.markup }), mark: b }, F = {
+  close: D,
+  expelEnclosingWhitespace: !0,
+  mixable: !0,
+  open: D
+}, Be = (e) => {
+  e.addMarkSpec(b, () => j).addMarkdownTokenParserSpec(b, () => E).addMarkSerializerSpec(b, () => F);
+};
+function D(e, t) {
+  return t.attrs[d.Markup] || y;
+}
+var K = /* @__PURE__ */ ((e) => (e.HardBreak = "hard_break", e.SoftBreak = "soft_break", e))(K || {});
+const U = P(), V = P(), N = {
+  hardbreak: {
+    node: "hard_break"
+    /* HardBreak */
+  },
+  softbreak: {
+    node: "soft_break"
+    /* SoftBreak */
+  }
+}, J = (e, t, r, a) => {
+  H(t.type.name, r, a) && e.write(`\\
+`);
+}, Q = (e, t, r, a) => {
+  H(t.type.name, r, a) && e.write(`
+`);
+}, xe = (e, t) => {
+  const r = t?.preferredBreak ?? "hard";
+  e.addNodeSpec("hard_break", () => ({
+    ...U,
+    parseDOM: r === "hard" ? [{ tag: "br" }] : void 0
+  })).addNodeSpec("soft_break", () => ({
+    ...V,
+    parseDOM: r === "soft" ? [{ tag: "br" }] : void 0
+  })).addMarkdownTokenParserSpec("hardbreak", () => N.hardbreak).addMarkdownTokenParserSpec("softbreak", () => N.softbreak).addNodeSerializerSpec("hard_break", () => J).addNodeSerializerSpec("soft_break", () => Q);
+};
+function P() {
+  return {
+    group: "inline break",
+    inline: !0,
+    isBreak: !0,
+    marks: "",
+    parseDOM: [{ tag: "br" }],
+    selectable: !1,
+    toDOM: () => ["br"]
+  };
+}
+function H(e, t, r) {
+  for (let a = r + 1; a < t.childCount; a += 1)
+    if (t.child(a).type.name !== e) return !0;
+  return !1;
+}
+const m = "code", X = {
+  code: !0,
+  parseDOM: [{ tag: "code" }],
+  toDOM: () => ["code"]
+}, Y = { mark: m, noCloseToken: !0 }, Z = {
+  close: (e, t, r, a) => L(r.child(a - 1), 1),
+  escape: !1,
+  open: (e, t, r, a) => L(r.child(a), -1)
+}, Ce = (e) => {
+  e.addMarkSpec(m, () => X, e.Priority.Lowest).addMarkdownTokenParserSpec("code_inline", () => Y).addMarkSerializerSpec(m, () => Z);
+};
+function L(e, t) {
+  const r = /`+/g;
+  let a, o = 0;
+  if (e.isText)
+    for (; (a = r.exec(e.text ?? "")) !== null; ) o = Math.max(o, a[0].length);
+  let l = o > 0 && t > 0 ? " `" : "`";
+  for (let c = 0; c < o; c += 1) l += "`";
+  return o > 0 && t < 0 && (l += " "), l;
+}
+const u = "code_block", s = {
+  Lang: "data-language",
+  Line: "data-line",
+  Markup: "data-markup"
+}, ee = {
+  attrs: {
+    [s.Lang]: { default: "" },
+    [s.Line]: { default: null },
+    [s.Markup]: { default: "```" }
+  },
+  code: !0,
+  content: "text*",
+  group: "block",
+  marks: "",
+  parseDOM: [{
+    getAttrs: (e) => ({ [s.Lang]: re(e) }),
+    preserveWhitespace: "full",
+    tag: "pre"
+  }],
+  selectable: !0,
+  toDOM: ({ attrs: e }) => ["pre", e, ["code", 0]]
+}, z = {
+  code_block: { block: u, noCloseToken: !0 },
+  fence: {
+    block: u,
+    getAttrs: (e) => ({
+      [s.Lang]: e.info.split(/\s+/)[0] ?? "",
+      [s.Line]: e.attrGet("data-line"),
+      [s.Markup]: e.markup
+    }),
+    noCloseToken: !0
+  }
+}, te = (e, t) => {
+  const r = t.attrs[s.Lang], a = ae(t.attrs[s.Markup], t.textContent);
+  e.write(`${a}${r}
+`), e.text(t.textContent, !1), e.write(`
+`), e.write(a), e.closeBlock(t);
+}, _e = (e) => {
+  e.addNodeSpec(u, () => ee).addMarkdownTokenParserSpec("code_block", () => z.code_block).addMarkdownTokenParserSpec("fence", () => z.fence).addNodeSerializerSpec(u, () => te).addKeymap(({ schema: t }) => ({
+    Tab: (r, a) => {
+      const { $anchor: o, $head: l } = r.selection;
+      return !o.sameParent(l) || o.parent.type !== t.nodes[u] ? !1 : (a?.(r.tr.replaceSelectionWith(r.schema.text("	")).scrollIntoView()), !0);
+    }
+  }));
+};
+function re(e) {
+  const t = e.getAttribute(s.Lang);
+  if (t !== null && t.length > 0) return t;
+  const r = e.firstElementChild;
+  return r?.nodeName.toLowerCase() === "code" && r.classList.contains("hljs") ? r.classList[1] ?? "" : "";
+}
+function ae(e, t) {
+  const r = e.trim() || "```", a = r.startsWith("~") ? "~" : "`", l = (t.match(a === "~" ? /~{3,}/g : /`{3,}/g) ?? []).reduce((c, i) => Math.max(c, i.length), 0);
+  return a.repeat(Math.max(r.length, 3, l + 1));
+}
+var R = /* @__PURE__ */ ((e) => (e.List = "dl", e.Term = "dt", e.Desc = "dd", e))(R || {});
+const T = { Line: "data-line" }, ne = {
+  dl: {
+    content: "(dt dd)+",
+    group: "block",
+    parseDOM: [{ tag: "dl" }],
+    selectable: !0,
+    toDOM: () => ["dl", 0]
+  },
+  dt: {
+    attrs: { [T.Line]: { default: null } },
+    content: "inline*",
+    defining: !0,
+    group: "block",
+    parseDOM: [{ tag: "dt" }],
+    selectable: !1,
+    toDOM: (e) => ["dt", e.attrs, 0]
+  },
+  dd: {
+    content: "block+",
+    defining: !0,
+    group: "block",
+    parseDOM: [{ tag: "dd" }],
+    selectable: !1,
+    toDOM: () => ["dd", 0]
+  }
+}, oe = {
+  dl: {
+    block: "dl"
+    /* List */
+  },
+  dt: { block: "dt", getAttrs: (e) => ({ [T.Line]: e.attrGet(T.Line) }) },
+  dd: {
+    block: "dd"
+    /* Desc */
+  }
+}, le = {
+  dl: (e, t) => e.renderContent(t),
+  dt: (e, t) => {
+    e.renderInline(t), e.ensureNewLine();
+  },
+  dd: (e, t) => {
+    e.wrapBlock("  ", ": ", t, () => e.renderContent(t));
+  }
+}, ye = (e) => {
+  e.configureMd((t) => t.use(I));
+  for (const t of Object.values(R))
+    e.addNodeSpec(t, () => ne[t]), e.addMarkdownTokenParserSpec(t, () => oe[t]), e.addNodeSerializerSpec(t, () => le[t]);
+}, O = "horizontal_rule", A = "markup", se = {
+  attrs: { [A]: { default: "---" } },
+  group: "block",
+  parseDOM: [{ tag: "hr" }],
+  selectable: !0,
+  toDOM: () => ["div", ["hr"]]
+}, ce = {
+  getAttrs: (e) => ({ [A]: e.markup }),
+  node: O
+}, ie = (e, t) => {
+  e.write(t.attrs[A]), e.closeBlock(t);
+}, Pe = (e) => {
+  e.addNodeSpec(O, () => se).addMarkdownTokenParserSpec("hr", () => ce).addNodeSerializerSpec(O, () => ie);
+}, h = "em", k = { Markup: "data-markup" }, $ = "*", de = {
+  attrs: { [k.Markup]: { default: $ } },
+  parseDOM: [
+    { tag: "i" },
+    { getAttrs: (e) => ({ [k.Markup]: e.getAttribute(k.Markup) }), tag: "em" },
+    { getAttrs: (e) => e === "italic" && null, style: "font-style" }
+  ],
+  toDOM: (e) => ["em", e.attrs]
+}, ue = { getAttrs: (e) => ({ [k.Markup]: e.markup }), mark: h }, ke = {
+  close: B,
+  expelEnclosingWhitespace: !0,
+  mixable: !0,
+  open: B
+}, He = (e) => {
+  e.addMarkSpec(h, () => de).addMarkdownTokenParserSpec(h, () => ue).addMarkSerializerSpec(h, () => ke);
+};
+function B(e, t) {
+  return t.attrs[k.Markup] || $;
+}
+const M = "link", n = {
+  Href: "href",
+  IsPlaceholder: "is-placeholder",
+  Rel: "rel",
+  RawLink: "raw-link",
+  Target: "target",
+  Title: "title"
+}, pe = {
+  attrs: {
+    [n.Href]: {},
+    [n.IsPlaceholder]: { default: !1 },
+    [n.Rel]: { default: null },
+    [n.RawLink]: { default: !1 },
+    [n.Target]: { default: null },
+    [n.Title]: { default: null }
+  },
+  inclusive: !1,
+  parseDOM: [{
+    getAttrs: (e) => ({
+      [n.Href]: e.getAttribute(n.Href),
+      [n.Rel]: e.getAttribute(n.Rel),
+      [n.Target]: e.getAttribute(n.Target),
+      [n.Title]: e.getAttribute(n.Title)
+    }),
+    tag: "a[href]"
+  }],
+  toDOM: (e) => ["a", {
+    href: e.attrs[n.Href],
+    rel: e.attrs[n.Rel],
+    target: e.attrs[n.Target],
+    title: e.attrs[n.Title],
+    "data-link-tooltip": e.attrs[n.Href]
+  }, 0]
+}, ge = {
+  getAttrs: (e) => ({
+    [n.Href]: e.attrGet("href"),
+    [n.Rel]: e.attrGet("rel"),
+    [n.Target]: e.attrGet("target"),
+    [n.Title]: e.attrGet("title") || null
+  }),
+  mark: M
+}, fe = {
+  close: (e, t) => {
+    if (e.inAutolink)
+      return e.inAutolink = void 0, t.attrs[n.RawLink] ? "" : ">";
+    e.inAutolink = void 0;
+    const r = t.attrs[n.Target] === "_blank" ? ' {target="_blank" rel="noopener noreferrer"}' : "";
+    return `](${he(t.attrs[n.Href])}${t.attrs[n.Title] ? ` ${e.quote(t.attrs[n.Title])}` : ""})${r}`;
+  },
+  open: (e, t, r, a) => (e.inAutolink = Me(t, r, a), e.inAutolink ? t.attrs[n.RawLink] ? "" : "<" : "[")
+};
+function be(e) {
+  return e.core.ruler.after("inline", "link_attributes", (t) => {
+    for (const r of t.tokens) {
+      const a = r.children;
+      if (a !== null)
+        for (let o = 0; o < a.length - 1; o += 1) {
+          if (a[o]?.type !== "link_close" || a[o + 1]?.type !== "text") continue;
+          const l = a[o + 1], c = l.content.match(/^\s*\{target="_blank" rel="noopener noreferrer"}/);
+          if (c !== null)
+            for (let i = o - 1; i >= 0; i -= 1) {
+              const w = a[i];
+              if (w?.type === "link_open") {
+                w.attrSet("target", "_blank"), w.attrSet("rel", "noopener noreferrer"), l.content = l.content.slice(c[0].length);
+                break;
+              }
+            }
+        }
+    }
+  }), e;
+}
+const Re = (e) => {
+  e.configureMd(be).addMarkSpec(M, () => pe, e.Priority.High).addMarkdownTokenParserSpec(M, () => ge).addMarkSerializerSpec(M, () => fe);
+};
+function he(e) {
+  return e.replaceAll(/[()]/g, (t) => `\\${t}`);
+}
+function Me(e, t, r, a) {
+  if (e.attrs[n.Title] || !/^\w+:/.test(e.attrs[n.Href])) return !1;
+  const o = t.child(r + 0);
+  return !o.isText || o.text !== e.attrs[n.Href] || o.marks.at(-1) !== e ? !1 : r === t.childCount - 1 ? !0 : !e.isInSet(t.child(r + 1).marks);
+}
+var v = /* @__PURE__ */ ((e) => (e.Table = "table", e.Head = "thead", e.Body = "tbody", e.Row = "tr", e.HeaderCell = "th", e.DataCell = "td", e))(v || {}), Se = /* @__PURE__ */ ((e) => (e.CellAlign = "cell-align", e.Line = "data-line", e))(Se || {}), we = /* @__PURE__ */ ((e) => (e.Center = "center", e.Left = "left", e.Right = "right", e))(we || {});
+const me = {
+  table: { content: "thead tbody", group: "block", isolating: !0, parseDOM: [{ tag: "table" }], selectable: !0, toDOM: () => ["table", 0] },
+  thead: { content: "tr", group: "block", isolating: !0, parseDOM: [{ tag: "thead" }], toDOM: () => ["thead", 0] },
+  tbody: { content: "tr+", group: "block", isolating: !0, parseDOM: [{ tag: "tbody" }], toDOM: () => ["tbody", 0] },
+  tr: { attrs: { "data-line": { default: null } }, content: "(th|td)+", group: "block", isolating: !0, parseDOM: [{ tag: "tr" }], toDOM: (e) => ["tr", e.attrs, 0] },
+  th: x("th"),
+  td: x("td")
+};
+function x(e) {
+  return {
+    attrs: { "cell-align": {
+      default: "left"
+      /* Left */
+    } },
+    group: "block",
+    content: "(text | inline)*",
+    isolating: !0,
+    parseDOM: [{
+      getAttrs: (t) => ({
+        "cell-align": t.style.textAlign || "left"
+        /* Left */
+      }),
+      tag: e
+    }],
+    toDOM: (t) => [e, { ...t.attrs, style: `text-align:${t.attrs[
+      "cell-align"
+      /* CellAlign */
+    ]}` }, 0]
+  };
+}
+const Te = {
+  table: {
+    block: "table"
+    /* Table */
+  },
+  thead: {
+    block: "thead"
+    /* Head */
+  },
+  tbody: {
+    block: "tbody"
+    /* Body */
+  },
+  tr: {
+    block: "tr",
+    getAttrs: (e) => ({ "data-line": e.attrGet(
+      "data-line"
+      /* Line */
+    ) })
+  },
+  th: { block: "th", getAttrs: C },
+  td: { block: "td", getAttrs: C }
+};
+function C(e) {
+  return {
+    "cell-align": (Object.fromEntries(e.attrs ?? []).style ?? "").split(";").find((a) => a.startsWith("text-align:"))?.split(":")[1] ?? "left"
+    /* Left */
+  };
+}
+const Oe = {
+  table: (e, t) => {
+    e.ensureNewLine(), e.renderContent(t), e.ensureNewLine(), e.closeBlock(t);
+  },
+  thead: (e, t) => {
+    e.renderContent(t);
+    const r = t.firstChild;
+    for (let a = 0; r !== null && a < r.childCount; a += 1) {
+      const l = r.child(a).attrs[
+        "cell-align"
+        /* CellAlign */
+      ];
+      e.write(l === "left" ? "|:---" : l === "center" ? "|:---:" : l === "right" ? "|---:" : "|---");
+    }
+    e.write("|"), e.ensureNewLine();
+  },
+  tbody: (e, t) => e.renderContent(t),
+  tr: (e, t) => {
+    e.renderContent(t), e.write("|"), e.ensureNewLine();
+  },
+  th: _,
+  td: _
+};
+function _(e, t) {
+  e.write("|"), e.renderInline(t);
+}
+const $e = (e) => {
+  for (const t of Object.values(v))
+    e.addNodeSpec(t, () => me[t]).addMarkdownTokenParserSpec(t, () => Te[t]).addNodeSerializerSpec(t, () => Oe[t]);
+}, S = "heading", p = "level", g = "data-line", Ae = {
+  attrs: { [p]: { default: 1 }, [g]: { default: null } },
+  content: "(text | inline)*",
+  defining: !0,
+  group: "block",
+  parseDOM: [1, 2, 3, 4, 5, 6].map((e) => ({ attrs: { [p]: e }, tag: `h${e}` })),
+  toDOM: (e) => [
+    `h${e.attrs[p]}`,
+    e.attrs[g] === null ? {} : { [g]: e.attrs[g] },
+    0
+  ]
+}, De = {
+  block: S,
+  getAttrs: (e) => ({ [p]: Number(e.tag.slice(1)) })
+}, Ne = (e, t) => {
+  e.write(`${e.repeat("#", t.attrs[p])} `), e.renderInline(t), e.closeBlock(t);
+}, ve = (e) => {
+  e.addNodeSpec(S, () => Ae).addMarkdownTokenParserSpec(S, () => De).addNodeSerializerSpec(S, () => Ne);
+};
+export {
+  ge as $,
+  Y as A,
+  ze as B,
+  s as C,
+  T as D,
+  be as E,
+  ne as F,
+  le as G,
+  ve as H,
+  k as I,
+  oe as J,
+  U as K,
+  n as L,
+  p as M,
+  g as N,
+  S as O,
+  Ae as P,
+  De as Q,
+  A as R,
+  O as S,
+  Se as T,
+  se as U,
+  ce as V,
+  h as W,
+  de as X,
+  ue as Y,
+  M as Z,
+  pe as _,
+  d as a,
+  W as a0,
+  F as a1,
+  Z as a2,
+  te as a3,
+  J as a4,
+  Ne as a5,
+  ie as a6,
+  ke as a7,
+  fe as a8,
+  Q as a9,
+  V as aa,
+  me as ab,
+  Oe as ac,
+  Te as ad,
+  Be as b,
+  K as c,
+  xe as d,
+  _e as e,
+  Ce as f,
+  R as g,
+  ye as h,
+  Pe as i,
+  He as j,
+  Re as k,
+  we as l,
+  v as m,
+  $e as n,
+  f as o,
+  q as p,
+  G as q,
+  b as r,
+  j as s,
+  E as t,
+  N as u,
+  u as v,
+  ee as w,
+  z as x,
+  m as y,
+  X as z
+};

package/dist/i18n/index.d.ts

@@ -0,0 +1,70 @@
+import { MarkdownEditorLocale } from '../public-types';
+declare const en: {
+    readonly apply: "Submit";
+    readonly bold: "Bold";
+    readonly bulletList: "Bulleted list";
+    readonly cancel: "Cancel";
+    readonly code: "Inline code";
+    readonly codeBlock: "Code block";
+    readonly codeLanguage: "Code language";
+    readonly doubleClickToEdit: "Double-click to edit";
+    readonly color: "Text color";
+    readonly foldHeading: "Collapse section";
+    readonly formula: "Formula";
+    readonly formulaBlock: "Formula block";
+    readonly formulaInline: "Inline formula";
+    readonly formulaInsert: "Insert formula";
+    readonly heading: "Heading level";
+    readonly horizontalRule: "Horizontal rule";
+    readonly html: "HTML";
+    readonly image: "Image";
+    readonly imageAlt: "Alt text";
+    readonly imageAltAria: "Image description";
+    readonly imageAltHelp: "Displayed if the image cannot be loaded.";
+    readonly imageFit: "Image display";
+    readonly imageHeight: "Height";
+    readonly imageName: "Image name";
+    readonly imageSizes: "Size, px";
+    readonly imageTitle: "Image title";
+    readonly imageUpload: "Upload image";
+    readonly imageUploading: "Uploading…";
+    readonly imageUploadError: "Could not upload the image.";
+    readonly imageUrl: "Image link";
+    readonly imageUrlAria: "Image address";
+    readonly imageUrlError: "Enter a valid image address.";
+    readonly imageWidth: "Width";
+    readonly imageWidthFull: "Full width";
+    readonly italic: "Italic";
+    readonly link: "Link";
+    readonly linkNewWindow: "Open in a new window";
+    readonly linkRemove: "Remove";
+    readonly linkText: "Link text";
+    readonly linkTextHelp: "Text displayed as a link.";
+    readonly linkUrl: "Link address";
+    readonly mermaid: "Mermaid diagram";
+    readonly linkUrlError: "Enter a valid link address.";
+    readonly listIndent: "Increase indent";
+    readonly listOutdent: "Decrease indent";
+    readonly mark: "Highlight";
+    readonly markup: "Markup";
+    readonly mode: "Editor mode";
+    readonly orderedList: "Numbered list";
+    readonly paragraph: "Text";
+    readonly quote: "Quote";
+    readonly redo: "Redo";
+    readonly selectionBold: "Bold selection";
+    readonly selectionItalic: "Italic selection";
+    readonly split: "Split";
+    readonly strike: "Strikethrough";
+    readonly table: "Table 3×3";
+    readonly toolbar: "Markdown formatting";
+    readonly underline: "Underline";
+    readonly undo: "Undo";
+    readonly visual: "Visual";
+};
+export type MarkdownEditorMessageKey = keyof typeof en;
+export type MarkdownEditorMessages = Readonly<Record<MarkdownEditorMessageKey, string>>;
+export declare const markdownEditorMessages: Readonly<Record<MarkdownEditorLocale, MarkdownEditorMessages>>;
+export declare function getMarkdownEditorMessages(locale: MarkdownEditorLocale): MarkdownEditorMessages;
+export {};
+//# sourceMappingURL=index.d.ts.map

package/dist/i18n/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/i18n/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,oBAAoB,EAAC,MAAM,iBAAiB,CAAC;AAE1D,QAAA,MAAM,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAUE,CAAC;AAcX,MAAM,MAAM,wBAAwB,GAAG,MAAM,OAAO,EAAE,CAAC;AACvD,MAAM,MAAM,sBAAsB,GAAG,QAAQ,CAAC,MAAM,CAAC,wBAAwB,EAAE,MAAM,CAAC,CAAC,CAAC;AAExF,eAAO,MAAM,sBAAsB,EAAE,QAAQ,CAAC,MAAM,CAAC,oBAAoB,EAAE,sBAAsB,CAAC,CAAY,CAAC;AAE/G,wBAAgB,yBAAyB,CAAC,MAAM,EAAE,oBAAoB,GAAG,sBAAsB,CAE9F"}

package/dist/i18n.js

@@ -0,0 +1,132 @@
+const i = {
+  apply: "Submit",
+  bold: "Bold",
+  bulletList: "Bulleted list",
+  cancel: "Cancel",
+  code: "Inline code",
+  codeBlock: "Code block",
+  codeLanguage: "Code language",
+  doubleClickToEdit: "Double-click to edit",
+  color: "Text color",
+  foldHeading: "Collapse section",
+  formula: "Formula",
+  formulaBlock: "Formula block",
+  formulaInline: "Inline formula",
+  formulaInsert: "Insert formula",
+  heading: "Heading level",
+  horizontalRule: "Horizontal rule",
+  html: "HTML",
+  image: "Image",
+  imageAlt: "Alt text",
+  imageAltAria: "Image description",
+  imageAltHelp: "Displayed if the image cannot be loaded.",
+  imageFit: "Image display",
+  imageHeight: "Height",
+  imageName: "Image name",
+  imageSizes: "Size, px",
+  imageTitle: "Image title",
+  imageUpload: "Upload image",
+  imageUploading: "Uploading…",
+  imageUploadError: "Could not upload the image.",
+  imageUrl: "Image link",
+  imageUrlAria: "Image address",
+  imageUrlError: "Enter a valid image address.",
+  imageWidth: "Width",
+  imageWidthFull: "Full width",
+  italic: "Italic",
+  link: "Link",
+  linkNewWindow: "Open in a new window",
+  linkRemove: "Remove",
+  linkText: "Link text",
+  linkTextHelp: "Text displayed as a link.",
+  linkUrl: "Link address",
+  mermaid: "Mermaid diagram",
+  linkUrlError: "Enter a valid link address.",
+  listIndent: "Increase indent",
+  listOutdent: "Decrease indent",
+  mark: "Highlight",
+  markup: "Markup",
+  mode: "Editor mode",
+  orderedList: "Numbered list",
+  paragraph: "Text",
+  quote: "Quote",
+  redo: "Redo",
+  selectionBold: "Bold selection",
+  selectionItalic: "Italic selection",
+  split: "Split",
+  strike: "Strikethrough",
+  table: "Table 3×3",
+  toolbar: "Markdown formatting",
+  underline: "Underline",
+  undo: "Undo",
+  visual: "Visual"
+}, l = {
+  apply: "Сохранить",
+  bold: "Жирный",
+  bulletList: "Маркированный список",
+  cancel: "Отмена",
+  code: "Встроенный код",
+  codeBlock: "Блок кода",
+  codeLanguage: "Язык кода",
+  doubleClickToEdit: "Дважды нажмите, чтобы редактировать",
+  color: "Цвет текста",
+  foldHeading: "Свернуть раздел",
+  formula: "Формула",
+  formulaBlock: "Блок с формулой",
+  formulaInline: "Формула в тексте",
+  formulaInsert: "Вставить формулу",
+  heading: "Уровень заголовка",
+  horizontalRule: "Горизонтальная линия",
+  html: "HTML",
+  image: "Изображение",
+  imageAlt: "Альтернативный текст",
+  imageAltAria: "Описание изображения",
+  imageAltHelp: "Отображается, если изображение не загрузилось.",
+  imageFit: "Отображение изображения",
+  imageHeight: "Высота",
+  imageName: "Подпись к рисунку",
+  imageSizes: "Размер в пикселях",
+  imageTitle: "Заголовок изображения",
+  imageUpload: "Загрузить изображение",
+  imageUploading: "Загрузка…",
+  imageUploadError: "Не удалось загрузить изображение.",
+  imageUrl: "Ссылка картинки",
+  imageUrlAria: "Адрес изображения",
+  imageUrlError: "Введите корректный адрес изображения.",
+  imageWidth: "Ширина",
+  imageWidthFull: "На всю ширину",
+  italic: "Курсив",
+  link: "Ссылка",
+  linkNewWindow: "Открывать в новом окне",
+  linkRemove: "Удалить",
+  linkText: "Текст ссылки",
+  linkTextHelp: "Текст, который отображается как ссылка.",
+  linkUrl: "Адрес ссылки",
+  mermaid: "Диаграмма Mermaid",
+  linkUrlError: "Введите корректный адрес ссылки.",
+  listIndent: "Увеличить отступ",
+  listOutdent: "Уменьшить отступ",
+  mark: "Выделить",
+  markup: "Разметка",
+  mode: "Режим редактора",
+  orderedList: "Нумерованный список",
+  paragraph: "Текст",
+  quote: "Цитата",
+  redo: "Повторить",
+  selectionBold: "Жирный для выделения",
+  selectionItalic: "Курсив для выделения",
+  split: "Разделить",
+  strike: "Зачёркивание",
+  table: "Таблица 3×3",
+  toolbar: "Форматирование Markdown",
+  underline: "Подчёркивание",
+  undo: "Отменить",
+  visual: "Визуальный"
+}, a = { en: i, ru: l };
+function o(e) {
+  return a[e];
+}
+export {
+  o as getMarkdownEditorMessages,
+  a as markdownEditorMessages
+};