@valbuild/shared 0.48.1 → 0.50.0

package/internal/dist/valbuild-shared-internal.esm.js

@@ -1,79 +1,25 @@
 import { VAL_EXTENSION, Internal, FILE_REF_PROP } from '@valbuild/core';
 import * as marked from 'marked';
+import { z } from 'zod';
 
-function _arrayWithHoles(arr) {
-  if (Array.isArray(arr)) return arr;
-}
-
-function _iterableToArrayLimit(r, l) {
-  var t = null == r ? null : "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"];
-  if (null != t) {
-    var e,
-      n,
-      i,
-      u,
-      a = [],
-      f = !0,
-      o = !1;
-    try {
-      if (i = (t = t.call(r)).next, 0 === l) {
-        if (Object(t) !== t) return;
-        f = !1;
-      } else for (; !(f = (e = i.call(t)).done) && (a.push(e.value), a.length !== l); f = !0);
-    } catch (r) {
-      o = !0, n = r;
-    } finally {
-      try {
-        if (!f && null != t.return && (u = t.return(), Object(u) !== u)) return;
-      } finally {
-        if (o) throw n;
-      }
-    }
-    return a;
-  }
-}
-
-function _arrayLikeToArray(arr, len) {
-  if (len == null || len > arr.length) len = arr.length;
-  for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i];
-  return arr2;
-}
-
-function _unsupportedIterableToArray(o, minLen) {
-  if (!o) return;
-  if (typeof o === "string") return _arrayLikeToArray(o, minLen);
-  var n = Object.prototype.toString.call(o).slice(8, -1);
-  if (n === "Object" && o.constructor) n = o.constructor.name;
-  if (n === "Map" || n === "Set") return Array.from(o);
-  if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen);
-}
-
-function _nonIterableRest() {
-  throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
-}
-
-function _slicedToArray(arr, i) {
-  return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest();
-}
-
-function _toPrimitive(input, hint) {
-  if (typeof input !== "object" || input === null) return input;
-  var prim = input[Symbol.toPrimitive];
-  if (prim !== undefined) {
-    var res = prim.call(input, hint || "default");
-    if (typeof res !== "object") return res;
+function toPrimitive(t, r) {
+  if ("object" != typeof t || !t) return t;
+  var e = t[Symbol.toPrimitive];
+  if (void 0 !== e) {
+    var i = e.call(t, r || "default");
+    if ("object" != typeof i) return i;
     throw new TypeError("@@toPrimitive must return a primitive value.");
   }
-  return (hint === "string" ? String : Number)(input);
+  return ("string" === r ? String : Number)(t);
 }
 
-function _toPropertyKey(arg) {
-  var key = _toPrimitive(arg, "string");
-  return typeof key === "symbol" ? key : String(key);
+function toPropertyKey(t) {
+  var i = toPrimitive(t, "string");
+  return "symbol" == typeof i ? i : String(i);
 }
 
 function _defineProperty(obj, key, value) {
-  key = _toPropertyKey(key);
+  key = toPropertyKey(key);
   if (key in obj) {
     Object.defineProperty(obj, key, {
       value: value,
@@ -87,6 +33,21 @@ function _defineProperty(obj, key, value) {
   return obj;
 }
 
+function _arrayLikeToArray(arr, len) {
+  if (len == null || len > arr.length) len = arr.length;
+  for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i];
+  return arr2;
+}
+
+function _unsupportedIterableToArray(o, minLen) {
+  if (!o) return;
+  if (typeof o === "string") return _arrayLikeToArray(o, minLen);
+  var n = Object.prototype.toString.call(o).slice(8, -1);
+  if (n === "Object" && o.constructor) n = o.constructor.name;
+  if (n === "Map" || n === "Set") return Array.from(o);
+  if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen);
+}
+
 function _createForOfIteratorHelper(o, allowArrayLike) {
   var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"];
   if (!it) {
@@ -155,7 +116,746 @@ function _toConsumableArray(arr) {
   return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread();
 }
 
-var MIME_TYPE_REGEX = /^data:(image\/(png|jpeg|jpg|gif|webp|bmp|tiff|ico|svg\+xml));base64,/;
+function _arrayWithHoles(arr) {
+  if (Array.isArray(arr)) return arr;
+}
+
+function _iterableToArrayLimit(r, l) {
+  var t = null == r ? null : "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"];
+  if (null != t) {
+    var e,
+      n,
+      i,
+      u,
+      a = [],
+      f = !0,
+      o = !1;
+    try {
+      if (i = (t = t.call(r)).next, 0 === l) {
+        if (Object(t) !== t) return;
+        f = !1;
+      } else for (; !(f = (e = i.call(t)).done) && (a.push(e.value), a.length !== l); f = !0);
+    } catch (r) {
+      o = !0, n = r;
+    } finally {
+      try {
+        if (!f && null != t.return && (u = t.return(), Object(u) !== u)) return;
+      } finally {
+        if (o) throw n;
+      }
+    }
+    return a;
+  }
+}
+
+function _nonIterableRest() {
+  throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+
+function _slicedToArray(arr, i) {
+  return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest();
+}
+
+var EXT_TO_MIME_TYPES = {
+  x3d: "application/vnd.hzn-3d-crossword",
+  "3gp": "video/3gpp",
+  "3g2": "video/3gpp2",
+  mseq: "application/vnd.mseq",
+  pwn: "application/vnd.3m.post-it-notes",
+  plb: "application/vnd.3gpp.pic-bw-large",
+  psb: "application/vnd.3gpp.pic-bw-small",
+  pvb: "application/vnd.3gpp.pic-bw-var",
+  tcap: "application/vnd.3gpp2.tcap",
+  "7z": "application/x-7z-compressed",
+  abw: "application/x-abiword",
+  ace: "application/x-ace-compressed",
+  acc: "application/vnd.americandynamics.acc",
+  acu: "application/vnd.acucobol",
+  atc: "application/vnd.acucorp",
+  adp: "audio/adpcm",
+  aab: "application/x-authorware-bin",
+  aam: "application/x-authorware-map",
+  aas: "application/x-authorware-seg",
+  air: "application/vnd.adobe.air-application-installer-package+zip",
+  swf: "application/x-shockwave-flash",
+  fxp: "application/vnd.adobe.fxp",
+  pdf: "application/pdf",
+  ppd: "application/vnd.cups-ppd",
+  dir: "application/x-director",
+  xdp: "application/vnd.adobe.xdp+xml",
+  xfdf: "application/vnd.adobe.xfdf",
+  aac: "audio/x-aac",
+  ahead: "application/vnd.ahead.space",
+  azf: "application/vnd.airzip.filesecure.azf",
+  azs: "application/vnd.airzip.filesecure.azs",
+  azw: "application/vnd.amazon.ebook",
+  ami: "application/vnd.amiga.ami",
+  "N/A": "application/andrew-inset",
+  apk: "application/vnd.android.package-archive",
+  cii: "application/vnd.anser-web-certificate-issue-initiation",
+  fti: "application/vnd.anser-web-funds-transfer-initiation",
+  atx: "application/vnd.antix.game-component",
+  dmg: "application/x-apple-diskimage",
+  mpkg: "application/vnd.apple.installer+xml",
+  aw: "application/applixware",
+  mp3: "audio/mpeg",
+  les: "application/vnd.hhe.lesson-player",
+  swi: "application/vnd.aristanetworks.swi",
+  s: "text/x-asm",
+  atomcat: "application/atomcat+xml",
+  atomsvc: "application/atomsvc+xml",
+  atom: "application/atom+xml",
+  ac: "application/pkix-attr-cert",
+  aif: "audio/x-aiff",
+  avi: "video/x-msvideo",
+  aep: "application/vnd.audiograph",
+  dxf: "image/vnd.dxf",
+  dwf: "model/vnd.dwf",
+  par: "text/plain-bas",
+  bcpio: "application/x-bcpio",
+  bin: "application/octet-stream",
+  bmp: "image/bmp",
+  torrent: "application/x-bittorrent",
+  cod: "application/vnd.rim.cod",
+  mpm: "application/vnd.blueice.multipass",
+  bmi: "application/vnd.bmi",
+  sh: "application/x-sh",
+  btif: "image/prs.btif",
+  rep: "application/vnd.businessobjects",
+  bz: "application/x-bzip",
+  bz2: "application/x-bzip2",
+  csh: "application/x-csh",
+  c: "text/x-c",
+  cdxml: "application/vnd.chemdraw+xml",
+  css: "text/css",
+  cdx: "chemical/x-cdx",
+  cml: "chemical/x-cml",
+  csml: "chemical/x-csml",
+  cdbcmsg: "application/vnd.contact.cmsg",
+  cla: "application/vnd.claymore",
+  c4g: "application/vnd.clonk.c4group",
+  sub: "image/vnd.dvb.subtitle",
+  cdmia: "application/cdmi-capability",
+  cdmic: "application/cdmi-container",
+  cdmid: "application/cdmi-domain",
+  cdmio: "application/cdmi-object",
+  cdmiq: "application/cdmi-queue",
+  c11amc: "application/vnd.cluetrust.cartomobile-config",
+  c11amz: "application/vnd.cluetrust.cartomobile-config-pkg",
+  ras: "image/x-cmu-raster",
+  dae: "model/vnd.collada+xml",
+  csv: "text/csv",
+  cpt: "application/mac-compactpro",
+  wmlc: "application/vnd.wap.wmlc",
+  cgm: "image/cgm",
+  ice: "x-conference/x-cooltalk",
+  cmx: "image/x-cmx",
+  xar: "application/vnd.xara",
+  cmc: "application/vnd.cosmocaller",
+  cpio: "application/x-cpio",
+  clkx: "application/vnd.crick.clicker",
+  clkk: "application/vnd.crick.clicker.keyboard",
+  clkp: "application/vnd.crick.clicker.palette",
+  clkt: "application/vnd.crick.clicker.template",
+  clkw: "application/vnd.crick.clicker.wordbank",
+  wbs: "application/vnd.criticaltools.wbs+xml",
+  cryptonote: "application/vnd.rig.cryptonote",
+  cif: "chemical/x-cif",
+  cmdf: "chemical/x-cmdf",
+  cu: "application/cu-seeme",
+  cww: "application/prs.cww",
+  curl: "text/vnd.curl",
+  dcurl: "text/vnd.curl.dcurl",
+  mcurl: "text/vnd.curl.mcurl",
+  scurl: "text/vnd.curl.scurl",
+  car: "application/vnd.curl.car",
+  pcurl: "application/vnd.curl.pcurl",
+  cmp: "application/vnd.yellowriver-custom-menu",
+  dssc: "application/dssc+der",
+  xdssc: "application/dssc+xml",
+  deb: "application/x-debian-package",
+  uva: "audio/vnd.dece.audio",
+  uvi: "image/vnd.dece.graphic",
+  uvh: "video/vnd.dece.hd",
+  uvm: "video/vnd.dece.mobile",
+  uvu: "video/vnd.uvvu.mp4",
+  uvp: "video/vnd.dece.pd",
+  uvs: "video/vnd.dece.sd",
+  uvv: "video/vnd.dece.video",
+  dvi: "application/x-dvi",
+  seed: "application/vnd.fdsn.seed",
+  dtb: "application/x-dtbook+xml",
+  res: "application/x-dtbresource+xml",
+  ait: "application/vnd.dvb.ait",
+  svc: "application/vnd.dvb.service",
+  eol: "audio/vnd.digital-winds",
+  djvu: "image/vnd.djvu",
+  dtd: "application/xml-dtd",
+  mlp: "application/vnd.dolby.mlp",
+  wad: "application/x-doom",
+  dpg: "application/vnd.dpgraph",
+  dra: "audio/vnd.dra",
+  dfac: "application/vnd.dreamfactory",
+  dts: "audio/vnd.dts",
+  dtshd: "audio/vnd.dts.hd",
+  dwg: "image/vnd.dwg",
+  geo: "application/vnd.dynageo",
+  es: "application/ecmascript",
+  mag: "application/vnd.ecowin.chart",
+  mmr: "image/vnd.fujixerox.edmics-mmr",
+  rlc: "image/vnd.fujixerox.edmics-rlc",
+  exi: "application/exi",
+  mgz: "application/vnd.proteus.magazine",
+  epub: "application/epub+zip",
+  eml: "message/rfc822",
+  nml: "application/vnd.enliven",
+  xpr: "application/vnd.is-xpr",
+  xif: "image/vnd.xiff",
+  xfdl: "application/vnd.xfdl",
+  emma: "application/emma+xml",
+  ez2: "application/vnd.ezpix-album",
+  ez3: "application/vnd.ezpix-package",
+  fst: "image/vnd.fst",
+  fvt: "video/vnd.fvt",
+  fbs: "image/vnd.fastbidsheet",
+  fe_launch: "application/vnd.denovo.fcselayout-link",
+  f4v: "video/x-f4v",
+  flv: "video/x-flv",
+  fpx: "image/vnd.fpx",
+  npx: "image/vnd.net-fpx",
+  flx: "text/vnd.fmi.flexstor",
+  fli: "video/x-fli",
+  ftc: "application/vnd.fluxtime.clip",
+  fdf: "application/vnd.fdf",
+  f: "text/x-fortran",
+  mif: "application/vnd.mif",
+  fm: "application/vnd.framemaker",
+  fh: "image/x-freehand",
+  fsc: "application/vnd.fsc.weblaunch",
+  fnc: "application/vnd.frogans.fnc",
+  ltf: "application/vnd.frogans.ltf",
+  ddd: "application/vnd.fujixerox.ddd",
+  xdw: "application/vnd.fujixerox.docuworks",
+  xbd: "application/vnd.fujixerox.docuworks.binder",
+  oas: "application/vnd.fujitsu.oasys",
+  oa2: "application/vnd.fujitsu.oasys2",
+  oa3: "application/vnd.fujitsu.oasys3",
+  fg5: "application/vnd.fujitsu.oasysgp",
+  bh2: "application/vnd.fujitsu.oasysprs",
+  spl: "application/x-futuresplash",
+  fzs: "application/vnd.fuzzysheet",
+  g3: "image/g3fax",
+  gmx: "application/vnd.gmx",
+  gtw: "model/vnd.gtw",
+  txd: "application/vnd.genomatix.tuxedo",
+  ggb: "application/vnd.geogebra.file",
+  ggt: "application/vnd.geogebra.tool",
+  gdl: "model/vnd.gdl",
+  gex: "application/vnd.geometry-explorer",
+  gxt: "application/vnd.geonext",
+  g2w: "application/vnd.geoplan",
+  g3w: "application/vnd.geospace",
+  gsf: "application/x-font-ghostscript",
+  bdf: "application/x-font-bdf",
+  gtar: "application/x-gtar",
+  texinfo: "application/x-texinfo",
+  gnumeric: "application/x-gnumeric",
+  kml: "application/vnd.google-earth.kml+xml",
+  kmz: "application/vnd.google-earth.kmz",
+  gqf: "application/vnd.grafeq",
+  gif: "image/gif",
+  gv: "text/vnd.graphviz",
+  gac: "application/vnd.groove-account",
+  ghf: "application/vnd.groove-help",
+  gim: "application/vnd.groove-identity-message",
+  grv: "application/vnd.groove-injector",
+  gtm: "application/vnd.groove-tool-message",
+  tpl: "application/vnd.groove-tool-template",
+  vcg: "application/vnd.groove-vcard",
+  h261: "video/h261",
+  h263: "video/h263",
+  h264: "video/h264",
+  hpid: "application/vnd.hp-hpid",
+  hps: "application/vnd.hp-hps",
+  hdf: "application/x-hdf",
+  rip: "audio/vnd.rip",
+  hbci: "application/vnd.hbci",
+  jlt: "application/vnd.hp-jlyt",
+  pcl: "application/vnd.hp-pcl",
+  hpgl: "application/vnd.hp-hpgl",
+  hvs: "application/vnd.yamaha.hv-script",
+  hvd: "application/vnd.yamaha.hv-dic",
+  hvp: "application/vnd.yamaha.hv-voice",
+  "sfd-hdstx": "application/vnd.hydrostatix.sof-data",
+  stk: "application/hyperstudio",
+  hal: "application/vnd.hal+xml",
+  html: "text/html",
+  irm: "application/vnd.ibm.rights-management",
+  sc: "application/vnd.ibm.secure-container",
+  ics: "text/calendar",
+  icc: "application/vnd.iccprofile",
+  ico: "image/x-icon",
+  igl: "application/vnd.igloader",
+  ief: "image/ief",
+  ivp: "application/vnd.immervision-ivp",
+  ivu: "application/vnd.immervision-ivu",
+  rif: "application/reginfo+xml",
+  "3dml": "text/vnd.in3d.3dml",
+  spot: "text/vnd.in3d.spot",
+  igs: "model/iges",
+  i2g: "application/vnd.intergeo",
+  cdy: "application/vnd.cinderella",
+  xpw: "application/vnd.intercon.formnet",
+  fcs: "application/vnd.isac.fcs",
+  ipfix: "application/ipfix",
+  cer: "application/pkix-cert",
+  pki: "application/pkixcmp",
+  crl: "application/pkix-crl",
+  pkipath: "application/pkix-pkipath",
+  igm: "application/vnd.insors.igm",
+  rcprofile: "application/vnd.ipunplugged.rcprofile",
+  irp: "application/vnd.irepository.package+xml",
+  jad: "text/vnd.sun.j2me.app-descriptor",
+  jar: "application/java-archive",
+  "class": "application/java-vm",
+  jnlp: "application/x-java-jnlp-file",
+  ser: "application/java-serialized-object",
+  java: "text/x-java-source,java",
+  js: "application/javascript",
+  json: "application/json",
+  joda: "application/vnd.joost.joda-archive",
+  jpm: "video/jpm",
+  jpeg: "image/jpeg",
+  jpg: "image/jpeg",
+  pjpeg: "image/pjpeg",
+  jpgv: "video/jpeg",
+  ktz: "application/vnd.kahootz",
+  mmd: "application/vnd.chipnuts.karaoke-mmd",
+  karbon: "application/vnd.kde.karbon",
+  chrt: "application/vnd.kde.kchart",
+  kfo: "application/vnd.kde.kformula",
+  flw: "application/vnd.kde.kivio",
+  kon: "application/vnd.kde.kontour",
+  kpr: "application/vnd.kde.kpresenter",
+  ksp: "application/vnd.kde.kspread",
+  kwd: "application/vnd.kde.kword",
+  htke: "application/vnd.kenameaapp",
+  kia: "application/vnd.kidspiration",
+  kne: "application/vnd.kinar",
+  sse: "application/vnd.kodak-descriptor",
+  lasxml: "application/vnd.las.las+xml",
+  latex: "application/x-latex",
+  lbd: "application/vnd.llamagraphics.life-balance.desktop",
+  lbe: "application/vnd.llamagraphics.life-balance.exchange+xml",
+  jam: "application/vnd.jam",
+  "123": "application/vnd.lotus-1-2-3",
+  apr: "application/vnd.lotus-approach",
+  pre: "application/vnd.lotus-freelance",
+  nsf: "application/vnd.lotus-notes",
+  org: "application/vnd.lotus-organizer",
+  scm: "application/vnd.lotus-screencam",
+  lwp: "application/vnd.lotus-wordpro",
+  lvp: "audio/vnd.lucent.voice",
+  m3u: "audio/x-mpegurl",
+  m4v: "video/x-m4v",
+  hqx: "application/mac-binhex40",
+  portpkg: "application/vnd.macports.portpkg",
+  mgp: "application/vnd.osgeo.mapguide.package",
+  mrc: "application/marc",
+  mrcx: "application/marcxml+xml",
+  mxf: "application/mxf",
+  nbp: "application/vnd.wolfram.player",
+  ma: "application/mathematica",
+  mathml: "application/mathml+xml",
+  mbox: "application/mbox",
+  mc1: "application/vnd.medcalcdata",
+  mscml: "application/mediaservercontrol+xml",
+  cdkey: "application/vnd.mediastation.cdkey",
+  mwf: "application/vnd.mfer",
+  mfm: "application/vnd.mfmp",
+  msh: "model/mesh",
+  mads: "application/mads+xml",
+  mets: "application/mets+xml",
+  mods: "application/mods+xml",
+  meta4: "application/metalink4+xml",
+  mcd: "application/vnd.mcd",
+  flo: "application/vnd.micrografx.flo",
+  igx: "application/vnd.micrografx.igx",
+  es3: "application/vnd.eszigno3+xml",
+  mdb: "application/x-msaccess",
+  asf: "video/x-ms-asf",
+  exe: "application/x-msdownload",
+  cil: "application/vnd.ms-artgalry",
+  cab: "application/vnd.ms-cab-compressed",
+  ims: "application/vnd.ms-ims",
+  application: "application/x-ms-application",
+  clp: "application/x-msclip",
+  mdi: "image/vnd.ms-modi",
+  eot: "application/vnd.ms-fontobject",
+  xls: "application/vnd.ms-excel",
+  xlam: "application/vnd.ms-excel.addin.macroenabled.12",
+  xlsb: "application/vnd.ms-excel.sheet.binary.macroenabled.12",
+  xltm: "application/vnd.ms-excel.template.macroenabled.12",
+  xlsm: "application/vnd.ms-excel.sheet.macroenabled.12",
+  chm: "application/vnd.ms-htmlhelp",
+  crd: "application/x-mscardfile",
+  lrm: "application/vnd.ms-lrm",
+  mvb: "application/x-msmediaview",
+  mny: "application/x-msmoney",
+  pptx: "application/vnd.openxmlformats-officedocument.presentationml.presentation",
+  sldx: "application/vnd.openxmlformats-officedocument.presentationml.slide",
+  ppsx: "application/vnd.openxmlformats-officedocument.presentationml.slideshow",
+  potx: "application/vnd.openxmlformats-officedocument.presentationml.template",
+  xlsx: "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
+  xltx: "application/vnd.openxmlformats-officedocument.spreadsheetml.template",
+  docx: "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
+  dotx: "application/vnd.openxmlformats-officedocument.wordprocessingml.template",
+  obd: "application/x-msbinder",
+  thmx: "application/vnd.ms-officetheme",
+  onetoc: "application/onenote",
+  pya: "audio/vnd.ms-playready.media.pya",
+  pyv: "video/vnd.ms-playready.media.pyv",
+  ppt: "application/vnd.ms-powerpoint",
+  ppam: "application/vnd.ms-powerpoint.addin.macroenabled.12",
+  sldm: "application/vnd.ms-powerpoint.slide.macroenabled.12",
+  pptm: "application/vnd.ms-powerpoint.presentation.macroenabled.12",
+  ppsm: "application/vnd.ms-powerpoint.slideshow.macroenabled.12",
+  potm: "application/vnd.ms-powerpoint.template.macroenabled.12",
+  mpp: "application/vnd.ms-project",
+  pub: "application/x-mspublisher",
+  scd: "application/x-msschedule",
+  xap: "application/x-silverlight-app",
+  stl: "application/vnd.ms-pki.stl",
+  cat: "application/vnd.ms-pki.seccat",
+  vsd: "application/vnd.visio",
+  vsdx: "application/vnd.visio2013",
+  wm: "video/x-ms-wm",
+  wma: "audio/x-ms-wma",
+  wax: "audio/x-ms-wax",
+  wmx: "video/x-ms-wmx",
+  wmd: "application/x-ms-wmd",
+  wpl: "application/vnd.ms-wpl",
+  wmz: "application/x-ms-wmz",
+  wmv: "video/x-ms-wmv",
+  wvx: "video/x-ms-wvx",
+  wmf: "application/x-msmetafile",
+  trm: "application/x-msterminal",
+  doc: "application/msword",
+  docm: "application/vnd.ms-word.document.macroenabled.12",
+  dotm: "application/vnd.ms-word.template.macroenabled.12",
+  wri: "application/x-mswrite",
+  wps: "application/vnd.ms-works",
+  xbap: "application/x-ms-xbap",
+  xps: "application/vnd.ms-xpsdocument",
+  mid: "audio/midi",
+  mpy: "application/vnd.ibm.minipay",
+  afp: "application/vnd.ibm.modcap",
+  rms: "application/vnd.jcp.javame.midlet-rms",
+  tmo: "application/vnd.tmobile-livetv",
+  prc: "application/x-mobipocket-ebook",
+  mbk: "application/vnd.mobius.mbk",
+  dis: "application/vnd.mobius.dis",
+  plc: "application/vnd.mobius.plc",
+  mqy: "application/vnd.mobius.mqy",
+  msl: "application/vnd.mobius.msl",
+  txf: "application/vnd.mobius.txf",
+  daf: "application/vnd.mobius.daf",
+  fly: "text/vnd.fly",
+  mpc: "application/vnd.mophun.certificate",
+  mpn: "application/vnd.mophun.application",
+  mj2: "video/mj2",
+  mpga: "audio/mpeg",
+  mxu: "video/vnd.mpegurl",
+  mpeg: "video/mpeg",
+  m21: "application/mp21",
+  mp4a: "audio/mp4",
+  mp4: "video/mp4",
+  m3u8: "application/vnd.apple.mpegurl",
+  mus: "application/vnd.musician",
+  msty: "application/vnd.muvee.style",
+  mxml: "application/xv+xml",
+  ngdat: "application/vnd.nokia.n-gage.data",
+  "n-gage": "application/vnd.nokia.n-gage.symbian.install",
+  ncx: "application/x-dtbncx+xml",
+  nc: "application/x-netcdf",
+  nlu: "application/vnd.neurolanguage.nlu",
+  dna: "application/vnd.dna",
+  nnd: "application/vnd.noblenet-directory",
+  nns: "application/vnd.noblenet-sealer",
+  nnw: "application/vnd.noblenet-web",
+  rpst: "application/vnd.nokia.radio-preset",
+  rpss: "application/vnd.nokia.radio-presets",
+  n3: "text/n3",
+  edm: "application/vnd.novadigm.edm",
+  edx: "application/vnd.novadigm.edx",
+  ext: "application/vnd.novadigm.ext",
+  gph: "application/vnd.flographit",
+  ecelp4800: "audio/vnd.nuera.ecelp4800",
+  ecelp7470: "audio/vnd.nuera.ecelp7470",
+  ecelp9600: "audio/vnd.nuera.ecelp9600",
+  oda: "application/oda",
+  ogx: "application/ogg",
+  oga: "audio/ogg",
+  ogv: "video/ogg",
+  dd2: "application/vnd.oma.dd2+xml",
+  oth: "application/vnd.oasis.opendocument.text-web",
+  opf: "application/oebps-package+xml",
+  qbo: "application/vnd.intu.qbo",
+  oxt: "application/vnd.openofficeorg.extension",
+  osf: "application/vnd.yamaha.openscoreformat",
+  weba: "audio/webm",
+  webm: "video/webm",
+  odc: "application/vnd.oasis.opendocument.chart",
+  otc: "application/vnd.oasis.opendocument.chart-template",
+  odb: "application/vnd.oasis.opendocument.database",
+  odf: "application/vnd.oasis.opendocument.formula",
+  odft: "application/vnd.oasis.opendocument.formula-template",
+  odg: "application/vnd.oasis.opendocument.graphics",
+  otg: "application/vnd.oasis.opendocument.graphics-template",
+  odi: "application/vnd.oasis.opendocument.image",
+  oti: "application/vnd.oasis.opendocument.image-template",
+  odp: "application/vnd.oasis.opendocument.presentation",
+  otp: "application/vnd.oasis.opendocument.presentation-template",
+  ods: "application/vnd.oasis.opendocument.spreadsheet",
+  ots: "application/vnd.oasis.opendocument.spreadsheet-template",
+  odt: "application/vnd.oasis.opendocument.text",
+  odm: "application/vnd.oasis.opendocument.text-master",
+  ott: "application/vnd.oasis.opendocument.text-template",
+  ktx: "image/ktx",
+  sxc: "application/vnd.sun.xml.calc",
+  stc: "application/vnd.sun.xml.calc.template",
+  sxd: "application/vnd.sun.xml.draw",
+  std: "application/vnd.sun.xml.draw.template",
+  sxi: "application/vnd.sun.xml.impress",
+  sti: "application/vnd.sun.xml.impress.template",
+  sxm: "application/vnd.sun.xml.math",
+  sxw: "application/vnd.sun.xml.writer",
+  sxg: "application/vnd.sun.xml.writer.global",
+  stw: "application/vnd.sun.xml.writer.template",
+  otf: "application/x-font-otf",
+  osfpvg: "application/vnd.yamaha.openscoreformat.osfpvg+xml",
+  dp: "application/vnd.osgi.dp",
+  pdb: "application/vnd.palm",
+  p: "text/x-pascal",
+  paw: "application/vnd.pawaafile",
+  pclxl: "application/vnd.hp-pclxl",
+  efif: "application/vnd.picsel",
+  pcx: "image/x-pcx",
+  psd: "image/vnd.adobe.photoshop",
+  prf: "application/pics-rules",
+  pic: "image/x-pict",
+  chat: "application/x-chat",
+  p10: "application/pkcs10",
+  p12: "application/x-pkcs12",
+  p7m: "application/pkcs7-mime",
+  p7s: "application/pkcs7-signature",
+  p7r: "application/x-pkcs7-certreqresp",
+  p7b: "application/x-pkcs7-certificates",
+  p8: "application/pkcs8",
+  plf: "application/vnd.pocketlearn",
+  pnm: "image/x-portable-anymap",
+  pbm: "image/x-portable-bitmap",
+  pcf: "application/x-font-pcf",
+  pfr: "application/font-tdpfr",
+  pgn: "application/x-chess-pgn",
+  pgm: "image/x-portable-graymap",
+  png: "image/png",
+  ppm: "image/x-portable-pixmap",
+  pskcxml: "application/pskc+xml",
+  pml: "application/vnd.ctc-posml",
+  ai: "application/postscript",
+  pfa: "application/x-font-type1",
+  pbd: "application/vnd.powerbuilder6",
+  pgp: "application/pgp-signature",
+  box: "application/vnd.previewsystems.box",
+  ptid: "application/vnd.pvi.ptid1",
+  pls: "application/pls+xml",
+  str: "application/vnd.pg.format",
+  ei6: "application/vnd.pg.osasli",
+  dsc: "text/prs.lines.tag",
+  psf: "application/x-font-linux-psf",
+  qps: "application/vnd.publishare-delta-tree",
+  wg: "application/vnd.pmi.widget",
+  qxd: "application/vnd.quark.quarkxpress",
+  esf: "application/vnd.epson.esf",
+  msf: "application/vnd.epson.msf",
+  ssf: "application/vnd.epson.ssf",
+  qam: "application/vnd.epson.quickanime",
+  qfx: "application/vnd.intu.qfx",
+  qt: "video/quicktime",
+  rar: "application/x-rar-compressed",
+  ram: "audio/x-pn-realaudio",
+  rmp: "audio/x-pn-realaudio-plugin",
+  rsd: "application/rsd+xml",
+  rm: "application/vnd.rn-realmedia",
+  bed: "application/vnd.realvnc.bed",
+  mxl: "application/vnd.recordare.musicxml",
+  musicxml: "application/vnd.recordare.musicxml+xml",
+  rnc: "application/relax-ng-compact-syntax",
+  rdz: "application/vnd.data-vision.rdz",
+  rdf: "application/rdf+xml",
+  rp9: "application/vnd.cloanto.rp9",
+  jisp: "application/vnd.jisp",
+  rtf: "application/rtf",
+  rtx: "text/richtext",
+  link66: "application/vnd.route66.link66+xml",
+  rss: "application/rss+xml",
+  shf: "application/shf+xml",
+  st: "application/vnd.sailingtracker.track",
+  svg: "image/svg+xml",
+  sus: "application/vnd.sus-calendar",
+  sru: "application/sru+xml",
+  setpay: "application/set-payment-initiation",
+  setreg: "application/set-registration-initiation",
+  sema: "application/vnd.sema",
+  semd: "application/vnd.semd",
+  semf: "application/vnd.semf",
+  see: "application/vnd.seemail",
+  snf: "application/x-font-snf",
+  spq: "application/scvp-vp-request",
+  spp: "application/scvp-vp-response",
+  scq: "application/scvp-cv-request",
+  scs: "application/scvp-cv-response",
+  sdp: "application/sdp",
+  etx: "text/x-setext",
+  movie: "video/x-sgi-movie",
+  ifm: "application/vnd.shana.informed.formdata",
+  itp: "application/vnd.shana.informed.formtemplate",
+  iif: "application/vnd.shana.informed.interchange",
+  ipk: "application/vnd.shana.informed.package",
+  tfi: "application/thraud+xml",
+  shar: "application/x-shar",
+  rgb: "image/x-rgb",
+  slt: "application/vnd.epson.salt",
+  aso: "application/vnd.accpac.simply.aso",
+  imp: "application/vnd.accpac.simply.imp",
+  twd: "application/vnd.simtech-mindmapper",
+  csp: "application/vnd.commonspace",
+  saf: "application/vnd.yamaha.smaf-audio",
+  mmf: "application/vnd.smaf",
+  spf: "application/vnd.yamaha.smaf-phrase",
+  teacher: "application/vnd.smart.teacher",
+  svd: "application/vnd.svd",
+  rq: "application/sparql-query",
+  srx: "application/sparql-results+xml",
+  gram: "application/srgs",
+  grxml: "application/srgs+xml",
+  ssml: "application/ssml+xml",
+  skp: "application/vnd.koan",
+  sgml: "text/sgml",
+  sdc: "application/vnd.stardivision.calc",
+  sda: "application/vnd.stardivision.draw",
+  sdd: "application/vnd.stardivision.impress",
+  smf: "application/vnd.stardivision.math",
+  sdw: "application/vnd.stardivision.writer",
+  sgl: "application/vnd.stardivision.writer-global",
+  sm: "application/vnd.stepmania.stepchart",
+  sit: "application/x-stuffit",
+  sitx: "application/x-stuffitx",
+  sdkm: "application/vnd.solent.sdkm+xml",
+  xo: "application/vnd.olpc-sugar",
+  au: "audio/basic",
+  wqd: "application/vnd.wqd",
+  sis: "application/vnd.symbian.install",
+  smi: "application/smil+xml",
+  xsm: "application/vnd.syncml+xml",
+  bdm: "application/vnd.syncml.dm+wbxml",
+  xdm: "application/vnd.syncml.dm+xml",
+  sv4cpio: "application/x-sv4cpio",
+  sv4crc: "application/x-sv4crc",
+  sbml: "application/sbml+xml",
+  tsv: "text/tab-separated-values",
+  tiff: "image/tiff",
+  tao: "application/vnd.tao.intent-module-archive",
+  tar: "application/x-tar",
+  tcl: "application/x-tcl",
+  tex: "application/x-tex",
+  tfm: "application/x-tex-tfm",
+  tei: "application/tei+xml",
+  txt: "text/plain",
+  dxp: "application/vnd.spotfire.dxp",
+  sfs: "application/vnd.spotfire.sfs",
+  tsd: "application/timestamped-data",
+  tpt: "application/vnd.trid.tpt",
+  mxs: "application/vnd.triscape.mxs",
+  t: "text/troff",
+  tra: "application/vnd.trueapp",
+  ttf: "application/x-font-ttf",
+  ttl: "text/turtle",
+  umj: "application/vnd.umajin",
+  uoml: "application/vnd.uoml+xml",
+  unityweb: "application/vnd.unity",
+  ufd: "application/vnd.ufdl",
+  uri: "text/uri-list",
+  utz: "application/vnd.uiq.theme",
+  ustar: "application/x-ustar",
+  uu: "text/x-uuencode",
+  vcs: "text/x-vcalendar",
+  vcf: "text/x-vcard",
+  vcd: "application/x-cdlink",
+  vsf: "application/vnd.vsf",
+  wrl: "model/vrml",
+  vcx: "application/vnd.vcx",
+  mts: "model/vnd.mts",
+  vtu: "model/vnd.vtu",
+  vis: "application/vnd.visionary",
+  viv: "video/vnd.vivo",
+  ccxml: "application/ccxml+xml,",
+  vxml: "application/voicexml+xml",
+  src: "application/x-wais-source",
+  wbxml: "application/vnd.wap.wbxml",
+  wbmp: "image/vnd.wap.wbmp",
+  wav: "audio/x-wav",
+  davmount: "application/davmount+xml",
+  woff: "application/x-font-woff",
+  wspolicy: "application/wspolicy+xml",
+  webp: "image/webp",
+  wtb: "application/vnd.webturbo",
+  wgt: "application/widget",
+  hlp: "application/winhlp",
+  wml: "text/vnd.wap.wml",
+  wmls: "text/vnd.wap.wmlscript",
+  wmlsc: "application/vnd.wap.wmlscriptc",
+  wpd: "application/vnd.wordperfect",
+  stf: "application/vnd.wt.stf",
+  wsdl: "application/wsdl+xml",
+  xbm: "image/x-xbitmap",
+  xpm: "image/x-xpixmap",
+  xwd: "image/x-xwindowdump",
+  der: "application/x-x509-ca-cert",
+  fig: "application/x-xfig",
+  xhtml: "application/xhtml+xml",
+  xml: "application/xml",
+  xdf: "application/xcap-diff+xml",
+  xenc: "application/xenc+xml",
+  xer: "application/patch-ops-error+xml",
+  rl: "application/resource-lists+xml",
+  rs: "application/rls-services+xml",
+  rld: "application/resource-lists-diff+xml",
+  xslt: "application/xslt+xml",
+  xop: "application/xop+xml",
+  xpi: "application/x-xpinstall",
+  xspf: "application/xspf+xml",
+  xul: "application/vnd.mozilla.xul+xml",
+  xyz: "chemical/x-xyz",
+  yaml: "text/yaml",
+  yang: "application/yang",
+  yin: "application/yin+xml",
+  zir: "application/vnd.zul",
+  zip: "application/zip",
+  zmm: "application/vnd.handheld-entertainment+xml",
+  zaz: "application/vnd.zzazz.deck+xml"
+};
+
+// TODO: write this out to avoid compute
+var MIME_TYPES_TO_EXT = Object.fromEntries(Object.entries(EXT_TO_MIME_TYPES).map(function (_ref) {
+  var _ref2 = _slicedToArray(_ref, 2),
+    k = _ref2[0],
+    v = _ref2[1];
+  return [v, k];
+}));
+
+var MIME_TYPE_REGEX = /^data:(.*?);base64,/;
 function getMimeType(base64Url) {
   var match = MIME_TYPE_REGEX.exec(base64Url);
   if (match && match[1]) {
@@ -164,41 +864,32 @@ function getMimeType(base64Url) {
   return;
 }
 function mimeTypeToFileExt(mimeType) {
-  if (mimeType === "image/svg+xml") {
-    return "svg";
-  }
-  if (mimeType === "image/vnd.microsoft.icon") {
-    return "ico";
-  }
-  if (mimeType.startsWith("image/")) {
-    return mimeType.slice("image/".length);
+  var recognizedMimeType = MIME_TYPES_TO_EXT[mimeType];
+  if (recognizedMimeType) {
+    return recognizedMimeType;
   }
-  return mimeType;
+  return mimeType.split("/")[1];
 }
 function filenameToMimeType(filename) {
   var ext = filename.split(".").pop();
-  return ext && imageTypeToMimeType(ext);
-}
-function imageTypeToMimeType(imageType) {
-  if (imageType === "svg") {
-    return "image/svg+xml";
-  }
-  if (imageType === "ico") {
-    return "image/vnd.microsoft.icon";
+  var recognizedExt = ext && EXT_TO_MIME_TYPES[ext];
+  if (recognizedExt) {
+    return recognizedExt;
   }
-  return "image/".concat(imageType);
 }
 
-var HeaderRegEx = /^h([\d+])$/;
-function lexicalToRichTextSource(node) {
-  var markdownIRBlocks = node.children.map(createBlock);
-  return fromIRToRichTextSource(markdownIRBlocks);
+function remirrorToRichTextSource(node) {
+  var files = {};
+  var markdownIRBlocks = node.content.map(function (child) {
+    return createBlock(child, files);
+  });
+  return fromIRToRichTextSource(markdownIRBlocks, files);
 }
-function createBlock(node) {
+function createBlock(node, files) {
   if (node.type === "heading") {
-    var _node$tag$match;
+    var _node$attrs, _node$content;
     var headingTag = "";
-    var depth = Number((_node$tag$match = node.tag.match(HeaderRegEx)) === null || _node$tag$match === void 0 ? void 0 : _node$tag$match[1]);
+    var depth = ((_node$attrs = node.attrs) === null || _node$attrs === void 0 ? void 0 : _node$attrs.level) || 1;
     if (Number.isNaN(depth)) {
       throw new Error("Invalid header depth");
     }
@@ -208,10 +899,13 @@ function createBlock(node) {
     var headingText = ["".concat(headingTag, " ")];
     return {
       type: "block",
-      children: headingText.concat.apply(headingText, _toConsumableArray(node.children.map(transformLeafNode)))
+      children: headingText.concat.apply(headingText, _toConsumableArray(((_node$content = node.content) === null || _node$content === void 0 ? void 0 : _node$content.map(function (child) {
+        return transformLeafNode(child, files);
+      })) || []))
     };
   } else if (node.type === "paragraph") {
-    if (node.children.length === 0) {
+    var _node$content2;
+    if (!node.content || ((_node$content2 = node.content) === null || _node$content2 === void 0 ? void 0 : _node$content2.length) === 0) {
       return {
         type: "block",
         children: ["<br />"]
@@ -219,26 +913,26 @@ function createBlock(node) {
     }
     return {
       type: "block",
-      children: node.children.map(function (child) {
-        return transformLeafNode(child);
+      children: node.content.map(function (child) {
+        return transformLeafNode(child, files);
       })
     };
-  } else if (node.type === "list") {
+  } else if (node.type === "bulletList" || node.type === "orderedList") {
+    var _node$content3;
     return {
       type: "block",
-      children: node.children.flatMap(function (child, i) {
-        return formatListItemNode(getListPrefix(node), child, 0, i === 0);
-      })
+      children: ((_node$content3 = node.content) === null || _node$content3 === void 0 ? void 0 : _node$content3.flatMap(function (child, i) {
+        return formatListItemNode(getListPrefix(node), child, 0, files, i === 0);
+      })) || []
     };
   } else {
     var exhaustiveCheck = node;
     throw new Error("Unhandled node type: ".concat("type" in exhaustiveCheck ? "exhaustiveCheck.type" : "unknown"));
   }
 }
-function fromIRToRichTextSource(markdownIRBlocks) {
+function fromIRToRichTextSource(markdownIRBlocks, files) {
   var templateStrings = ["\n"];
   var exprs = [];
-  var files = {};
   for (var blockIdx = 0; blockIdx < markdownIRBlocks.length; blockIdx++) {
     var block = markdownIRBlocks[blockIdx];
     var _iterator = _createForOfIteratorHelper(block.children),
@@ -249,10 +943,10 @@ function fromIRToRichTextSource(markdownIRBlocks) {
         if (typeof child === "string") {
           templateStrings[templateStrings.length - 1] += child;
         } else {
-          if (child.type === "image") {
-            exprs.push(fromLexicalImageNode(child, files));
-          } else if (child.type === "link") {
-            exprs.push(fromLexicalLinkNode(child));
+          if (child._type === "file") {
+            exprs.push(child);
+          } else if (child._type === "link") {
+            exprs.push(child);
           } else {
             var exhaustiveCheck = child;
             throw new Error("Unexpected node type: ".concat(JSON.stringify(exhaustiveCheck, null, 2)));
@@ -274,7 +968,17 @@ function fromIRToRichTextSource(markdownIRBlocks) {
   return _defineProperty(_defineProperty(_defineProperty(_defineProperty({}, VAL_EXTENSION, "richtext"), "templateStrings", templateStrings), "exprs", exprs), "files", files);
 }
 function formatText(node) {
-  var classes = typeof node.format === "number" ? fromLexicalFormat(node.format) : [];
+  var _node$marks;
+  var classes = ((_node$marks = node.marks) === null || _node$marks === void 0 ? void 0 : _node$marks.flatMap(function (mark) {
+    if (mark.type === "bold") {
+      return ["bold"];
+    } else if (mark.type === "italic") {
+      return ["italic"];
+    } else if (mark.type === "strike") {
+      return ["line-through"];
+    }
+    return [];
+  })) || [];
   var text = node.text.trimStart();
   var prefixWS = node.text.length - text.length;
   text = text.trimEnd();
@@ -293,87 +997,94 @@ function formatText(node) {
   // text = splitIntoChunks(text);
   return "".concat(" ".repeat(prefixWS)).concat(text).concat(" ".repeat(suffixWS));
 }
-function transformLeafNode(node) {
+function transformLeafNode(node, files) {
   if (node.type === "text") {
+    var _node$marks2;
+    var linkMark = (_node$marks2 = node.marks) === null || _node$marks2 === void 0 ? void 0 : _node$marks2.find(function (mark) {
+      return mark.type === "link";
+    });
+    if ((linkMark === null || linkMark === void 0 ? void 0 : linkMark.type) === "link") {
+      return {
+        _type: "link",
+        href: linkMark.attrs.href,
+        children: [formatText(node)]
+      };
+    }
     return formatText(node);
-  } else if (node.type === "linebreak") {
-    return "\n";
+  } else if (node.type === "hardBreak") {
+    return "<br />";
+  } else if (node.type === "image") {
+    return fromRemirrorImageNode(node, files);
   } else {
-    return node;
+    var exhaustiveCheck = node;
+    throw new Error("Unexpected node type: ".concat(JSON.stringify(exhaustiveCheck)));
   }
 }
-function formatListItemNode(listPrefix, node, indent) {
-  var _node$children;
-  var isFirstTopLevelListItem = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : false;
+function formatListItemNode(listPrefix, node, indent, files) {
+  var _node$content4, _node$content5;
+  var isFirstTopLevelListItem = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : false;
   var newLine = isFirstTopLevelListItem ? "" : "\n";
   var prefix = ["".concat(newLine).concat(" ".repeat(indent)).concat(listPrefix)];
-  if (((_node$children = node.children) === null || _node$children === void 0 || (_node$children = _node$children[0]) === null || _node$children === void 0 ? void 0 : _node$children.type) !== "list") {
+  if (!(((_node$content4 = node.content) === null || _node$content4 === void 0 || (_node$content4 = _node$content4[0]) === null || _node$content4 === void 0 ? void 0 : _node$content4.type) === "bulletList" || ((_node$content5 = node.content) === null || _node$content5 === void 0 || (_node$content5 = _node$content5[0]) === null || _node$content5 === void 0 ? void 0 : _node$content5.type) === "orderedList")) {
     prefix.push(" ");
   }
-  return prefix.concat(node.children.flatMap(function (child) {
-    if (child.type === "list") {
-      return child.children.flatMap(function (subChild) {
-        return formatListItemNode(getListPrefix(child), subChild, indent + 4);
+  return prefix.concat((node.content || []).flatMap(function (child, i) {
+    if (child.type === "bulletList" || child.type === "orderedList") {
+      return (child.content || []).flatMap(function (subChild) {
+        return formatListItemNode(getListPrefix(child), subChild, indent + 4, files);
       });
     } else {
-      return [transformLeafNode(child)];
+      return (child.content || []).flatMap(function (subChild) {
+        var _child$content, _child$content2;
+        var res = [];
+        if ((_child$content = child.content) !== null && _child$content !== void 0 && _child$content.length && ((_child$content2 = child.content) === null || _child$content2 === void 0 ? void 0 : _child$content2.length) > 0 && i > 0) {
+          res.push("<br />\n");
+        }
+        res.push(transformLeafNode(subChild, files));
+        return res;
+      });
     }
   }));
 }
 function getListPrefix(node) {
-  if (node.listType === "bullet") {
+  if (node.type === "bulletList") {
     return "-";
-  } else if (node.listType === "number") {
+  } else if (node.type === "orderedList") {
     return "1.";
   } else {
-    throw new Error("Unhandled list type: ".concat(node.listType));
+    var exhaustiveCheck = node;
+    throw new Error("Unhandled list node: ".concat(JSON.stringify(exhaustiveCheck)));
   }
 }
-var FORMAT_MAPPING$1 = {
-  bold: 1,
-  // 0001
-  italic: 2,
-  // 0010
-  "line-through": 4 // 0100
-  // underline: 8, // 1000
-};
-
-function fromLexicalFormat(format) {
-  return Object.entries(FORMAT_MAPPING$1).flatMap(function (_ref2) {
-    var _ref3 = _slicedToArray(_ref2, 2),
-      key = _ref3[0],
-      value = _ref3[1];
-    if ((value & /* bitwise and */format) === value) {
-      return [key];
-    }
-    return [];
-  });
-}
 var textEncoder = new TextEncoder();
-function fromLexicalImageNode(node, files) {
-  if (node.src.startsWith("data:")) {
-    var sha256 = Internal.getSHA256Hash(textEncoder.encode(node.src));
-    var mimeType = getMimeType(node.src);
+function fromRemirrorImageNode(node, files) {
+  if (node.attrs && node.attrs.src.startsWith("data:")) {
+    var sha256 = Internal.getSHA256Hash(textEncoder.encode(node.attrs.src));
+    var mimeType = getMimeType(node.attrs.src);
     if (mimeType === undefined) {
-      throw new Error("Could not detect Mime Type for image: ".concat(node.src));
+      throw new Error("Could not detect Mime Type for image: ".concat(node.attrs.src));
     }
     var fileExt = mimeTypeToFileExt(mimeType);
-    var filePath = "/public/".concat(sha256, ".").concat(fileExt);
-    files[filePath] = node.src;
+    var fileName = node.attrs.fileName || "".concat(sha256, ".").concat(fileExt);
+    var filePath = "/public/".concat(fileName);
+    files[filePath] = node.attrs.src;
     return _defineProperty(_defineProperty(_defineProperty({}, VAL_EXTENSION, "file"), FILE_REF_PROP, filePath), "metadata", {
-      width: node.width || 0,
-      height: node.height || 0,
+      width: typeof node.attrs.width === "number" ? node.attrs.width : 0,
+      height: typeof node.attrs.height === "number" ? node.attrs.height : 0,
       sha256: sha256 || "",
       mimeType: mimeType
     });
-  } else {
-    var _sha = getParam("sha256", node.src);
-    return _defineProperty(_defineProperty(_defineProperty({}, VAL_EXTENSION, "file"), FILE_REF_PROP, "/public".concat(node.src.split("?")[0])), "metadata", {
-      width: node.width || 0,
-      height: node.height || 0,
+  } else if (node.attrs) {
+    var _sha = getParam("sha256", node.attrs.src);
+    var noParamsSrc = node.attrs.src.split("?")[0];
+    return _defineProperty(_defineProperty(_defineProperty({}, VAL_EXTENSION, "file"), FILE_REF_PROP, "/public".concat(node.attrs.src.split("?")[0])), "metadata", {
+      width: typeof node.attrs.width === "number" ? node.attrs.width : 0,
+      height: typeof node.attrs.height === "number" ? node.attrs.height : 0,
       sha256: _sha || "",
-      mimeType: node.mimeType || ""
+      mimeType: noParamsSrc && filenameToMimeType(noParamsSrc) || ""
     });
+  } else {
+    throw new Error("Invalid image node (no attrs): " + JSON.stringify(node));
   }
 }
 function getParam(param, url) {
@@ -388,196 +1099,6 @@ function getParam(param, url) {
   }
   return undefined;
 }
-function fromLexicalLinkNode(node) {
-  return _defineProperty(_defineProperty(_defineProperty({}, VAL_EXTENSION, "link"), "href", node.url), "children", node.children.map(formatText));
-}
-
-function ownKeys(e, r) {
-  var t = Object.keys(e);
-  if (Object.getOwnPropertySymbols) {
-    var o = Object.getOwnPropertySymbols(e);
-    r && (o = o.filter(function (r) {
-      return Object.getOwnPropertyDescriptor(e, r).enumerable;
-    })), t.push.apply(t, o);
-  }
-  return t;
-}
-function _objectSpread2(e) {
-  for (var r = 1; r < arguments.length; r++) {
-    var t = null != arguments[r] ? arguments[r] : {};
-    r % 2 ? ownKeys(Object(t), !0).forEach(function (r) {
-      _defineProperty(e, r, t[r]);
-    }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) {
-      Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r));
-    });
-  }
-  return e;
-}
-
-/// Serialized Lexical Nodes:
-// TODO: replace with Lexical libs types - not currently exported?
-var COMMON_LEXICAL_PROPS = {
-  version: 1,
-  format: "",
-  indent: 0,
-  direction: null
-};
-function toLexicalNode(node) {
-  var useBreakNode = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
-  if (typeof node === "string") {
-    return _objectSpread2(_objectSpread2({}, COMMON_LEXICAL_PROPS), {}, {
-      type: "text",
-      format: "",
-      text: node
-    });
-  }
-  if ("tag" in node) {
-    switch (node.tag) {
-      case "h1":
-        return toLexicalHeadingNode(node);
-      case "h2":
-        return toLexicalHeadingNode(node);
-      case "h3":
-        return toLexicalHeadingNode(node);
-      case "h4":
-        return toLexicalHeadingNode(node);
-      case "h5":
-        return toLexicalHeadingNode(node);
-      case "h6":
-        return toLexicalHeadingNode(node);
-      case "li":
-        return toLexicalListItemNode(node);
-      case "p":
-        return toLexicalParagraphNode(node);
-      case "ul":
-        return toLexicalListNode(node);
-      case "ol":
-        return toLexicalListNode(node);
-      case "span":
-        return toLexicalTextNode(node);
-      case "a":
-        return toLexicalLinkNode(node);
-      case "img":
-        return toLexicalImageNode(node);
-      case "br":
-        if (useBreakNode) {
-          return _objectSpread2(_objectSpread2({}, COMMON_LEXICAL_PROPS), {}, {
-            type: "linebreak"
-          });
-        }
-        return toLexicalPseudoLineBreakNode();
-      default:
-        throw Error("Unexpected node tag: " + JSON.stringify(node, null, 2));
-    }
-  } else {
-    throw Error("Unexpected node: " + JSON.stringify(node, null, 2));
-  }
-}
-function toLexicalImageNode(node) {
-  var url = node.src;
-  return _objectSpread2(_objectSpread2({}, COMMON_LEXICAL_PROPS), {}, {
-    type: "image",
-    src: url,
-    width: node.width,
-    height: node.height,
-    mimeType: node.mimeType
-    // TODO: altText
-  });
-}
-
-function toLexicalLinkNode(link) {
-  return _objectSpread2(_objectSpread2({}, COMMON_LEXICAL_PROPS), {}, {
-    type: "link",
-    url: link.href,
-    children: link.children.map(function (child) {
-      return toLexicalNode(child);
-    })
-  });
-}
-function richTextSourceToLexical(richtext) {
-  return _objectSpread2(_objectSpread2({}, COMMON_LEXICAL_PROPS), {}, {
-    format: "",
-    type: "root",
-    children: richtext.children.map(function (child) {
-      return toLexicalNode(child);
-    })
-  });
-}
-function toLexicalHeadingNode(heading) {
-  return _objectSpread2(_objectSpread2({}, COMMON_LEXICAL_PROPS), {}, {
-    type: "heading",
-    tag: heading.tag,
-    children: heading.children.map(function (child) {
-      return toLexicalNode(child);
-    })
-  });
-}
-function toLexicalParagraphNode(paragraph) {
-  return _objectSpread2(_objectSpread2({}, COMMON_LEXICAL_PROPS), {}, {
-    type: "paragraph",
-    children: paragraph.children.map(function (child) {
-      return toLexicalNode(child, true);
-    })
-  });
-}
-
-// Lexical does not support line breaks, so we convert them to empty paragraphs
-function toLexicalPseudoLineBreakNode() {
-  return _objectSpread2(_objectSpread2({}, COMMON_LEXICAL_PROPS), {}, {
-    type: "paragraph",
-    children: []
-  });
-}
-function toLexicalListItemNode(listItem) {
-  return _objectSpread2(_objectSpread2({}, COMMON_LEXICAL_PROPS), {}, {
-    type: "listitem",
-    children: listItem.children.map(function (child) {
-      return toLexicalNode(child, true);
-    })
-  });
-}
-function toLexicalListNode(list) {
-  return _objectSpread2(_objectSpread2({}, COMMON_LEXICAL_PROPS), {}, {
-    type: "list",
-    listType: list.tag === "ol" ? "number" : "bullet",
-    children: list.children.map(function (child) {
-      return toLexicalNode(child);
-    })
-  }, list.dir ? {
-    direction: list.dir
-  } : {
-    direction: null
-  });
-}
-var FORMAT_MAPPING = {
-  bold: 1,
-  // 0001
-  italic: 2,
-  // 0010
-  "line-through": 4 // 0100
-  // underline: 8, // 1000
-};
-
-function toLexicalFormat(classes) {
-  return classes.reduce(function (prev, curr) {
-    return prev | /* bitwise or */FORMAT_MAPPING[curr];
-  }, 0);
-}
-function toLexicalTextNode(spanNode) {
-  var child = spanNode.children[0];
-  if (typeof child === "string") {
-    return _objectSpread2(_objectSpread2({}, COMMON_LEXICAL_PROPS), {}, {
-      type: "text",
-      text: child,
-      format: toLexicalFormat(spanNode.classes)
-    });
-  } else {
-    // recurse the spans and merge their classes
-    return toLexicalTextNode(_objectSpread2(_objectSpread2({}, child), {}, {
-      classes: spanNode.classes.concat(child.classes)
-    }));
-  }
-}
 
 var VAL_START_TAG_PREFIX = '<val value="';
 var VAL_START_TAG_SUFFIX = '">';
@@ -585,6 +1106,18 @@ var VAL_END_TAG = "</val>";
 function parseTokens(tokens, sourceNodes, cursor) {
   var insideList = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : false;
   var children = [];
+  function merge(token, clazz) {
+    var parsedTokens = parseTokens(token.tokens ? token.tokens : [], sourceNodes, 0);
+    children.push({
+      tag: "span",
+      classes: [clazz].concat(parsedTokens.children.flatMap(function (child) {
+        return typeof child === "string" ? [] : child.classes;
+      })),
+      children: parsedTokens.children.flatMap(function (child) {
+        return typeof child === "string" ? child : child.children;
+      })
+    });
+  }
   var _loop = function _loop() {
       var token = tokens[cursor];
       if (token.type === "heading") {
@@ -598,23 +1131,11 @@ function parseTokens(tokens, sourceNodes, cursor) {
           children: parseTokens(token.tokens ? token.tokens : [], sourceNodes, 0).children
         });
       } else if (token.type === "strong") {
-        children.push({
-          tag: "span",
-          classes: ["bold"],
-          children: parseTokens(token.tokens ? token.tokens : [], sourceNodes, 0).children
-        });
+        merge(token, "bold");
       } else if (token.type === "em") {
-        children.push({
-          tag: "span",
-          classes: ["italic"],
-          children: parseTokens(token.tokens ? token.tokens : [], sourceNodes, 0).children
-        });
+        merge(token, "italic");
       } else if (token.type === "del") {
-        children.push({
-          tag: "span",
-          classes: ["line-through"],
-          children: parseTokens(token.tokens ? token.tokens : [], sourceNodes, 0).children
-        });
+        merge(token, "line-through");
       } else if (token.type === "text") {
         if ("tokens" in token && Array.isArray(token.tokens)) {
           children.push.apply(children, _toConsumableArray(parseTokens(token.tokens, sourceNodes, cursor, insideList).children));
@@ -623,6 +1144,11 @@ function parseTokens(tokens, sourceNodes, cursor) {
             var lines = token.raw.split("\n");
             var tags = lines.flatMap(function (line, i) {
               if (i === lines.length - 1) return [line];
+              if (i === lines.length - 1 && line === "") return [];
+              if (line === "") return {
+                tag: "br",
+                children: []
+              };
               return [line, {
                 tag: "br",
                 children: []
@@ -692,10 +1218,16 @@ function parseTokens(tokens, sourceNodes, cursor) {
         }
         var br_html_regex = /<br\s*\/?>/gi; // matches <br>, <br/>, <br />; case insensitive
         if (token.text.trim().match(br_html_regex)) {
+          var _tokens;
           children.push({
             tag: "br",
             children: []
           });
+          if (((_tokens = tokens[cursor + 1]) === null || _tokens === void 0 ? void 0 : _tokens.raw.trim()) === "") {
+            // if next token is a new line or white-spaces, skip it
+            // this typically means we have a <br> AND a new line, which, semantically, is just a <br>
+            cursor++;
+          }
         }
       } else if (token.type === "link") {
         if (token.raw === token.href) {
@@ -755,8 +1287,338 @@ function parseRichTextSource(_ref) {
   return _defineProperty(_defineProperty({}, VAL_EXTENSION, "richtext"), "children", children);
 }
 
+var RemirrorTextMark = z.object({
+  type: z.union([z.literal("bold"), z.literal("strike"), z.literal("italic")])
+});
+var RemirrorLinkMark = z.object({
+  type: z.literal("link"),
+  attrs: z.object({
+    href: z.string(),
+    target: z.union([z.literal("_blank"), z["null"]()]),
+    auto: z["boolean"]()
+  })
+});
+var RemirrorText = z.intersection(z.object({
+  type: z.literal("text"),
+  text: z.string()
+}), z.object({
+  marks: z.array(z.union([RemirrorTextMark, RemirrorLinkMark]))
+}).partial());
+var RemirrorBr = z.intersection(z.object({
+  type: z.literal("hardBreak")
+}), z.object({
+  marks: z.array(RemirrorTextMark)
+}).partial());
+var RemirrorImage = z.intersection(z.object({
+  type: z.literal("image")
+}), z.object({
+  attrs: z.intersection(z.object({
+    src: z.string()
+  }), z.object({
+    align: z.union([z.literal("center"), z.literal("end"), z.literal("justify"), z.literal("left"), z.literal("match-parent"), z.literal("right"), z.literal("start"), z["null"]()]),
+    alt: z.union([z.string(), z["null"]()]),
+    height: z.union([z.string(), z.number(), z["null"]()]),
+    width: z.union([z.string(), z.number(), z["null"]()]),
+    rotate: z.union([z.string(), z["null"]()]),
+    title: z.union([z.string(), z["null"]()]),
+    fileName: z.union([z.string(), z["null"]()])
+  }).partial())
+}).partial());
+var RemirrorHeading = z.intersection(z.object({
+  type: z.literal("heading")
+}), z.object({
+  attrs: z.object({
+    level: z.number()
+  }),
+  content: z.array(z.union([RemirrorText, RemirrorBr]))
+}).partial());
+var RemirrorBulletList = z.lazy(function () {
+  return z.intersection(z.object({
+    type: z.literal("bulletList")
+  }), z.object({
+    content: z.array(RemirrorListItem)
+  }).partial());
+});
+var RemirrorOrderedList = z.lazy(function () {
+  return z.intersection(z.object({
+    type: z.literal("orderedList")
+  }), z.object({
+    content: z.array(RemirrorListItem)
+  }).partial());
+});
+var RemirrorListItem = z.lazy(function () {
+  return z.intersection(z.object({
+    type: z.literal("listItem")
+  }), z.object({
+    content: z.array(z.union([RemirrorParagraph, RemirrorBulletList, RemirrorOrderedList]))
+  }).partial());
+});
+var RemirrorParagraph = z.intersection(z.object({
+  type: z.literal("paragraph")
+}), z.object({
+  content: z.array(z.union([RemirrorText, RemirrorImage, RemirrorBr]))
+}).partial());
+var RemirrorJSON = z.object({
+  type: z.literal("doc"),
+  content: z.array(z.union([RemirrorParagraph, RemirrorHeading, RemirrorBulletList, RemirrorOrderedList]))
+});
+
+function ownKeys(e, r) {
+  var t = Object.keys(e);
+  if (Object.getOwnPropertySymbols) {
+    var o = Object.getOwnPropertySymbols(e);
+    r && (o = o.filter(function (r) {
+      return Object.getOwnPropertyDescriptor(e, r).enumerable;
+    })), t.push.apply(t, o);
+  }
+  return t;
+}
+function _objectSpread2(e) {
+  for (var r = 1; r < arguments.length; r++) {
+    var t = null != arguments[r] ? arguments[r] : {};
+    r % 2 ? ownKeys(Object(t), !0).forEach(function (r) {
+      _defineProperty(e, r, t[r]);
+    }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) {
+      Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r));
+    });
+  }
+  return e;
+}
+
+function richTextToRemirror(richtext) {
+  return {
+    type: "doc",
+    content: richtext.children.map(function (child) {
+      return toRemirrorNode(child);
+    })
+  };
+}
+function toRemirrorNode(child) {
+  switch (child.tag) {
+    case "h1":
+      return convertHeadingToRemirror(1, child.children);
+    case "h2":
+      return convertHeadingToRemirror(2, child.children);
+    case "h3":
+      return convertHeadingToRemirror(3, child.children);
+    case "h4":
+      return convertHeadingToRemirror(4, child.children);
+    case "h5":
+      return convertHeadingToRemirror(5, child.children);
+    case "h6":
+      return convertHeadingToRemirror(6, child.children);
+    case "p":
+      return convertParagraphToRemirror(child.children);
+    case "ul":
+      return convertUlToRemirror(child);
+    case "ol":
+      return convertOlToRemirror(child);
+    case "br":
+      return convertParagraphToRemirror([child]);
+    default:
+      {
+        var _exhaustiveCheck = child;
+        throw Error("Unexpected child node: " + JSON.stringify(_exhaustiveCheck));
+      }
+  }
+}
+function convertHeadingToRemirror(level, children) {
+  return {
+    type: "heading",
+    attrs: {
+      level: level
+    },
+    content: children.flatMap(convertStringOrSpanNodeToRemirror)
+  };
+}
+function convertStringToRemirror(child) {
+  return {
+    type: "text",
+    text: child
+  };
+}
+function convertStringOrSpanNodeToRemirror(child) {
+  if (typeof child === "string") {
+    return [convertStringToRemirror(child)];
+  }
+  return convertSpanNodeToRemirror(child);
+}
+function convertSpanNodeToRemirror(spanNode) {
+  if (spanNode.classes.length === 0 && spanNode.children.length === 1) {
+    if (typeof spanNode.children[0] === "string") {
+      return [convertStringToRemirror(spanNode.children[0])];
+    } else {
+      // TODO: replace with error logging and something more graceful?
+      throw Error("Unexpected amount of children in span node: " + JSON.stringify(spanNode, null, 2));
+    }
+  }
+  return spanNode.children.map(function (child) {
+    return {
+      type: "text",
+      text: child,
+      marks: spanNode.classes.map(function (className) {
+        switch (className) {
+          case "bold":
+            return {
+              type: "bold"
+            };
+          case "italic":
+            return {
+              type: "italic"
+            };
+          case "line-through":
+            return {
+              type: "strike"
+            };
+          default:
+            {
+              var _exhaustiveCheck = className;
+              throw Error("Unexpected span class: " + _exhaustiveCheck);
+            }
+        }
+      })
+    };
+  });
+}
+function convertParagraphToRemirror(children) {
+  return {
+    type: "paragraph",
+    content: children.flatMap(function (child) {
+      if (typeof child === "string") {
+        return [convertStringToRemirror(child)];
+      }
+      switch (child.tag) {
+        case "span":
+          return convertSpanNodeToRemirror(child);
+        case "a":
+          return convertLinkNodeToRemirror(child);
+        case "img":
+          return [convertImageNodeToRemirror(child)];
+        case "br":
+          return [createRemirrorBr()];
+        default:
+          {
+            var _exhaustiveCheck = child;
+            throw Error("Unexpected paragraph child: " + JSON.stringify(_exhaustiveCheck));
+          }
+      }
+    })
+  };
+}
+function createRemirrorBr() {
+  return {
+    type: "hardBreak",
+    marks: []
+  };
+}
+function convertLinkNodeToRemirror(linkNode) {
+  return linkNode.children.flatMap(convertStringOrSpanNodeToRemirror).map(function (remirrorText) {
+    return _objectSpread2(_objectSpread2({}, remirrorText), {}, {
+      marks: (remirrorText.marks || []).concat({
+        type: "link",
+        attrs: {
+          href: linkNode.href,
+          auto: false,
+          target: null
+        }
+      })
+    });
+  });
+}
+function convertImageNodeToRemirror(imageNode) {
+  return {
+    type: "image",
+    attrs: {
+      height: imageNode.height,
+      width: imageNode.width,
+      src: imageNode.src // at time of writing we are not sure if src as href or data url works, also: how to keep mimeType etc?
+    }
+  };
+}
+function convertUlToRemirror(ulNode) {
+  return {
+    type: "bulletList",
+    content: ulNode.children.map(convertListItemToRemirror)
+  };
+}
+function convertOlToRemirror(olNode) {
+  return {
+    type: "orderedList",
+    content: olNode.children.map(convertListItemToRemirror)
+  };
+}
+function convertListItemToRemirror(liNode) {
+  return {
+    type: "listItem",
+    content: convertListItemToRemirrorParagraph(liNode.children)
+  };
+}
+function convertListItemToRemirrorParagraph(rtChildren) {
+  var children = [];
+  var _iterator = _createForOfIteratorHelper(rtChildren),
+    _step;
+  try {
+    for (_iterator.s(); !(_step = _iterator.n()).done;) {
+      var child = _step.value;
+      var lastChild = children[children.length - 1];
+      if (!lastChild) {
+        lastChild = {
+          type: "paragraph",
+          content: []
+        };
+        children.push(lastChild);
+      }
+      var lastChildContent = lastChild.content;
+      if (typeof child === "string") {
+        lastChildContent.push(convertStringToRemirror(child));
+      } else {
+        switch (child.tag) {
+          case "a":
+            {
+              lastChildContent.push.apply(lastChildContent, _toConsumableArray(convertLinkNodeToRemirror(child)));
+              break;
+            }
+          case "br":
+            {
+              children.push({
+                type: "paragraph",
+                content: [] // create new paragraph
+              });
+              break;
+            }
+          case "span":
+            {
+              lastChildContent.push.apply(lastChildContent, _toConsumableArray(convertSpanNodeToRemirror(child)));
+              break;
+            }
+          case "ol":
+            {
+              children.push(convertOlToRemirror(child));
+              break;
+            }
+          case "ul":
+            {
+              children.push(convertUlToRemirror(child));
+              break;
+            }
+          default:
+            {
+              var _exhaustiveCheck = child;
+              throw Error("Unexpected list item child: " + JSON.stringify(_exhaustiveCheck));
+            }
+        }
+      }
+    }
+  } catch (err) {
+    _iterator.e(err);
+  } finally {
+    _iterator.f();
+  }
+  return children;
+}
+
 var VAL_SESSION_COOKIE = Internal.VAL_SESSION_COOKIE;
 var VAL_STATE_COOKIE = Internal.VAL_STATE_COOKIE;
 var VAL_ENABLE_COOKIE_NAME = Internal.VAL_ENABLE_COOKIE_NAME;
 
-export { COMMON_LEXICAL_PROPS, VAL_ENABLE_COOKIE_NAME, VAL_SESSION_COOKIE, VAL_STATE_COOKIE, filenameToMimeType, fromLexicalFormat, getMimeType, imageTypeToMimeType, lexicalToRichTextSource, mimeTypeToFileExt, parseRichTextSource, richTextSourceToLexical, toLexicalFormat, toLexicalNode };
+export { EXT_TO_MIME_TYPES, MIME_TYPES_TO_EXT, RemirrorBr, RemirrorBulletList, RemirrorHeading, RemirrorImage, RemirrorJSON, RemirrorLinkMark, RemirrorListItem, RemirrorOrderedList, RemirrorParagraph, RemirrorText, RemirrorTextMark, VAL_ENABLE_COOKIE_NAME, VAL_SESSION_COOKIE, VAL_STATE_COOKIE, filenameToMimeType, getMimeType, mimeTypeToFileExt, parseRichTextSource, remirrorToRichTextSource, richTextToRemirror };