@harbour-enterprises/superdoc 1.3.0-next.1 → 1.3.0-next.3

package/dist/superdoc.umd.js

@@ -12179,134 +12179,200 @@
     "italic",
     "strike",
     "underline",
-    "letterSpacing",
-    "vertAlign",
-    "position"
+    "letterSpacing"
   ];
   const DEFAULT_FONT_SIZE_HALF_POINTS = 20;
-  const SUBSCRIPT_SUPERSCRIPT_SCALE$1 = 0.65;
-  const resolveRunProperties = (params2, inlineRpr, resolvedPpr, isListNumber = false, numberingDefinedInline = false) => {
+  function isObject$4(item) {
+    return item != null && typeof item === "object" && !Array.isArray(item);
+  }
+  function combineProperties$1(propertiesArray, options = {}) {
+    const { fullOverrideProps = [], specialHandling = {} } = options;
+    if (!propertiesArray || propertiesArray.length === 0) {
+      return {};
+    }
+    const merge2 = (target, source) => {
+      const output = { ...target };
+      if (isObject$4(target) && isObject$4(source)) {
+        for (const key2 in source) {
+          if (Object.prototype.hasOwnProperty.call(source, key2)) {
+            const handler2 = specialHandling[key2];
+            if (handler2 && typeof handler2 === "function") {
+              output[key2] = handler2(output, source);
+            } else if (!fullOverrideProps.includes(key2) && isObject$4(source[key2])) {
+              if (key2 in target && isObject$4(target[key2])) {
+                output[key2] = merge2(target[key2], source[key2]);
+              } else {
+                output[key2] = source[key2];
+              }
+            } else {
+              output[key2] = source[key2];
+            }
+          }
+        }
+      }
+      return output;
+    };
+    return propertiesArray.reduce((acc, current) => merge2(acc, current ?? {}), {});
+  }
+  function combineRunProperties$1(propertiesArray) {
+    return combineProperties$1(propertiesArray, {
+      fullOverrideProps: ["fontFamily", "color"]
+    });
+  }
+  function applyInlineOverrides(finalProps, inlineProps, overrideKeys = INLINE_OVERRIDE_PROPERTIES) {
+    if (!inlineProps) return finalProps;
+    for (const prop of overrideKeys) {
+      if (inlineProps[prop] != null) {
+        finalProps[prop] = inlineProps[prop];
+      }
+    }
+    return finalProps;
+  }
+  function isValidFontSize(value) {
+    return typeof value === "number" && Number.isFinite(value) && value > 0;
+  }
+  function resolveFontSizeWithFallback(value, defaultProps2, normalProps) {
+    if (isValidFontSize(value)) {
+      return value;
+    }
+    if (defaultProps2 && isValidFontSize(defaultProps2.fontSize)) {
+      return defaultProps2.fontSize;
+    }
+    if (normalProps && isValidFontSize(normalProps.fontSize)) {
+      return normalProps.fontSize;
+    }
+    return DEFAULT_FONT_SIZE_HALF_POINTS;
+  }
+  function orderDefaultsAndNormal(defaultProps2, normalProps, isNormalDefault) {
+    if (isNormalDefault) {
+      return [defaultProps2, normalProps];
+    } else {
+      return [normalProps, defaultProps2];
+    }
+  }
+  function createFirstLineIndentHandler() {
+    return (target, source) => {
+      if (target.hanging != null && source.firstLine != null) {
+        delete target.hanging;
+      }
+      return source.firstLine;
+    };
+  }
+  function combineIndentProperties(indentChain) {
+    const indentOnly = indentChain.map((props) => props.indent != null ? { indent: props.indent } : {});
+    return combineProperties$1(indentOnly, {
+      specialHandling: {
+        firstLine: createFirstLineIndentHandler()
+      }
+    });
+  }
+  function createOoxmlResolver(translators) {
+    return {
+      resolveRunProperties: (params2, inlineRpr, resolvedPpr, isListNumber = false, numberingDefinedInline = false) => resolveRunProperties$1(translators, params2, inlineRpr, resolvedPpr, isListNumber, numberingDefinedInline),
+      resolveParagraphProperties: (params2, inlineProps, insideTable = false, overrideInlineStyleId = false, tableStyleId = null) => resolveParagraphProperties$1(translators, params2, inlineProps, insideTable, overrideInlineStyleId, tableStyleId),
+      getDefaultProperties,
+      getStyleProperties,
+      resolveStyleChain: resolveStyleChain$1,
+      getNumberingProperties: (params2, ilvl, numId, translator2, tries = 0) => getNumberingProperties(translators, params2, ilvl, numId, translator2, tries)
+    };
+  }
+  function resolveRunProperties$1(translators, params2, inlineRpr, resolvedPpr, isListNumber = false, numberingDefinedInline = false) {
     const paragraphStyleId = resolvedPpr?.styleId;
-    const paragraphStyleProps = resolveStyleChain$1(params2, paragraphStyleId, translator$1O);
-    const defaultProps2 = getDefaultProperties(params2, translator$1O);
-    const { properties: normalProps, isDefault: isNormalDefault } = getStyleProperties(params2, "Normal", translator$1O);
+    const paragraphStyleProps = resolveStyleChain$1(params2, paragraphStyleId, translators.rPr);
+    const defaultProps2 = getDefaultProperties(params2, translators.rPr);
+    const { properties: normalProps, isDefault: isNormalDefault } = getStyleProperties(params2, "Normal", translators.rPr);
     let runStyleProps = {};
     if (!paragraphStyleId?.startsWith("TOC")) {
-      runStyleProps = inlineRpr.styleId ? resolveStyleChain$1(params2, inlineRpr.styleId, translator$1O) : {};
+      runStyleProps = inlineRpr?.styleId ? resolveStyleChain$1(params2, inlineRpr.styleId, translators.rPr) : {};
     }
+    const defaultsChain = orderDefaultsAndNormal(defaultProps2, normalProps, isNormalDefault);
+    const inlineRprSafe = inlineRpr ?? {};
     let styleChain;
-    if (isNormalDefault) {
-      styleChain = [defaultProps2, normalProps];
-    } else {
-      styleChain = [normalProps, defaultProps2];
-    }
+    let inlineOverrideSource = inlineRprSafe;
     if (isListNumber) {
       let numberingProps = {};
-      const numId = resolvedPpr?.numberingProperties?.numId;
+      const numberingProperties = resolvedPpr?.numberingProperties;
+      const numId = numberingProperties?.numId;
       if (numId != null && numId !== 0 && numId !== "0") {
         numberingProps = getNumberingProperties(
+          translators,
           params2,
-          resolvedPpr.numberingProperties.ilvl ?? 0,
+          numberingProperties?.ilvl ?? 0,
           numId,
-          translator$1O
+          translators.rPr
         );
       }
-      if (!numberingDefinedInline) {
-        inlineRpr = {};
-      }
-      if (inlineRpr?.underline) {
-        delete inlineRpr.underline;
+      const inlineRprForList = numberingDefinedInline ? inlineRprSafe : {};
+      if (inlineRprForList?.underline) {
+        delete inlineRprForList.underline;
       }
-      styleChain = [...styleChain, paragraphStyleProps, runStyleProps, inlineRpr, numberingProps];
+      styleChain = [...defaultsChain, paragraphStyleProps, runStyleProps, inlineRprForList, numberingProps];
+      inlineOverrideSource = inlineRprForList;
     } else {
-      styleChain = [...styleChain, paragraphStyleProps, runStyleProps, inlineRpr];
-    }
-    const finalProps = combineProperties(styleChain, ["fontFamily", "color"]);
-    for (const prop of INLINE_OVERRIDE_PROPERTIES) {
-      if (inlineRpr?.[prop] != null) {
-        finalProps[prop] = inlineRpr[prop];
-      }
-    }
-    if (finalProps.fontSize == null || typeof finalProps.fontSize !== "number" || !Number.isFinite(finalProps.fontSize) || finalProps.fontSize <= 0) {
-      let defaultFontSize = DEFAULT_FONT_SIZE_HALF_POINTS;
-      if (defaultProps2?.fontSize != null && typeof defaultProps2.fontSize === "number" && Number.isFinite(defaultProps2.fontSize) && defaultProps2.fontSize > 0) {
-        defaultFontSize = defaultProps2.fontSize;
-      } else if (normalProps?.fontSize != null && typeof normalProps.fontSize === "number" && Number.isFinite(normalProps.fontSize) && normalProps.fontSize > 0) {
-        defaultFontSize = normalProps.fontSize;
-      }
-      finalProps.fontSize = defaultFontSize;
+      styleChain = [...defaultsChain, paragraphStyleProps, runStyleProps, inlineRprSafe];
     }
+    const finalProps = combineRunProperties$1(styleChain);
+    applyInlineOverrides(finalProps, inlineOverrideSource);
+    finalProps.fontSize = resolveFontSizeWithFallback(finalProps.fontSize, defaultProps2, normalProps);
     return finalProps;
-  };
-  function resolveParagraphProperties(params2, inlineProps, insideTable = false, overrideInlineStyleId = false, tableStyleId = null) {
-    const defaultProps2 = getDefaultProperties(params2, translator$14);
-    const { properties: normalProps, isDefault: isNormalDefault } = getStyleProperties(params2, "Normal", translator$14);
-    let styleId = inlineProps?.styleId;
-    let styleProps = inlineProps?.styleId ? resolveStyleChain$1(params2, inlineProps?.styleId, translator$14) : {};
+  }
+  function resolveParagraphProperties$1(translators, params2, inlineProps, insideTable = false, overrideInlineStyleId = false, tableStyleId = null) {
+    const defaultProps2 = getDefaultProperties(params2, translators.pPr);
+    const { properties: normalProps, isDefault: isNormalDefault } = getStyleProperties(params2, "Normal", translators.pPr);
+    const inlinePropsSafe = inlineProps ?? {};
+    let styleId = inlinePropsSafe?.styleId;
+    let styleProps = inlinePropsSafe?.styleId ? resolveStyleChain$1(params2, inlinePropsSafe.styleId, translators.pPr) : {};
     let numberingProps = {};
-    let ilvl = inlineProps?.numberingProperties?.ilvl ?? styleProps?.numberingProperties?.ilvl;
-    let numId = inlineProps?.numberingProperties?.numId ?? styleProps?.numberingProperties?.numId;
-    let numberingDefinedInline = inlineProps?.numberingProperties?.numId != null;
-    const inlineNumIdDisablesNumbering = inlineProps?.numberingProperties?.numId === 0 || inlineProps?.numberingProperties?.numId === "0";
+    const ilvl = inlinePropsSafe?.numberingProperties?.ilvl ?? styleProps?.numberingProperties?.ilvl;
+    let numId = inlinePropsSafe?.numberingProperties?.numId ?? styleProps?.numberingProperties?.numId;
+    let numberingDefinedInline = inlinePropsSafe?.numberingProperties?.numId != null;
+    const inlineNumId = inlinePropsSafe?.numberingProperties?.numId;
+    const inlineNumIdDisablesNumbering = inlineNumId === 0 || inlineNumId === "0";
     if (inlineNumIdDisablesNumbering) {
       numId = null;
     }
     const isList2 = numId != null && numId !== 0 && numId !== "0";
     if (isList2) {
-      ilvl = ilvl != null ? ilvl : 0;
-      numberingProps = getNumberingProperties(params2, ilvl, numId, translator$14);
+      const ilvlNum = ilvl != null ? ilvl : 0;
+      numberingProps = getNumberingProperties(translators, params2, ilvlNum, numId, translators.pPr);
       if (overrideInlineStyleId && numberingProps.styleId) {
         styleId = numberingProps.styleId;
-        styleProps = resolveStyleChain$1(params2, styleId, translator$14);
-        if (inlineProps) {
-          inlineProps.styleId = styleId;
-          if (styleProps.numberingProperties?.ilvl === inlineProps.numberingProperties?.ilvl && styleProps.numberingProperties?.numId === inlineProps.numberingProperties?.numId) {
-            delete inlineProps.numberingProperties;
+        styleProps = resolveStyleChain$1(params2, styleId, translators.pPr);
+        if (inlinePropsSafe) {
+          inlinePropsSafe.styleId = styleId;
+          const inlineNumProps = inlinePropsSafe.numberingProperties;
+          if (styleProps.numberingProperties?.ilvl === inlineNumProps?.ilvl && styleProps.numberingProperties?.numId === inlineNumProps?.numId) {
+            delete inlinePropsSafe.numberingProperties;
             numberingDefinedInline = false;
           }
         }
       }
     }
-    const tableProps = tableStyleId ? resolveStyleChain$1(params2, tableStyleId, translator$14) : {};
-    let defaultsChain;
-    if (isNormalDefault) {
-      defaultsChain = [defaultProps2, normalProps];
-    } else {
-      defaultsChain = [normalProps, defaultProps2];
-    }
-    const propsChain = [...defaultsChain, tableProps, numberingProps, styleProps, inlineProps];
+    const tableProps = tableStyleId ? resolveStyleChain$1(params2, tableStyleId, translators.pPr) : {};
+    const defaultsChain = orderDefaultsAndNormal(defaultProps2, normalProps, isNormalDefault);
+    const propsChain = [...defaultsChain, tableProps, numberingProps, styleProps, inlinePropsSafe];
     let indentChain;
     if (isList2) {
       if (numberingDefinedInline) {
-        indentChain = [...defaultsChain, styleProps, numberingProps, inlineProps];
+        indentChain = [...defaultsChain, styleProps, numberingProps, inlinePropsSafe];
       } else {
-        styleProps = resolveStyleChain$1(params2, styleId, translator$14, false);
-        indentChain = [...defaultsChain, numberingProps, styleProps, inlineProps];
+        styleProps = resolveStyleChain$1(params2, styleId, translators.pPr, false);
+        indentChain = [...defaultsChain, numberingProps, styleProps, inlinePropsSafe];
       }
     } else {
-      indentChain = [...defaultsChain, numberingProps, styleProps, inlineProps];
+      indentChain = [...defaultsChain, numberingProps, styleProps, inlinePropsSafe];
     }
-    let finalProps = combineProperties(propsChain);
-    let finalIndent = combineProperties(
-      indentChain.map((props) => props.indent != null ? { indent: props.indent } : {}),
-      [],
-      {
-        firstLine: (target, source) => {
-          if (target.hanging != null && source.firstLine != null) {
-            delete target.hanging;
-          }
-          return source.firstLine;
-        }
-      }
-    );
+    const finalProps = combineProperties$1(propsChain);
+    const finalIndent = combineIndentProperties(indentChain);
     finalProps.indent = finalIndent.indent;
-    if (insideTable && !inlineProps?.spacing && !styleProps.spacing) {
+    if (insideTable && !inlinePropsSafe?.spacing && !styleProps?.spacing) {
       finalProps.spacing = void 0;
     }
     return finalProps;
   }
-  const resolveStyleChain$1 = (params2, styleId, translator2, followBasedOnChain = true) => {
-    let styleProps = {}, basedOn = null;
+  function resolveStyleChain$1(params2, styleId, translator2, followBasedOnChain = true) {
+    let styleProps = {};
+    let basedOn = void 0;
     if (styleId && styleId !== "Normal") {
       ({ properties: styleProps, basedOn } = getStyleProperties(params2, styleId, translator2));
     }
@@ -12318,7 +12384,7 @@
         break;
       }
       seenStyles.add(basedOn);
-      const result = getStyleProperties(params2, basedOn, translator2);
+      const result = getStyleProperties(params2, nextBasedOn, translator2);
       const basedOnProps = result.properties;
       nextBasedOn = result.basedOn;
       if (basedOnProps && Object.keys(basedOnProps).length) {
@@ -12327,120 +12393,499 @@
       basedOn = nextBasedOn;
     }
     styleChain = styleChain.reverse();
-    const combinedStyleProps = combineProperties(styleChain);
-    return combinedStyleProps;
-  };
+    return combineProperties$1(styleChain);
+  }
   function getDefaultProperties(params2, translator2) {
-    const { docx } = params2;
-    const styles = docx["word/styles.xml"];
+    const docx = params2?.docx;
+    const styles = docx?.["word/styles.xml"];
     const rootElements = styles?.elements?.[0]?.elements;
     if (!rootElements?.length) {
       return {};
     }
     const defaults2 = rootElements.find((el) => el.name === "w:docDefaults");
     const xmlName = translator2.xmlName;
-    const elementPrDefault = defaults2?.elements?.find((el) => el.name === `${xmlName}Default`) || {};
-    const elementPr = elementPrDefault?.elements?.find((el) => el.name === xmlName);
+    const defaultsElements = defaults2?.elements;
+    const elementPrDefault = defaultsElements?.find((el) => el.name === `${xmlName}Default`);
+    const elementPrDefaultElements = elementPrDefault?.elements;
+    const elementPr = elementPrDefaultElements?.find((el) => el.name === xmlName);
     if (!elementPr) {
       return {};
     }
-    const result = translator2.encode({ ...params2, nodes: [elementPr] }) || {};
-    return result;
+    return translator2.encode({ ...params2, nodes: [elementPr] }) || {};
   }
   function getStyleProperties(params2, styleId, translator2) {
-    const { docx } = params2;
-    const emptyResult = { properties: {}, isDefault: false, basedOn: null };
+    const emptyResult = { properties: {}, isDefault: false, basedOn: void 0 };
     if (!styleId) return emptyResult;
-    const styles = docx["word/styles.xml"];
+    const docx = params2?.docx;
+    const styles = docx?.["word/styles.xml"];
     const rootElements = styles?.elements?.[0]?.elements;
     if (!rootElements?.length) {
       return emptyResult;
     }
-    const style2 = rootElements.find((el) => el.name === "w:style" && el.attributes["w:styleId"] === styleId);
-    let basedOn = style2?.elements?.find((el) => el.name === "w:basedOn");
-    if (basedOn) {
-      basedOn = basedOn?.attributes?.["w:val"];
-    }
-    const elementPr = style2?.elements?.find((el) => el.name === translator2.xmlName);
+    const style2 = rootElements.find(
+      (el) => el.name === "w:style" && el.attributes?.["w:styleId"] === styleId
+    );
+    const styleElements = style2?.elements;
+    const basedOnElement = styleElements?.find((el) => el.name === "w:basedOn");
+    const basedOn = basedOnElement?.attributes?.["w:val"];
+    const elementPr = styleElements?.find((el) => el.name === translator2.xmlName);
     if (!elementPr) {
       return { ...emptyResult, basedOn };
     }
     const result = translator2.encode({ ...params2, nodes: [elementPr] }) || {};
-    return { properties: result, isDefault: style2?.attributes?.["w:default"] === "1", basedOn };
+    const isDefault = style2?.attributes?.["w:default"] === "1";
+    return { properties: result, isDefault, basedOn };
   }
-  function getNumberingProperties(params2, ilvl, numId, translator2, tries = 0) {
-    const { numbering: allDefinitions } = params2;
-    if (!allDefinitions) return {};
-    const { definitions, abstracts } = allDefinitions;
+  function getNumberingProperties(translators, params2, ilvl, numId, translator2, tries = 0) {
+    const numbering = params2?.numbering;
+    if (!numbering) return {};
+    const { definitions, abstracts } = numbering;
+    if (!definitions || !abstracts) return {};
     const propertiesChain = [];
     const numDefinition = definitions[numId];
     if (!numDefinition) return {};
-    const lvlOverride = numDefinition?.elements?.find(
-      (element2) => element2.name === "w:lvlOverride" && element2.attributes["w:ilvl"] == ilvl
+    const numDefElements = numDefinition.elements;
+    const lvlOverride = numDefElements?.find(
+      (element2) => element2.name === "w:lvlOverride" && element2.attributes?.["w:ilvl"] == ilvl
     );
-    const overridePr = lvlOverride?.elements?.find((el) => el.name === translator2.xmlName);
+    const lvlOverrideElements = lvlOverride?.elements;
+    const overridePr = lvlOverrideElements?.find((el) => el.name === translator2.xmlName);
     if (overridePr) {
       const overrideProps = translator2.encode({ ...params2, nodes: [overridePr] }) || {};
       propertiesChain.push(overrideProps);
     }
-    const abstractNumId = numDefinition.elements?.find((item) => item.name === "w:abstractNumId")?.attributes?.["w:val"];
+    const abstractNumIdElement = numDefElements?.find((item) => item.name === "w:abstractNumId");
+    const abstractNumId = abstractNumIdElement?.attributes?.["w:val"];
     const listDefinitionForThisNumId = abstracts[abstractNumId];
     if (!listDefinitionForThisNumId) return {};
-    const numStyleLink = listDefinitionForThisNumId.elements?.find((item) => item.name === "w:numStyleLink");
+    const listDefElements = listDefinitionForThisNumId.elements;
+    const numStyleLink = listDefElements?.find((item) => item.name === "w:numStyleLink");
     const styleId = numStyleLink?.attributes?.["w:val"];
     if (styleId && tries < 1) {
-      const { properties: styleProps } = getStyleProperties(params2, styleId, translator$14);
-      if (styleProps?.numberingProperties?.numId) {
-        return getNumberingProperties(params2, ilvl, styleProps.numberingProperties.numId, translator2, tries + 1);
+      const { properties: styleProps } = getStyleProperties(params2, styleId, translators.pPr);
+      const numIdFromStyle = styleProps?.numberingProperties?.numId;
+      if (numIdFromStyle) {
+        return getNumberingProperties(
+          translators,
+          params2,
+          ilvl,
+          numIdFromStyle,
+          translator2,
+          tries + 1
+        );
       }
     }
-    const levelDefinition = listDefinitionForThisNumId?.elements?.find(
-      (element2) => element2.name === "w:lvl" && element2.attributes["w:ilvl"] == ilvl
+    const levelDefinition = listDefElements?.find(
+      (element2) => element2.name === "w:lvl" && element2.attributes?.["w:ilvl"] == ilvl
     );
     if (!levelDefinition) return {};
-    const abstractElementPr = levelDefinition?.elements?.find((el) => el.name === translator2.xmlName);
+    const levelDefElements = levelDefinition.elements;
+    const abstractElementPr = levelDefElements?.find((el) => el.name === translator2.xmlName);
     if (!abstractElementPr) return {};
     const abstractProps = translator2.encode({ ...params2, nodes: [abstractElementPr] }) || {};
-    const pStyleElement = levelDefinition?.elements?.find((el) => el.name === "w:pStyle");
+    const pStyleElement = levelDefElements?.find((el) => el.name === "w:pStyle");
     if (pStyleElement) {
-      const pStyleId = pStyleElement?.attributes?.["w:val"];
+      const pStyleId = pStyleElement.attributes?.["w:val"];
       abstractProps.styleId = pStyleId;
     }
     propertiesChain.push(abstractProps);
     propertiesChain.reverse();
-    const result = combineProperties(propertiesChain);
-    return result;
+    return combineProperties$1(propertiesChain);
   }
-  const combineProperties = (propertiesArray, fullOverrideProps = [], specialHandling = {}) => {
-    if (!propertiesArray || propertiesArray.length === 0) {
-      return {};
+  function resolveDocxFontFamily(attributes, docx, toCssFontFamily2) {
+    if (!attributes || typeof attributes !== "object") return null;
+    const ascii = attributes["w:ascii"] ?? attributes["ascii"];
+    const themeAscii = attributes["w:asciiTheme"] ?? attributes["asciiTheme"];
+    let resolved = ascii;
+    if (docx && themeAscii) {
+      const theme = docx["word/theme/theme1.xml"];
+      const themeElements = theme?.elements;
+      if (themeElements?.length) {
+        const topElement = themeElements[0];
+        const topElementElements = topElement?.elements;
+        const themeElementsNode = topElementElements?.find((el) => el.name === "a:themeElements");
+        const themeElementsElements = themeElementsNode?.elements;
+        const fontScheme = themeElementsElements?.find((el) => el.name === "a:fontScheme");
+        const fontSchemeElements = fontScheme?.elements;
+        const prefix2 = themeAscii.startsWith("minor") ? "minor" : "major";
+        const font = fontSchemeElements?.find((el) => el.name === `a:${prefix2}Font`);
+        const fontElements = font?.elements;
+        const latin = fontElements?.find((el) => el.name === "a:latin");
+        const typeface = latin?.attributes?.typeface;
+        resolved = typeface || resolved;
+      }
     }
-    const isObject2 = (item) => item && typeof item === "object" && !Array.isArray(item);
-    const merge2 = (target, source) => {
-      const output = { ...target };
-      if (isObject2(target) && isObject2(source)) {
-        for (const key2 in source) {
-          if (Object.prototype.hasOwnProperty.call(source, key2)) {
-            if (!fullOverrideProps.includes(key2) && isObject2(source[key2])) {
-              if (key2 in target && isObject2(target[key2])) {
-                output[key2] = merge2(target[key2], source[key2]);
-              } else {
-                output[key2] = source[key2];
-              }
-            } else {
-              const handler2 = specialHandling[key2];
-              if (handler2 && typeof handler2 === "function") {
-                output[key2] = handler2(output, source);
-              } else {
-                output[key2] = source[key2];
-              }
-            }
-          }
-        }
+    if (!resolved) return null;
+    if (toCssFontFamily2) {
+      return toCssFontFamily2(resolved, docx ?? void 0);
+    }
+    return resolved;
+  }
+  const FONT_FAMILY_FALLBACKS$1 = Object.freeze({
+    swiss: "Arial, sans-serif",
+    roman: "Times New Roman, serif",
+    modern: "Courier New, monospace",
+    script: "cursive",
+    decorative: "fantasy",
+    system: "system-ui",
+    auto: "sans-serif"
+  });
+  const DEFAULT_GENERIC_FALLBACK$1 = "sans-serif";
+  const normalizeParts = (value) => (value || "").split(",").map((part) => part.trim()).filter(Boolean);
+  function mapWordFamilyFallback(wordFamily) {
+    if (!wordFamily) return DEFAULT_GENERIC_FALLBACK$1;
+    const mapped = FONT_FAMILY_FALLBACKS$1[wordFamily.toLowerCase()];
+    return mapped || DEFAULT_GENERIC_FALLBACK$1;
+  }
+  function toCssFontFamily(fontName, options = {}) {
+    if (!fontName || typeof fontName !== "string") return fontName;
+    const trimmed = fontName.trim();
+    if (!trimmed || trimmed.includes(",")) return trimmed;
+    const { fallback, wordFamily } = options;
+    const fallbackValue = fallback ?? (wordFamily ? mapWordFamilyFallback(wordFamily) : void 0) ?? DEFAULT_GENERIC_FALLBACK$1;
+    const fallbackParts = normalizeParts(fallbackValue);
+    if (fallbackParts.length === 0) {
+      return trimmed;
+    }
+    const normalizedName = trimmed.toLowerCase();
+    const includesName = fallbackParts.some((part) => part.toLowerCase() === normalizedName);
+    if (includesName) {
+      return fallbackParts.join(", ");
+    }
+    return [trimmed, ...fallbackParts].join(", ");
+  }
+  const sdtMetadataCache = /* @__PURE__ */ new Map();
+  function resolveStyle(node2, context, options = {}) {
+    let paragraph2 = createDefaultParagraph();
+    let character = createDefaultCharacter(context);
+    let numbering;
+    const chain = resolveStyleChain(node2.styleId, context.styles);
+    for (const style2 of chain) {
+      paragraph2 = mergeParagraph(paragraph2, style2.paragraph);
+      character = mergeCharacter(character, style2.character);
+      if (!numbering && style2.numbering) {
+        numbering = resolveNumbering(style2.numbering.numId, style2.numbering.level, context);
       }
-      return output;
+    }
+    paragraph2 = mergeParagraph(paragraph2, node2.paragraphProps);
+    character = mergeCharacter(character, node2.characterProps);
+    if (node2.numbering) {
+      numbering = resolveNumbering(node2.numbering.numId, node2.numbering.level, context);
+    }
+    const sdt = options?.sdt ? resolveSdtMetadata(options.sdt) : void 0;
+    return {
+      paragraph: paragraph2,
+      character,
+      numbering,
+      sdt
+    };
+  }
+  function resolveNumbering(numId, level, context) {
+    const def2 = context.numbering?.[numId];
+    if (!def2) return void 0;
+    const levelDef = def2.levels.find((entry) => entry.level === level) ?? def2.levels[level];
+    if (!levelDef) return void 0;
+    return {
+      numId,
+      level,
+      indent: {
+        left: levelDef.indent?.left,
+        hanging: levelDef.indent?.hanging
+      },
+      format: levelDef.format ?? "decimal",
+      text: levelDef.text ?? "%1.",
+      start: levelDef.start ?? 1
+    };
+  }
+  function resolveSdtMetadata(input2) {
+    if (!input2) return void 0;
+    const { nodeType, attrs, cacheKey: explicitKey } = input2;
+    if (!nodeType) return void 0;
+    const normalizedAttrs = isPlainObject$7(attrs) ? attrs : {};
+    const cacheKey = buildSdtCacheKey(nodeType, normalizedAttrs, explicitKey);
+    if (cacheKey && sdtMetadataCache.has(cacheKey)) {
+      return sdtMetadataCache.get(cacheKey);
+    }
+    let metadata;
+    switch (nodeType) {
+      case "fieldAnnotation":
+        metadata = normalizeFieldAnnotationMetadata(normalizedAttrs);
+        break;
+      case "structuredContent":
+      case "structuredContentBlock":
+        metadata = normalizeStructuredContentMetadata(nodeType, normalizedAttrs);
+        break;
+      case "documentSection":
+        metadata = normalizeDocumentSectionMetadata(normalizedAttrs);
+        break;
+      case "docPartObject":
+        metadata = normalizeDocPartMetadata(normalizedAttrs);
+        break;
+    }
+    if (metadata && cacheKey) {
+      sdtMetadataCache.set(cacheKey, metadata);
+    }
+    return metadata;
+  }
+  function createDefaultParagraph(_context) {
+    return {
+      alignment: "left",
+      spacing: {
+        before: 0,
+        after: 0,
+        line: 12,
+        lineRule: "auto"
+      },
+      indent: {
+        left: 0,
+        right: 0,
+        firstLine: 0,
+        hanging: 0
+      },
+      tabs: []
+    };
+  }
+  function createDefaultCharacter(context) {
+    const baseFont = context.defaults?.paragraphFont ?? "Calibri";
+    const fallback = context.defaults?.paragraphFontFallback;
+    const wordFamily = context.defaults?.paragraphFontFamily;
+    const resolvedFamily = toCssFontFamily(baseFont, { fallback, wordFamily }) ?? baseFont;
+    return {
+      font: {
+        family: resolvedFamily,
+        size: context.defaults?.fontSize ?? 11,
+        weight: 400,
+        italic: false
+      },
+      color: "#000000"
+    };
+  }
+  function resolveStyleChain(styleId, styles) {
+    if (!styleId || !styles) return [];
+    const result = [];
+    const visited = /* @__PURE__ */ new Set();
+    let current = styles[styleId];
+    while (current && !visited.has(current.id)) {
+      result.unshift(current);
+      visited.add(current.id);
+      current = current.basedOn ? styles[current.basedOn] : void 0;
+    }
+    return result;
+  }
+  function mergeParagraph(base2, overrides) {
+    if (!overrides) return base2;
+    return {
+      ...base2,
+      alignment: overrides.alignment ?? base2.alignment,
+      spacing: overrides.spacing ? { ...base2.spacing, ...overrides.spacing } : base2.spacing,
+      indent: overrides.indent ? { ...base2.indent, ...overrides.indent } : base2.indent,
+      borders: overrides.borders ? { ...base2.borders, ...overrides.borders } : base2.borders,
+      shading: overrides.shading ?? base2.shading,
+      tabs: overrides.tabs ?? base2.tabs
+    };
+  }
+  function mergeCharacter(base2, overrides) {
+    if (!overrides) return base2;
+    return {
+      ...base2,
+      font: overrides.font ? { ...base2.font, ...overrides.font } : base2.font,
+      color: overrides.color ?? base2.color,
+      underline: overrides.underline ?? base2.underline,
+      strike: overrides.strike ?? base2.strike,
+      highlight: overrides.highlight ?? base2.highlight,
+      letterSpacing: overrides.letterSpacing ?? base2.letterSpacing
     };
-    return propertiesArray.reduce((acc, current) => merge2(acc, current), {});
+  }
+  function normalizeFieldAnnotationMetadata(attrs) {
+    const fieldId = toOptionalString(attrs.fieldId) ?? "";
+    const formatting = extractFormatting(attrs);
+    const size2 = normalizeSize(attrs.size);
+    const extras = isPlainObject$7(attrs.extras) ? attrs.extras : null;
+    const marks = isPlainObject$7(attrs.marks) ? attrs.marks : void 0;
+    return {
+      type: "fieldAnnotation",
+      fieldId,
+      variant: normalizeFieldAnnotationVariant(attrs.type),
+      fieldType: toOptionalString(attrs.fieldType),
+      displayLabel: toOptionalString(attrs.displayLabel),
+      defaultDisplayLabel: toOptionalString(attrs.defaultDisplayLabel),
+      alias: toOptionalString(attrs.alias),
+      fieldColor: normalizeColorValue(attrs.fieldColor),
+      borderColor: normalizeColorValue(attrs.borderColor),
+      highlighted: toBoolean$3(attrs.highlighted, true),
+      fontFamily: toNullableString(attrs.fontFamily),
+      fontSize: normalizeFontSize(attrs.fontSize),
+      textColor: normalizeColorValue(attrs.textColor) ?? null,
+      textHighlight: normalizeColorValue(attrs.textHighlight) ?? null,
+      linkUrl: toNullableString(attrs.linkUrl),
+      imageSrc: toNullableString(attrs.imageSrc),
+      rawHtml: attrs.rawHtml ?? void 0,
+      size: size2 ?? null,
+      extras,
+      multipleImage: toBoolean$3(attrs.multipleImage, false),
+      hash: toOptionalString(attrs.hash) ?? null,
+      generatorIndex: toNumber$1(attrs.generatorIndex),
+      sdtId: toOptionalString(attrs.sdtId) ?? null,
+      hidden: toBoolean$3(attrs.hidden, false),
+      visibility: normalizeVisibility(attrs.visibility),
+      isLocked: toBoolean$3(attrs.isLocked, false),
+      formatting,
+      marks
+    };
+  }
+  function normalizeStructuredContentMetadata(nodeType, attrs) {
+    return {
+      type: "structuredContent",
+      scope: nodeType === "structuredContentBlock" ? "block" : "inline",
+      id: toNullableString(attrs.id),
+      tag: toOptionalString(attrs.tag),
+      alias: toOptionalString(attrs.alias),
+      sdtPr: attrs.sdtPr
+    };
+  }
+  function normalizeDocumentSectionMetadata(attrs) {
+    return {
+      type: "documentSection",
+      id: toNullableString(attrs.id),
+      title: toOptionalString(attrs.title) ?? null,
+      description: toOptionalString(attrs.description) ?? null,
+      sectionType: toOptionalString(attrs.sectionType) ?? null,
+      isLocked: toBoolean$3(attrs.isLocked, false),
+      sdBlockId: toNullableString(attrs.sdBlockId)
+    };
+  }
+  function normalizeDocPartMetadata(attrs) {
+    return {
+      type: "docPartObject",
+      gallery: toOptionalString(attrs.docPartGallery ?? attrs.gallery) ?? null,
+      // Source uniqueId from attrs.id (PM adapter uses getDocPartObjectId which extracts attrs.id)
+      // Fall back to attrs.uniqueId for compatibility
+      uniqueId: toOptionalString(attrs.id ?? attrs.uniqueId) ?? null,
+      alias: toOptionalString(attrs.alias) ?? null,
+      instruction: toOptionalString(attrs.instruction) ?? null
+    };
+  }
+  function isPlainObject$7(value) {
+    return !!value && typeof value === "object" && !Array.isArray(value);
+  }
+  function toOptionalString(value) {
+    if (value == null) return void 0;
+    if (typeof value === "string") {
+      const trimmed = value.trim();
+      return trimmed.length ? trimmed : void 0;
+    }
+    return String(value);
+  }
+  function toNullableString(value) {
+    const str = toOptionalString(value);
+    return str ?? null;
+  }
+  function toBoolean$3(value, fallback) {
+    if (typeof value === "boolean") return value;
+    if (typeof value === "string") {
+      const lower = value.toLowerCase();
+      if (lower === "true") return true;
+      if (lower === "false") return false;
+    }
+    if (value == null) return fallback;
+    return Boolean(value);
+  }
+  function normalizeVisibility(value) {
+    if (typeof value !== "string") return void 0;
+    const normalized = value.toLowerCase();
+    if (normalized === "visible" || normalized === "hidden") {
+      return normalized;
+    }
+    return void 0;
+  }
+  function normalizeColorValue(value) {
+    if (typeof value !== "string") return void 0;
+    const trimmed = value.trim();
+    if (!trimmed || trimmed.toLowerCase() === "none") return void 0;
+    return trimmed;
+  }
+  function normalizeFontSize(value) {
+    if (value == null) return null;
+    if (typeof value === "number") {
+      return Number.isFinite(value) ? value : null;
+    }
+    if (typeof value === "string") {
+      const trimmed = value.trim();
+      return trimmed.length ? trimmed : null;
+    }
+    return null;
+  }
+  function toNumber$1(value) {
+    if (typeof value === "number") {
+      return Number.isFinite(value) ? value : null;
+    }
+    if (typeof value === "string") {
+      const parsed = parseFloat(value);
+      return Number.isFinite(parsed) ? parsed : null;
+    }
+    return null;
+  }
+  function normalizeSize(value) {
+    if (!isPlainObject$7(value)) return null;
+    const obj = value;
+    const width = toNumber$1(obj.width);
+    const height = toNumber$1(obj.height);
+    if (width == null && height == null) return null;
+    const result = {};
+    if (width != null) result.width = width;
+    if (height != null) result.height = height;
+    return result;
+  }
+  function normalizeFieldAnnotationVariant(value) {
+    if (typeof value !== "string") return void 0;
+    const normalized = value.toLowerCase();
+    if (normalized === "text" || normalized === "image" || normalized === "signature" || normalized === "checkbox" || normalized === "html" || normalized === "link") {
+      return normalized;
+    }
+    return void 0;
+  }
+  function extractFormatting(attrs) {
+    const bold = toBoolean$3(attrs.bold, false);
+    const italic = toBoolean$3(attrs.italic, false);
+    const underline = toBoolean$3(attrs.underline, false);
+    const formatting = {};
+    if (bold) formatting.bold = true;
+    if (italic) formatting.italic = true;
+    if (underline) formatting.underline = true;
+    return Object.keys(formatting).length ? formatting : void 0;
+  }
+  function buildSdtCacheKey(nodeType, attrs, explicitKey) {
+    const provided = toOptionalString(explicitKey);
+    if (provided) {
+      return `${nodeType}:${provided}`;
+    }
+    const hash2 = toOptionalString(attrs.hash);
+    if (hash2) {
+      return `${nodeType}:${hash2}`;
+    }
+    const id = toOptionalString(attrs.id);
+    if (id) {
+      return `${nodeType}:${id}`;
+    }
+    return void 0;
+  }
+  const ooxmlResolver$1 = createOoxmlResolver({ pPr: translator$14, rPr: translator$1O });
+  const getToCssFontFamily = () => {
+    return SuperConverter.toCssFontFamily;
+  };
+  const SUBSCRIPT_SUPERSCRIPT_SCALE$1 = 0.65;
+  const resolveRunProperties = (params2, inlineRpr, resolvedPpr, isListNumber = false, numberingDefinedInline = false) => ooxmlResolver$1.resolveRunProperties(params2, inlineRpr, resolvedPpr, isListNumber, numberingDefinedInline);
+  function resolveParagraphProperties(params2, inlineProps, insideTable = false, overrideInlineStyleId = false, tableStyleId = null) {
+    return ooxmlResolver$1.resolveParagraphProperties(
+      params2,
+      inlineProps,
+      insideTable,
+      overrideInlineStyleId,
+      tableStyleId
+    );
+  }
+  const combineProperties = (propertiesArray, fullOverrideProps = [], specialHandling = {}) => {
+    return combineProperties$1(propertiesArray, { fullOverrideProps, specialHandling });
   };
   const combineRunProperties = (propertiesArray) => {
     return combineProperties(propertiesArray, ["fontFamily", "color"]);
@@ -12499,9 +12944,9 @@
           textStyleAttrs[key2] = `${spacing}pt`;
           break;
         case "fontFamily":
-          const fontFamily2 = getFontFamilyValue$1(value, docx);
+          const fontFamily2 = resolveDocxFontFamily(value, docx, getToCssFontFamily());
           textStyleAttrs[key2] = fontFamily2;
-          const eastAsiaFamily = value["eastAsia"];
+          const eastAsiaFamily = typeof value === "object" && value !== null ? value["eastAsia"] : void 0;
           if (eastAsiaFamily) {
             const eastAsiaCss = getFontFamilyValue$1({ "w:ascii": eastAsiaFamily }, docx);
             if (!fontFamily2 || eastAsiaCss !== textStyleAttrs.fontFamily) {
@@ -12756,11 +13201,11 @@
         }
         case "fontFamily": {
           if (!value) break;
-          const fontFamily2 = getFontFamilyValue$1(value, docx);
+          const fontFamily2 = resolveDocxFontFamily(value, docx, getToCssFontFamily());
           if (fontFamily2) {
             css["font-family"] = fontFamily2;
           }
-          const eastAsiaFamily = value["eastAsia"];
+          const eastAsiaFamily = typeof value === "object" && value !== null ? value["eastAsia"] : void 0;
           if (eastAsiaFamily) {
             const eastAsiaCss = getFontFamilyValue$1({ "w:ascii": eastAsiaFamily }, docx);
             if (eastAsiaCss && (!fontFamily2 || eastAsiaCss !== fontFamily2)) {
@@ -32519,7 +32964,8 @@ Please report this to https://github.com/markedjs/marked.`, e) {
         text2 = text2.replace(/^[ \t\n\r]+/, "").replace(/[ \t\n\r]+$/, "");
       }
       text2 = text2.replace(/\[\[sdspace\]\]/g, "");
-      if (xmlSpace !== "preserve" && typeof text2 === "string" && !text2.trim()) {
+      const isWhitespaceOnly = /^[ \t\n\r]*$/.test(text2);
+      if (xmlSpace !== "preserve" && isWhitespaceOnly) {
         return null;
       }
     } else if (!elements.length && encodedAttrs.xmlSpace === "preserve") {
@@ -35473,7 +35919,7 @@ Please report this to https://github.com/markedjs/marked.`, e) {
     const result = additions.length ? [...existingRelationships, ...additions] : existingRelationships;
     return result;
   };
-  const FONT_FAMILY_FALLBACKS$1 = Object.freeze({
+  const FONT_FAMILY_FALLBACKS = Object.freeze({
     swiss: "Arial, sans-serif",
     roman: "Times New Roman, serif",
     modern: "Courier New, monospace",
@@ -35482,7 +35928,7 @@ Please report this to https://github.com/markedjs/marked.`, e) {
     system: "system-ui",
     auto: "sans-serif"
   });
-  const DEFAULT_GENERIC_FALLBACK$1 = "sans-serif";
+  const DEFAULT_GENERIC_FALLBACK = "sans-serif";
   const DEFAULT_FONT_SIZE_PT = 10;
   const collectRunDefaultProperties = (runProps, { allowOverrideTypeface = true, allowOverrideSize = true, themeResolver, state }) => {
     if (!runProps?.elements?.length || !state) return;
@@ -35577,13 +36023,13 @@ Please report this to https://github.com/markedjs/marked.`, e) {
       const fontEntry = SuperConverter.getFontTableEntry(docx, fontName);
       const family = fontEntry?.elements?.find((child) => child.name === "w:family")?.attributes?.["w:val"];
       if (!family) return null;
-      const mapped = FONT_FAMILY_FALLBACKS$1[family.toLowerCase()];
-      return mapped || DEFAULT_GENERIC_FALLBACK$1;
+      const mapped = FONT_FAMILY_FALLBACKS[family.toLowerCase()];
+      return mapped || DEFAULT_GENERIC_FALLBACK;
     }
     static toCssFontFamily(fontName, docx) {
       if (!fontName) return fontName;
       if (fontName.includes(",")) return fontName;
-      const fallback = SuperConverter.getFallbackFromFontTable(docx, fontName) || DEFAULT_GENERIC_FALLBACK$1;
+      const fallback = SuperConverter.getFallbackFromFontTable(docx, fontName) || DEFAULT_GENERIC_FALLBACK;
       const normalizedFallbackParts = fallback.split(",").map((part) => part.trim().toLowerCase()).filter(Boolean);
       if (normalizedFallbackParts.includes(fontName.trim().toLowerCase())) {
         return fallback;
@@ -35919,7 +36365,7 @@ Please report this to https://github.com/markedjs/marked.`, e) {
     static getStoredSuperdocVersion(docx) {
       return SuperConverter.getStoredCustomProperty(docx, "SuperdocVersion");
     }
-    static setStoredSuperdocVersion(docx = this.convertedXml, version2 = "1.3.0-next.1") {
+    static setStoredSuperdocVersion(docx = this.convertedXml, version2 = "1.3.0-next.3") {
       return SuperConverter.setStoredCustomProperty(docx, "SuperdocVersion", version2, false);
     }
     /**
@@ -45269,15 +45715,19 @@ Please report this to https://github.com/markedjs/marked.`, e) {
       dispatchTransaction = editor.dispatch.bind(editor);
     }
     if (!dispatchTransaction) return false;
-    const handled = splitBlockPatch(state, (transaction) => {
-      dispatchTransaction(transaction);
-    });
+    const handled = splitBlockPatch(
+      state,
+      (transaction) => {
+        dispatchTransaction(transaction);
+      },
+      editor
+    );
     if (handled) {
       tr.setMeta("preventDispatch", true);
     }
     return handled;
   };
-  function splitBlockPatch(state, dispatch) {
+  function splitBlockPatch(state, dispatch, editor) {
     let { $from } = state.selection;
     if (state.selection instanceof NodeSelection && state.selection.node.isBlock) {
       if (!$from.parentOffset || !canSplit(state.doc, $from.pos)) return false;
@@ -45286,14 +45736,15 @@ Please report this to https://github.com/markedjs/marked.`, e) {
     }
     if (!$from.depth) return false;
     let types2 = [];
-    let splitDepth, deflt, atEnd = false, atStart = false;
+    let splitDepth, deflt, paragraphAttrs = null, atEnd = false, atStart = false;
     for (let d2 = $from.depth; ; d2--) {
       let node2 = $from.node(d2);
       if (node2.isBlock) {
         atEnd = $from.end(d2) == $from.pos + ($from.depth - d2);
         atStart = $from.start(d2) == $from.pos - ($from.depth - d2);
         deflt = defaultBlockAt$1($from.node(d2 - 1).contentMatchAt($from.indexAfter(d2 - 1)));
-        types2.unshift(null);
+        paragraphAttrs = { ...node2.attrs };
+        types2.unshift({ type: deflt || node2.type, attrs: paragraphAttrs });
         splitDepth = d2;
         break;
       } else {
@@ -45306,7 +45757,7 @@ Please report this to https://github.com/markedjs/marked.`, e) {
     let splitPos = tr.mapping.map($from.pos);
     let can = canSplit(tr.doc, splitPos, types2.length, types2);
     if (!can) {
-      types2[0] = deflt ? { type: deflt } : null;
+      types2[0] = deflt ? { type: deflt, attrs: paragraphAttrs } : null;
       can = canSplit(tr.doc, splitPos, types2.length, types2);
     }
     if (!can) return false;
@@ -45316,9 +45767,37 @@ Please report this to https://github.com/markedjs/marked.`, e) {
       if (deflt && $from.node(splitDepth - 1).canReplaceWith($first.index(), $first.index() + 1, deflt))
         tr.setNodeMarkup(tr.mapping.map($from.before(splitDepth)), deflt);
     }
+    applyStyleMarks(state, tr, editor, paragraphAttrs);
     if (dispatch) dispatch(tr.scrollIntoView());
     return true;
   }
+  function applyStyleMarks(state, tr, editor, paragraphAttrs) {
+    const styleId = paragraphAttrs?.paragraphProperties?.styleId;
+    if (!editor?.converter && !styleId) {
+      return;
+    }
+    try {
+      const params2 = { docx: editor?.converter?.convertedXml ?? {}, numbering: editor?.converter?.numbering ?? {} };
+      const resolvedPpr = styleId ? { styleId } : {};
+      const runProperties = styleId ? resolveRunProperties(params2, {}, resolvedPpr, false, false) : {};
+      const markDefsFromStyle = styleId ? (
+        /** @type {Array<{type: string, attrs: Record<string, unknown>}>} */
+        encodeMarksFromRPr(runProperties, editor?.converter?.convertedXml ?? {})
+      ) : [];
+      const selectionMarks = state.selection?.$from?.marks ? state.selection.$from.marks() : [];
+      const selectionMarkDefs = selectionMarks.map((mark2) => ({ type: mark2.type.name, attrs: mark2.attrs }));
+      const markDefsToApply = selectionMarks.length ? selectionMarkDefs : markDefsFromStyle;
+      const marksToApply = markDefsToApply.map((def2) => {
+        const markType = state.schema.marks[def2.type];
+        return markType ? markType.create(def2.attrs) : null;
+      }).filter(Boolean);
+      if (marksToApply.length > 0) {
+        tr.ensureMarks(marksToApply);
+        tr.setMeta("sdStyleMarks", markDefsToApply);
+      }
+    } catch {
+    }
+  }
   const splitRunAtCursor = () => (props) => {
     let { state, dispatch, tr } = props;
     const sel = state.selection;
@@ -46202,7 +46681,7 @@ Please report this to https://github.com/markedjs/marked.`, e) {
     }
     return true;
   };
-  const isPlainObject$7 = (value) => Boolean(value) && typeof value === "object" && !Array.isArray(value);
+  const isPlainObject$6 = (value) => Boolean(value) && typeof value === "object" && !Array.isArray(value);
   const assignNestedValue = (target, path2, value) => {
     if (!path2.includes(".")) {
       target[path2] = value;
@@ -46216,7 +46695,7 @@ Please report this to https://github.com/markedjs/marked.`, e) {
       if (isLast) {
         current[part] = value;
       } else {
-        if (!isPlainObject$7(current[part])) {
+        if (!isPlainObject$6(current[part])) {
           current[part] = {};
         }
         current = current[part];
@@ -52665,7 +53144,7 @@ Please report this to https://github.com/markedjs/marked.`, e) {
   const toRawType = (value) => {
     return toTypeString(value).slice(8, -1);
   };
-  const isPlainObject$6 = (val) => toTypeString(val) === "[object Object]";
+  const isPlainObject$5 = (val) => toTypeString(val) === "[object Object]";
   const isIntegerKey = (key2) => isString(key2) && key2 !== "NaN" && key2[0] !== "-" && "" + parseInt(key2, 10) === key2;
   const isReservedProp = /* @__PURE__ */ makeMap(
     // the leading comma is intentional so empty string "" is also included
@@ -52715,7 +53194,7 @@ Please report this to https://github.com/markedjs/marked.`, e) {
     const n = parseFloat(val);
     return isNaN(n) ? val : n;
   };
-  const toNumber$1 = (val) => {
+  const toNumber = (val) => {
     const n = isString(val) ? Number(val) : NaN;
     return isNaN(n) ? val : n;
   };
@@ -52814,7 +53293,7 @@ Please report this to https://github.com/markedjs/marked.`, e) {
       };
     } else if (isSymbol$1(val)) {
       return stringifySymbol(val);
-    } else if (isObject$2(val) && !isArray$1(val) && !isPlainObject$6(val)) {
+    } else if (isObject$2(val) && !isArray$1(val) && !isPlainObject$5(val)) {
       return String(val);
     }
     return val;
@@ -54431,7 +54910,7 @@ Please report this to https://github.com/markedjs/marked.`, e) {
       value.forEach((v2) => {
         traverse(v2, depth, seen);
       });
-    } else if (isPlainObject$6(value)) {
+    } else if (isPlainObject$5(value)) {
       for (const key2 in value) {
         traverse(value[key2], depth, seen);
       }
@@ -59660,7 +60139,7 @@ Please report this to https://github.com/markedjs/marked.`, e) {
     }
   }
   function NumberOf(val) {
-    const res = toNumber$1(val);
+    const res = toNumber(val);
     return res;
   }
   function addTransitionClass(el, cls) {
@@ -61541,7 +62020,7 @@ Please report this to https://github.com/markedjs/marked.`, e) {
       return false;
     }
   };
-  const summaryVersion = "1.3.0-next.1";
+  const summaryVersion = "1.3.0-next.3";
   const nodeKeys = ["group", "content", "marks", "inline", "atom", "defining", "code", "tableRole", "summary"];
   const markKeys = ["group", "inclusive", "excludes", "spanning", "code"];
   function mapAttributes(attrs) {
@@ -64175,7 +64654,7 @@ Please report this to https://github.com/markedjs/marked.`, e) {
      * Process collaboration migrations
      */
     processCollaborationMigrations() {
-      console.debug("[checkVersionMigrations] Current editor version", "1.3.0-next.1");
+      console.debug("[checkVersionMigrations] Current editor version", "1.3.0-next.3");
       if (!this.options.ydoc) return;
       const metaMap = this.options.ydoc.getMap("meta");
       let docVersion = metaMap.get("version");
@@ -66595,18 +67074,18 @@ Please report this to https://github.com/markedjs/marked.`, e) {
       case "decimal":
         return num.toString();
       case "lowerLetter":
-        return toLetter$1(num, false);
+        return toLetter(num, false);
       case "upperLetter":
-        return toLetter$1(num, true);
+        return toLetter(num, true);
       case "lowerRoman":
-        return toRoman$2(num).toLowerCase();
+        return toRoman$1(num).toLowerCase();
       case "upperRoman":
-        return toRoman$2(num);
+        return toRoman$1(num);
       default:
         return num.toString();
     }
   }
-  function toLetter$1(num, uppercase) {
+  function toLetter(num, uppercase) {
     let result = "";
     let n = num;
     while (n > 0) {
@@ -66617,7 +67096,7 @@ Please report this to https://github.com/markedjs/marked.`, e) {
     }
     return result || (uppercase ? "A" : "a");
   }
-  function toRoman$2(num) {
+  function toRoman$1(num) {
     const lookup = [
       [1e3, "M"],
       [900, "CM"],
@@ -69751,39 +70230,6 @@ ${l}
       right: borderValueToSpec(isLastCol ? tableBorders?.right : null)
     };
   };
-  const FONT_FAMILY_FALLBACKS = Object.freeze({
-    swiss: "Arial, sans-serif",
-    roman: "Times New Roman, serif",
-    modern: "Courier New, monospace",
-    script: "cursive",
-    decorative: "fantasy",
-    system: "system-ui",
-    auto: "sans-serif"
-  });
-  const DEFAULT_GENERIC_FALLBACK = "sans-serif";
-  const normalizeParts = (value) => (value || "").split(",").map((part) => part.trim()).filter(Boolean);
-  function mapWordFamilyFallback(wordFamily) {
-    if (!wordFamily) return DEFAULT_GENERIC_FALLBACK;
-    const mapped = FONT_FAMILY_FALLBACKS[wordFamily.toLowerCase()];
-    return mapped || DEFAULT_GENERIC_FALLBACK;
-  }
-  function toCssFontFamily(fontName, options = {}) {
-    if (!fontName || typeof fontName !== "string") return fontName;
-    const trimmed = fontName.trim();
-    if (!trimmed || trimmed.includes(",")) return trimmed;
-    const { fallback, wordFamily } = options;
-    const fallbackValue = fallback ?? (wordFamily ? mapWordFamilyFallback(wordFamily) : void 0) ?? DEFAULT_GENERIC_FALLBACK;
-    const fallbackParts = normalizeParts(fallbackValue);
-    if (fallbackParts.length === 0) {
-      return trimmed;
-    }
-    const normalizedName = trimmed.toLowerCase();
-    const includesName = fallbackParts.some((part) => part.toLowerCase() === normalizedName);
-    if (includesName) {
-      return fallbackParts.join(", ");
-    }
-    return [trimmed, ...fallbackParts].join(", ");
-  }
   const LIST_MARKER_GAP$3 = 8;
   function renderListMarker(params2) {
     const { doc: doc2, lineEl, markerLayout, markerMeasure, indentLeftPx } = params2;
@@ -72021,7 +72467,14 @@ ${l}
           fragmentEl.dataset.continuesOnNext = "true";
         }
         const lines = fragment.lines ?? measure.lines.slice(fragment.fromLine, fragment.toLine);
-        applyParagraphBlockStyles(fragmentEl, block.attrs);
+        applyParagraphBlockStyles(fragmentEl, block.attrs, { includeBorders: false, includeShading: false });
+        const { shadingLayer, borderLayer } = createParagraphDecorationLayers(this.doc, fragment.width, block.attrs);
+        if (shadingLayer) {
+          fragmentEl.appendChild(shadingLayer);
+        }
+        if (borderLayer) {
+          fragmentEl.appendChild(borderLayer);
+        }
         if (block.attrs?.styleId) {
           fragmentEl.dataset.styleId = block.attrs.styleId;
           fragmentEl.setAttribute("styleid", block.attrs.styleId);
@@ -72405,10 +72858,18 @@ ${l}
         contentEl.classList.add("superdoc-list-content");
         this.applySdtDataset(contentEl, paragraphMetadata);
         contentEl.style.display = "inline-block";
+        contentEl.style.position = "relative";
         contentEl.style.width = `${fragment.width}px`;
         const lines = itemMeasure.paragraph.lines.slice(fragment.fromLine, fragment.toLine);
         const contentAttrs = wordLayout ? item.paragraph.attrs : stripListIndent(item.paragraph.attrs);
-        applyParagraphBlockStyles(contentEl, contentAttrs);
+        applyParagraphBlockStyles(contentEl, contentAttrs, { includeBorders: false, includeShading: false });
+        const { shadingLayer, borderLayer } = createParagraphDecorationLayers(this.doc, fragment.width, contentAttrs);
+        if (shadingLayer) {
+          contentEl.appendChild(shadingLayer);
+        }
+        if (borderLayer) {
+          contentEl.appendChild(borderLayer);
+        }
         contentEl.style.textAlign = "left";
         const paraForList = {
           ...item.paragraph,
@@ -74632,7 +75093,7 @@ ${l}
       }
     });
   };
-  const applyParagraphBlockStyles = (element2, attrs) => {
+  const applyParagraphBlockStyles = (element2, attrs, options = {}) => {
     if (!attrs) return;
     if (attrs.styleId) {
       element2.setAttribute("styleid", attrs.styleId);
@@ -74659,8 +75120,55 @@ ${l}
         }
       }
     }
-    applyParagraphBorderStyles(element2, attrs.borders);
-    applyParagraphShadingStyles(element2, attrs.shading);
+    if (options.includeBorders ?? true) {
+      applyParagraphBorderStyles(element2, attrs.borders);
+    }
+    if (options.includeShading ?? true) {
+      applyParagraphShadingStyles(element2, attrs.shading);
+    }
+  };
+  const getParagraphBorderBox = (fragmentWidth, indent2) => {
+    const indentLeft = Number.isFinite(indent2?.left) ? indent2.left : 0;
+    const indentRight = Number.isFinite(indent2?.right) ? indent2.right : 0;
+    const firstLine = Number.isFinite(indent2?.firstLine) ? indent2.firstLine : 0;
+    const hanging = Number.isFinite(indent2?.hanging) ? indent2.hanging : 0;
+    const firstLineOffset = firstLine - hanging;
+    const minLeftInset = Math.min(indentLeft, indentLeft + firstLineOffset);
+    const leftInset = Math.max(0, minLeftInset);
+    const rightInset = Math.max(0, indentRight);
+    return {
+      leftInset,
+      width: Math.max(0, fragmentWidth - leftInset - rightInset)
+    };
+  };
+  const createParagraphDecorationLayers = (doc2, fragmentWidth, attrs) => {
+    if (!attrs?.borders && !attrs?.shading) return {};
+    const borderBox = getParagraphBorderBox(fragmentWidth, attrs.indent);
+    const baseStyles = {
+      position: "absolute",
+      top: "0px",
+      bottom: "0px",
+      left: `${borderBox.leftInset}px`,
+      width: `${borderBox.width}px`,
+      pointerEvents: "none",
+      boxSizing: "border-box"
+    };
+    let shadingLayer;
+    if (attrs.shading) {
+      shadingLayer = doc2.createElement("div");
+      shadingLayer.classList.add("superdoc-paragraph-shading");
+      Object.assign(shadingLayer.style, baseStyles);
+      applyParagraphShadingStyles(shadingLayer, attrs.shading);
+    }
+    let borderLayer;
+    if (attrs.borders) {
+      borderLayer = doc2.createElement("div");
+      borderLayer.classList.add("superdoc-paragraph-border");
+      Object.assign(borderLayer.style, baseStyles);
+      borderLayer.style.zIndex = "1";
+      applyParagraphBorderStyles(borderLayer, attrs.borders);
+    }
+    return { shadingLayer, borderLayer };
   };
   const BORDER_SIDES = ["top", "right", "bottom", "left"];
   const applyParagraphBorderStyles = (element2, borders) => {
@@ -78311,33 +78819,13 @@ ${l}
       toLineByCell.push(cutLine);
       heightByCell.push(cumulativeHeight);
     }
-    const allCellsCompleteInFirstPass = toLineByCell.every((cutLine, idx) => {
-      const totalLines = getCellTotalLines(row2.cells[idx]);
-      return cutLine >= totalLines;
-    });
-    const lineAdvancements = toLineByCell.map((cutLine, idx) => cutLine - (startLines[idx] || 0));
-    const positiveAdvancements = lineAdvancements.filter((adv) => adv > 0);
-    const minLineAdvancement = positiveAdvancements.length > 0 ? Math.min(...positiveAdvancements) : 0;
     let actualPartialHeight = 0;
     let maxPaddingTotal = 0;
     for (let cellIdx = 0; cellIdx < cellCount; cellIdx++) {
-      const cell2 = row2.cells[cellIdx];
-      const startLine = startLines[cellIdx] || 0;
-      const lines = getCellLines(cell2);
       const cellPadding = cellPaddings[cellIdx];
       const paddingTotal = cellPadding.top + cellPadding.bottom;
       maxPaddingTotal = Math.max(maxPaddingTotal, paddingTotal);
-      if (allCellsCompleteInFirstPass) {
-        actualPartialHeight = Math.max(actualPartialHeight, heightByCell[cellIdx] + paddingTotal);
-      } else {
-        const targetLine = Math.min(startLine + minLineAdvancement, lines.length);
-        let cumulativeHeight = 0;
-        for (let i2 = startLine; i2 < targetLine; i2++) {
-          cumulativeHeight += lines[i2].lineHeight || 0;
-        }
-        toLineByCell[cellIdx] = targetLine;
-        actualPartialHeight = Math.max(actualPartialHeight, cumulativeHeight + paddingTotal);
-      }
+      actualPartialHeight = Math.max(actualPartialHeight, heightByCell[cellIdx] + paddingTotal);
     }
     const madeProgress = toLineByCell.some((cutLine, idx) => cutLine > (startLines[idx] || 0));
     const isFirstPart = startLines.every((l) => l === 0);
@@ -78890,7 +79378,7 @@ ${l}
   function toLowerLetter(num) {
     return toUpperLetter(num).toLowerCase();
   }
-  function formatPageNumber$1(pageNumber, format) {
+  function formatPageNumber(pageNumber, format) {
     const num = Math.max(1, pageNumber);
     switch (format) {
       case "decimal":
@@ -78903,6 +79391,8 @@ ${l}
         return toUpperLetter(num);
       case "lowerLetter":
         return toLowerLetter(num);
+      case "numberInDash":
+        return `-${num}-`;
       default:
         return String(num);
     }
@@ -78931,7 +79421,7 @@ ${l}
       const sectionMetadata = sectionMap.get(pageSectionIndex);
       const format = sectionMetadata?.numbering?.format ?? "decimal";
       const displayNumber = runningCounter;
-      const displayText = formatPageNumber$1(displayNumber, format);
+      const displayText = formatPageNumber(displayNumber, format);
       result.push({
         physicalPage: page.number,
         displayNumber,
@@ -79067,59 +79557,6 @@ ${l}
     if (!layoutDebugEnabled$1) return;
     console.log(...args);
   };
-  function formatPageNumber(num, format) {
-    switch (format) {
-      case "decimal":
-        return String(num);
-      case "lowerLetter":
-        return toLetter(num, false);
-      case "upperLetter":
-        return toLetter(num, true);
-      case "lowerRoman":
-        return toRoman$1(num).toLowerCase();
-      case "upperRoman":
-        return toRoman$1(num);
-      default:
-        return String(num);
-    }
-  }
-  function toLetter(num, uppercase) {
-    let result = "";
-    let n = Math.max(1, Math.floor(num));
-    while (n > 0) {
-      const remainder = (n - 1) % 26;
-      const char = String.fromCharCode((uppercase ? 65 : 97) + remainder);
-      result = char + result;
-      n = Math.floor((n - 1) / 26);
-    }
-    return result;
-  }
-  function toRoman$1(num) {
-    const lookup = [
-      [1e3, "M"],
-      [900, "CM"],
-      [500, "D"],
-      [400, "CD"],
-      [100, "C"],
-      [90, "XC"],
-      [50, "L"],
-      [40, "XL"],
-      [10, "X"],
-      [9, "IX"],
-      [5, "V"],
-      [4, "IV"],
-      [1, "I"]
-    ];
-    let result = "";
-    let n = Math.max(1, Math.floor(num));
-    for (const [value, numeral] of lookup) {
-      while (n >= value) {
-        result += numeral;
-        n -= value;
-      }
-    }
-    return result;
-  }
   function layoutDocument(blocks2, measures, options = {}) {
     if (blocks2.length !== measures.length) {
       throw new Error(
@@ -80575,7 +81012,7 @@ ${l}
       return `${block.id}@${safeWidth}x${safeHeight}:${hash2}`;
     }
   }
-  function resolveHeaderFooterTokens(blocks2, pageNumber, totalPages) {
+  function resolveHeaderFooterTokens(blocks2, pageNumber, totalPages, pageNumberText) {
     if (!blocks2 || blocks2.length === 0) {
       return;
     }
@@ -80587,7 +81024,7 @@ ${l}
       console.warn("[resolveHeaderFooterTokens] Invalid totalPages:", totalPages, "- using 1 as fallback");
       totalPages = 1;
     }
-    const pageNumberStr = String(pageNumber);
+    const pageNumberStr = pageNumberText ?? String(pageNumber);
     const totalPagesStr = String(totalPages);
     for (const block of blocks2) {
       if (block.kind !== "paragraph") continue;
@@ -81011,15 +81448,31 @@ ${l}
       for (const pageNum of pagesToLayout) {
         const clonedBlocks = cloneHeaderFooterBlocks(blocks2);
         const { displayText, totalPages: totalPagesForPage } = pageResolver(pageNum);
-        const resolvedPageNum = parseInt(displayText, 10) || pageNum;
-        resolveHeaderFooterTokens(clonedBlocks, resolvedPageNum, totalPagesForPage);
+        resolveHeaderFooterTokens(clonedBlocks, pageNum, totalPagesForPage, displayText);
         const measures = await cache2.measureBlocks(clonedBlocks, constraints, measureBlock2);
         const pageLayout = layoutHeaderFooter(clonedBlocks, measures, constraints);
+        const measuresById = /* @__PURE__ */ new Map();
+        for (let i2 = 0; i2 < clonedBlocks.length; i2 += 1) {
+          measuresById.set(clonedBlocks[i2].id, measures[i2]);
+        }
+        const fragmentsWithLines = pageLayout.pages[0]?.fragments.map((fragment) => {
+          if (fragment.kind !== "para") {
+            return fragment;
+          }
+          const measure = measuresById.get(fragment.blockId);
+          if (!measure || measure.kind !== "paragraph") {
+            return fragment;
+          }
+          return {
+            ...fragment,
+            lines: measure.lines.slice(fragment.fromLine, fragment.toLine)
+          };
+        }) ?? [];
         pages.push({
           number: pageNum,
           blocks: clonedBlocks,
           measures,
-          fragments: pageLayout.pages[0]?.fragments ?? []
+          fragments: fragmentsWithLines
         });
       }
       const firstPageLayout = pages[0] ? layoutHeaderFooter(pages[0].blocks, pages[0].measures, constraints) : { height: 0 };
@@ -85898,7 +86351,14 @@ ${l}
     const pgNumType = elements.find((el) => el?.name === "w:pgNumType");
     if (!pgNumType?.attributes) return void 0;
     const fmtRaw = pgNumType.attributes["w:fmt"];
-    const validFormats = ["decimal", "lowerLetter", "upperLetter", "lowerRoman", "upperRoman"];
+    const validFormats = [
+      "decimal",
+      "lowerLetter",
+      "upperLetter",
+      "lowerRoman",
+      "upperRoman",
+      "numberInDash"
+    ];
     const fmt = validFormats.includes(fmtRaw) ? fmtRaw : void 0;
     const startRaw = pgNumType.attributes["w:start"];
     const startNum = startRaw != null ? Number(startRaw) : void 0;
@@ -86321,7 +86781,7 @@ ${l}
     return px / PX_PER_PT;
   };
   const isFiniteNumber = (value) => typeof value === "number" && Number.isFinite(value);
-  const isPlainObject$5 = (value) => value !== null && typeof value === "object" && !Array.isArray(value);
+  const isPlainObject$4 = (value) => value !== null && typeof value === "object" && !Array.isArray(value);
   const normalizePrefix = (value) => {
     if (!value) return "";
     return String(value);
@@ -86383,7 +86843,7 @@ ${l}
     }
     return void 0;
   }
-  const toBoolean$3 = (value) => {
+  const toBoolean$2 = (value) => {
     if (typeof value === "boolean") return value;
     if (typeof value === "string") {
       const v2 = value.trim().toLowerCase();
@@ -86674,7 +87134,7 @@ ${l}
     });
   }
   function isGradientFill(value) {
-    if (!isPlainObject$5(value)) return false;
+    if (!isPlainObject$4(value)) return false;
     if (value.type !== "gradient") return false;
     const gradientType = value.gradientType;
     if (gradientType !== "linear" && gradientType !== "radial") return false;
@@ -86685,12 +87145,12 @@ ${l}
     }
     if (!Array.isArray(value.stops) || value.stops.length === 0) return false;
     return value.stops.every((stop) => {
-      if (!isPlainObject$5(stop)) return false;
+      if (!isPlainObject$4(stop)) return false;
       return typeof stop.position === "number" && Number.isFinite(stop.position) && typeof stop.color === "string" && (stop.alpha === void 0 || typeof stop.alpha === "number" && Number.isFinite(stop.alpha));
     });
   }
   function isSolidFillWithAlpha(value) {
-    return isPlainObject$5(value) && value.type === "solidWithAlpha" && typeof value.color === "string" && typeof value.alpha === "number";
+    return isPlainObject$4(value) && value.type === "solidWithAlpha" && typeof value.color === "string" && typeof value.alpha === "number";
   }
   function normalizeFillColor(value) {
     if (value === null) return null;
@@ -86705,10 +87165,10 @@ ${l}
     return void 0;
   }
   function normalizeTextContent(value) {
-    if (!isPlainObject$5(value)) return void 0;
+    if (!isPlainObject$4(value)) return void 0;
     if (!Array.isArray(value.parts)) return void 0;
     if (value.parts.length === 0) return void 0;
-    const validParts = value.parts.filter((p2) => isPlainObject$5(p2) && typeof p2.text === "string");
+    const validParts = value.parts.filter((p2) => isPlainObject$4(p2) && typeof p2.text === "string");
     if (validParts.length === 0) return void 0;
     const result = {
       parts: validParts
@@ -86726,7 +87186,7 @@ ${l}
     return void 0;
   }
   function normalizeTextInsets(value) {
-    if (!isPlainObject$5(value)) return void 0;
+    if (!isPlainObject$4(value)) return void 0;
     const top2 = pickNumber(value.top);
     const right2 = pickNumber(value.right);
     const bottom2 = pickNumber(value.bottom);
@@ -86738,7 +87198,7 @@ ${l}
   }
   const OOXML_Z_INDEX_BASE = 251658240;
   function normalizeZIndex(originalAttributes) {
-    if (!isPlainObject$5(originalAttributes)) return void 0;
+    if (!isPlainObject$4(originalAttributes)) return void 0;
     const relativeHeight = originalAttributes.relativeHeight;
     if (typeof relativeHeight !== "number") return void 0;
     return Math.max(0, relativeHeight - OOXML_Z_INDEX_BASE);
@@ -87892,321 +88352,6 @@ ${l}
     }
     return adjusted;
   };
-  const sdtMetadataCache = /* @__PURE__ */ new Map();
-  function resolveStyle(node2, context, options = {}) {
-    let paragraph2 = createDefaultParagraph();
-    let character = createDefaultCharacter(context);
-    let numbering;
-    const chain = resolveStyleChain(node2.styleId, context.styles);
-    for (const style2 of chain) {
-      paragraph2 = mergeParagraph(paragraph2, style2.paragraph);
-      character = mergeCharacter(character, style2.character);
-      if (!numbering && style2.numbering) {
-        numbering = resolveNumbering(style2.numbering.numId, style2.numbering.level, context);
-      }
-    }
-    paragraph2 = mergeParagraph(paragraph2, node2.paragraphProps);
-    character = mergeCharacter(character, node2.characterProps);
-    if (node2.numbering) {
-      numbering = resolveNumbering(node2.numbering.numId, node2.numbering.level, context);
-    }
-    const sdt = options?.sdt ? resolveSdtMetadata(options.sdt) : void 0;
-    return {
-      paragraph: paragraph2,
-      character,
-      numbering,
-      sdt
-    };
-  }
-  function resolveNumbering(numId, level, context) {
-    const def2 = context.numbering?.[numId];
-    if (!def2) return void 0;
-    const levelDef = def2.levels.find((entry) => entry.level === level) ?? def2.levels[level];
-    if (!levelDef) return void 0;
-    return {
-      numId,
-      level,
-      indent: {
-        left: levelDef.indent?.left,
-        hanging: levelDef.indent?.hanging
-      },
-      format: levelDef.format ?? "decimal",
-      text: levelDef.text ?? "%1.",
-      start: levelDef.start ?? 1
-    };
-  }
-  function resolveSdtMetadata(input2) {
-    if (!input2) return void 0;
-    const { nodeType, attrs, cacheKey: explicitKey } = input2;
-    if (!nodeType) return void 0;
-    const normalizedAttrs = isPlainObject$4(attrs) ? attrs : {};
-    const cacheKey = buildSdtCacheKey(nodeType, normalizedAttrs, explicitKey);
-    if (cacheKey && sdtMetadataCache.has(cacheKey)) {
-      return sdtMetadataCache.get(cacheKey);
-    }
-    let metadata;
-    switch (nodeType) {
-      case "fieldAnnotation":
-        metadata = normalizeFieldAnnotationMetadata(normalizedAttrs);
-        break;
-      case "structuredContent":
-      case "structuredContentBlock":
-        metadata = normalizeStructuredContentMetadata(nodeType, normalizedAttrs);
-        break;
-      case "documentSection":
-        metadata = normalizeDocumentSectionMetadata(normalizedAttrs);
-        break;
-      case "docPartObject":
-        metadata = normalizeDocPartMetadata(normalizedAttrs);
-        break;
-    }
-    if (metadata && cacheKey) {
-      sdtMetadataCache.set(cacheKey, metadata);
-    }
-    return metadata;
-  }
-  function createDefaultParagraph(_context) {
-    return {
-      alignment: "left",
-      spacing: {
-        before: 0,
-        after: 0,
-        line: 12,
-        lineRule: "auto"
-      },
-      indent: {
-        left: 0,
-        right: 0,
-        firstLine: 0,
-        hanging: 0
-      },
-      tabs: []
-    };
-  }
-  function createDefaultCharacter(context) {
-    const baseFont = context.defaults?.paragraphFont ?? "Calibri";
-    const fallback = context.defaults?.paragraphFontFallback;
-    const wordFamily = context.defaults?.paragraphFontFamily;
-    const resolvedFamily = toCssFontFamily(baseFont, { fallback, wordFamily }) ?? baseFont;
-    return {
-      font: {
-        family: resolvedFamily,
-        size: context.defaults?.fontSize ?? 11,
-        weight: 400,
-        italic: false
-      },
-      color: "#000000"
-    };
-  }
-  function resolveStyleChain(styleId, styles) {
-    if (!styleId || !styles) return [];
-    const result = [];
-    const visited = /* @__PURE__ */ new Set();
-    let current = styles[styleId];
-    while (current && !visited.has(current.id)) {
-      result.unshift(current);
-      visited.add(current.id);
-      current = current.basedOn ? styles[current.basedOn] : void 0;
-    }
-    return result;
-  }
-  function mergeParagraph(base2, overrides) {
-    if (!overrides) return base2;
-    return {
-      ...base2,
-      alignment: overrides.alignment ?? base2.alignment,
-      spacing: overrides.spacing ? { ...base2.spacing, ...overrides.spacing } : base2.spacing,
-      indent: overrides.indent ? { ...base2.indent, ...overrides.indent } : base2.indent,
-      borders: overrides.borders ? { ...base2.borders, ...overrides.borders } : base2.borders,
-      shading: overrides.shading ?? base2.shading,
-      tabs: overrides.tabs ?? base2.tabs
-    };
-  }
-  function mergeCharacter(base2, overrides) {
-    if (!overrides) return base2;
-    return {
-      ...base2,
-      font: overrides.font ? { ...base2.font, ...overrides.font } : base2.font,
-      color: overrides.color ?? base2.color,
-      underline: overrides.underline ?? base2.underline,
-      strike: overrides.strike ?? base2.strike,
-      highlight: overrides.highlight ?? base2.highlight,
-      letterSpacing: overrides.letterSpacing ?? base2.letterSpacing
-    };
-  }
-  function normalizeFieldAnnotationMetadata(attrs) {
-    const fieldId = toOptionalString(attrs.fieldId) ?? "";
-    const formatting = extractFormatting(attrs);
-    const size2 = normalizeSize(attrs.size);
-    const extras = isPlainObject$4(attrs.extras) ? attrs.extras : null;
-    const marks = isPlainObject$4(attrs.marks) ? attrs.marks : void 0;
-    return {
-      type: "fieldAnnotation",
-      fieldId,
-      variant: normalizeFieldAnnotationVariant(attrs.type),
-      fieldType: toOptionalString(attrs.fieldType),
-      displayLabel: toOptionalString(attrs.displayLabel),
-      defaultDisplayLabel: toOptionalString(attrs.defaultDisplayLabel),
-      alias: toOptionalString(attrs.alias),
-      fieldColor: normalizeColorValue(attrs.fieldColor),
-      borderColor: normalizeColorValue(attrs.borderColor),
-      highlighted: toBoolean$2(attrs.highlighted, true),
-      fontFamily: toNullableString(attrs.fontFamily),
-      fontSize: normalizeFontSize(attrs.fontSize),
-      textColor: normalizeColorValue(attrs.textColor) ?? null,
-      textHighlight: normalizeColorValue(attrs.textHighlight) ?? null,
-      linkUrl: toNullableString(attrs.linkUrl),
-      imageSrc: toNullableString(attrs.imageSrc),
-      rawHtml: attrs.rawHtml ?? void 0,
-      size: size2 ?? null,
-      extras,
-      multipleImage: toBoolean$2(attrs.multipleImage, false),
-      hash: toOptionalString(attrs.hash) ?? null,
-      generatorIndex: toNumber(attrs.generatorIndex),
-      sdtId: toOptionalString(attrs.sdtId) ?? null,
-      hidden: toBoolean$2(attrs.hidden, false),
-      visibility: normalizeVisibility(attrs.visibility),
-      isLocked: toBoolean$2(attrs.isLocked, false),
-      formatting,
-      marks
-    };
-  }
-  function normalizeStructuredContentMetadata(nodeType, attrs) {
-    return {
-      type: "structuredContent",
-      scope: nodeType === "structuredContentBlock" ? "block" : "inline",
-      id: toNullableString(attrs.id),
-      tag: toOptionalString(attrs.tag),
-      alias: toOptionalString(attrs.alias),
-      sdtPr: attrs.sdtPr
-    };
-  }
-  function normalizeDocumentSectionMetadata(attrs) {
-    return {
-      type: "documentSection",
-      id: toNullableString(attrs.id),
-      title: toOptionalString(attrs.title) ?? null,
-      description: toOptionalString(attrs.description) ?? null,
-      sectionType: toOptionalString(attrs.sectionType) ?? null,
-      isLocked: toBoolean$2(attrs.isLocked, false),
-      sdBlockId: toNullableString(attrs.sdBlockId)
-    };
-  }
-  function normalizeDocPartMetadata(attrs) {
-    return {
-      type: "docPartObject",
-      gallery: toOptionalString(attrs.docPartGallery ?? attrs.gallery) ?? null,
-      // Source uniqueId from attrs.id (PM adapter uses getDocPartObjectId which extracts attrs.id)
-      // Fall back to attrs.uniqueId for compatibility
-      uniqueId: toOptionalString(attrs.id ?? attrs.uniqueId) ?? null,
-      alias: toOptionalString(attrs.alias) ?? null,
-      instruction: toOptionalString(attrs.instruction) ?? null
-    };
-  }
-  function isPlainObject$4(value) {
-    return !!value && typeof value === "object" && !Array.isArray(value);
-  }
-  function toOptionalString(value) {
-    if (value == null) return void 0;
-    if (typeof value === "string") {
-      const trimmed = value.trim();
-      return trimmed.length ? trimmed : void 0;
-    }
-    return String(value);
-  }
-  function toNullableString(value) {
-    const str = toOptionalString(value);
-    return str ?? null;
-  }
-  function toBoolean$2(value, fallback) {
-    if (typeof value === "boolean") return value;
-    if (typeof value === "string") {
-      const lower = value.toLowerCase();
-      if (lower === "true") return true;
-      if (lower === "false") return false;
-    }
-    if (value == null) return fallback;
-    return Boolean(value);
-  }
-  function normalizeVisibility(value) {
-    if (typeof value !== "string") return void 0;
-    const normalized = value.toLowerCase();
-    if (normalized === "visible" || normalized === "hidden") {
-      return normalized;
-    }
-    return void 0;
-  }
-  function normalizeColorValue(value) {
-    if (typeof value !== "string") return void 0;
-    const trimmed = value.trim();
-    if (!trimmed || trimmed.toLowerCase() === "none") return void 0;
-    return trimmed;
-  }
-  function normalizeFontSize(value) {
-    if (value == null) return null;
-    if (typeof value === "number") {
-      return Number.isFinite(value) ? value : null;
-    }
-    if (typeof value === "string") {
-      const trimmed = value.trim();
-      return trimmed.length ? trimmed : null;
-    }
-    return null;
-  }
-  function toNumber(value) {
-    if (typeof value === "number") {
-      return Number.isFinite(value) ? value : null;
-    }
-    if (typeof value === "string") {
-      const parsed = parseFloat(value);
-      return Number.isFinite(parsed) ? parsed : null;
-    }
-    return null;
-  }
-  function normalizeSize(value) {
-    if (!isPlainObject$4(value)) return null;
-    const obj = value;
-    const width = toNumber(obj.width);
-    const height = toNumber(obj.height);
-    if (width == null && height == null) return null;
-    const result = {};
-    if (width != null) result.width = width;
-    if (height != null) result.height = height;
-    return result;
-  }
-  function normalizeFieldAnnotationVariant(value) {
-    if (typeof value !== "string") return void 0;
-    const normalized = value.toLowerCase();
-    if (normalized === "text" || normalized === "image" || normalized === "signature" || normalized === "checkbox" || normalized === "html" || normalized === "link") {
-      return normalized;
-    }
-    return void 0;
-  }
-  function extractFormatting(attrs) {
-    const bold = toBoolean$2(attrs.bold, false);
-    const italic = toBoolean$2(attrs.italic, false);
-    const underline = toBoolean$2(attrs.underline, false);
-    const formatting = {};
-    if (bold) formatting.bold = true;
-    if (italic) formatting.italic = true;
-    if (underline) formatting.underline = true;
-    return Object.keys(formatting).length ? formatting : void 0;
-  }
-  function buildSdtCacheKey(nodeType, attrs, explicitKey) {
-    const provided = toOptionalString(explicitKey);
-    if (provided) {
-      return `${nodeType}:${provided}`;
-    }
-    const hash2 = toOptionalString(attrs.hash);
-    if (hash2) {
-      return `${nodeType}:${hash2}`;
-    }
-    const id = toOptionalString(attrs.id);
-    if (id) {
-      return `${nodeType}:${id}`;
-    }
-    return void 0;
-  }
   const DEFAULT_LIST_HANGING_PX = 18;
   const LIST_MARKER_GAP = 8;
   const DEFAULT_BULLET_GLYPH = "•";
@@ -88766,6 +88911,7 @@ ${l}
     definitions: {},
     abstracts: {}
   };
+  const ooxmlResolver = createOoxmlResolver({ pPr: translator$14, rPr: translator$1O });
   const hydrateParagraphStyleAttrs = (para, context, preResolved) => {
     if (!hasParagraphStyleContext(context)) {
       return null;
@@ -88793,7 +88939,7 @@ ${l}
       // should still get docDefaults spacing from style resolution
       numbering: context.numbering ?? EMPTY_NUMBERING_CONTEXT
     };
-    const resolved = resolveParagraphProperties(resolverParams, inlineProps);
+    const resolved = ooxmlResolver.resolveParagraphProperties(resolverParams, inlineProps);
     if (!resolved) {
       return null;
     }
@@ -88848,6 +88994,138 @@ ${l}
     }
     return { ...value };
   };
+  const buildCharacterStyleHydration = (resolved, docx) => {
+    const fontFamily2 = extractFontFamily(resolved.fontFamily, docx);
+    const fontSize2 = typeof resolved.fontSize === "number" ? resolved.fontSize : 20;
+    const color2 = extractColorValue(resolved.color);
+    const bold = normalizeBooleanProp(resolved.bold);
+    const italic = normalizeBooleanProp(resolved.italic);
+    const strike = normalizeBooleanProp(resolved.strike);
+    const underline = extractUnderline(resolved.underline);
+    const letterSpacing = typeof resolved.letterSpacing === "number" ? resolved.letterSpacing : void 0;
+    return {
+      fontFamily: fontFamily2,
+      fontSize: fontSize2,
+      color: color2,
+      bold,
+      italic,
+      strike,
+      underline,
+      letterSpacing
+    };
+  };
+  const hydrateCharacterStyleAttrs = (para, context, resolvedPpr) => {
+    if (!hasParagraphStyleContext(context)) {
+      return null;
+    }
+    const attrs = para.attrs ?? {};
+    const paragraphProps = typeof attrs.paragraphProperties === "object" && attrs.paragraphProperties !== null ? attrs.paragraphProperties : {};
+    const styleIdSource = attrs.styleId ?? paragraphProps.styleId;
+    const styleId = typeof styleIdSource === "string" && styleIdSource.trim() ? styleIdSource : null;
+    const inlineRpr = {};
+    const pprForChain = resolvedPpr ?? { styleId };
+    const numberingProps = attrs.numberingProperties ?? paragraphProps.numberingProperties;
+    if (numberingProps != null) {
+      pprForChain.numberingProperties = numberingProps;
+    }
+    const resolverParams = {
+      docx: context.docx,
+      numbering: context.numbering ?? EMPTY_NUMBERING_CONTEXT
+    };
+    let resolved = null;
+    try {
+      resolved = ooxmlResolver.resolveRunProperties(
+        resolverParams,
+        inlineRpr,
+        pprForChain,
+        false,
+        // not list number marker
+        false
+        // not numberingDefinedInline
+      );
+      if (!resolved || typeof resolved !== "object") {
+        return null;
+      }
+    } catch {
+      return null;
+    }
+    return buildCharacterStyleHydration(resolved, context.docx);
+  };
+  const hydrateMarkerStyleAttrs = (para, context, resolvedPpr) => {
+    if (!hasParagraphStyleContext(context)) {
+      return null;
+    }
+    const attrs = para.attrs ?? {};
+    const paragraphProps = typeof attrs.paragraphProperties === "object" && attrs.paragraphProperties !== null ? attrs.paragraphProperties : {};
+    const styleIdSource = attrs.styleId ?? paragraphProps.styleId;
+    const styleId = typeof styleIdSource === "string" && styleIdSource.trim() ? styleIdSource : null;
+    const inlineRpr = {};
+    const numberingProps = attrs.numberingProperties ?? paragraphProps.numberingProperties;
+    const numberingDefinedInline = numberingProps?.numId != null;
+    const pprForChain = resolvedPpr ? { ...resolvedPpr } : { styleId };
+    if (styleId && !pprForChain.styleId) {
+      pprForChain.styleId = styleId;
+    }
+    if (numberingProps != null) {
+      pprForChain.numberingProperties = numberingProps;
+    }
+    const resolverParams = {
+      docx: context.docx,
+      numbering: context.numbering ?? EMPTY_NUMBERING_CONTEXT
+    };
+    let resolved = null;
+    try {
+      resolved = ooxmlResolver.resolveRunProperties(
+        resolverParams,
+        inlineRpr,
+        pprForChain,
+        true,
+        numberingDefinedInline
+      );
+      if (!resolved || typeof resolved !== "object") {
+        return null;
+      }
+    } catch {
+      return null;
+    }
+    return buildCharacterStyleHydration(resolved, context.docx);
+  };
+  function extractFontFamily(fontFamily2, docx) {
+    if (!fontFamily2 || typeof fontFamily2 !== "object") return void 0;
+    const toCssFontFamily2 = SuperConverter.toCssFontFamily;
+    const resolved = resolveDocxFontFamily(fontFamily2, docx ?? null, toCssFontFamily2);
+    return resolved ?? void 0;
+  }
+  function extractColorValue(color2) {
+    if (!color2 || typeof color2 !== "object") return void 0;
+    const c2 = color2;
+    const val = c2.val;
+    if (typeof val !== "string") return void 0;
+    if (!val || val.toLowerCase() === "auto") return void 0;
+    return val;
+  }
+  function normalizeBooleanProp(value) {
+    if (value == null) return void 0;
+    if (typeof value === "boolean") return value;
+    if (typeof value === "number") return value !== 0;
+    if (typeof value === "string") {
+      const lower = value.toLowerCase();
+      if (lower === "0" || lower === "false" || lower === "off") return false;
+      if (lower === "1" || lower === "true" || lower === "on" || lower === "") return true;
+    }
+    return Boolean(value);
+  }
+  function extractUnderline(underline) {
+    if (!underline || typeof underline !== "object") return void 0;
+    const u = underline;
+    const type = u["w:val"] ?? u.type ?? u.val;
+    if (typeof type !== "string" || type === "none") return void 0;
+    const color2 = u["w:color"] ?? u.color;
+    return {
+      type,
+      color: typeof color2 === "string" ? color2 : void 0
+    };
+  }
   const { resolveSpacingIndent } = Engines;
   const DEFAULT_DECIMAL_SEPARATOR$2 = ".";
   const isValidNumberingId = (numId) => {
@@ -89363,7 +89641,7 @@ ${l}
     }
     return dropCapRun;
   };
-  const computeWordLayoutForParagraph = (paragraphAttrs, numberingProps, styleContext, _paragraphNode) => {
+  const computeWordLayoutForParagraph = (paragraphAttrs, numberingProps, styleContext, paragraphNode, converterContext, resolvedPpr) => {
     if (numberingProps === null) {
       return null;
     }
@@ -89401,7 +89679,23 @@ ${l}
           spacing: {}
         }
       };
-      let markerRun = numberingProps?.resolvedMarkerRpr;
+      let markerRun;
+      const markerHydration = paragraphNode && converterContext ? hydrateMarkerStyleAttrs(paragraphNode, converterContext, resolvedPpr) : null;
+      if (markerHydration) {
+        const resolvedColor = markerHydration.color ? `#${markerHydration.color.replace("#", "")}` : void 0;
+        markerRun = {
+          fontFamily: markerHydration.fontFamily ?? "Times New Roman",
+          fontSize: markerHydration.fontSize / 2,
+          // half-points to points
+          bold: markerHydration.bold,
+          italic: markerHydration.italic,
+          color: resolvedColor,
+          letterSpacing: markerHydration.letterSpacing != null ? twipsToPx$1(markerHydration.letterSpacing) : void 0
+        };
+      }
+      if (!markerRun) {
+        markerRun = numberingProps?.resolvedMarkerRpr;
+      }
       if (!markerRun) {
         const { character: characterStyle } = resolveStyle({ styleId: paragraphAttrs.styleId }, styleContext);
         if (characterStyle) {
@@ -89722,7 +90016,12 @@ ${l}
       const numId = numberingProps.numId;
       const ilvl = Number.isFinite(numberingProps.ilvl) ? Math.max(0, Math.floor(Number(numberingProps.ilvl))) : 0;
       const numericNumId = typeof numId === "number" ? numId : void 0;
-      const resolvedLevel = resolveNumberingFromContext(numId, ilvl, converterContext?.numbering);
+      let resolvedLevel;
+      try {
+        resolvedLevel = resolveNumberingFromContext(numId, ilvl, converterContext?.numbering);
+      } catch (error) {
+        resolvedLevel = void 0;
+      }
       if (resolvedLevel) {
         if (resolvedLevel.format && numberingProps.format == null) {
           numberingProps.format = resolvedLevel.format;
@@ -89783,7 +90082,19 @@ ${l}
           }
         }
       }
-      let wordLayout = computeWordLayoutForParagraph(paragraphAttrs, enrichedNumberingProps, styleContext);
+      let wordLayout = null;
+      try {
+        wordLayout = computeWordLayoutForParagraph(
+          paragraphAttrs,
+          enrichedNumberingProps,
+          styleContext,
+          para,
+          converterContext,
+          hydrated?.resolved
+        );
+      } catch (error) {
+        wordLayout = null;
+      }
       if (!wordLayout && enrichedNumberingProps.resolvedLevelIndent) {
         const resolvedIndentPx = convertIndentTwipsToPx(enrichedNumberingProps.resolvedLevelIndent);
         const baseIndent = resolvedIndentPx ?? enrichedNumberingProps.resolvedLevelIndent;
@@ -90328,7 +90639,7 @@ ${l}
   const H_ALIGN_VALUES$1 = /* @__PURE__ */ new Set(["left", "center", "right"]);
   const V_ALIGN_VALUES$1 = /* @__PURE__ */ new Set(["top", "center", "bottom"]);
   const getAttrs$1 = (node2) => {
-    return isPlainObject$5(node2.attrs) ? node2.attrs : {};
+    return isPlainObject$4(node2.attrs) ? node2.attrs : {};
   };
   const normalizeWrapType$1 = (value) => {
     if (typeof value !== "string") return void 0;
@@ -90351,7 +90662,7 @@ ${l}
     return polygon.length > 0 ? polygon : void 0;
   };
   const normalizeWrap$2 = (value) => {
-    if (!isPlainObject$5(value)) {
+    if (!isPlainObject$4(value)) {
       return void 0;
     }
     const type = normalizeWrapType$1(value.type);
@@ -90359,7 +90670,7 @@ ${l}
       return void 0;
     }
     const wrap2 = { type };
-    const attrs = isPlainObject$5(value.attrs) ? value.attrs : {};
+    const attrs = isPlainObject$4(value.attrs) ? value.attrs : {};
     const wrapText = normalizeWrapText$1(attrs.wrapText);
     if (wrapText) {
       wrap2.wrapText = wrapText;
@@ -90376,7 +90687,7 @@ ${l}
     if (polygon) {
       wrap2.polygon = polygon;
     }
-    const behindDoc = toBoolean$3(attrs.behindDoc);
+    const behindDoc = toBoolean$2(attrs.behindDoc);
     if (behindDoc != null) {
       wrap2.behindDoc = behindDoc;
     }
@@ -90391,10 +90702,10 @@ ${l}
     return allowed.has(value) ? value : void 0;
   };
   const normalizeAnchorData$1 = (value, attrs, wrapBehindDoc) => {
-    const raw = isPlainObject$5(value) ? value : void 0;
-    const marginOffset = isPlainObject$5(attrs.marginOffset) ? attrs.marginOffset : void 0;
-    const simplePos = isPlainObject$5(attrs.simplePos) ? attrs.simplePos : void 0;
-    const originalAttrs = isPlainObject$5(attrs.originalAttributes) ? attrs.originalAttributes : void 0;
+    const raw = isPlainObject$4(value) ? value : void 0;
+    const marginOffset = isPlainObject$4(attrs.marginOffset) ? attrs.marginOffset : void 0;
+    const simplePos = isPlainObject$4(attrs.simplePos) ? attrs.simplePos : void 0;
+    const originalAttrs = isPlainObject$4(attrs.originalAttributes) ? attrs.originalAttributes : void 0;
     const isAnchored = attrs.isAnchor === true || Boolean(raw);
     const anchor = {};
     if (isAnchored) {
@@ -90412,7 +90723,7 @@ ${l}
     if (offsetH != null) anchor.offsetH = offsetH;
     const offsetV = pickNumber(marginOffset?.top ?? marginOffset?.vertical ?? raw?.offsetV ?? simplePos?.y);
     if (offsetV != null) anchor.offsetV = offsetV;
-    const behindDoc = toBoolean$3(raw?.behindDoc ?? wrapBehindDoc ?? originalAttrs?.behindDoc);
+    const behindDoc = toBoolean$2(raw?.behindDoc ?? wrapBehindDoc ?? originalAttrs?.behindDoc);
     if (behindDoc != null) anchor.behindDoc = behindDoc;
     const hasData = anchor.isAnchored || anchor.hRelativeFrom != null || anchor.vRelativeFrom != null || anchor.alignH != null || anchor.alignV != null || anchor.offsetH != null || anchor.offsetV != null || anchor.behindDoc != null;
     return hasData ? anchor : void 0;
@@ -90537,7 +90848,7 @@ ${l}
     }
   }
   const getAttrs = (node2) => {
-    return isPlainObject$5(node2.attrs) ? { ...node2.attrs } : {};
+    return isPlainObject$4(node2.attrs) ? { ...node2.attrs } : {};
   };
   const parseFullWidth = (value) => {
     if (typeof value === "string") {
@@ -90556,7 +90867,7 @@ ${l}
     if (rawAttrs.horizontalRule !== true) {
       return null;
     }
-    const size2 = isPlainObject$5(rawAttrs.size) ? rawAttrs.size : void 0;
+    const size2 = isPlainObject$4(rawAttrs.size) ? rawAttrs.size : void 0;
     const { width, isFullWidth } = parseFullWidth(size2?.width);
     const height = pickNumber(size2?.height);
     if (!height || height <= 0) {
@@ -90758,6 +91069,9 @@ ${l}
     return null;
   };
   const DEFAULT_IMAGE_DIMENSION_PX = 100;
+  const HALF_POINTS_PER_POINT = 2;
+  const SCREEN_DPI = 96;
+  const POINT_DPI = 72;
   function isInlineImage(node2) {
     const attrs = node2.attrs ?? {};
     const wrap2 = attrs.wrap;
@@ -90785,8 +91099,8 @@ ${l}
     const size2 = attrs.size ?? {};
     const width = typeof size2.width === "number" && Number.isFinite(size2.width) && size2.width > 0 ? size2.width : DEFAULT_IMAGE_DIMENSION_PX;
     const height = typeof size2.height === "number" && Number.isFinite(size2.height) && size2.height > 0 ? size2.height : DEFAULT_IMAGE_DIMENSION_PX;
-    const wrap2 = isPlainObject$5(attrs.wrap) ? attrs.wrap : {};
-    const wrapAttrs = isPlainObject$5(wrap2.attrs) ? wrap2.attrs : {};
+    const wrap2 = isPlainObject$4(attrs.wrap) ? attrs.wrap : {};
+    const wrapAttrs = isPlainObject$4(wrap2.attrs) ? wrap2.attrs : {};
     const run2 = {
       kind: "image",
       src,
@@ -90996,15 +91310,6 @@ ${l}
     if (defaults2.letterSpacing != null && run2.letterSpacing == null) {
       run2.letterSpacing = defaults2.letterSpacing;
     }
-    if (defaults2.bold && run2.bold === void 0) {
-      run2.bold = true;
-    }
-    if (defaults2.italic && run2.italic === void 0) {
-      run2.italic = true;
-    }
-    if (defaults2.underline && !run2.underline) {
-      run2.underline = defaults2.underline;
-    }
   };
   function paragraphToFlowBlocks$1(para, nextBlockId, positions, defaultFont, defaultSize, styleContext, listCounterContext, trackedChanges, bookmarks, hyperlinkConfig = DEFAULT_HYPERLINK_CONFIG$1, themeColors, converters, converterContext) {
     const baseBlockId = nextBlockId("paragraph");
@@ -91013,28 +91318,45 @@ ${l}
     const paragraphHydration = converterContext ? hydrateParagraphStyleAttrs(para, converterContext) : null;
     let baseRunDefaults = {};
     try {
-      const spacingSource = para.attrs?.spacing !== void 0 ? para.attrs.spacing : paragraphProps.spacing !== void 0 ? paragraphProps.spacing : paragraphHydration?.spacing;
-      const indentSource = para.attrs?.indent ?? paragraphProps.indent ?? paragraphHydration?.indent;
-      const normalizedSpacing = normalizeParagraphSpacing(spacingSource);
-      const normalizedIndent = normalizePxIndent(indentSource) ?? normalizeParagraphIndent(indentSource ?? para.attrs?.textIndent);
-      const styleNodeAttrs = paragraphHydration?.tabStops && !para.attrs?.tabStops && !para.attrs?.tabs ? { ...para.attrs ?? {}, tabStops: paragraphHydration.tabStops } : para.attrs ?? {};
-      const styleNode = buildStyleNodeFromAttrs(styleNodeAttrs, normalizedSpacing, normalizedIndent);
-      if (styleNodeAttrs.styleId == null && paragraphProps.styleId) {
-        styleNode.styleId = paragraphProps.styleId;
-      }
-      const resolved = resolveStyle(styleNode, styleContext);
-      baseRunDefaults = {
-        fontFamily: resolved.character.font?.family,
-        fontSizePx: ptToPx(resolved.character.font?.size),
-        color: resolved.character.color,
-        bold: resolved.character.font?.weight != null ? resolved.character.font.weight >= 600 : void 0,
-        italic: resolved.character.font?.italic,
-        underline: resolved.character.underline ? {
-          style: resolved.character.underline.style,
-          color: resolved.character.underline.color
-        } : void 0,
-        letterSpacing: ptToPx(resolved.character.letterSpacing)
-      };
+      const charHydration = converterContext ? hydrateCharacterStyleAttrs(para, converterContext, paragraphHydration?.resolved) : null;
+      if (charHydration) {
+        const fontSizePx = charHydration.fontSize / HALF_POINTS_PER_POINT * (SCREEN_DPI / POINT_DPI);
+        baseRunDefaults = {
+          fontFamily: charHydration.fontFamily,
+          fontSizePx,
+          color: charHydration.color ? `#${charHydration.color.replace("#", "")}` : void 0,
+          bold: charHydration.bold,
+          italic: charHydration.italic,
+          underline: charHydration.underline ? {
+            style: charHydration.underline.type,
+            color: charHydration.underline.color
+          } : void 0,
+          letterSpacing: charHydration.letterSpacing != null ? twipsToPx$1(charHydration.letterSpacing) : void 0
+        };
+      } else {
+        const spacingSource = para.attrs?.spacing !== void 0 ? para.attrs.spacing : paragraphProps.spacing !== void 0 ? paragraphProps.spacing : paragraphHydration?.spacing;
+        const indentSource = para.attrs?.indent ?? paragraphProps.indent ?? paragraphHydration?.indent;
+        const normalizedSpacing = normalizeParagraphSpacing(spacingSource);
+        const normalizedIndent = normalizePxIndent(indentSource) ?? normalizeParagraphIndent(indentSource ?? para.attrs?.textIndent);
+        const styleNodeAttrs = paragraphHydration?.tabStops && !para.attrs?.tabStops && !para.attrs?.tabs ? { ...para.attrs ?? {}, tabStops: paragraphHydration.tabStops } : para.attrs ?? {};
+        const styleNode = buildStyleNodeFromAttrs(styleNodeAttrs, normalizedSpacing, normalizedIndent);
+        if (styleNodeAttrs.styleId == null && paragraphProps.styleId) {
+          styleNode.styleId = paragraphProps.styleId;
+        }
+        const resolved = resolveStyle(styleNode, styleContext);
+        baseRunDefaults = {
+          fontFamily: resolved.character.font?.family,
+          fontSizePx: ptToPx(resolved.character.font?.size),
+          color: resolved.character.color,
+          bold: resolved.character.font?.weight != null ? resolved.character.font.weight >= 600 : void 0,
+          italic: resolved.character.font?.italic,
+          underline: resolved.character.underline ? {
+            style: resolved.character.underline.style,
+            color: resolved.character.underline.color
+          } : void 0,
+          letterSpacing: ptToPx(resolved.character.letterSpacing)
+        };
+      }
     } catch {
       baseRunDefaults = {};
     }
@@ -94585,7 +94907,8 @@ ${l}
         const originX = currentLine.width;
         const { target, nextIndex, stop } = getNextTabStopPx(currentLine.width, tabStops, tabStopCursor);
         tabStopCursor = nextIndex;
-        const tabAdvance = Math.max(0, target - currentLine.width);
+        const clampedTarget = Math.min(target, currentLine.maxWidth);
+        const tabAdvance = Math.max(0, clampedTarget - currentLine.width);
         currentLine.width = roundValue(currentLine.width + tabAdvance);
         run2.width = tabAdvance;
         currentLine.maxFontSize = Math.max(currentLine.maxFontSize, 12);
@@ -94593,14 +94916,14 @@ ${l}
         currentLine.toChar = 1;
         if (stop) {
           validateTabStopVal(stop);
-          pendingTabAlignment = { target, val: stop.val };
+          pendingTabAlignment = { target: clampedTarget, val: stop.val };
         } else {
           pendingTabAlignment = null;
         }
         if (stop && stop.leader && stop.leader !== "none") {
           const leaderStyle = stop.leader;
-          const from2 = Math.min(originX, target);
-          const to = Math.max(originX, target);
+          const from2 = Math.min(originX, clampedTarget);
+          const to = Math.max(originX, clampedTarget);
           if (!currentLine.leaders) currentLine.leaders = [];
           currentLine.leaders.push({ from: from2, to, style: leaderStyle });
         }
@@ -95195,7 +95518,8 @@ ${l}
           const originX = currentLine.width;
           const { target, nextIndex, stop } = getNextTabStopPx(currentLine.width, tabStops, tabStopCursor);
           tabStopCursor = nextIndex;
-          const tabAdvance = Math.max(0, target - currentLine.width);
+          const clampedTarget = Math.min(target, currentLine.maxWidth);
+          const tabAdvance = Math.max(0, clampedTarget - currentLine.width);
           currentLine.width = roundValue(currentLine.width + tabAdvance);
           currentLine.maxFontInfo = updateMaxFontInfo(currentLine.maxFontSize, currentLine.maxFontInfo, run2);
           currentLine.maxFontSize = Math.max(currentLine.maxFontSize, run2.fontSize);
@@ -95204,14 +95528,14 @@ ${l}
           charPosInRun += 1;
           if (stop) {
             validateTabStopVal(stop);
-            pendingTabAlignment = { target, val: stop.val };
+            pendingTabAlignment = { target: clampedTarget, val: stop.val };
           } else {
             pendingTabAlignment = null;
           }
           if (stop && stop.leader && stop.leader !== "none" && stop.leader !== "middleDot") {
             const leaderStyle = stop.leader;
-            const from2 = Math.min(originX, target);
-            const to = Math.max(originX, target);
+            const from2 = Math.min(originX, clampedTarget);
+            const to = Math.max(originX, clampedTarget);
             if (!currentLine.leaders) currentLine.leaders = [];
             currentLine.leaders.push({ from: from2, to, style: leaderStyle });
           }
@@ -103720,16 +104044,112 @@ ${l}
     });
     return mergeRanges$2(mapped, docSize);
   };
-  const buildWrapTransaction = (state, ranges, runType) => {
+  const getParagraphAtPos = (doc2, pos) => {
+    try {
+      const $pos = doc2.resolve(pos);
+      for (let depth = $pos.depth; depth >= 0; depth--) {
+        const node2 = $pos.node(depth);
+        if (node2.type.name === "paragraph") {
+          return node2;
+        }
+      }
+    } catch (_e2) {
+    }
+    return null;
+  };
+  const resolveRunPropertiesFromParagraphStyle = (paragraphNode, editor) => {
+    if (!paragraphNode || !editor?.converter) return {};
+    const styleId = paragraphNode.attrs?.paragraphProperties?.styleId;
+    if (!styleId) return {};
+    try {
+      const params2 = { docx: editor.converter.convertedXml, numbering: editor.converter.numbering };
+      const resolvedPpr = { styleId };
+      const runProps = resolveRunProperties(params2, {}, resolvedPpr, false, false);
+      const runProperties = {};
+      if (runProps.fontFamily) {
+        const fontValue = runProps.fontFamily.ascii || runProps.fontFamily;
+        if (fontValue) {
+          runProperties.fontFamily = typeof fontValue === "string" ? fontValue : fontValue.ascii;
+        }
+      }
+      if (runProps.fontSize) {
+        runProperties.fontSize = `${runProps.fontSize / 2}pt`;
+      }
+      if (runProps.bold) runProperties.bold = true;
+      if (runProps.italic) runProperties.italic = true;
+      if (runProps.underline) runProperties.underline = runProps.underline;
+      if (runProps.strike) runProperties.strike = true;
+      return runProperties;
+    } catch (_e2) {
+      return {};
+    }
+  };
+  const createMarksFromDefs = (schema, markDefs = []) => markDefs.map((def2) => {
+    const markType = schema.marks[def2.type];
+    return markType ? markType.create(def2.attrs) : null;
+  }).filter(Boolean);
+  const createMarkDefsFromStyleRunProps = (styleRunProps) => {
+    const markDefs = [];
+    const textStyleAttrs = {};
+    if (styleRunProps.fontSize) {
+      textStyleAttrs.fontSize = styleRunProps.fontSize;
+    }
+    if (styleRunProps.fontFamily) {
+      textStyleAttrs.fontFamily = styleRunProps.fontFamily;
+    }
+    if (Object.keys(textStyleAttrs).length > 0) {
+      markDefs.push({ type: "textStyle", attrs: textStyleAttrs });
+    }
+    if (styleRunProps.bold) {
+      markDefs.push({ type: "bold", attrs: { value: true } });
+    }
+    if (styleRunProps.italic) {
+      markDefs.push({ type: "italic", attrs: { value: true } });
+    }
+    if (styleRunProps.strike) {
+      markDefs.push({ type: "strike", attrs: { value: true } });
+    }
+    if (styleRunProps.underline) {
+      const underlineType = styleRunProps.underline["w:val"];
+      if (underlineType) {
+        let underlineColor = styleRunProps.underline["w:color"];
+        if (underlineColor && underlineColor.toLowerCase() !== "auto" && !underlineColor.startsWith("#")) {
+          underlineColor = `#${underlineColor}`;
+        }
+        markDefs.push({
+          type: "underline",
+          attrs: { underlineType, underlineColor }
+        });
+      }
+    }
+    return markDefs;
+  };
+  const buildWrapTransaction = (state, ranges, runType, editor, markDefsFromMeta = []) => {
     if (!ranges.length) return null;
     const replacements = [];
+    const metaStyleMarks = createMarksFromDefs(state.schema, markDefsFromMeta);
     ranges.forEach(({ from: from2, to }) => {
       state.doc.nodesBetween(from2, to, (node2, pos, parent, index2) => {
         if (!node2.isText || !parent || parent.type === runType) return;
         const match = parent.contentMatchAt ? parent.contentMatchAt(index2) : null;
         if (match && !match.matchType(runType)) return;
         if (!match && !parent.type.contentMatch.matchType(runType)) return;
-        const runProperties = decodeRPrFromMarks(node2.marks);
+        let runProperties = decodeRPrFromMarks(node2.marks);
+        if ((!node2.marks || node2.marks.length === 0) && editor?.converter) {
+          const paragraphNode = getParagraphAtPos(state.doc, pos);
+          const styleRunProps = resolveRunPropertiesFromParagraphStyle(paragraphNode, editor);
+          if (Object.keys(styleRunProps).length > 0) {
+            runProperties = styleRunProps;
+            const markDefs = metaStyleMarks.length ? markDefsFromMeta : createMarkDefsFromStyleRunProps(styleRunProps);
+            const styleMarks = metaStyleMarks.length ? metaStyleMarks : createMarksFromDefs(state.schema, markDefs);
+            if (styleMarks.length && typeof state.schema.text === "function") {
+              const textNode = state.schema.text(node2.text || "", styleMarks);
+              if (textNode) {
+                node2 = textNode;
+              }
+            }
+          }
+        }
         const runNode = runType.create({ runProperties }, node2);
         replacements.push({ from: pos, to: pos + node2.nodeSize, runNode });
       });
@@ -103739,9 +104159,10 @@ ${l}
     replacements.sort((a2, b2) => b2.from - a2.from).forEach(({ from: from2, to, runNode }) => tr.replaceWith(from2, to, runNode));
     return tr.docChanged ? tr : null;
   };
-  const wrapTextInRunsPlugin = () => {
+  const wrapTextInRunsPlugin = (editor) => {
     let view = null;
     let pendingRanges = [];
+    let lastStyleMarksMeta = [];
     const flush = () => {
       if (!view) return;
       const runType = view.state.schema.nodes.run;
@@ -103749,7 +104170,7 @@ ${l}
         pendingRanges = [];
         return;
       }
-      const tr = buildWrapTransaction(view.state, pendingRanges, runType);
+      const tr = buildWrapTransaction(view.state, pendingRanges, runType, editor, lastStyleMarksMeta);
       pendingRanges = [];
       if (tr) {
         view.dispatch(tr);
@@ -103768,6 +104189,7 @@ ${l}
             editorView.dom.removeEventListener("compositionend", onCompositionEnd2);
             view = null;
             pendingRanges = [];
+            lastStyleMarksMeta = [];
           }
         };
       },
@@ -103781,7 +104203,11 @@ ${l}
         if (view?.composing) {
           return null;
         }
-        const tr = buildWrapTransaction(newState, pendingRanges, runType);
+        const latestStyleMarksMeta = [...transactions].reverse().find((tr2) => tr2.getMeta && tr2.getMeta("sdStyleMarks"))?.getMeta("sdStyleMarks") || lastStyleMarksMeta;
+        if (latestStyleMarksMeta && latestStyleMarksMeta.length) {
+          lastStyleMarksMeta = latestStyleMarksMeta;
+        }
+        const tr = buildWrapTransaction(newState, pendingRanges, runType, editor, latestStyleMarksMeta);
         pendingRanges = [];
         return tr;
       }
@@ -104044,7 +104470,7 @@ ${l}
     },
     addPmPlugins() {
       return [
-        wrapTextInRunsPlugin(),
+        wrapTextInRunsPlugin(this.editor),
         splitRunsAfterMarkPlugin,
         calculateInlineRunPropertiesPlugin(this.editor),
         cleanupEmptyRunsPlugin
@@ -143178,7 +143604,7 @@ ${reason}`);
       this.config.colors = shuffleArray(this.config.colors);
       this.userColorMap = /* @__PURE__ */ new Map();
       this.colorIndex = 0;
-      this.version = "1.3.0-next.1";
+      this.version = "1.3.0-next.3";
       this.#log("🦋 [superdoc] Using SuperDoc version:", this.version);
       this.superdocId = config2.superdocId || v4();
       this.colors = this.config.colors;