@bendyline/squisq-formats 2.1.0 → 2.3.0

package/dist/{chunk-WQSHGBLN.js → chunk-G6J326JW.js}

@@ -1,10 +1,11 @@
 import {
   ConversionError
-} from "./chunk-ODL3SSPT.js";
+} from "./chunk-KXOZMWBS.js";
 import {
   ZipSafetyError,
-  openBoundedZipArchive
-} from "./chunk-FE6OJV6O.js";
+  openBoundedZipArchive,
+  resolveZipSafetyLimits
+} from "./chunk-7AWFHP5U.js";
 
 // src/registry/types.ts
 var BUILTIN_FORMAT_IDS = [
@@ -20,6 +21,84 @@ var BUILTIN_FORMAT_IDS = [
   "dbk"
 ];
 
+// src/registry/limits.ts
+var DEFAULT_CONVERSION_LIMITS = Object.freeze({
+  maxInputBytes: 256 * 1024 * 1024,
+  maxMarkdownBytes: 16 * 1024 * 1024,
+  maxMarkdownNodes: 25e4,
+  maxMarkdownDepth: 128,
+  maxTableCells: 1e5,
+  maxBlocks: 5e4,
+  maxBlockDepth: 128,
+  maxDurationSeconds: 24 * 60 * 60,
+  maxAudioSegments: 1e4
+});
+function resolveConversionLimits(limits) {
+  const resolved = { ...DEFAULT_CONVERSION_LIMITS, ...limits };
+  for (const [name, value] of Object.entries(resolved)) {
+    if (!Number.isSafeInteger(value) || value < 0) {
+      throw new RangeError(`${name} must be a non-negative safe integer`);
+    }
+  }
+  return resolved;
+}
+function markdownLimitsFromConversion(limits) {
+  if (limits === false) return false;
+  const resolved = resolveConversionLimits(limits);
+  return {
+    maxSourceBytes: resolved.maxMarkdownBytes,
+    maxNodes: resolved.maxMarkdownNodes,
+    maxDepth: resolved.maxMarkdownDepth,
+    maxTableCells: resolved.maxTableCells
+  };
+}
+function assertDocWithinConversionLimits(doc, limits, signal) {
+  if (limits === false) return;
+  const resolved = resolveConversionLimits(limits);
+  if (!Number.isFinite(doc.duration) || doc.duration < 0 || doc.duration > resolved.maxDurationSeconds) {
+    throw new RangeError(
+      `Document duration must be between 0 and ${resolved.maxDurationSeconds} seconds`
+    );
+  }
+  if (doc.audio.segments.length > resolved.maxAudioSegments) {
+    throw new RangeError(
+      `Document exceeds the ${resolved.maxAudioSegments}-audio-segment safety limit`
+    );
+  }
+  let audioDuration = 0;
+  for (const segment of doc.audio.segments) {
+    if (!Number.isFinite(segment.duration) || segment.duration < 0) {
+      throw new RangeError("Audio segment durations must be non-negative finite numbers");
+    }
+    audioDuration += segment.duration;
+    if (audioDuration > resolved.maxDurationSeconds) {
+      throw new RangeError(
+        `Narration exceeds the ${resolved.maxDurationSeconds}-second safety limit`
+      );
+    }
+  }
+  const stack = [];
+  for (let index = doc.blocks.length - 1; index >= 0; index--) {
+    stack.push({ block: doc.blocks[index], depth: 0 });
+  }
+  let count = 0;
+  while (stack.length > 0) {
+    if ((count & 1023) === 0) signal?.throwIfAborted();
+    const { block, depth } = stack.pop();
+    if (++count > resolved.maxBlocks) {
+      throw new RangeError(`Document exceeds the ${resolved.maxBlocks}-block safety limit`);
+    }
+    if (depth > resolved.maxBlockDepth) {
+      throw new RangeError(
+        `Document exceeds the ${resolved.maxBlockDepth}-level block nesting safety limit`
+      );
+    }
+    for (let index = (block.children?.length ?? 0) - 1; index >= 0; index--) {
+      stack.push({ block: block.children[index], depth: depth + 1 });
+    }
+  }
+}
+
 // src/shared/fidelity.ts
 var CONTENT_NODE_TYPES = {
   heading: true,
@@ -86,7 +165,7 @@ var PROFILE_LABELS = {
   pptx: "PPTX",
   epub: "EPUB"
 };
-function markdownFidelityWarnings(document2, profile) {
+function markdownFidelityWarnings(document, profile) {
   const supported = PROFILE_SUPPORT[profile];
   const omitted = /* @__PURE__ */ new Map();
   const visit = (candidate) => {
@@ -103,7 +182,7 @@ function markdownFidelityWarnings(document2, profile) {
       for (const child of node.children) visit(child);
     }
   };
-  for (const child of document2.children) visit(child);
+  for (const child of document.children) visit(child);
   if (omitted.size === 0) return [];
   const total = [...omitted.values()].reduce((sum, count) => sum + count, 0);
   const details = [...omitted].map(([type, count]) => `${type} (${count})`).join(", ");
@@ -142,17 +221,22 @@ function resolveThemeId(input, options) {
   return options.themeId ?? input.doc.themeId;
 }
 function optionsFor(options, id) {
-  return options.formatOptions?.[id] ?? {};
+  return {
+    ...options.formatOptions?.[id] ?? {},
+    ...options.signal ? { signal: options.signal } : {}
+  };
 }
 async function markdownOf(input) {
   if (input.markdownDoc) return input.markdownDoc;
   const { docToMarkdown } = await import("@bendyline/squisq/doc");
   return docToMarkdown(input.doc);
 }
-async function collectContainerImages(container) {
+async function collectContainerImages(container, signal) {
   const images = /* @__PURE__ */ new Map();
   const files = await container.listFiles();
-  for (const file of files) {
+  for (let index = 0; index < files.length; index++) {
+    if ((index & 63) === 0) signal?.throwIfAborted();
+    const file = files[index];
     if (!/\.(jpg|jpeg|png|gif|webp|svg|bmp|avif)$/i.test(file.path)) continue;
     const data = await container.readFile(file.path);
     if (!data) continue;
@@ -162,9 +246,9 @@ async function collectContainerImages(container) {
   }
   return images;
 }
-async function collectContainerDocxImages(container) {
-  const images = await collectContainerImages(container);
-  const { extToMime } = await import("./images-7FBWPKE3.js");
+async function collectContainerDocxImages(container, signal) {
+  const images = await collectContainerImages(container, signal);
+  const { extToMime } = await import("./images-ESPQKVTW.js");
   return new Map(
     [...images].map(([path, data]) => [
       path,
@@ -172,11 +256,13 @@ async function collectContainerDocxImages(container) {
     ])
   );
 }
-async function snapshotContainerWithDocument(input) {
+async function snapshotContainerWithDocument(input, signal) {
   const { MemoryContentContainer } = await import("@bendyline/squisq/storage");
   const snapshot = new MemoryContentContainer();
   const entries = await input.container.listFiles();
-  for (const entry of entries) {
+  for (let index = 0; index < entries.length; index++) {
+    if ((index & 63) === 0) signal?.throwIfAborted();
+    const entry = entries[index];
     const data = await input.container.readFile(entry.path);
     if (data) await snapshot.writeFile(entry.path, new Uint8Array(data), entry.mimeType);
   }
@@ -214,11 +300,21 @@ function defaultFormats() {
     extensions: [".md", ".markdown"],
     async importDoc(data, options) {
       const { parseMarkdown } = await import("@bendyline/squisq/markdown");
-      return parseMarkdown(new TextDecoder().decode(data), optionsFor(options, "md").parse);
+      const raw = optionsFor(options, "md").parse ?? {};
+      return parseMarkdown(new TextDecoder().decode(data), {
+        ...raw,
+        signal: options.signal,
+        limits: raw.limits ?? markdownLimitsFromConversion(options.limits)
+      });
     },
     async exportDoc(input, options) {
       const { stringifyMarkdown } = await import("@bendyline/squisq/markdown");
-      const text = stringifyMarkdown(await markdownOf(input), optionsFor(options, "md").stringify);
+      const raw = optionsFor(options, "md").stringify ?? {};
+      const text = stringifyMarkdown(await markdownOf(input), {
+        ...raw,
+        signal: options.signal,
+        limits: raw.limits ?? markdownLimitsFromConversion(options.limits)
+      });
       return ok(new TextEncoder().encode(text), MIME.md);
     }
   };
@@ -239,7 +335,7 @@ function defaultFormats() {
       const { markdownDocToDocx } = await import("./docx/index.js");
       const raw = optionsFor(options, "docx");
       const markdownDoc = await markdownOf(input);
-      const containerImages = await collectContainerDocxImages(input.container);
+      const containerImages = await collectContainerDocxImages(input.container, options.signal);
       const images = new Map([...containerImages, ...raw.images ?? /* @__PURE__ */ new Map()]);
       const buf = await markdownDocToDocx(markdownDoc, {
         ...raw,
@@ -268,13 +364,18 @@ function defaultFormats() {
       const { markdownDocToPdf } = await import("./pdf/index.js");
       const raw = optionsFor(options, "pdf");
       const markdownDoc = await markdownOf(input);
+      const pdfWarnings = [];
       const buf = await markdownDocToPdf(markdownDoc, {
         ...raw,
         ...options.title !== void 0 ? { title: options.title } : {},
         themeId: resolveThemeId(input, options),
-        themeRegistry: options.themeRegistry ?? raw.themeRegistry
+        themeRegistry: options.themeRegistry ?? raw.themeRegistry,
+        onWarning: (message) => pdfWarnings.push(message)
       });
-      return ok(await toBytes(buf), MIME.pdf, markdownFidelityWarnings(markdownDoc, "pdf"));
+      return ok(await toBytes(buf), MIME.pdf, [
+        ...markdownFidelityWarnings(markdownDoc, "pdf"),
+        ...pdfWarnings
+      ]);
     }
   };
   const pptx = {
@@ -294,7 +395,7 @@ function defaultFormats() {
       const { markdownDocToPptx } = await import("./pptx/index.js");
       const raw = optionsFor(options, "pptx");
       const markdownDoc = await markdownOf(input);
-      const containerImages = await collectContainerImages(input.container);
+      const containerImages = await collectContainerImages(input.container, options.signal);
       const images = new Map([...containerImages, ...raw.images ?? /* @__PURE__ */ new Map()]);
       const buf = await markdownDocToPptx(markdownDoc, {
         ...raw,
@@ -368,7 +469,7 @@ function defaultFormats() {
       const playerScript = await requirePlayerScript(options, "html");
       const { docToHtml } = await import("./html/index.js");
       const raw = optionsFor(options, "html");
-      const containerImages = await collectContainerImages(input.container);
+      const containerImages = await collectContainerImages(input.container, options.signal);
       const images = new Map([...containerImages, ...raw.images ?? /* @__PURE__ */ new Map()]);
       const htmlText = docToHtml(input.doc, {
         ...raw,
@@ -391,7 +492,7 @@ function defaultFormats() {
       const playerScript = await requirePlayerScript(options, "htmlzip");
       const { docToHtmlZip } = await import("./html/index.js");
       const raw = optionsFor(options, "htmlzip");
-      const containerImages = await collectContainerImages(input.container);
+      const containerImages = await collectContainerImages(input.container, options.signal);
       const images = new Map([...containerImages, ...raw.images ?? /* @__PURE__ */ new Map()]);
       const blob = await docToHtmlZip(input.doc, {
         ...raw,
@@ -414,7 +515,7 @@ function defaultFormats() {
       const { markdownDocToEpub } = await import("./epub/index.js");
       const raw = optionsFor(options, "epub");
       const markdownDoc = await markdownOf(input);
-      const containerImages = await collectContainerImages(input.container);
+      const containerImages = await collectContainerImages(input.container, options.signal);
       const images = new Map([...containerImages, ...raw.images ?? /* @__PURE__ */ new Map()]);
       const buf = await markdownDocToEpub(markdownDoc, {
         ...raw,
@@ -438,7 +539,7 @@ function defaultFormats() {
     async exportDoc(input, options) {
       const { containerToZip } = await import("./container/index.js");
       const blob = await containerToZip(
-        await snapshotContainerWithDocument(input),
+        await snapshotContainerWithDocument(input, options.signal),
         optionsFor(options, "dbk")
       );
       return ok(await toBytes(blob), MIME.zip);
@@ -485,6 +586,22 @@ function defaultRegistry() {
 function markdownFormatOptions(options) {
   return options.formatOptions?.md ?? {};
 }
+function parseOptions(options) {
+  const raw = markdownFormatOptions(options).parse ?? {};
+  return {
+    ...raw,
+    signal: options.signal,
+    limits: raw.limits ?? markdownLimitsFromConversion(options.limits)
+  };
+}
+function stringifyOptions(options) {
+  const raw = markdownFormatOptions(options).stringify ?? {};
+  return {
+    ...raw,
+    signal: options.signal,
+    limits: raw.limits ?? markdownLimitsFromConversion(options.limits)
+  };
+}
 function throwIfAborted(signal) {
   if (!signal?.aborted) return;
   if (signal.reason !== void 0) throw signal.reason;
@@ -501,11 +618,26 @@ function hasPrefix(bytes, prefix) {
 }
 var ZIP_MAGIC = [80, 75, 3, 4];
 var PDF_MAGIC = [37, 80, 68, 70];
-async function sniffZip(bytes) {
-  const archive = await openBoundedZipArchive(bytes).catch((cause) => {
-    if (cause instanceof ZipSafetyError && cause.code !== "invalid-archive") throw cause;
-    throw new ConversionError("invalid-input", "Input is not a readable ZIP archive.", { cause });
-  });
+var ZIP_SNIFF_CANDIDATES = ["docx", "pptx", "xlsx", "dbk"];
+function sniffZipLimits(options) {
+  const effective = ZIP_SNIFF_CANDIDATES.map(
+    (id) => resolveZipSafetyLimits(options.formatOptions?.[id] ?? {})
+  );
+  return {
+    signal: options.signal,
+    maxEntries: Math.max(...effective.map((l) => l.maxEntries)),
+    maxUncompressedBytes: Math.max(...effective.map((l) => l.maxUncompressedBytes)),
+    maxEntryUncompressedBytes: Math.max(...effective.map((l) => l.maxEntryUncompressedBytes)),
+    maxCompressionRatio: Math.max(...effective.map((l) => l.maxCompressionRatio))
+  };
+}
+async function sniffZip(bytes, options) {
+  const archive = await openBoundedZipArchive(bytes, sniffZipLimits(options)).catch(
+    (cause) => {
+      if (cause instanceof ZipSafetyError && cause.code !== "invalid-archive") throw cause;
+      throw new ConversionError("invalid-input", "Input is not a readable ZIP archive.", { cause });
+    }
+  );
   const contentTypes = archive.entries.find((entry) => entry.path === "[Content_Types].xml");
   if (!contentTypes) return "dbk";
   const maxContentTypesBytes = 1024 * 1024;
@@ -528,7 +660,7 @@ async function detectByteFormat(bytes, filename, options, registry) {
     if (byExt) return byExt.id;
   }
   if (hasPrefix(bytes, PDF_MAGIC)) return "pdf";
-  if (hasPrefix(bytes, ZIP_MAGIC)) return sniffZip(bytes);
+  if (hasPrefix(bytes, ZIP_MAGIC)) return sniffZip(bytes, options);
   return "md";
 }
 function extractExt(filename) {
@@ -546,6 +678,12 @@ function baseNameOf(filename) {
 }
 async function normalizeBytes(source, options, registry) {
   const bytes = source.data instanceof Uint8Array ? source.data : new Uint8Array(source.data);
+  if (options.limits !== false && bytes.byteLength > resolveConversionLimits(options.limits).maxInputBytes) {
+    throw new ConversionError(
+      "invalid-input",
+      `Input exceeds the ${resolveConversionLimits(options.limits).maxInputBytes}-byte safety limit.`
+    );
+  }
   const buffer = bytes.buffer.slice(
     bytes.byteOffset,
     bytes.byteOffset + bytes.byteLength
@@ -574,21 +712,23 @@ async function normalizeBytes(source, options, registry) {
   let container;
   if (fromDef.importContainer) {
     container = await fromDef.importContainer(buffer, options);
-    if (fromDef.id === "pdf" && typeof document === "undefined") {
-      warnings.push(
-        "PDF embedded images were skipped \u2014 image decoding requires a browser canvas (running under Node)."
-      );
-    }
     const text = await container.readDocument();
-    markdownDoc = text ? parseMarkdown(text, markdownFormatOptions(options).parse) : { type: "document", children: [] };
+    markdownDoc = text ? parseMarkdown(text, parseOptions(options)) : { type: "document", children: [] };
   } else {
     markdownDoc = await fromDef.importDoc(buffer, options);
     const { MemoryContentContainer } = await import("@bendyline/squisq/storage");
     const mem = new MemoryContentContainer();
-    await mem.writeDocument(stringifyMarkdown(markdownDoc));
+    await mem.writeDocument(stringifyMarkdown(markdownDoc, stringifyOptions(options)));
     container = mem;
   }
+  const { assertMarkdownDocumentWithinLimits } = await import("@bendyline/squisq/markdown");
+  assertMarkdownDocumentWithinLimits(
+    markdownDoc,
+    markdownLimitsFromConversion(options.limits),
+    options.signal
+  );
   const doc = markdownToDoc(markdownDoc, { autoTemplates: options.autoTemplates });
+  assertDocWithinConversionLimits(doc, options.limits, options.signal);
   const baseName = source.filename ? baseNameOf(source.filename) : "document";
   return {
     input: { doc, markdownDoc, container, baseName },
@@ -599,26 +739,36 @@ async function normalizeMarkdown(source, options) {
   const { markdownToDoc } = await import("@bendyline/squisq/doc");
   const { parseMarkdown } = await import("@bendyline/squisq/markdown");
   const { stringifyMarkdown } = await import("@bendyline/squisq/markdown");
-  const markdownDoc = typeof source.markdown === "string" ? parseMarkdown(source.markdown, markdownFormatOptions(options).parse) : source.markdown;
+  const markdownDoc = typeof source.markdown === "string" ? parseMarkdown(source.markdown, parseOptions(options)) : source.markdown;
+  const { assertMarkdownDocumentWithinLimits } = await import("@bendyline/squisq/markdown");
+  assertMarkdownDocumentWithinLimits(
+    markdownDoc,
+    markdownLimitsFromConversion(options.limits),
+    options.signal
+  );
   let container = source.container;
   if (!container) {
     const { MemoryContentContainer } = await import("@bendyline/squisq/storage");
     const mem = new MemoryContentContainer();
-    await mem.writeDocument(stringifyMarkdown(markdownDoc));
+    await mem.writeDocument(stringifyMarkdown(markdownDoc, stringifyOptions(options)));
     container = mem;
   }
   const doc = markdownToDoc(markdownDoc, { autoTemplates: options.autoTemplates });
+  assertDocWithinConversionLimits(doc, options.limits, options.signal);
   const baseName = source.baseName ?? "document";
   return { input: { doc, markdownDoc, container, baseName }, warnings: [] };
 }
-async function normalizeDoc(source) {
+async function normalizeDoc(source, options) {
+  assertDocWithinConversionLimits(source.doc, options.limits, options.signal);
   let container = source.container;
   if (!container) {
     const { MemoryContentContainer } = await import("@bendyline/squisq/storage");
     const { docToMarkdown } = await import("@bendyline/squisq/doc");
     const { stringifyMarkdown } = await import("@bendyline/squisq/markdown");
     const mem = new MemoryContentContainer();
-    await mem.writeDocument(stringifyMarkdown(docToMarkdown(source.doc)));
+    await mem.writeDocument(
+      stringifyMarkdown(docToMarkdown(source.doc), stringifyOptions(options))
+    );
     container = mem;
   }
   const baseName = source.baseName ?? "document";
@@ -631,7 +781,7 @@ async function normalize(source, options, registry) {
     case "markdown":
       return normalizeMarkdown(source, options);
     case "doc":
-      return normalizeDoc(source);
+      return normalizeDoc(source, options);
   }
 }
 async function applyTransformStyle(input, transformStyle, themeId, registry) {
@@ -758,10 +908,11 @@ async function convert(source, to, options = {}) {
 
 export {
   BUILTIN_FORMAT_IDS,
+  DEFAULT_CONVERSION_LIMITS,
+  resolveConversionLimits,
   defaultFormats,
   createRegistry,
   defaultRegistry,
   prepareConversion,
   convert
 };
-//# sourceMappingURL=chunk-WQSHGBLN.js.map

package/dist/chunk-GX7RAUME.js

@@ -0,0 +1,121 @@
+import {
+  stripHtmlTags
+} from "./chunk-SBUW7NHR.js";
+
+// src/ooxml/relIds.ts
+var RelIdAllocator = class {
+  constructor() {
+    /** part path → next free numeric suffix */
+    this.next = /* @__PURE__ */ new Map();
+  }
+  /**
+   * Allocate the next free relationship id for `part`'s rels file.
+   *
+   * @param part - Zip path of the part that owns the relationship
+   *   (e.g. `"word/document.xml"`). Use `""` for the package root.
+   *   Ids are only unique per `part`, which is exactly the OOXML rule.
+   */
+  alloc(part = "") {
+    const n = this.next.get(part) ?? 1;
+    this.next.set(part, n + 1);
+    return `rId${n}`;
+  }
+};
+
+// src/shared/ooxmlColor.ts
+var HEX3_RE = /^#?([0-9a-fA-F])([0-9a-fA-F])([0-9a-fA-F])$/;
+var HEX6_RE = /^#?([0-9a-fA-F]{6})$/;
+var HEX8_RE = /^#?([0-9a-fA-F]{6})[0-9a-fA-F]{2}$/;
+function toOoxmlHex(color, fallback = "000000") {
+  const normalized = normalizeOoxmlHex(color);
+  if (normalized) return normalized;
+  return normalizeOoxmlHex(fallback) ?? "000000";
+}
+function normalizeOoxmlHex(color) {
+  if (typeof color !== "string") return void 0;
+  const trimmed = color.trim();
+  const six = HEX6_RE.exec(trimmed);
+  if (six) return six[1].toUpperCase();
+  const eight = HEX8_RE.exec(trimmed);
+  if (eight) return eight[1].toUpperCase();
+  const three = HEX3_RE.exec(trimmed);
+  if (three) {
+    const [, r, g, b] = three;
+    return `${r}${r}${g}${g}${b}${b}`.toUpperCase();
+  }
+  return void 0;
+}
+
+// src/shared/officeHyperlinks.ts
+import { sanitizeUrl } from "@bendyline/squisq/markdown";
+function sanitizeOfficeHyperlink(input, policy = {}) {
+  if (typeof input !== "string") return null;
+  const value = input.trim();
+  if (!value || hasControls(value)) return null;
+  if (value.startsWith("#")) return /^#[^\s]*$/.test(value) ? value : null;
+  if (/^(?:\\\\|\/\/|\/|[a-z]:[\\/])/i.test(value)) return null;
+  const hasScheme = /^[a-z][a-z0-9+.-]*:/i.test(value);
+  if (hasScheme) return sanitizeUrl(value);
+  if (!policy.allowRelative || value.includes("\\")) return null;
+  let decoded;
+  try {
+    decoded = decodeURIComponent(value);
+  } catch {
+    return null;
+  }
+  if (hasControls(decoded) || decoded.includes("\\") || decoded.startsWith("//")) return null;
+  return value;
+}
+function hasControls(value) {
+  for (const char of value) {
+    const code = char.charCodeAt(0);
+    if (code <= 31 || code === 127) return true;
+  }
+  return false;
+}
+
+// src/shared/inlineRuns.ts
+function inlineNodesToRuns(nodes, handlers, format = {}) {
+  let out = "";
+  for (const node of nodes) {
+    out += inlineNodeToRuns(node, handlers, format);
+  }
+  return out;
+}
+function inlineNodeToRuns(node, handlers, format) {
+  switch (node.type) {
+    case "text":
+      return handlers.run(node.value, format);
+    case "strong":
+      return inlineNodesToRuns(node.children, handlers, { ...format, bold: true });
+    case "emphasis":
+      return inlineNodesToRuns(node.children, handlers, { ...format, italic: true });
+    case "delete":
+      return inlineNodesToRuns(node.children, handlers, { ...format, strike: true });
+    case "inlineCode":
+      return handlers.run(node.value, { ...format, code: true });
+    case "inlineMath":
+      return handlers.run(node.value, { ...format, code: true });
+    case "htmlInline":
+      return handlers.run(stripHtmlTags(node.rawHtml), format);
+    case "link":
+      return handlers.link(node, format);
+    case "image":
+      return handlers.image(node, format);
+    case "break":
+      return handlers.lineBreak();
+    case "footnoteReference":
+      return handlers.footnoteRef ? handlers.footnoteRef(node) : "";
+    default:
+      return "";
+  }
+}
+
+export {
+  RelIdAllocator,
+  toOoxmlHex,
+  normalizeOoxmlHex,
+  sanitizeOfficeHyperlink,
+  inlineNodesToRuns,
+  inlineNodeToRuns
+};