pptx2js 0.4.1 → 0.4.3

package/lib/placeholder.js

@@ -2,7 +2,7 @@
  * 母版 / 版式占位符继承（design.html §4.1）
  * 优先级：slide → slideLayout → slideMaster
  */
-const { asArray, attr, child } = require('./xml-utils');
+const { attr, child, children, documentRoot } = require('./xml-utils');
 
 const REL_SLIDE_LAYOUT =
   'http://schemas.openxmlformats.org/officeDocument/2006/relationships/slideLayout';
@@ -69,10 +69,7 @@ function resolveRelByType(relIndex, sourcePath, typeFragment) {
 function getSpTree(parsed, partPath) {
   const doc = parsed[partPath];
   if (!doc) return null;
-  const root =
-    child(doc, 'p:sld') ??
-    child(doc, 'p:sldLayout') ??
-    child(doc, 'p:sldMaster');
+  const root = documentRoot(doc, 'p:sld', 'p:sldLayout', 'p:sldMaster');
   if (!root) return null;
   return child(child(root, 'p:cSld'), 'p:spTree');
 }
@@ -112,12 +109,11 @@ function findSpByPlaceholder(spTree, key) {
  * @returns {object[]}
  */
 function* walkAllSp(spTree) {
-  for (const sp of asArray(spTree['p:sp'])) {
+  for (const sp of children(spTree, 'p:sp')) {
     yield sp;
   }
-  for (const grp of asArray(spTree['p:grpSp'])) {
-    const inner = child(grp, 'p:spTree');
-    if (inner) yield* walkAllSp(inner);
+  for (const grp of children(spTree, 'p:grpSp')) {
+    yield* walkAllSp(grp);
   }
 }
 
@@ -152,10 +148,12 @@ function resolvePlaceholderSps(slideSp, inheritance) {
 function mergeXfrm(slideXfrm, layoutXfrm, masterXfrm) {
   const layers = [slideXfrm, layoutXfrm, masterXfrm];
   const off = mergeXfrmPart(
+    'a:off',
     layers.map((x) => child(x, 'a:off')),
     ['x', 'y']
   );
   const ext = mergeXfrmPart(
+    'a:ext',
     layers.map((x) => child(x, 'a:ext')),
     ['cx', 'cy'],
     { skipZero: true }
@@ -163,18 +161,24 @@ function mergeXfrm(slideXfrm, layoutXfrm, masterXfrm) {
 
   if (!off && !ext) return null;
   return {
-    'a:off': off ?? { $: { x: '0', y: '0' } },
-    'a:ext': ext ?? { $: { cx: '0', cy: '0' } },
+    tag: 'a:xfrm',
+    attrs: {},
+    children: [
+      off ?? makeXfrmPart('a:off', { x: '0', y: '0' }),
+      ext ?? makeXfrmPart('a:ext', { cx: '0', cy: '0' }),
+    ],
+    text: '',
   };
 }
 
 /**
+ * @param {string} tag
  * @param {(object|null|undefined)[]} parts
  * @param {string[]} attrNames
  * @param {{ skipZero?: boolean }} [opts]
- * @returns {object|null}
+ * @returns {import('./xml-parser').OONode|null}
  */
-function mergeXfrmPart(parts, attrNames, opts = {}) {
+function mergeXfrmPart(tag, parts, attrNames, opts = {}) {
   const values = {};
   let hasAny = false;
 
@@ -193,7 +197,29 @@ function mergeXfrmPart(parts, attrNames, opts = {}) {
   }
 
   if (!hasAny) return null;
-  return { $: values };
+  return makeXfrmPart(tag, values);
+}
+
+/**
+ * @param {string} tag
+ * @param {Record<string, string>} attrs
+ * @returns {import('./xml-parser').OONode}
+ */
+function makeXfrmPart(tag, attrs) {
+  return { tag, attrs, children: [], text: '' };
+}
+
+/**
+ * @param {import('./xml-parser').OONode} node
+ * @returns {import('./xml-parser').OONode}
+ */
+function cloneNode(node) {
+  return {
+    tag: node.tag,
+    attrs: { ...node.attrs },
+    children: node.children.map(cloneNode),
+    text: node.text,
+  };
 }
 
 /**
@@ -213,35 +239,137 @@ function getEffectiveXfrm(slideSp, inheritance) {
 }
 
 /**
- * 合并 txBody 默认样式：用 layout/master 的首段/首 run 补全 slide 层缺失的 rPr
+ * @param {import('./xml-parser').OONode} slide p:sld
+ * @returns {boolean}
+ */
+function shouldShowMasterShapes(slide) {
+  const v = attr(slide, 'showMasterSp');
+  if (v === '0' || v === 'false') return false;
+  return true;
+}
+
+/**
+ * 从 txBody 的 lstStyle / endParaRPr 取默认 run 样式
+ * @param {object|null|undefined} txBody
+ * @returns {import('./xml-parser').OONode|null}
+ */
+function getDefaultRPrFromTxBody(txBody) {
+  if (!txBody) return null;
+
+  const lstStyle = child(txBody, 'a:lstStyle');
+  if (lstStyle) {
+    for (let lvl = 1; lvl <= 9; lvl++) {
+      const lvlPPr = child(lstStyle, `a:lvl${lvl}pPr`);
+      const defRPr = lvlPPr && child(lvlPPr, 'a:defRPr');
+      if (defRPr) return defRPr;
+    }
+    const defPPr = child(lstStyle, 'a:defPPr');
+    const defRPr = defPPr && child(defPPr, 'a:defRPr');
+    if (defRPr) return defRPr;
+  }
+
+  const firstP = children(txBody, 'a:p')[0];
+  if (firstP) {
+    const endRPr = child(firstP, 'a:endParaRPr');
+    if (endRPr) return endRPr;
+    const firstR = children(firstP, 'a:r')[0];
+    if (firstR) {
+      const rPr = child(firstR, 'a:rPr');
+      if (rPr) return rPr;
+    }
+  }
+  return null;
+}
+
+/**
+ * @param {import('./xml-parser').OONode|null|undefined} slideRPr
+ * @param {import('./xml-parser').OONode} fallbackRPr
+ * @returns {import('./xml-parser').OONode}
+ */
+function mergeRPrAttrs(slideRPr, fallbackRPr) {
+  if (!fallbackRPr) return slideRPr;
+  if (!slideRPr) return cloneNode(fallbackRPr);
+
+  const merged = cloneNode(slideRPr);
+  for (const [k, v] of Object.entries(fallbackRPr.attrs)) {
+    if (merged.attrs[k] == null || merged.attrs[k] === '') {
+      merged.attrs[k] = v;
+    }
+  }
+  for (const fc of fallbackRPr.children) {
+    if (!child(merged, fc.tag)) {
+      merged.children.push(cloneNode(fc));
+    }
+  }
+  return merged;
+}
+
+/**
+ * 合并 txBody：补全 lstStyle 与 layout/master 的 defRPr
  * @param {object} slideTxBody
  * @param {object|null} layoutSp
  * @param {object|null} masterSp
  * @returns {object}
  */
 function mergeTxBody(slideTxBody, layoutSp, masterSp) {
-  const slideBody = slideTxBody;
   const fallbackBody =
     (layoutSp && child(layoutSp, 'p:txBody')) ||
     (masterSp && child(masterSp, 'p:txBody'));
-  if (!fallbackBody) return slideBody;
 
-  const slideParas = asArray(slideBody['a:p']);
-  const fallbackPara = asArray(fallbackBody['a:p'])[0];
-  const fallbackRPr = fallbackPara && child(asArray(fallbackPara['a:r'])[0], 'a:rPr');
+  const merged = cloneNode(slideTxBody);
+
+  if (fallbackBody) {
+    const fallbackLst = child(fallbackBody, 'a:lstStyle');
+    if (fallbackLst && !child(merged, 'a:lstStyle')) {
+      merged.children.unshift(cloneNode(fallbackLst));
+    }
+  }
 
-  if (!fallbackRPr) return slideBody;
+  const fallbackRPr = fallbackBody
+    ? getDefaultRPrFromTxBody(fallbackBody)
+    : null;
+  if (!fallbackRPr) return merged;
 
-  const mergedParas = slideParas.map((p) => {
-    const runs = asArray(p['a:r']).map((r) => {
+  for (const p of children(merged, 'a:p')) {
+    for (const r of children(p, 'a:r')) {
       const rPr = child(r, 'a:rPr');
-      if (rPr) return r;
-      return { ...r, 'a:rPr': JSON.parse(JSON.stringify(fallbackRPr)) };
-    });
-    return { ...p, 'a:r': runs.length === 1 ? runs[0] : runs };
-  });
+      const mergedRPr = mergeRPrAttrs(rPr, fallbackRPr);
+      if (rPr) {
+        const idx = r.children.findIndex((c) => c.tag === 'a:rPr');
+        r.children[idx] = mergedRPr;
+      } else {
+        r.children.unshift(mergedRPr);
+      }
+    }
+    const endRPr = child(p, 'a:endParaRPr');
+    if (endRPr) {
+      const idx = p.children.findIndex((c) => c.tag === 'a:endParaRPr');
+      p.children[idx] = mergeRPrAttrs(endRPr, fallbackRPr);
+    }
+  }
+  return merged;
+}
+
+/**
+ * 按级别读取 lstStyle 中的 defRPr（lvl1pPr → 索引 0）
+ * @param {object|null|undefined} txBody
+ * @returns {Record<number, import('./xml-parser').OONode>}
+ */
+function getLstStyleDefRPrByLevel(txBody) {
+  /** @type {Record<number, import('./xml-parser').OONode>} */
+  const byLevel = {};
+  const lstStyle = txBody && child(txBody, 'a:lstStyle');
+  if (!lstStyle) return byLevel;
 
-  return { ...slideBody, 'a:p': mergedParas.length === 1 ? mergedParas[0] : mergedParas };
+  for (let lvl = 1; lvl <= 9; lvl++) {
+    const lvlPPr = child(lstStyle, `a:lvl${lvl}pPr`);
+    const defRPr = lvlPPr && child(lvlPPr, 'a:defRPr');
+    if (defRPr) byLevel[lvl - 1] = defRPr;
+  }
+  const defPPr = child(lstStyle, 'a:defPPr');
+  const defRPr = defPPr && child(defPPr, 'a:defRPr');
+  if (defRPr && byLevel[0] == null) byLevel[0] = defRPr;
+  return byLevel;
 }
 
 module.exports = {
@@ -254,5 +382,9 @@ module.exports = {
   mergeXfrm,
   getEffectiveXfrm,
   mergeTxBody,
+  mergeRPrAttrs,
+  getDefaultRPrFromTxBody,
+  getLstStyleDefRPrByLevel,
+  shouldShowMasterShapes,
   getSpTree,
 };

package/lib/presentation.js

@@ -1,8 +1,8 @@
 /**
  * presentation.xml：幻灯片列表与版面尺寸
  */
-const { asArray, attr, child } = require('./xml-utils');
-const { emuToInch } = require('./utils/emu');
+const { attr, child, children, documentRoot } = require('./xml-utils');
+const { emuToInch } = require('./bounds');
 
 const PRESENTATION_PATH = 'ppt/presentation.xml';
 
@@ -13,10 +13,10 @@ const PRESENTATION_PATH = 'ppt/presentation.xml';
  */
 function getSlidePaths(parsed, relIndex) {
   const doc = parsed[PRESENTATION_PATH];
-  const pres = child(doc, 'p:presentation');
+  const pres = documentRoot(doc, 'p:presentation');
   if (!pres) return [];
 
-  const sldIds = asArray(child(child(pres, 'p:sldIdLst'), 'p:sldId'));
+  const sldIds = children(child(pres, 'p:sldIdLst'), 'p:sldId');
   const paths = [];
   for (const sldId of sldIds) {
     const relId = attr(sldId, 'r:id');
@@ -32,7 +32,7 @@ function getSlidePaths(parsed, relIndex) {
  * @returns {{ width: number, height: number }}
  */
 function getSlideSizeInches(parsed) {
-  const pres = child(parsed[PRESENTATION_PATH], 'p:presentation');
+  const pres = documentRoot(parsed[PRESENTATION_PATH], 'p:presentation');
   const sldSz = child(pres, 'p:sldSz');
   const cx = parseInt(attr(sldSz, 'cx') ?? '9144000', 10);
   const cy = parseInt(attr(sldSz, 'cy') ?? '6858000', 10);

package/lib/rels.js

@@ -2,7 +2,7 @@
  * OOXML 关系（.rels）解析与路径解析
  */
 const path = require('path');
-const { asArray, attr } = require('./xml-utils');
+const { attr, children, documentRoot } = require('./xml-utils');
 
 /**
  * @typedef {object} Relationship
@@ -76,8 +76,8 @@ function resolveTargetPath(ownerPath, target) {
  * @returns {Relationship[]}
  */
 function parseRelationships(relsDoc) {
-  const root = relsDoc?.Relationships ?? relsDoc;
-  const rels = asArray(root?.Relationship);
+  const root = documentRoot(relsDoc, 'Relationships');
+  const rels = children(root, 'Relationship');
   return rels
     .map((rel) => ({
       id: attr(rel, 'Id'),
@@ -97,7 +97,7 @@ function buildRelationIndex(parsed) {
   const bySource = new Map();
 
   for (const [filePath, doc] of Object.entries(parsed)) {
-    if (!filePath.endsWith('.rels')) continue;
+    if (!/\.rels$/i.test(filePath)) continue;
     const owner = relsOwnerPath(filePath);
     const relationships = parseRelationships(doc);
     const map = new Map();

package/lib/run-utils.js

@@ -97,7 +97,9 @@ function compressTextRuns(runs) {
     if (optionsEqual(prev.options, tail.options) && !prev.text.endsWith('\n')) {
       prev.text += tail.text.includes('\r') ? '\r\n' : '\n';
     } else {
-      out.push(tail);
+      const nlOpts = { ...tail.options };
+      delete nlOpts.bullet;
+      out.push({ text: tail.text, options: nlOpts });
       break;
     }
   }

package/lib/smartart.js

@@ -3,7 +3,7 @@
  */
 const { attr, child, textContent } = require('./xml-utils');
 const { getGraphicXfrm } = require('./graphic');
-const { boundsFromXfrm } = require('./utils/bounds');
+const { boundsFromXfrm } = require('./bounds');
 
 /**
  * @param {object} graphicFrame
@@ -74,22 +74,14 @@ function extractSmartArtTexts(graphicFrame, ctx) {
  * @param {string[]} out
  */
 function collectTextNodes(node, out) {
-  if (node == null) return;
-  if (typeof node === 'string') return;
-  if (typeof node !== 'object') return;
-
-  if (node['a:t'] != null) {
-    const t = textContent(node['a:t']);
+  if (!node || typeof node !== 'object') return;
+  if (node.tag === 'a:t') {
+    const t = textContent(node);
     if (t) out.push(t);
+    return;
   }
-
-  for (const [key, val] of Object.entries(node)) {
-    if (key === '$') continue;
-    if (Array.isArray(val)) {
-      for (const item of val) collectTextNodes(item, out);
-    } else if (val && typeof val === 'object') {
-      collectTextNodes(val, out);
-    }
+  for (const c of node.children || []) {
+    collectTextNodes(c, out);
   }
 }
 

package/lib/table.js

@@ -1,12 +1,12 @@
 /**
  * 表格提取（design.html §4.5）
  */
-const { asArray, attr, child } = require('./xml-utils');
+const { attr, child, children } = require('./xml-utils');
 const { getGraphicXfrm } = require('./graphic');
-const { boundsFromXfrm } = require('./utils/bounds');
-const { resolveFillColor } = require('./utils/color');
-const { emuToInch } = require('./utils/emu');
+const { boundsFromXfrm, emuToInch } = require('./bounds');
+const { resolveFillColor } = require('./color');
 const { compressCellBorder, flattenTableCellText } = require('./run-utils');
+const { extractTextRuns } = require('./text-utils');
 
 /**
  * @param {object} graphicFrame
@@ -50,16 +50,15 @@ function extractTable(graphicFrame, ctx) {
  */
 function extractTableRows(tbl, scheme) {
   const rows = [];
-  for (const tr of asArray(tbl['a:tr'])) {
+  for (const tr of children(tbl, 'a:tr')) {
     const cells = [];
-    for (const tc of asArray(tr['a:tc'])) {
+    for (const tc of children(tr, 'a:tc')) {
       const tcPr = child(tc, 'a:tcPr');
       const txBody = child(tc, 'a:txBody');
       let text = '';
       /** @type {object} */
       let runOptions = {};
       if (txBody) {
-        const { extractTextRuns } = require('./extractor');
         const flat = flattenTableCellText(extractTextRuns(txBody, scheme, null));
         text = flat.text;
         runOptions = flat.runOptions;
@@ -133,7 +132,7 @@ function extractCellBorderSides(tcPr, scheme) {
  */
 function extractColWidths(tbl) {
   const grid = child(tbl, 'a:tblGrid');
-  const cols = asArray(child(grid, 'a:gridCol'));
+  const cols = children(grid, 'a:gridCol');
   if (!cols.length) return undefined;
   return cols.map((col) => {
     const w = parseInt(attr(col, 'w') ?? '0', 10);

package/lib/text-utils.js

@@ -0,0 +1,235 @@
+/**
+ * 文本 run 提取（从 extractor 拆出，避免 extractor ↔ table 循环依赖）
+ */
+const { attr, child, childNodes, children, textContent } = require('./xml-utils');
+const {
+  resolveFillColor,
+  resolveColorFromContainer,
+} = require('./color');
+const { compressTextRuns } = require('./run-utils');
+const {
+  getLstStyleDefRPrByLevel,
+  mergeRPrAttrs,
+} = require('./placeholder');
+
+const PARA_ALIGN_MAP = {
+  l: 'left',
+  ctr: 'center',
+  r: 'right',
+  just: 'justify',
+  dist: 'justify',
+};
+
+/**
+ * @param {object} txBody a:txBody
+ * @param {Record<string, string>} scheme
+ * @param {{ relIndex?: import('./rels').RelationIndex, slidePath?: string }|null} linkCtx
+ */
+function extractTextRuns(txBody, scheme, linkCtx) {
+  const runs = [];
+  const bodyParaOpts = extractBodyPrParaOptions(txBody);
+  const defRPrByLevel = getLstStyleDefRPrByLevel(txBody);
+  const defaultFontSize =
+    bodyParaOpts._defaultFontSize ??
+    runFontSizeFromDefRPr(defRPrByLevel[0]);
+  const paragraphs = children(txBody, 'a:p');
+
+  for (let pi = 0; pi < paragraphs.length; pi++) {
+    const p = paragraphs[pi];
+    let currentPPr = null;
+    let firstPPr = null;
+
+    for (const node of childNodes(p)) {
+      if (node.tag === 'a:pPr') {
+        currentPPr = node;
+        if (!firstPPr) firstPPr = node;
+        continue;
+      }
+
+      const pPr = currentPPr ?? firstPPr;
+      const paraOpts = {
+        ...bodyParaOpts,
+        ...extractParaOptions(pPr, defaultFontSize),
+      };
+      delete paraOpts._defaultFontSize;
+      const bullet0 = extractBullet(firstPPr);
+      const bullet = extractBullet(pPr) ?? bullet0;
+
+      const lvl = paraOpts.indentLevel ?? 0;
+      const defRPr =
+        defRPrByLevel[lvl] ?? defRPrByLevel[0] ?? null;
+
+      if (node.tag === 'a:r') {
+        const text = textContent(child(node, 'a:t'));
+        if (!text) continue;
+        const rPr = mergeRPrAttrs(child(node, 'a:rPr'), defRPr);
+        const options = extractRunOptions(rPr, scheme, linkCtx);
+        Object.assign(options, paraOpts);
+        if (bullet) Object.assign(options, bullet);
+        runs.push({ text, options, degraded: options._degraded });
+      } else if (node.tag === 'a:fld') {
+        const text = textContent(child(node, 'a:t'));
+        if (!text) continue;
+        const rPr = mergeRPrAttrs(child(node, 'a:rPr'), defRPr);
+        const options = extractRunOptions(rPr, scheme, linkCtx);
+        Object.assign(options, paraOpts);
+        runs.push({ text, options, degraded: options._degraded });
+      } else if (node.tag === 'a:br') {
+        runs.push({ text: '\n', options: { ...paraOpts }, degraded: false });
+      }
+    }
+
+    if (pi < paragraphs.length - 1) {
+      const last = runs[runs.length - 1];
+      if (!last || !last.text.endsWith('\n')) {
+        const paraOpts = {
+          ...bodyParaOpts,
+          ...extractParaOptions(firstPPr, defaultFontSize),
+        };
+        delete paraOpts._defaultFontSize;
+        if (extractBullet(firstPPr)) delete paraOpts.bullet;
+        runs.push({ text: '\n', options: { ...paraOpts }, degraded: false });
+      }
+    }
+  }
+  return compressTextRuns(runs);
+}
+
+/**
+ * @param {import('./xml-parser').OONode|null|undefined} defRPr
+ * @returns {number|undefined}
+ */
+function runFontSizeFromDefRPr(defRPr) {
+  if (!defRPr) return undefined;
+  const sz = attr(defRPr, 'sz');
+  return sz ? parseInt(sz, 10) / 100 : undefined;
+}
+
+/**
+ * @param {object|null|undefined} txBody
+ */
+function extractBodyPrParaOptions(txBody) {
+  if (!txBody) return {};
+  const bodyPr = child(txBody, 'a:bodyPr');
+  const lstStyle = child(txBody, 'a:lstStyle');
+  const defPPr = lstStyle && child(lstStyle, 'a:defPPr');
+  const defRPr = defPPr && child(defPPr, 'a:defRPr');
+  const fontSize = runFontSizeFromDefRPr(defRPr);
+  const opts = defPPr ? extractParaOptions(defPPr, fontSize) : {};
+  if (fontSize != null) opts._defaultFontSize = fontSize;
+  if (bodyPr && attr(bodyPr, 'anchor')) {
+    // bodyPr anchor 不映射到 run
+  }
+  return opts;
+}
+
+/**
+ * @param {object|null|undefined} spcParent a:spcBef | a:spcAft | a:lnSpc
+ * @param {number|undefined} fontSizePt
+ * @returns {number|undefined} 点数
+ */
+function readSpacingPt(spcParent, fontSizePt) {
+  if (!spcParent) return undefined;
+  const spcPts = child(spcParent, 'a:spcPts');
+  if (spcPts) {
+    const val = attr(spcPts, 'val');
+    return val ? parseInt(val, 10) / 100 : undefined;
+  }
+  const spcPct = child(spcParent, 'a:spcPct');
+  if (spcPct && fontSizePt) {
+    const val = attr(spcPct, 'val');
+    if (!val) return undefined;
+    return (fontSizePt * parseInt(val, 10)) / 100000;
+  }
+  return undefined;
+}
+
+/**
+ * @param {object|null|undefined} pPr
+ * @param {number|undefined} [defaultFontSizePt]
+ */
+function extractParaOptions(pPr, defaultFontSizePt) {
+  if (!pPr) return {};
+  const node = pPr;
+  const opts = {};
+
+  const algn = attr(node, 'algn');
+  if (algn && PARA_ALIGN_MAP[algn]) opts.align = PARA_ALIGN_MAP[algn];
+
+  const lvl = attr(node, 'lvl');
+  if (lvl) opts.indentLevel = parseInt(lvl, 10);
+
+  const defRPr = child(node, 'a:defRPr');
+  const fontSize = runFontSizeFromDefRPr(defRPr) ?? defaultFontSizePt;
+
+  const spcBef = readSpacingPt(child(node, 'a:spcBef'), fontSize);
+  if (spcBef != null) opts.paraSpaceBefore = spcBef;
+
+  const spcAft = readSpacingPt(child(node, 'a:spcAft'), fontSize);
+  if (spcAft != null) opts.paraSpaceAfter = spcAft;
+
+  const lnSpc = readSpacingPt(child(node, 'a:lnSpc'), fontSize);
+  if (lnSpc != null) opts.lineSpacing = lnSpc;
+
+  return opts;
+}
+
+/**
+ * @param {object|null|undefined} pPr
+ */
+function extractBullet(pPr) {
+  if (!pPr) return null;
+  if (child(pPr, 'a:buChar')) return { bullet: true };
+  if (child(pPr, 'a:buAutoNum')) return { bullet: { type: 'number' } };
+  return null;
+}
+
+/**
+ * @param {object|null|undefined} rPr
+ * @param {Record<string, string>} scheme
+ * @param {{ relIndex?: import('./rels').RelationIndex, slidePath?: string }|null} linkCtx
+ */
+function extractRunOptions(rPr, scheme, linkCtx) {
+  const options = {};
+  let degraded = false;
+  if (!rPr) return options;
+
+  const sz = attr(rPr, 'sz');
+  if (sz) options.fontSize = parseInt(sz, 10) / 100;
+  if (attr(rPr, 'b') === '1') options.bold = true;
+  if (attr(rPr, 'i') === '1') options.italic = true;
+
+  const u = attr(rPr, 'u');
+  if (u && u !== 'none') options.underline = { style: 'sng' };
+
+  const face = attr(child(rPr, 'a:latin'), 'typeface');
+  if (face) options.fontFace = face;
+
+  const solid = child(rPr, 'a:solidFill');
+  const grad = child(rPr, 'a:gradFill');
+  if (grad) {
+    degraded = true;
+    const g = resolveFillColor(grad, scheme);
+    if (g.color) options.color = g.color;
+  } else if (solid) {
+    const c = resolveColorFromContainer(solid, scheme);
+    if (c) options.color = c;
+  }
+
+  const hlink = child(rPr, 'a:hlinkClick');
+  if (hlink && linkCtx) {
+    const relId = attr(hlink, 'r:id');
+    const url = relId && linkCtx.relIndex.resolve(linkCtx.slidePath, relId);
+    if (url) options.hyperlink = { url };
+  }
+
+  if (degraded) options._degraded = true;
+  return options;
+}
+
+module.exports = {
+  extractTextRuns,
+  extractParaOptions,
+  extractRunOptions,
+  readSpacingPt,
+};