gt-sanity 4.0.25 → 4.0.27

package/dist/index.d.ts

@@ -53,7 +53,7 @@ export declare interface Adapter {
 export declare function attachGTData(
   html: string,
   data: Record<string, unknown>,
-  type: "markDef",
+  type: GTDataType,
 ): string;
 
 export declare const BaseDocumentDeserializer: Deserializer;
@@ -82,7 +82,7 @@ export declare const BaseDocumentSerializer: (schemas: Schema) => {
     baseLang: string,
   ) => Record<string, unknown>;
   serializeArray: (
-    fieldContent: Array<Record<string, unknown> | string>,
+    fieldContent: unknown[],
     fieldName: string,
     stopTypes: string[],
     serializers: Partial<PortableTextHtmlComponents>,
@@ -93,6 +93,7 @@ export declare const BaseDocumentSerializer: (schemas: Schema) => {
     stopTypes: string[],
     serializers: Partial<PortableTextHtmlComponents>,
     declaredFields?: ObjectField[],
+    isDocument?: boolean,
   ) => string;
 };
 
@@ -127,7 +128,7 @@ declare interface Deserializer {
 
 export declare function detachGTData(html: string): {
   html: string;
-  data?: Record<"markDef", Record<string, unknown>>;
+  data?: GTData;
 };
 
 export { documentInternationalization };
@@ -186,6 +187,16 @@ export declare const findLatestDraft: (
 
 declare const gt: GT;
 
+declare type GTData = Record<"markDef", Record<string, unknown>> &
+  Partial<Record<"inlineObject", Record<string, unknown>>>;
+
+/**
+ * Kinds of Sanity data that can be carried on an element:
+ * - `markDef`: an annotation (e.g. a link) applied to the element's children
+ * - `inlineObject`: an inline object in a block's `children`, restored as-is
+ */
+declare type GTDataType = "markDef" | "inlineObject";
+
 /**
  * Field-level localization options. `gtPlugin` forwards these to
  * `sanity-plugin-internationalized-array` — the reference Sanity plugin, which

package/dist/index.js

@@ -1,6 +1,6 @@
 import { GT, getLocaleProperties } from "generaltranslation";
 import { createDiagnosticMessage } from "generaltranslation/diagnostics";
-import { createGtApiAdapter, defaultBaseUrl, libraryDefaultLocale, decode, encode } from "generaltranslation/internal";
+import { createGtApiAdapter, defaultBaseUrl, libraryDefaultLocale, encode, decode } from "generaltranslation/internal";
 import { useClient as useClient$1, useSchema, Preview, definePlugin } from "sanity";
 import { useIntentLink, Link, route } from "sanity/router";
 import { jsx, jsxs, Fragment } from "react/jsx-runtime";
@@ -13,8 +13,8 @@ import { extractWithPath, arrayToJSONMatchPath } from "@sanity/mutator";
 import { JSONPath } from "jsonpath-plus";
 import JSONPointer from "jsonpointer";
 import { htmlToBlocks } from "@portabletext/block-tools";
+import { defaultComponents, toHTML } from "@portabletext/to-html";
 import { Schema } from "@sanity/schema";
-import { toHTML } from "@portabletext/to-html";
 import merge from "lodash.merge";
 import { Tooltip } from "@sanity/ui/tooltip";
 import { Code } from "@sanity/ui/code";
@@ -213,7 +213,22 @@ const gtRadius = [0, 4, 6, 8, 12, 16, 24], baseTheme = buildTheme(), theme = {
     !loadingSecrets && secrets && children
   ] });
   return /* @__PURE__ */ jsx(ThemeProvider, { theme, children: /* @__PURE__ */ jsx(ToastProvider, { paddingY: 7, children: showContainer ? /* @__PURE__ */ jsx(Box, { padding, children: content }) : content }) });
-}, isRecord$5 = (value) => typeof value == "object" && value !== null && !Array.isArray(value), reconcileArray = (origArray, translatedArray) => {
+}, isRecord$5 = (value) => typeof value == "object" && value !== null && !Array.isArray(value), withMarkDefOrder = (translatedBlock, origBlock) => {
+  if (!Array.isArray(translatedBlock.markDefs) || !Array.isArray(origBlock.markDefs))
+    return translatedBlock;
+  const origOrder = origBlock.markDefs.map(
+    (markDef) => isRecord$5(markDef) ? markDef._key : void 0
+  ), position = (markDef) => {
+    const index = isRecord$5(markDef) ? origOrder.indexOf(markDef._key) : -1;
+    return index < 0 ? origOrder.length : index;
+  };
+  return {
+    ...translatedBlock,
+    markDefs: [...translatedBlock.markDefs].sort(
+      (a, b) => position(a) - position(b)
+    )
+  };
+}, reconcileArray = (origArray, translatedArray) => {
   if (translatedArray && translatedArray.some((el) => typeof el == "string"))
     return translatedArray;
   const combined = JSON.parse(JSON.stringify(origArray));
@@ -227,7 +242,10 @@ const gtRadius = [0, 4, 6, 8, 12, 16, 24], baseTheme = buildTheme(), theme = {
       `This block no longer exists on the original document. Was it removed? ${JSON.stringify(
         translatedItem
       )}`
-    ) : isRecord$5(origArray[foundBlockIdx]) && (origArray[foundBlockIdx]._type === "block" || origArray[foundBlockIdx]._type === "span") ? combined[foundBlockIdx] = translatedItem : isRecord$5(origArray[foundBlockIdx]) && (combined[foundBlockIdx] = reconcileObject(
+    ) : isRecord$5(origArray[foundBlockIdx]) && (origArray[foundBlockIdx]._type === "block" || origArray[foundBlockIdx]._type === "span") ? combined[foundBlockIdx] = withMarkDefOrder(
+      translatedItem,
+      origArray[foundBlockIdx]
+    ) : isRecord$5(origArray[foundBlockIdx]) && (combined[foundBlockIdx] = reconcileObject(
       origArray[foundBlockIdx],
       translatedItem
     ));
@@ -765,7 +783,34 @@ function detachGTData(html) {
     data: extractedData
   };
 }
-const isRecord$3 = (value) => typeof value == "object" && value !== null && !Array.isArray(value), defaultStopTypes = [
+function mergeBlocks(blocks) {
+  const mergedBlock = { ...blocks[0] };
+  mergedBlock.markDefs = mergedBlock.markDefs ?? [];
+  for (const [idx, block] of blocks.entries())
+    idx !== 0 && (mergedBlock.children.push(...block.children), mergedBlock.markDefs.push(...block.markDefs ?? []));
+  mergedBlock._type = "block";
+  const seenMarkKeys = /* @__PURE__ */ new Set();
+  return mergedBlock.markDefs = mergedBlock.markDefs.filter((markDef) => seenMarkKeys.has(markDef._key) ? !1 : (seenMarkKeys.add(markDef._key), !0)), mergedBlock;
+}
+const htmlEscapes = {
+  "&": "&amp;",
+  "<": "&lt;",
+  ">": "&gt;",
+  '"': "&quot;"
+}, escapeHTML = (value) => value.replace(/[&<>"]/g, (char) => htmlEscapes[char]), SIGNIFICANT_WHITESPACE = /[\t\n\f\r]|^\s|\s$|\s\s/, STRING_ATTRIBUTE = "data-gt-string", LEADING_NEWLINES_ATTRIBUTE = "data-gt-leading-newlines", serializeString = (value, className, multiline = !1) => {
+  const classAttribute = className ? ` class="${className}"` : "";
+  if (!multiline && !SIGNIFICANT_WHITESPACE.test(value))
+    return `<span${classAttribute}>${escapeHTML(value)}</span>`;
+  const text = value.replace(/^\n+/, ""), leadingNewlines = value.length - text.length, leadingNewlinesAttribute = leadingNewlines ? ` ${LEADING_NEWLINES_ATTRIBUTE}="${leadingNewlines}"` : "";
+  return `<pre${classAttribute} ${STRING_ATTRIBUTE}=""${leadingNewlinesAttribute}>${escapeHTML(text)}</pre>`;
+}, INLINE_OBJECT_KEY_FIELD = "__gtInlineObjectKey", restoreInlineObjectKeys = (block) => (block.children?.forEach(
+  (child) => {
+    INLINE_OBJECT_KEY_FIELD in child && (typeof child[INLINE_OBJECT_KEY_FIELD] == "string" && (child._key = child[INLINE_OBJECT_KEY_FIELD]), delete child[INLINE_OBJECT_KEY_FIELD]);
+  }
+), block), MARKED_LINE_BREAK = "\uFDD0", restoreMarkedLineBreaks = (block) => (block.children?.forEach((child) => {
+  typeof child.text == "string" && (child.text = child.text.replaceAll(MARKED_LINE_BREAK, `
+`));
+}), block), isRecord$3 = (value) => typeof value == "object" && value !== null && !Array.isArray(value), defaultStopTypes = [
   "reference",
   "date",
   "datetime",
@@ -779,7 +824,30 @@ const isRecord$3 = (value) => typeof value == "object" && value !== null && !Arr
   "url",
   "color",
   "code"
-], defaultMarks = {}, defaultPortableTextBlockStyles = {
+], BUILTIN_ATTRIBUTE = "data-gt-builtin", annotationMark = (fallback) => (props) => {
+  const { value, children, markType } = props;
+  if (!(isRecord$3(value) && typeof value._key == "string"))
+    return fallback(props);
+  const href = markType === "link" && typeof value.href == "string" ? ` href="${escapeHTML(value.href)}"` : "", tag = markType === "link" ? "a" : "span";
+  return attachGTData(
+    `<${tag}${href} ${BUILTIN_ATTRIBUTE}="">${children}</${tag}>`,
+    value,
+    "markDef"
+  );
+}, DECORATOR_ATTRIBUTE = "data-gt-decorator", decoratorMark = ({ children, markType }) => `<span ${DECORATOR_ATTRIBUTE}="${escapeHTML(markType)}">${children}</span>`, DECORATOR_ELEMENTS = {
+  sup: "sup",
+  sub: "sub",
+  u: "underline"
+}, defaultMarks = {
+  link: annotationMark(
+    defaultComponents.marks.link
+  ),
+  // annotations share the mark registry, so an annotation named like one of
+  // these decorators keeps its markDef
+  sup: annotationMark(({ children }) => `<sup>${children}</sup>`),
+  sub: annotationMark(({ children }) => `<sub>${children}</sub>`),
+  underline: annotationMark(({ children }) => `<u>${children}</u>`)
+}, defaultPortableTextBlockStyles = {
   normal: ({ value, children }) => `<p id="${value._key}">${children}</p>`,
   blockquote: ({ value, children }) => `<blockquote id="${value._key}">${children}</blockquote>`,
   h1: ({ value, children }) => `<h1 id="${value._key}">${children}</h1>`,
@@ -797,37 +865,102 @@ const isRecord$3 = (value) => typeof value == "object" && value !== null && !Arr
 }) => {
   const { _key, level } = value;
   return `<li id="${(_key || "").replace("-parent", "")}" data-level="${level}">${children}</li>`;
-}, unknownBlockFunc = ({ value, children }) => `<p id="${value._key}" data-type="unknown-block-style" data-style="${value.style}">${children}</p>`, customSerializers = {
-  unknownType: ({ value }) => `<div class="${value._type}"></div>`,
+}, unknownBlockFunc = ({ value, children }) => `<p id="${value._key}" data-type="unknown-block-style" data-style="${value.style}">${children}</p>`, INLINE_OBJECT_CONTENT = "\u200B", customSerializers = {
+  // Inline objects must stay inline: a <div> inside a <p> closes the
+  // paragraph and the rest of its text is dropped on import. The object is
+  // carried as data and restored by the inline-object rule below. The
+  // zero-width space keeps the span non-empty: HTML formatters (GT's
+  // included) collapse the spaces on both sides of an empty element into one.
+  unknownType: ({ value, isInline }) => isInline ? attachGTData(
+    `<span class="${escapeHTML(value._type)}">${INLINE_OBJECT_CONTENT}</span>`,
+    value,
+    "inlineObject"
+  ) : `<div class="${escapeHTML(value._type)}"></div>`,
+  unknownMark: annotationMark(decoratorMark),
   types: {},
   marks: defaultMarks,
   block: defaultPortableTextBlockStyles,
   list: defaultLists,
   listItem: defaultListItem,
   unknownBlockStyle: unknownBlockFunc
-}, customDeserializers = { types: {} }, customBlockDeserializers = [
-  // handle marks with data-gt-internal
+}, customDeserializers = { types: {} }, MARK_ELEMENTS = /* @__PURE__ */ new Set([
+  "a",
+  "b",
+  "code",
+  "del",
+  "em",
+  "i",
+  "s",
+  "span",
+  "strike",
+  "strong",
+  "sub",
+  "sup",
+  "u"
+]), markDefRule = (claims) => ({
+  deserialize(node, next) {
+    if (node.nodeType !== 1)
+      return;
+    const el = node;
+    if (!el.hasChildNodes() || !el.getAttribute("data-gt-internal") || !claims(el))
+      return;
+    const markDef = detachGTData(el.outerHTML).data?.markDef;
+    if (!(!isRecord$3(markDef) || typeof markDef._key != "string"))
+      return {
+        _type: "__annotation",
+        markDef,
+        children: next(el.childNodes)
+      };
+  }
+}), decoratorRule = (decoratorName) => ({
+  deserialize(node, next) {
+    if (node.nodeType !== 1)
+      return;
+    const name = decoratorName(node);
+    if (name)
+      return {
+        _type: "__decorator",
+        name,
+        children: next(node.childNodes)
+      };
+  }
+}), customBlockDeserializers = [
+  // keep whitespace-only text inside a mark (`Note:<strong> </strong>The`,
+  // or next to a nested mark: `<strong><em>Note:</em> </strong>The`):
+  // block-tools drops it and glues the words on either side together
   {
-    deserialize(node, next) {
+    deserialize(node) {
+      const parent = node.parentElement;
+      if (!(node.nodeType !== 3 || !node.textContent || node.textContent.trim() || !parent || !MARK_ELEMENTS.has(parent.tagName.toLowerCase())))
+        return {
+          _type: "span",
+          marks: [],
+          text: node.textContent.replace(/[\t\n\f\r ]+/g, " ")
+        };
+    }
+  },
+  // handle inline objects with data-gt-internal
+  {
+    deserialize(node) {
       if (node.nodeType !== 1)
         return;
       const el = node;
-      if (!el.hasChildNodes() || !el.getAttribute("data-gt-internal"))
+      if (!el.getAttribute("data-gt-internal"))
         return;
-      const { html, data } = detachGTData(el.outerHTML), block = htmlToBlocks(html, blockContentType)[0], children = next(el.childNodes);
-      let markDefs = [];
-      return "markDefs" in block && (markDefs = block.markDefs ?? []), data?.markDef && markDefs.push(data.markDef), Array.isArray(children) && children.forEach((child) => {
-        if (!isRecord$3(child))
-          return;
-        const marks = Array.isArray(child.marks) ? child.marks : [];
-        child.marks = data?.markDef?._key ? [...marks, data.markDef._key] : marks;
-      }), {
-        ...block,
-        markDefs,
-        children
-      };
+      const inlineObject = detachGTData(el.outerHTML).data?.inlineObject;
+      if (!(!isRecord$3(inlineObject) || typeof inlineObject._type != "string"))
+        return {
+          ...inlineObject,
+          _type: inlineObject._type,
+          [INLINE_OBJECT_KEY_FIELD]: inlineObject._key
+        };
     }
   },
+  // handle marks with data-gt-internal from a user's serializer
+  // (attachGTData); the built-in ones are in fallbackBlockDeserializers
+  markDefRule((el) => !el.hasAttribute(BUILTIN_ATTRIBUTE)),
+  // handle decorators, whether or not the generic import schema declares them
+  decoratorRule((el) => el.getAttribute(DECORATOR_ATTRIBUTE)),
   //handle undeclared styles
   {
     deserialize(node, next) {
@@ -872,7 +1005,13 @@ const isRecord$3 = (value) => typeof value == "object" && value !== null && !Arr
           // @ts-ignore
           style: customStyle ?? newBlock.style
         }, customStyle))
-          return block;
+          return {
+            ...block,
+            level,
+            _key,
+            listItem,
+            children: next(el.children[0].childNodes)
+          };
       }
       return {
         ...block,
@@ -883,21 +1022,45 @@ const isRecord$3 = (value) => typeof value == "object" && value !== null && !Arr
       };
     }
   }
-];
-function mergeBlocks(blocks) {
-  const mergedBlock = { ...blocks[0] };
-  mergedBlock.markDefs = mergedBlock.markDefs ?? [];
-  for (const [idx, block] of blocks.entries())
-    idx !== 0 && (mergedBlock.children.push(...block.children), mergedBlock.markDefs.push(...block.markDefs ?? []));
-  return mergedBlock._type = "block", mergedBlock;
-}
-const deserializeArray = (arrayHTML, deserializers = customDeserializers, blockDeserializers = customBlockDeserializers) => {
+], fallbackBlockDeserializers = [
+  markDefRule((el) => el.hasAttribute(BUILTIN_ATTRIBUTE)),
+  decoratorRule((el) => DECORATOR_ELEMENTS[el.tagName.toLowerCase()]),
+  // a line break inside a mark (`<em>one<br>two</em>`) keeps that mark; one
+  // between marks (`<em>one</em><br><em>two</em>`) stays unmarked
+  {
+    deserialize(node) {
+      const parent = node.parentElement;
+      if (!(node.nodeName !== "BR" || !parent || !MARK_ELEMENTS.has(parent.tagName.toLowerCase())))
+        return {
+          _type: "span",
+          marks: [],
+          text: MARKED_LINE_BREAK
+        };
+    }
+  }
+], defaultBlockDeserializers = [
+  ...customBlockDeserializers,
+  ...fallbackBlockDeserializers
+], deserializeString = (element) => {
+  const tagName = element.tagName?.toLowerCase();
+  if (tagName === "pre" && element.hasAttribute(STRING_ATTRIBUTE)) {
+    const text = (element.textContent ?? "").replace(/^\n+/, ""), leadingNewlines = Number.parseInt(
+      element.getAttribute(LEADING_NEWLINES_ATTRIBUTE) ?? "",
+      10
+    ) || 0;
+    return `
+`.repeat(Math.max(leadingNewlines, 0)) + text;
+  }
+  if (tagName === "span")
+    return preprocess(element.innerHTML);
+}, deserializeArray = (arrayHTML, deserializers = customDeserializers, blockDeserializers = defaultBlockDeserializers) => {
   const output = [];
   return Array.from(arrayHTML.children).forEach((child) => {
     let deserializedObject;
     try {
-      if (child.tagName?.toLowerCase() === "span")
-        deserializedObject = preprocess(child.innerHTML);
+      const stringValue = deserializeString(child);
+      if (stringValue !== void 0)
+        deserializedObject = stringValue;
       else if (child.className || child.getAttribute("data-type") === "object")
         deserializedObject = deserializeObject(
           child,
@@ -908,8 +1071,10 @@ const deserializeArray = (arrayHTML, deserializers = customDeserializers, blockD
         const blocks = htmlToBlocks(child.outerHTML, blockContentType, {
           rules: blockDeserializers
         });
-        deserializedObject = mergeBlocks(
-          blocks
+        deserializedObject = restoreMarkedLineBreaks(
+          restoreInlineObjectKeys(
+            mergeBlocks(blocks)
+          )
         ), deserializedObject._key = child.id;
       }
     } catch (e) {
@@ -919,14 +1084,15 @@ const deserializeArray = (arrayHTML, deserializers = customDeserializers, blockD
     }
     output.push(deserializedObject);
   }), output;
-}, deserializeObject = (objectHTML, deserializers = customDeserializers, blockDeserializers = customBlockDeserializers) => {
+}, deserializeObject = (objectHTML, deserializers = customDeserializers, blockDeserializers = defaultBlockDeserializers) => {
   const deserialize = deserializers.types?.[objectHTML.className];
   if (deserialize)
     return deserialize(objectHTML);
   const output = {};
   return objectHTML.className && (output._type = objectHTML.className), Array.from(objectHTML.children).forEach((child) => {
-    if (child.tagName?.toLowerCase() === "span")
-      output[child.className] = preprocess(child.innerHTML);
+    const stringValue = deserializeString(child);
+    if (stringValue !== void 0)
+      output[child.className] = stringValue;
     else if (child.getAttribute("data-level") === "field") {
       const deserialized = deserializeHTML(
         child.outerHTML,
@@ -951,7 +1117,7 @@ const deserializeArray = (arrayHTML, deserializers = customDeserializers, blockD
   return deserialize ? output = deserialize(HTMLnode) : HTMLnode.getAttribute("data-type") === "object" ? output = deserializeObject(HTMLnode, deserializers, blockDeserializers) : HTMLnode.getAttribute("data-type") === "array" ? output = deserializeArray(HTMLnode, deserializers, blockDeserializers) : (output = {}, console.debug(
     `Tried to deserialize block ${HTMLnode.outerHTML} but failed to identify it!`
   )), output;
-}, deserializeDocument$1 = (serializedDoc, deserializers = customDeserializers, blockDeserializers = customBlockDeserializers) => {
+}, deserializeDocument$1 = (serializedDoc, deserializers = customDeserializers, blockDeserializers = defaultBlockDeserializers) => {
   const metadata = {}, head = new DOMParser().parseFromString(serializedDoc, "text/html").head;
   return Array.from(head.children).forEach((metaTag) => {
     const validTags = ["_id", "_rev", "_type"], metaName = metaTag.getAttribute("name");
@@ -1059,7 +1225,27 @@ const deserializeArray = (arrayHTML, deserializers = customDeserializers, blockD
       if (typeDef.fields) return typeDef.fields;
       current = typeof typeDef.type == "string" ? typeDef.type : void 0;
     }
-  }, serializeObject = (obj, stopTypes, serializers, declaredFields) => {
+  }, isTextType = (typeName) => {
+    const seen = /* @__PURE__ */ new Set();
+    let current = typeName;
+    for (; current && !seen.has(current); ) {
+      if (current === "text") return !0;
+      seen.add(current);
+      const typeDef = getSchema(current);
+      current = typeof typeDef?.type == "string" ? typeDef.type : void 0;
+    }
+    return !1;
+  }, resolveArrayMembers = (fieldDef) => {
+    if (fieldDef?.of) return fieldDef.of;
+    const seen = /* @__PURE__ */ new Set();
+    let current = fieldDef?.type;
+    for (; current && !seen.has(current); ) {
+      seen.add(current);
+      const typeDef = getSchema(current);
+      if (typeDef?.of) return typeDef.of;
+      current = typeof typeDef?.type == "string" ? typeDef.type : void 0;
+    }
+  }, serializeObject = (obj, stopTypes, serializers, declaredFields, isDocument = !1) => {
     if (stopTypes.includes(obj._type) || isTypeExcludedByOptions(obj._type, getSchema))
       return "";
     const typeSerializers = isRecord$1(serializers.types) ? serializers.types : {};
@@ -1091,7 +1277,11 @@ const deserializeArray = (arrayHTML, deserializers = customDeserializers, blockD
           (field) => field.name === fieldName
         );
         if (typeof value == "string")
-          new RegExp(/<("[^"]*"|'[^']*'|[^'">])*>/).test(value) ? htmlField = value : htmlField = `<span class="${fieldName}">${value}</span>`;
+          htmlField = serializeString(
+            value,
+            fieldName,
+            isTextType(fieldDef?.type)
+          );
         else if (Array.isArray(value))
           htmlField = serializeArray(
             value,
@@ -1101,12 +1291,12 @@ const deserializeArray = (arrayHTML, deserializers = customDeserializers, blockD
               ...serializers,
               types: { ...typeSerializers }
             },
-            fieldDef?.of
+            resolveArrayMembers(fieldDef)
           );
         else if (isRecord$1(value)) {
           const embeddedObject = value, embeddedFields = resolveSchemaFields(embeddedObject._type);
           let toTranslate = embeddedObject;
-          embeddedFields && (toTranslate = fieldFilter(
+          embeddedFields && !isDocument && (toTranslate = fieldFilter(
             toTranslate,
             embeddedFields,
             stopTypes,
@@ -1150,7 +1340,7 @@ const deserializeArray = (arrayHTML, deserializers = customDeserializers, blockD
     return serializedBlock;
   }, serializeArray = (fieldContent, fieldName, stopTypes, serializers, memberDefs) => {
     const validBlocks = fieldContent.filter(
-      (block) => typeof block == "string" || typeof block._type != "string" || !stopTypes.includes(block._type)
+      (block) => typeof block == "string" || isRecord$1(block) && (typeof block._type != "string" || !stopTypes.includes(block._type))
     ), declaredMemberFields = (blockType) => {
       if (!memberDefs?.length) return;
       const byName = memberDefs.find(
@@ -1160,7 +1350,11 @@ const deserializeArray = (arrayHTML, deserializers = customDeserializers, blockD
       if (!blockType && memberDefs.length === 1) return memberDefs[0].fields;
     }, output = validBlocks.map((block) => {
       if (typeof block == "string")
-        return `<span>${block}</span>`;
+        return serializeString(
+          block,
+          void 0,
+          memberDefs?.some((def) => isTextType(def.type))
+        );
       const blockType = typeof block._type == "string" ? block._type : void 0, memberFields = resolveSchemaFields(blockType), filtered = memberFields ? fieldFilter(block, memberFields, stopTypes, getSchema) : block;
       return serializeObject(
         filtered,
@@ -1181,37 +1375,13 @@ const deserializeArray = (arrayHTML, deserializers = customDeserializers, blockD
         stopTypes,
         getSchema
       );
-      const serializedFields = {};
-      for (const key in filteredObj) {
-        if (filteredObj.hasOwnProperty(key) === !1) continue;
-        const value = filteredObj[key], fieldDef = schema?.fields?.find((field) => field.name === key);
-        if (typeof value == "string")
-          serializedFields[key] = value;
-        else if (Array.isArray(value))
-          serializedFields[key] = serializeArray(
-            value.filter(
-              (item) => typeof item == "string" || isRecord$1(item)
-            ),
-            key,
-            stopTypes,
-            serializers,
-            fieldDef?.of
-          );
-        else if (value && isRecord$1(value) && !stopTypes.find((stopType) => stopType == value?._type)) {
-          const serialized = serializeObject(
-            value,
-            stopTypes,
-            serializers,
-            fieldDef?.fields
-          );
-          serializedFields[key] = `<div class="${key}" data-level='field'>${serialized}</div>`;
-        }
-      }
       const rawHTMLBody = document.createElement("body");
       rawHTMLBody.innerHTML = serializeObject(
-        serializedFields,
+        filteredObj,
         stopTypes,
-        serializers
+        serializers,
+        void 0,
+        !0
       );
       const rawHTMLHead = document.createElement("head");
       ["_id", "_type", "_rev"].forEach((field) => {
@@ -1255,7 +1425,8 @@ function deserializeDocument(document2) {
     pluginConfig.getAdditionalDeserializers()
   ), blockDeserializers = [
     ...customBlockDeserializers,
-    ...pluginConfig.getAdditionalBlockDeserializers()
+    ...pluginConfig.getAdditionalBlockDeserializers(),
+    ...fallbackBlockDeserializers
   ];
   return BaseDocumentDeserializer.deserializeDocument(
     document2,
@@ -2746,7 +2917,7 @@ const useTranslations = () => {
     ] }) })
   }
 ) : null;
-var version = "4.0.25";
+var version = "4.0.27";
 function buildDebugInfo({
   secrets,
   preferences,