@json-to-office/core-docx 7.5.1 → 7.6.4

package/dist/plugin/example/index.js

@@ -1666,6 +1666,46 @@ var init_themes = __esm({
   }
 });
 
+// src/utils/generationContext.ts
+import { AsyncLocalStorage } from "async_hooks";
+import { isAbsolute, resolve } from "path";
+function runWithBaseDir(baseDir, callback) {
+  return baseDir === void 0 ? callback() : baseDirStorage.run(resolve(baseDir), callback);
+}
+function getBaseDir() {
+  return baseDirStorage.getStore();
+}
+function resolveFromBaseDir(filePath) {
+  const base = baseDirStorage.getStore();
+  if (!base || isAbsolute(filePath)) return filePath;
+  return resolve(base, filePath);
+}
+function runWithWarnings(warnings, callback) {
+  return warnings === void 0 ? callback() : warningsStorage.run(warnings, callback);
+}
+function reportWarning(component, code, message, context) {
+  const warnings = warningsStorage.getStore();
+  if (warnings) {
+    warnings.push({
+      component,
+      message,
+      severity: "warning",
+      context: { code, ...context }
+    });
+    return;
+  }
+  console.warn(`[json-to-docx] [${code}] ${message}`);
+}
+var generationDateStorage, baseDirStorage, warningsStorage;
+var init_generationContext = __esm({
+  "src/utils/generationContext.ts"() {
+    "use strict";
+    generationDateStorage = new AsyncLocalStorage();
+    baseDirStorage = new AsyncLocalStorage();
+    warningsStorage = new AsyncLocalStorage();
+  }
+});
+
 // src/styles/utils/colorUtils.ts
 import {
   DEFAULT_CHART_THEME_COLORS,
@@ -2419,43 +2459,6 @@ var init_widthUtils = __esm({
   }
 });
 
-// src/utils/generationContext.ts
-import { AsyncLocalStorage } from "async_hooks";
-import { isAbsolute, resolve } from "path";
-function runWithBaseDir(baseDir, callback) {
-  return baseDir === void 0 ? callback() : baseDirStorage.run(resolve(baseDir), callback);
-}
-function resolveFromBaseDir(filePath) {
-  const base = baseDirStorage.getStore();
-  if (!base || isAbsolute(filePath)) return filePath;
-  return resolve(base, filePath);
-}
-function runWithWarnings(warnings, callback) {
-  return warnings === void 0 ? callback() : warningsStorage.run(warnings, callback);
-}
-function reportWarning(component, code, message, context) {
-  const warnings = warningsStorage.getStore();
-  if (warnings) {
-    warnings.push({
-      component,
-      message,
-      severity: "warning",
-      context: { code, ...context }
-    });
-    return;
-  }
-  console.warn(`[json-to-docx] [${code}] ${message}`);
-}
-var generationDateStorage, baseDirStorage, warningsStorage;
-var init_generationContext = __esm({
-  "src/utils/generationContext.ts"() {
-    "use strict";
-    generationDateStorage = new AsyncLocalStorage();
-    baseDirStorage = new AsyncLocalStorage();
-    warningsStorage = new AsyncLocalStorage();
-  }
-});
-
 // src/utils/imageUtils.ts
 import { readFileSync } from "fs";
 import { availableParallelism } from "os";
