@bagelink/vue 0.0.689 → 0.0.692

package/dist/index.mjs

@@ -110,21 +110,12 @@ function getPaddingObject(padding) {
   };
 }
 function rectToClientRect$1(rect) {
-  const {
-    x: x2,
-    y: y2,
-    width,
-    height
-  } = rect;
   return {
-    width,
-    height,
-    top: y2,
-    left: x2,
-    right: x2 + width,
-    bottom: y2 + height,
-    x: x2,
-    y: y2
+    ...rect,
+    top: rect.y,
+    left: rect.x,
+    right: rect.x + rect.width,
+    bottom: rect.y + rect.height
   };
 }
 function computeCoordsFromPlacement(_ref, placement, rtl) {
@@ -295,10 +286,9 @@ async function detectOverflow$1(state2, options) {
     strategy
   }));
   const rect = elementContext === "floating" ? {
+    ...rects.floating,
     x: x2,
-    y: y2,
-    width: rects.floating.width,
-    height: rects.floating.height
+    y: y2
   } : rects.reference;
   const offsetParent = await (platform2.getOffsetParent == null ? void 0 : platform2.getOffsetParent(elements.floating));
   const offsetScale = await (platform2.isElement == null ? void 0 : platform2.isElement(offsetParent)) ? await (platform2.getScale == null ? void 0 : platform2.getScale(offsetParent)) || {
@@ -509,12 +499,10 @@ const flip$2 = function(options) {
         return {};
       }
       const side = getSide$1(placement);
-      const initialSideAxis = getSideAxis(initialPlacement);
       const isBasePlacement = getSide$1(initialPlacement) === initialPlacement;
       const rtl = await (platform2.isRTL == null ? void 0 : platform2.isRTL(elements.floating));
       const fallbackPlacements = specifiedFallbackPlacements || (isBasePlacement || !flipAlignment ? [getOppositePlacement$1(initialPlacement)] : getExpandedPlacements(initialPlacement));
-      const hasFallbackAxisSideDirection = fallbackAxisSideDirection !== "none";
-      if (!specifiedFallbackPlacements && hasFallbackAxisSideDirection) {
+      if (!specifiedFallbackPlacements && fallbackAxisSideDirection !== "none") {
         fallbackPlacements.push(...getOppositeAxisPlacements(initialPlacement, flipAlignment, fallbackAxisSideDirection, rtl));
       }
       const placements2 = [initialPlacement, ...fallbackPlacements];
@@ -551,16 +539,8 @@ const flip$2 = function(options) {
         if (!resetPlacement) {
           switch (fallbackStrategy) {
             case "bestFit": {
-              var _overflowsData$filter2;
-              const placement2 = (_overflowsData$filter2 = overflowsData.filter((d2) => {
-                if (hasFallbackAxisSideDirection) {
-                  const currentSideAxis = getSideAxis(d2.placement);
-                  return currentSideAxis === initialSideAxis || // Create a bias to the `y` side axis due to horizontal
-                  // reading directions favoring greater width.
-                  currentSideAxis === "y";
-                }
-                return true;
-              }).map((d2) => [d2.placement, d2.overflows.filter((overflow2) => overflow2 > 0).reduce((acc, overflow2) => acc + overflow2, 0)]).sort((a2, b2) => a2[1] - b2[1])[0]) == null ? void 0 : _overflowsData$filter2[0];
+              var _overflowsData$map$so;
+              const placement2 = (_overflowsData$map$so = overflowsData.map((d2) => [d2.placement, d2.overflows.filter((overflow2) => overflow2 > 0).reduce((acc, overflow2) => acc + overflow2, 0)]).sort((a2, b2) => a2[1] - b2[1])[0]) == null ? void 0 : _overflowsData$map$so[0];
               if (placement2) {
                 resetPlacement = placement2;
               }
@@ -755,16 +735,16 @@ const size = function(options) {
         widthSide = side;
         heightSide = alignment === "end" ? "top" : "bottom";
       }
-      const maximumClippingHeight = height - overflow.top - overflow.bottom;
-      const maximumClippingWidth = width - overflow.left - overflow.right;
-      const overflowAvailableHeight = min$3(height - overflow[heightSide], maximumClippingHeight);
-      const overflowAvailableWidth = min$3(width - overflow[widthSide], maximumClippingWidth);
+      const overflowAvailableHeight = height - overflow[heightSide];
+      const overflowAvailableWidth = width - overflow[widthSide];
       const noShift = !state2.middlewareData.shift;
       let availableHeight = overflowAvailableHeight;
       let availableWidth = overflowAvailableWidth;
       if (isYAxis) {
+        const maximumClippingWidth = width - overflow.left - overflow.right;
         availableWidth = alignment || noShift ? min$3(overflowAvailableWidth, maximumClippingWidth) : maximumClippingWidth;
       } else {
+        const maximumClippingHeight = height - overflow.top - overflow.bottom;
         availableHeight = alignment || noShift ? min$3(overflowAvailableHeight, maximumClippingHeight) : maximumClippingHeight;
       }
       if (noShift && !alignment) {
@@ -2845,6 +2825,26 @@ const toJSONObject = (obj) => {
 };
 const isAsyncFn = kindOfTest("AsyncFunction");
 const isThenable = (thing) => thing && (isObject$1(thing) || isFunction$1(thing)) && isFunction$1(thing.then) && isFunction$1(thing.catch);
+const _setImmediate = ((setImmediateSupported, postMessageSupported) => {
+  if (setImmediateSupported) {
+    return setImmediate;
+  }
+  return postMessageSupported ? ((token, callbacks) => {
+    _global.addEventListener("message", ({ source, data: data2 }) => {
+      if (source === _global && data2 === token) {
+        callbacks.length && callbacks.shift()();
+      }
+    }, false);
+    return (cb) => {
+      callbacks.push(cb);
+      _global.postMessage(token, "*");
+    };
+  })(`axios@${Math.random()}`, []) : (cb) => setTimeout(cb);
+})(
+  typeof setImmediate === "function",
+  isFunction$1(_global.postMessage)
+);
+const asap = typeof queueMicrotask !== "undefined" ? queueMicrotask.bind(_global) : typeof process !== "undefined" && process.nextTick || _setImmediate;
 const utils$1 = {
   isArray,
   isArrayBuffer,
@@ -2901,7 +2901,9 @@ const utils$1 = {
   isSpecCompliantForm,
   toJSONObject,
   isAsyncFn,
-  isThenable
+  isThenable,
+  setImmediate: _setImmediate,
+  asap
 };
 function AxiosError(message2, code2, config, request, response) {
   Error.call(this);
@@ -3736,27 +3738,35 @@ function speedometer(samplesCount, min2) {
 }
 function throttle$2(fn3, freq) {
   let timestamp = 0;
-  const threshold = 1e3 / freq;
-  let timer = null;
-  return function throttled() {
-    const force = this === true;
+  let threshold = 1e3 / freq;
+  let lastArgs;
+  let timer;
+  const invoke = (args, now = Date.now()) => {
+    timestamp = now;
+    lastArgs = null;
+    if (timer) {
+      clearTimeout(timer);
+      timer = null;
+    }
+    fn3.apply(null, args);
+  };
+  const throttled = (...args) => {
     const now = Date.now();
-    if (force || now - timestamp > threshold) {
-      if (timer) {
-        clearTimeout(timer);
-        timer = null;
+    const passed = now - timestamp;
+    if (passed >= threshold) {
+      invoke(args, now);
+    } else {
+      lastArgs = args;
+      if (!timer) {
+        timer = setTimeout(() => {
+          timer = null;
+          invoke(lastArgs);
+        }, threshold - passed);
       }
-      timestamp = now;
-      return fn3.apply(null, arguments);
-    }
-    if (!timer) {
-      timer = setTimeout(() => {
-        timer = null;
-        timestamp = Date.now();
-        return fn3.apply(null, arguments);
-      }, threshold - (now - timestamp));
     }
   };
+  const flush = () => lastArgs && invoke(lastArgs);
+  return [throttled, flush];
 }
 const progressEventReducer = (listener, isDownloadStream, freq = 3) => {
   let bytesNotified = 0;
@@ -3776,12 +3786,21 @@ const progressEventReducer = (listener, isDownloadStream, freq = 3) => {
       rate: rate ? rate : void 0,
       estimated: rate && total && inRange ? (total - loaded) / rate : void 0,
       event: e,
-      lengthComputable: total != null
+      lengthComputable: total != null,
+      [isDownloadStream ? "download" : "upload"]: true
     };
-    data2[isDownloadStream ? "download" : "upload"] = true;
     listener(data2);
   }, freq);
 };
+const progressEventDecorator = (total, throttled) => {
+  const lengthComputable = total != null;
+  return [(loaded) => throttled[0]({
+    lengthComputable,
+    total,
+    loaded
+  }), throttled[1]];
+};
+const asyncDecorator = (fn3) => (...args) => utils$1.asap(() => fn3(...args));
 const isURLSameOrigin = platform.hasStandardBrowserEnv ? (
   // Standard browser envs have full support of the APIs needed to test
   // whether the request URL is of the same origin as current location.
@@ -3979,15 +3998,15 @@ const xhrAdapter = isXHRAdapterSupported && function(config) {
     const _config = resolveConfig(config);
     let requestData = _config.data;
     const requestHeaders = AxiosHeaders.from(_config.headers).normalize();
-    let { responseType } = _config;
+    let { responseType, onUploadProgress, onDownloadProgress } = _config;
     let onCanceled;
+    let uploadThrottled, downloadThrottled;
+    let flushUpload, flushDownload;
     function done() {
-      if (_config.cancelToken) {
-        _config.cancelToken.unsubscribe(onCanceled);
-      }
-      if (_config.signal) {
-        _config.signal.removeEventListener("abort", onCanceled);
-      }
+      flushUpload && flushUpload();
+      flushDownload && flushDownload();
+      _config.cancelToken && _config.cancelToken.unsubscribe(onCanceled);
+      _config.signal && _config.signal.removeEventListener("abort", onCanceled);
     }
     let request = new XMLHttpRequest();
     request.open(_config.method.toUpperCase(), _config.url, true);
@@ -4034,11 +4053,11 @@ const xhrAdapter = isXHRAdapterSupported && function(config) {
       if (!request) {
         return;
       }
-      reject3(new AxiosError("Request aborted", AxiosError.ECONNABORTED, _config, request));
+      reject3(new AxiosError("Request aborted", AxiosError.ECONNABORTED, config, request));
       request = null;
     };
     request.onerror = function handleError() {
-      reject3(new AxiosError("Network Error", AxiosError.ERR_NETWORK, _config, request));
+      reject3(new AxiosError("Network Error", AxiosError.ERR_NETWORK, config, request));
       request = null;
     };
     request.ontimeout = function handleTimeout() {
@@ -4050,7 +4069,7 @@ const xhrAdapter = isXHRAdapterSupported && function(config) {
       reject3(new AxiosError(
         timeoutErrorMessage,
         transitional2.clarifyTimeoutError ? AxiosError.ETIMEDOUT : AxiosError.ECONNABORTED,
-        _config,
+        config,
         request
       ));
       request = null;
@@ -4067,11 +4086,14 @@ const xhrAdapter = isXHRAdapterSupported && function(config) {
     if (responseType && responseType !== "json") {
       request.responseType = _config.responseType;
     }
-    if (typeof _config.onDownloadProgress === "function") {
-      request.addEventListener("progress", progressEventReducer(_config.onDownloadProgress, true));
+    if (onDownloadProgress) {
+      [downloadThrottled, flushDownload] = progressEventReducer(onDownloadProgress, true);
+      request.addEventListener("progress", downloadThrottled);
     }
-    if (typeof _config.onUploadProgress === "function" && request.upload) {
-      request.upload.addEventListener("progress", progressEventReducer(_config.onUploadProgress));
+    if (onUploadProgress && request.upload) {
+      [uploadThrottled, flushUpload] = progressEventReducer(onUploadProgress);
+      request.upload.addEventListener("progress", uploadThrottled);
+      request.upload.addEventListener("loadend", flushUpload);
     }
     if (_config.cancelToken || _config.signal) {
       onCanceled = (cancel) => {
@@ -4149,39 +4171,52 @@ const readBytes = async function* (iterable, chunkSize, encode2) {
 const trackStream = (stream, chunkSize, onProgress, onFinish, encode2) => {
   const iterator = readBytes(stream, chunkSize, encode2);
   let bytes = 0;
+  let done;
+  let _onFinish = (e) => {
+    if (!done) {
+      done = true;
+      onFinish && onFinish(e);
+    }
+  };
   return new ReadableStream({
-    type: "bytes",
     async pull(controller) {
-      const { done, value } = await iterator.next();
-      if (done) {
-        controller.close();
-        onFinish();
-        return;
+      try {
+        const { done: done2, value } = await iterator.next();
+        if (done2) {
+          _onFinish();
+          controller.close();
+          return;
+        }
+        let len = value.byteLength;
+        if (onProgress) {
+          let loadedBytes = bytes += len;
+          onProgress(loadedBytes);
+        }
+        controller.enqueue(new Uint8Array(value));
+      } catch (err) {
+        _onFinish(err);
+        throw err;
       }
-      let len = value.byteLength;
-      onProgress && onProgress(bytes += len);
-      controller.enqueue(new Uint8Array(value));
     },
     cancel(reason) {
-      onFinish(reason);
+      _onFinish(reason);
       return iterator.return();
     }
   }, {
     highWaterMark: 2
   });
 };
-const fetchProgressDecorator = (total, fn3) => {
-  const lengthComputable = total != null;
-  return (loaded) => setTimeout(() => fn3({
-    lengthComputable,
-    total,
-    loaded
-  }));
-};
 const isFetchSupported = typeof fetch === "function" && typeof Request === "function" && typeof Response === "function";
 const isReadableStreamSupported = isFetchSupported && typeof ReadableStream === "function";
 const encodeText = isFetchSupported && (typeof TextEncoder === "function" ? /* @__PURE__ */ ((encoder) => (str) => encoder.encode(str))(new TextEncoder()) : async (str) => new Uint8Array(await new Response(str).arrayBuffer()));
-const supportsRequestStream = isReadableStreamSupported && (() => {
+const test = (fn3, ...args) => {
+  try {
+    return !!fn3(...args);
+  } catch (e) {
+    return false;
+  }
+};
+const supportsRequestStream = isReadableStreamSupported && test(() => {
   let duplexAccessed = false;
   const hasContentType = new Request(platform.origin, {
     body: new ReadableStream(),
@@ -4192,14 +4227,9 @@ const supportsRequestStream = isReadableStreamSupported && (() => {
     }
   }).headers.has("Content-Type");
   return duplexAccessed && !hasContentType;
-})();
+});
 const DEFAULT_CHUNK_SIZE = 64 * 1024;
-const supportsResponseStream = isReadableStreamSupported && !!(() => {
-  try {
-    return utils$1.isReadableStream(new Response("").body);
-  } catch (err) {
-  }
-})();
+const supportsResponseStream = isReadableStreamSupported && test(() => utils$1.isReadableStream(new Response("").body));
 const resolvers = {
   stream: supportsResponseStream && ((res) => res.body)
 };
@@ -4220,7 +4250,7 @@ const getBodyLength = async (body) => {
   if (utils$1.isSpecCompliantForm(body)) {
     return (await new Request(body).arrayBuffer()).byteLength;
   }
-  if (utils$1.isArrayBufferView(body)) {
+  if (utils$1.isArrayBufferView(body) || utils$1.isArrayBuffer(body)) {
     return body.byteLength;
   }
   if (utils$1.isURLSearchParams(body)) {
@@ -4271,14 +4301,15 @@ const fetchAdapter = isFetchSupported && (async (config) => {
         headers.setContentType(contentTypeHeader);
       }
       if (_request.body) {
-        data2 = trackStream(_request.body, DEFAULT_CHUNK_SIZE, fetchProgressDecorator(
+        const [onProgress, flush] = progressEventDecorator(
           requestContentLength,
-          progressEventReducer(onUploadProgress)
-        ), null, encodeText);
+          progressEventReducer(asyncDecorator(onUploadProgress))
+        );
+        data2 = trackStream(_request.body, DEFAULT_CHUNK_SIZE, onProgress, flush, encodeText);
       }
     }
     if (!utils$1.isString(withCredentials)) {
-      withCredentials = withCredentials ? "cors" : "omit";
+      withCredentials = withCredentials ? "include" : "omit";
     }
     request = new Request(url, {
       ...fetchOptions,
@@ -4287,7 +4318,7 @@ const fetchAdapter = isFetchSupported && (async (config) => {
       headers: headers.normalize().toJSON(),
       body: data2,
       duplex: "half",
-      withCredentials
+      credentials: withCredentials
     });
     let response = await fetch(request);
     const isStreamResponse = supportsResponseStream && (responseType === "stream" || responseType === "response");
@@ -4297,11 +4328,15 @@ const fetchAdapter = isFetchSupported && (async (config) => {
         options[prop3] = response[prop3];
       });
       const responseContentLength = utils$1.toFiniteNumber(response.headers.get("content-length"));
+      const [onProgress, flush] = onDownloadProgress && progressEventDecorator(
+        responseContentLength,
+        progressEventReducer(asyncDecorator(onDownloadProgress), true)
+      ) || [];
       response = new Response(
-        trackStream(response.body, DEFAULT_CHUNK_SIZE, onDownloadProgress && fetchProgressDecorator(
-          responseContentLength,
-          progressEventReducer(onDownloadProgress, true)
-        ), isStreamResponse && onFinish, encodeText),
+        trackStream(response.body, DEFAULT_CHUNK_SIZE, onProgress, () => {
+          flush && flush();
+          isStreamResponse && onFinish();
+        }, encodeText),
         options
       );
     }
@@ -4427,7 +4462,7 @@ function dispatchRequest(config) {
     return Promise.reject(reason);
   });
 }
-const VERSION = "1.7.2";
+const VERSION = "1.7.4";
 const validators$1 = {};
 ["object", "boolean", "number", "function", "string", "symbol"].forEach((type3, i2) => {
   validators$1[type3] = function validator2(thing) {
@@ -5239,12 +5274,18 @@ const state$1 = reactive({
   availableLangs: [],
   lang: "en"
 });
+function $tdb(langEl) {
+  if (!langEl) {
+    console.warn("No language element provided for $tdb function");
+    return "";
+  }
+  return langEl[state$1.lang] || langEl[state$1.defaultLang] || "";
+}
 function useLang() {
   const lang = computed({
     get: () => state$1.lang,
     set: (val) => state$1.lang = val
   });
-  const $tdb = (langEl) => langEl[state$1.lang] || langEl[state$1.defaultLang] || "";
   const availableLangs = computed({
     get: () => state$1.availableLangs,
     set: (val) => state$1.availableLangs = val
@@ -5312,9 +5353,7 @@ function denullify(itemData, fieldID) {
 }
 const isDate$1 = (dateToTest) => !Number.isNaN(Date.parse(dateToTest));
 function getFallbackSchema(data2, showFields) {
-  const keys4 = [
-    ...new Set((data2 ?? []).map(Object.keys).flat())
-  ];
+  const keys4 = Array.from(new Set((data2 ?? []).map(Object.keys).flat()));
   const schema = keys4.map(
     (id) => ({
       id,
@@ -16068,7 +16107,7 @@ const _hoisted_4$c = {
 };
 const _hoisted_5$c = ["value"];
 const _hoisted_6$7 = { class: "selectinput-options" };
-const _hoisted_7$3 = ["onClick"];
+const _hoisted_7$3 = ["aria-selected", "onClick", "onKeydown"];
 const _sfc_main$m = /* @__PURE__ */ defineComponent({
   __name: "SelectInput",
   props: {
@@ -16238,7 +16277,11 @@ const _sfc_main$m = /* @__PURE__ */ defineComponent({
                   return openBlock(), createElementBlock("div", {
                     key: `${option2}${i2}`,
                     class: normalizeClass(["selectinput-option hover gap-1", { selected: isSelected(option2) }]),
-                    onClick: ($event) => select2(option2)
+                    role: "option",
+                    tabindex: "0",
+                    "aria-selected": isSelected(option2),
+                    onClick: ($event) => select2(option2),
+                    onKeydown: withKeys(($event) => select2(option2), ["enter"])
                   }, [
                     isSelected(option2) ? (openBlock(), createBlock(unref(_sfc_main$P), {
                       key: 0,
@@ -16250,7 +16293,7 @@ const _sfc_main$m = /* @__PURE__ */ defineComponent({
                       icon: "fiber_manual_record"
                     })) : createCommentVNode("", true),
                     createElementVNode("span", null, toDisplayString(getLabel(option2)), 1)
-                  ], 10, _hoisted_7$3);
+                  ], 42, _hoisted_7$3);
                 }), 128))
               ]),
               renderSlot(_ctx.$slots, "last", {}, void 0, true)
@@ -16306,7 +16349,7 @@ const _sfc_main$m = /* @__PURE__ */ defineComponent({
     };
   }
 });
-const SelectInput = /* @__PURE__ */ _export_sfc(_sfc_main$m, [["__scopeId", "data-v-6747635a"]]);
+const SelectInput = /* @__PURE__ */ _export_sfc(_sfc_main$m, [["__scopeId", "data-v-b33955d5"]]);
 /*!
   * vue-draggable-next v2.2.0
   * (c) 2023 Anish George
@@ -32246,7 +32289,7 @@ function pasteRulesPlugin(props2) {
 }
 function findDuplicates(items) {
   const filtered = items.filter((el, index2) => items.indexOf(el) !== index2);
-  return [...new Set(filtered)];
+  return Array.from(new Set(filtered));
 }
 class ExtensionManager {
   constructor(extensions, editor) {
@@ -33437,7 +33480,7 @@ function getMarksBetween(from2, to2, doc2) {
   const marks = [];
   if (from2 === to2) {
     doc2.resolve(from2).marks().forEach((mark) => {
-      const $pos = doc2.resolve(from2 - 1);
+      const $pos = doc2.resolve(from2);
       const range2 = getMarkRange($pos, mark.type);
       if (!range2) {
         return;
@@ -33551,27 +33594,36 @@ function isList(name, extensions) {
   }
   return group.split(" ").includes("list");
 }
-function isNodeEmpty(node, { checkChildren } = { checkChildren: true }) {
+function isNodeEmpty(node, { checkChildren = true, ignoreWhitespace = false } = {}) {
+  var _a2;
+  if (ignoreWhitespace) {
+    if (node.type.name === "hardBreak") {
+      return true;
+    }
+    if (node.isText) {
+      return /^\s*$/m.test((_a2 = node.text) !== null && _a2 !== void 0 ? _a2 : "");
+    }
+  }
   if (node.isText) {
     return !node.text;
   }
+  if (node.isAtom || node.isLeaf) {
+    return false;
+  }
   if (node.content.childCount === 0) {
     return true;
   }
-  if (node.isLeaf) {
-    return false;
-  }
   if (checkChildren) {
-    let hasSameContent = true;
+    let isContentEmpty = true;
     node.content.forEach((childNode) => {
-      if (hasSameContent === false) {
+      if (isContentEmpty === false) {
         return;
       }
-      if (!isNodeEmpty(childNode)) {
-        hasSameContent = false;
+      if (!isNodeEmpty(childNode, { ignoreWhitespace, checkChildren })) {
+        isContentEmpty = false;
       }
     });
-    return hasSameContent;
+    return isContentEmpty;
   }
   return false;
 }
@@ -33785,7 +33837,7 @@ const splitBlock = ({ keepMarks = true } = {}) => ({ tr: tr2, state: state2, dis
   }
   return can;
 };
-const splitListItem = (typeOrName) => ({ tr: tr2, state: state2, dispatch, editor }) => {
+const splitListItem = (typeOrName, overrideAttrs = {}) => ({ tr: tr2, state: state2, dispatch, editor }) => {
   var _a2;
   const type3 = getNodeType(typeOrName, state2.schema);
   const { $from, $to } = state2.selection;
@@ -33809,7 +33861,10 @@ const splitListItem = (typeOrName) => ({ tr: tr2, state: state2, dispatch, edito
         wrap2 = Fragment.from($from.node(d2).copy(wrap2));
       }
       const depthAfter = $from.indexAfter(-1) < $from.node(-2).childCount ? 1 : $from.indexAfter(-2) < $from.node(-3).childCount ? 2 : 3;
-      const newNextTypeAttributes2 = getSplittedAttributes(extensionAttributes, $from.node().type.name, $from.node().attrs);
+      const newNextTypeAttributes2 = {
+        ...getSplittedAttributes(extensionAttributes, $from.node().type.name, $from.node().attrs),
+        ...overrideAttrs
+      };
       const nextType2 = ((_a2 = type3.contentMatch.defaultType) === null || _a2 === void 0 ? void 0 : _a2.createAndFill(newNextTypeAttributes2)) || void 0;
       wrap2 = wrap2.append(Fragment.from(type3.createAndFill(null, nextType2) || void 0));
       const start2 = $from.before($from.depth - (depthBefore - 1));
@@ -33831,8 +33886,14 @@ const splitListItem = (typeOrName) => ({ tr: tr2, state: state2, dispatch, edito
     return true;
   }
   const nextType = $to.pos === $from.end() ? grandParent.contentMatchAt(0).defaultType : null;
-  const newTypeAttributes = getSplittedAttributes(extensionAttributes, grandParent.type.name, grandParent.attrs);
-  const newNextTypeAttributes = getSplittedAttributes(extensionAttributes, $from.node().type.name, $from.node().attrs);
+  const newTypeAttributes = {
+    ...getSplittedAttributes(extensionAttributes, grandParent.type.name, grandParent.attrs),
+    ...overrideAttrs
+  };
+  const newNextTypeAttributes = {
+    ...getSplittedAttributes(extensionAttributes, $from.node().type.name, $from.node().attrs),
+    ...overrideAttrs
+  };
   tr2.delete($from.pos, $to.pos);
   const types = nextType ? [
     { type: type3, attrs: newTypeAttributes },
@@ -34494,8 +34555,8 @@ img.ProseMirror-separator {
   display: inline !important;
   border: none !important;
   margin: 0 !important;
-  width: 1px !important;
-  height: 1px !important;
+  width: 0 !important;
+  height: 0 !important;
 }
 
 .ProseMirror-gapcursor {
@@ -34558,6 +34619,7 @@ let Editor$1 = class Editor2 extends EventEmitter {
   constructor(options = {}) {
     super();
     this.isFocused = false;
+    this.isInitialized = false;
     this.extensionStorage = {};
     this.options = {
       element: document.createElement("div"),
@@ -34610,6 +34672,7 @@ let Editor$1 = class Editor2 extends EventEmitter {
       }
       this.commands.focus(this.options.autofocus);
       this.emit("create", { editor: this });
+      this.isInitialized = true;
     }, 0);
   }
   /**
@@ -35246,14 +35309,16 @@ function nodePasteRule(config) {
     find: config.find,
     handler({ match: match2, chain, range: range2, pasteEvent }) {
       const attributes = callOrReturn(config.getAttributes, void 0, match2, pasteEvent);
+      const content = callOrReturn(config.getContent, void 0, attributes);
       if (attributes === false || attributes === null) {
         return null;
       }
+      const node = { type: config.type.name, attrs: attributes };
+      if (content) {
+        node.content = content;
+      }
       if (match2.input) {
-        chain().deleteRange(range2).insertContentAt(range2.from, {
-          type: config.type.name,
-          attrs: attributes
-        });
+        chain().deleteRange(range2).insertContentAt(range2.from, node);
       }
     }
   });
@@ -35408,6 +35473,7 @@ const ListItem$2 = Node$2.create({
 });
 const TextStyle$1 = Mark.create({
   name: "textStyle",
+  priority: 101,
   addOptions() {
     return {
       HTMLAttributes: {}
@@ -35567,6 +35633,7 @@ const CodeBlock = Node$2.create({
       languageClassPrefix: "language-",
       exitOnTripleEnter: true,
       exitOnArrowDown: true,
+      defaultLanguage: null,
       HTMLAttributes: {}
     };
   },
@@ -35578,7 +35645,7 @@ const CodeBlock = Node$2.create({
   addAttributes() {
     return {
       language: {
-        default: null,
+        default: this.options.defaultLanguage,
         parseHTML: (element) => {
           var _a2;
           const { languageClassPrefix } = this.options;
@@ -37003,6 +37070,7 @@ const ListItem = Node$2.create({
 });
 const TextStyle = Mark.create({
   name: "textStyle",
+  priority: 101,
   addOptions() {
     return {
       HTMLAttributes: {}
@@ -37060,6 +37128,10 @@ const OrderedList = Node$2.create({
         parseHTML: (element) => {
           return element.hasAttribute("start") ? parseInt(element.getAttribute("start") || "", 10) : 1;
         }
+      },
+      type: {
+        default: void 0,
+        parseHTML: (element) => element.getAttribute("type")
       }
     };
   },
@@ -48113,10 +48185,10 @@ var omit = /* @__PURE__ */ _curry2(function omit2(names, obj) {
   return result2;
 });
 var omit$1 = omit;
-var pickBy = /* @__PURE__ */ _curry2(function pickBy2(test, obj) {
+var pickBy = /* @__PURE__ */ _curry2(function pickBy2(test2, obj) {
   var result2 = {};
   for (var prop3 in obj) {
-    if (test(obj[prop3], prop3, obj)) {
+    if (test2(obj[prop3], prop3, obj)) {
       result2[prop3] = obj[prop3];
     }
   }