@@ -4237,6 +4240,8 @@ var init_normalizeTextCase = __esm({
 
 // src/utils/packageDocument.ts
 import AdmZip from "adm-zip";
+import { createHash as createHash3 } from "crypto";
+import { posix } from "path";
 function resolveGenerationDate(options) {
   if (options?.generatedAt !== void 0) {
     const date = new Date(options.generatedAt);
@@ -4304,6 +4309,70 @@ function canonicalizeRelationshipIds(zip) {
     if (entry) zip.updateFile(entry, Buffer.from(update.xml, "utf8"));
   }
 }
+function xorFontKey(bytes, guid) {
+  const key = Buffer.from(guid.replace(/-/g, ""), "hex").reverse();
+  const out = Buffer.from(bytes);
+  for (let i = 0; i < Math.min(32, out.length); i++) out[i] ^= key[i % 16];
+  return out;
+}
+function canonicalizeEmbeddedFontKeys(zip) {
+  const table2 = zip.getEntry("word/fontTable.xml");
+  if (!table2) return;
+  const xml = table2.getData().toString("utf8");
+  const embeds = [...xml.matchAll(FONT_EMBED)].flatMap(([element]) => {
+    const id = /\br:id="([^"]+)"/.exec(element)?.[1];
+    const key = /\bw:fontKey="\{([0-9A-Fa-f-]{36})\}"/.exec(element)?.[1];
+    return id && key ? [{ id, key }] : [];
+  });
+  if (embeds.length === 0) return;
+  const rels = zip.getEntry("word/_rels/fontTable.xml.rels")?.getData().toString("utf8") ?? "";
+  const targets = /* @__PURE__ */ new Map();
+  for (const [relationship] of rels.matchAll(/<Relationship\b[^>]*>/g)) {
+    const id = /\bId="([^"]+)"/.exec(relationship)?.[1];
+    const target = /\bTarget="([^"]+)"/.exec(relationship)?.[1];
+    if (id && target) targets.set(id, target);
+  }
+  const rekey = /* @__PURE__ */ new Map();
+  const parts = [];
+  for (const { id, key } of embeds) {
+    const target = targets.get(id);
+    if (!target) continue;
+    const name = target.startsWith("/") ? target.slice(1) : posix.normalize(posix.join("word", target));
+    const part = zip.getEntry(name);
+    if (!part) continue;
+    const font = xorFontKey(part.getData(), key);
+    const hex = createHash3("sha256").update(font).digest("hex").slice(0, 32).toUpperCase();
+    const fresh = [
+      hex.slice(0, 8),
+      hex.slice(8, 12),
+      hex.slice(12, 16),
+      hex.slice(16, 20),
+      hex.slice(20)
+    ].join("-");
+    rekey.set(key.toUpperCase(), fresh);
+    parts.push({ name, data: xorFontKey(font, fresh) });
+  }
+  if (rekey.size === 0) return;
+  for (const { name, data } of parts) {
+    const entry = zip.getEntry(name);
+    if (entry) zip.updateFile(entry, data);
+  }
+  const fontTable = zip.getEntry("word/fontTable.xml");
+  if (!fontTable) return;
+  zip.updateFile(
+    fontTable,
+    Buffer.from(
+      xml.replace(
+        /\bw:fontKey="\{([0-9A-Fa-f-]{36})\}"/g,
+        (whole, key) => {
+          const fresh = rekey.get(key.toUpperCase());
+          return fresh ? `w:fontKey="{${fresh}}"` : whole;
+        }
+      ),
+      "utf8"
+    )
+  );
+}
 function canonicalizeEmbeddedPackages(zip, generatedAt, depth = 1) {
   const names = zip.getEntries().map((entry) => entry.entryName).filter((name) => EMBEDDED_OFFICE_PACKAGE.test(name));
   let changed = false;
@@ -4356,6 +4425,7 @@ function canonicalizeDocxBuffer(buffer, generatedAt = DEFAULT_GENERATION_DATE) {
   normalizeTextCase(zip);
   canonicalizeRelationshipIds(zip);
   canonicalizeEmbeddedPackages(zip, generatedAt);
+  canonicalizeEmbeddedFontKeys(zip);
   const isoTimestamp = generatedAt.toISOString();
   const coreProperties3 = zip.getEntry("docProps/core.xml");
   if (coreProperties3) {
@@ -4372,13 +4442,14 @@ function normalizeDocxCaseBuffer(buffer) {
   const zip = new AdmZip(buffer);
   return normalizeTextCase(zip) ? zip.toBuffer() : buffer;
 }
-var DEFAULT_GENERATION_DATE, STABLE_RELATIONSHIP_ID, CORE_TIMESTAMP, EMBEDDED_OFFICE_PACKAGE, MAX_EMBEDDED_DEPTH;
+var DEFAULT_GENERATION_DATE, STABLE_RELATIONSHIP_ID, FONT_EMBED, CORE_TIMESTAMP, EMBEDDED_OFFICE_PACKAGE, MAX_EMBEDDED_DEPTH;
 var init_packageDocument = __esm({
   "src/utils/packageDocument.ts"() {
     "use strict";
     init_normalizeTextCase();
     DEFAULT_GENERATION_DATE = /* @__PURE__ */ new Date("2000-01-01T00:00:00.000Z");
     STABLE_RELATIONSHIP_ID = /^rId\d+$/;
+    FONT_EMBED = /<w:embed(?:Regular|Bold|Italic|BoldItalic)\b[^>]*>/g;
     CORE_TIMESTAMP = /(<dcterms:(?:created|modified)\b[^>]*>)[^<]*(<\/dcterms:(?:created|modified)>)/g;
     EMBEDDED_OFFICE_PACKAGE = /\.(?:docx|pptx|xlsx|xlsm)$/i;
     MAX_EMBEDDED_DEPTH = 3;
@@ -4979,7 +5050,12 @@ function createDocxJsRenderer() {
         });
       }
       const pageNumbers = needsPageNumbers(ir) ? await createPageNumberEstimator(ir) : void 0;
-      const document = buildDocument(ir, resources, pageNumbers);
+      const document = buildDocument(
+        ir,
+        resources,
+        pageNumbers,
+        renderOptions?.embeddedFonts
+      );
       const packed = await Packer.toBuffer(document);
       const fixed = fixFloatingImageIdsInBuffer(packed);
       const repaired = markers ? repairDrawingGroupsInBuffer(fixed, markers) : fixed;
@@ -4997,10 +5073,17 @@ function createDocxJsRenderer() {
     }
   };
 }
-function buildDocument(ir, resources = /* @__PURE__ */ new Map(), pageNumbers) {
+function buildDocument(ir, resources = /* @__PURE__ */ new Map(), pageNumbers, embeddedFonts) {
   return new Document({
     ...pageNumbers ? { pageNumbers } : {},
     styles: emitStyles(ir.styles),
+    // word/fonts/font<N>.odttf, their `w:embed*` entries in the font table and
+    // `w:embedTrueTypeFonts` in the settings, all from this one key. Passed
+    // only when a face embeds, so a document in any other mode is built from
+    // exactly the options it always was. `docx/layout` measures the text of an
+    // embedded family from these files, so a contents field's page numbers
+    // need nothing more.
+    ...embeddedFonts && embeddedFonts.length > 0 ? { fonts: embeddedFonts.map(fontOptions) } : {},
     ...ir.theme ? { theme: themeOptions(ir.theme) } : {},
     sections: ir.sections.map((section2) => sectionOptions(section2, resources)),
     ...coreProperties(ir),
@@ -5031,6 +5114,15 @@ function buildDocument(ir, resources = /* @__PURE__ */ new Map(), pageNumbers) {
     } : {}
   });
 }
+function fontOptions(face) {
+  return {
+    name: face.family,
+    data: face.regular,
+    ...face.bold ? { bold: face.bold } : {},
+    ...face.italic ? { italic: face.italic } : {},
+    ...face.boldItalic ? { boldItalic: face.boldItalic } : {}
+  };
+}
 function themeOptions(theme) {
   const colors = {};
   for (const [slot, color] of Object.entries(theme.colors)) {
@@ -7251,6 +7343,7 @@ async function exportPluginSchema(customComponents, outputPath, options = {}) {
 import { assertRendererSupports } from "@json-to-office/shared/rendering";
 
 // src/core/fontResolution.ts
+init_generationContext();
 import {
   collectFontNamesFromDocx,
   validateFontReferences,
@@ -7304,8 +7397,14 @@ async function resolveDocumentFonts(document, theme, fonts, warnings, forceMater
   if (!fonts?.onResolved && !forceMaterialize) return [];
   const registry2 = new FontRegistry({
     // Spread keeps baseDir/googleFonts/mode/substitution intact for
-    // materializeSource; extraEntries carries the merged registry.
-    opts: { ...fonts, extraEntries: registryEntries },
+    // materializeSource; extraEntries carries the merged registry. Without a
+    // `fonts.baseDir` of its own, kind:"file" sources resolve against the
+    // render's baseDir, as images do — not against process.cwd().
+    opts: {
+      ...fonts,
+      baseDir: fonts?.baseDir ?? getBaseDir(),
+      extraEntries: registryEntries
+    },
     fileLoader: loadFileFontSource,
     variableLoader: fetchVariableFontSource,
     diskCache: fonts?.googleFonts?.cacheDir ? new FontDiskCache(fonts.googleFonts.cacheDir) : void 0
@@ -7326,6 +7425,67 @@ import {
   toRasterizeFontFaces
 } from "@json-to-office/shared/fonts/node";
 
+// src/core/fontEmbedding.ts
+import { isSafeFont } from "@json-to-office/shared";
+import {
+  toEmbeddedFontFaces
+} from "@json-to-office/shared/fonts/node";
+
+// src/renderers/types.ts
+import {
+  DEFAULT_DOCX_RENDERER_ID
+} from "@json-to-office/shared-docx";
+
+// src/core/fontEmbedding.ts
+var EMBEDDING_RENDERER = "docxjs";
+var warning = (code, message) => ({
+  component: "fontRegistry",
+  message,
+  severity: "warning",
+  context: { code }
+});
+function embedsFonts(fonts, renderer, warnings) {
+  if (fonts?.mode !== "embed") return false;
+  const id = renderer ?? DEFAULT_DOCX_RENDERER_ID;
+  if (id === EMBEDDING_RENDERER) return true;
+  warnings.push(
+    warning(
+      "FONT_EMBED_UNSUPPORTED_RENDERER",
+      `Export mode "embed" needs the ${EMBEDDING_RENDERER} renderer; the ${id} renderer does not embed fonts, so references are kept as in custom mode and nothing is embedded.`
+    )
+  );
+  return false;
+}
+function selectEmbeddedFonts(resolved, warnings) {
+  const { faces, report } = toEmbeddedFontFaces(resolved, warnings);
+  const summary = embedSummary(resolved, report);
+  if (summary) warnings.push(warning("FONT_MODE_EMBED", summary));
+  return faces;
+}
+function embedSummary(resolved, report) {
+  const byFamily = new Map(report.map((r) => [r.family.toLowerCase(), r]));
+  const seen = /* @__PURE__ */ new Set();
+  const lines = [];
+  for (const font of resolved) {
+    const key = font.family.toLowerCase();
+    if (isSafeFont(font.family.trim()) || seen.has(key)) continue;
+    seen.add(key);
+    const entry = byFamily.get(key);
+    if (!entry) {
+      lines.push(`${font.family}: not embedded (unresolved)`);
+    } else if (entry.slots.length === 0) {
+      lines.push(
+        `${font.family}: not embedded (${entry.reason === "no-regular-face" ? "no regular face" : "no TTF/OTF face it may embed"})`
+      );
+    } else {
+      const nearest = entry.nearest.length ? ` (${entry.nearest.map((n) => `${n.slot} \u2190 ${n.weight}`).join(", ")})` : "";
+      lines.push(`${font.family}: ${entry.slots.join(", ")}${nearest}`);
+    }
+  }
+  if (lines.length === 0) return void 0;
+  return `Export mode "embed": ${lines.join("; ")}. Readers without these fonts installed see the embedded faces; any face or family not embedded stays a reference, as in custom mode.`;
+}
+
 // src/core/prerasterizeVisuals.ts
 import {
   clampVisualDpi,
@@ -7797,7 +7957,7 @@ function assertExportServerAllowed(serverUrl, servicesConfig, warnings) {
   const notice = remoteExportNotice(serverUrl, servicesConfig?.allowRemote);
   if (!notice || !warnings) return;
   const alreadySaid = warnings.some(
-    (warning) => warning.context?.code === REMOTE_EXPORT_WARNING && warning.context?.serverUrl === serverUrl
+    (warning2) => warning2.context?.code === REMOTE_EXPORT_WARNING && warning2.context?.serverUrl === serverUrl
   );
   if (alreadySaid) return;
   warnings.push({
@@ -13843,13 +14003,6 @@ function warnOnce(ctx, component, message, code) {
 import {
   RendererRegistry
 } from "@json-to-office/shared/rendering";
-
-// src/renderers/types.ts
-import {
-  DEFAULT_DOCX_RENDERER_ID
-} from "@json-to-office/shared-docx";
-
-// src/renderers/registry.ts
 var registry = new RendererRegistry(
   "docx",
   DEFAULT_DOCX_RENDERER_ID
@@ -16302,13 +16455,15 @@ async function compileDocumentScoped(document, options, warnings) {
   const { context } = prepared.model;
   const hasVisual = collectVisualProps(context.document).length > 0;
   const hasHighcharts = containsComponent(context.document, "highcharts");
+  const embedding = embedsFonts(options.fonts, options.renderer, warnings);
   const resolvedFonts = await resolveDocumentFonts(
     context.document,
     context.theme,
     options.fonts,
     warnings,
-    hasVisual || hasHighcharts
+    hasVisual || hasHighcharts || embedding
   );
+  const embeddedFonts = embedding ? selectEmbeddedFonts(resolvedFonts, warnings) : [];
   const visualFonts = hasVisual ? toRasterizeFontFaces(resolvedFonts, warnings) : [];
   const chartFonts = hasHighcharts ? toChartFontFaces(resolvedFonts) : [];
   const desugared = await desugarExternals(context.document, {
@@ -16348,7 +16503,8 @@ async function compileDocumentScoped(document, options, warnings) {
     theme: context.theme,
     warnings: compiled.warnings,
     required: compiled.required,
-    unsupported: compiled.unsupported
+    unsupported: compiled.unsupported,
+    embeddedFonts
   };
 }
 async function generateBufferViaIr(document, options = {}) {
@@ -16372,6 +16528,7 @@ async function renderScoped(document, options, warnings) {
     ...options.deterministic !== void 0 ? { deterministic: options.deterministic } : {},
     ...options.generatedAt !== void 0 ? { generatedAt: toDate(options.generatedAt) } : {},
     ...options.svgRasterFallback !== void 0 ? { svgRasterFallback: options.svgRasterFallback } : {},
+    ...compiled.embeddedFonts.length > 0 ? { embeddedFonts: compiled.embeddedFonts } : {},
     warnings: compiled.warnings
   });
   return { buffer: Buffer.from(bytes), warnings: compiled.warnings };
@@ -17368,10 +17525,10 @@ async function runPluginDemo() {
     if (result.warnings && result.warnings.length > 0) {
       console.log(`
 \u26A0\uFE0F  ${result.warnings.length} warning(s) generated:`);
-      result.warnings.forEach((warning) => {
-        console.log(`  - [${warning.component}] ${warning.message}`);
-        if (warning.context) {
-          console.log(`    Context: ${JSON.stringify(warning.context)}`);
+      result.warnings.forEach((warning2) => {
+        console.log(`  - [${warning2.component}] ${warning2.message}`);
+        if (warning2.context) {
+          console.log(`    Context: ${JSON.stringify(warning2.context)}`);
         }
       });
     }