@wonderwhy-er/desktop-commander 0.2.35 → 0.2.36

package/README.md

@@ -16,6 +16,8 @@ Work with code and text, run processes, and automate tasks, going far beyond oth
   <img width="380" height="200" src="https://glama.ai/mcp/servers/zempur9oh4/badge" alt="Desktop Commander MCP" />
 </a>
 
+## 👋 We’re hiring — come build with us: https://desktopcommander.app/careers/
+
 ## Table of Contents
 - [Features](#features)
 - [How to install](#how-to-install)

package/dist/handlers/filesystem-handlers.js

@@ -3,11 +3,34 @@ import { withTimeout } from '../utils/withTimeout.js';
 import { createErrorResponse } from '../error-handlers.js';
 import { configManager } from '../config-manager.js';
 import { ReadFileArgsSchema, ReadMultipleFilesArgsSchema, WriteFileArgsSchema, CreateDirectoryArgsSchema, ListDirectoryArgsSchema, MoveFileArgsSchema, GetFileInfoArgsSchema, WritePdfArgsSchema } from '../tools/schemas.js';
+import path from 'path';
+import os from 'os';
+import { buildUiToolMeta, FILE_PREVIEW_RESOURCE_URI } from '../ui/contracts.js';
+import { resolvePreviewFileType } from '../ui/file-preview/shared/preview-file-types.js';
+/**
+ * Expand home directory (~) in a file path
+ */
+function expandHome(filePath) {
+    if (filePath === '~' || filePath.startsWith('~/') || filePath.startsWith(`~${path.sep}`)) {
+        return path.join(os.homedir(), filePath.slice(1));
+    }
+    return filePath;
+}
+/**
+ * Resolve a file path to an absolute path for use in structured content.
+ * This ensures "Open in folder" always has a valid absolute path.
+ */
+function resolveAbsolutePath(filePath) {
+    const expanded = expandHome(filePath);
+    return path.isAbsolute(expanded)
+        ? path.resolve(expanded)
+        : path.resolve(process.cwd(), expanded);
+}
 /**
  * Helper function to check if path contains an error
  */
-function isErrorPath(path) {
-    return path.startsWith('__ERROR__:');
+function isErrorPath(filePath) {
+    return filePath.startsWith('__ERROR__:');
 }
 /**
  * Extract error message from error path
@@ -44,6 +67,10 @@ export async function handleReadFile(args) {
             sheet: sheetParam,
             range: parsed.range
         };
+        // Resolve to absolute path for local files (not URLs) so "Open in folder" works
+        const resolvedFilePath = parsed.isUrl
+            ? parsed.path
+            : resolveAbsolutePath(parsed.path);
         const fileResult = await readFile(parsed.path, options);
         // Handle PDF files
         if (fileResult.metadata?.isPdf) {
@@ -68,28 +95,40 @@ export async function handleReadFile(args) {
                         text: `PDF file: ${parsed.path}${author}${title} (${meta?.totalPages} pages) \n`
                     },
                     ...pdfContent
-                ]
+                ],
+                structuredContent: {
+                    fileName: path.basename(resolvedFilePath),
+                    filePath: resolvedFilePath,
+                    fileType: 'unsupported',
+                    content: ''
+                },
+                _meta: buildUiToolMeta(FILE_PREVIEW_RESOURCE_URI, true)
             };
         }
         // Handle image files
         if (fileResult.metadata?.isImage) {
-            // For image files, return as an image content type
-            // Content should already be base64-encoded string from handler
+            // For image files, keep content payload text-only for broad host compatibility.
+            // The preview widget reads image bytes from structuredContent.
             const imageData = typeof fileResult.content === 'string'
                 ? fileResult.content
                 : fileResult.content.toString('base64');
+            const imageSummary = `Image file: ${parsed.path} (${fileResult.mimeType})\n`;
             return {
                 content: [
                     {
                         type: "text",
-                        text: `Image file: ${parsed.path} (${fileResult.mimeType})\n`
-                    },
-                    {
-                        type: "image",
-                        data: imageData,
-                        mimeType: fileResult.mimeType
+                        text: imageSummary
                     }
                 ],
+                structuredContent: {
+                    fileName: path.basename(resolvedFilePath),
+                    filePath: resolvedFilePath,
+                    fileType: 'image',
+                    content: imageSummary,
+                    imageData,
+                    mimeType: fileResult.mimeType
+                },
+                _meta: buildUiToolMeta(FILE_PREVIEW_RESOURCE_URI, true)
             };
         }
         else {
@@ -97,8 +136,16 @@ export async function handleReadFile(args) {
             const textContent = typeof fileResult.content === 'string'
                 ? fileResult.content
                 : fileResult.content.toString('utf8');
+            const previewFileType = resolvePreviewFileType(resolvedFilePath);
             return {
                 content: [{ type: "text", text: textContent }],
+                structuredContent: {
+                    fileName: path.basename(resolvedFilePath),
+                    filePath: resolvedFilePath,
+                    fileType: previewFileType,
+                    content: textContent
+                },
+                _meta: buildUiToolMeta(FILE_PREVIEW_RESOURCE_URI, true)
             };
         }
     };

package/dist/handlers/history-handlers.d.ts

@@ -1,5 +1,12 @@
 import { ServerResult } from '../types.js';
+type TrackUiEventParams = Record<string, string | number | boolean | null>;
+export declare function buildTrackUiEventCapturePayload(event: string, component: string, params: TrackUiEventParams): Record<string, string | number | boolean | null>;
 /**
  * Handle get_recent_tool_calls command
  */
 export declare function handleGetRecentToolCalls(args: unknown): Promise<ServerResult>;
+/**
+ * Handle track_ui_event command
+ */
+export declare function handleTrackUiEvent(args: unknown): Promise<ServerResult>;
+export {};

package/dist/handlers/history-handlers.js

@@ -1,5 +1,13 @@
 import { toolHistory } from '../utils/toolHistory.js';
-import { GetRecentToolCallsArgsSchema } from '../tools/schemas.js';
+import { GetRecentToolCallsArgsSchema, TrackUiEventArgsSchema } from '../tools/schemas.js';
+import { capture_ui_event } from '../utils/capture.js';
+export function buildTrackUiEventCapturePayload(event, component, params) {
+    return {
+        ...params,
+        component,
+        event
+    };
+}
 /**
  * Handle get_recent_tool_calls command
  */
@@ -33,3 +41,27 @@ export async function handleGetRecentToolCalls(args) {
         };
     }
 }
+/**
+ * Handle track_ui_event command
+ */
+export async function handleTrackUiEvent(args) {
+    try {
+        const parsed = TrackUiEventArgsSchema.parse(args);
+        await capture_ui_event('mcp_ui_event', buildTrackUiEventCapturePayload(parsed.event, parsed.component, parsed.params));
+        return {
+            content: [{
+                    type: "text",
+                    text: `Tracked UI event: ${parsed.event}`
+                }]
+        };
+    }
+    catch (error) {
+        return {
+            content: [{
+                    type: "text",
+                    text: `Error tracking UI event: ${error instanceof Error ? error.message : String(error)}`
+                }],
+            isError: true
+        };
+    }
+}

package/dist/server.js

@@ -1,5 +1,5 @@
 import { Server } from "@modelcontextprotocol/sdk/server/index.js";
-import { CallToolRequestSchema, ListToolsRequestSchema, ListResourcesRequestSchema, ListResourceTemplatesRequestSchema, ListPromptsRequestSchema, InitializeRequestSchema, LATEST_PROTOCOL_VERSION, SUPPORTED_PROTOCOL_VERSIONS, } from "@modelcontextprotocol/sdk/types.js";
+import { CallToolRequestSchema, ListToolsRequestSchema, ListResourcesRequestSchema, ReadResourceRequestSchema, ListResourceTemplatesRequestSchema, ListPromptsRequestSchema, InitializeRequestSchema, LATEST_PROTOCOL_VERSION, SUPPORTED_PROTOCOL_VERSIONS, } from "@modelcontextprotocol/sdk/types.js";
 import { zodToJsonSchema } from "zod-to-json-schema";
 import { getSystemInfo, getOSSpecificGuidance, getPathGuidance, getDevelopmentToolGuidance } from './utils/system-info.js';
 // Get system information once at startup
@@ -21,6 +21,8 @@ import { handleWelcomePageOnboarding } from './utils/welcome-onboarding.js';
 import { VERSION } from './version.js';
 import { capture, capture_call_tool } from "./utils/capture.js";
 import { logToStderr, logger } from './utils/logger.js';
+import { buildUiToolMeta, FILE_PREVIEW_RESOURCE_URI } from './ui/contracts.js';
+import { listUiResources, readUiResource } from './ui/resources.js';
 // Store startup messages to send after initialization
 const deferredMessages = [];
 function deferLog(level, message) {
@@ -47,11 +49,18 @@ export const server = new Server({
 });
 // Add handler for resources/list method
 server.setRequestHandler(ListResourcesRequestSchema, async () => {
-    // Return an empty list of resources
     return {
-        resources: [],
+        resources: listUiResources(),
     };
 });
+server.setRequestHandler(ReadResourceRequestSchema, async (request) => {
+    const { uri } = request.params;
+    const response = await readUiResource(uri);
+    if (response) {
+        return response;
+    }
+    throw new Error(`Unknown resource URI: ${uri}`);
+});
 // Add handler for prompts/list method
 server.setRequestHandler(ListPromptsRequestSchema, async () => {
     // Return an empty list of prompts
@@ -237,6 +246,7 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
                         ${PATH_GUIDANCE}
                         ${CMD_PREFIX_DESCRIPTION}`,
                 inputSchema: zodToJsonSchema(ReadFileArgsSchema),
+                _meta: buildUiToolMeta(FILE_PREVIEW_RESOURCE_URI, true),
                 annotations: {
                     title: "Read File or URL",
                     readOnlyHint: true,
@@ -1179,6 +1189,18 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                     };
                 }
                 break;
+            case "track_ui_event":
+                try {
+                    result = await handlers.handleTrackUiEvent(args);
+                }
+                catch (error) {
+                    capture('server_request_error', { message: `Error in track_ui_event handler: ${error}` });
+                    result = {
+                        content: [{ type: "text", text: `Error: Failed to track UI event` }],
+                        isError: true,
+                    };
+                }
+                break;
             case "give_feedback_to_desktop_commander":
                 try {
                     result = await giveFeedbackToDesktopCommander(args);
@@ -1265,12 +1287,16 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
         // Add tool call to history (exclude only get_recent_tool_calls to prevent recursion)
         const duration = Date.now() - startTime;
         const EXCLUDED_TOOLS = [
-            'get_recent_tool_calls'
+            'get_recent_tool_calls',
+            'track_ui_event'
         ];
         if (!EXCLUDED_TOOLS.includes(name)) {
             toolHistory.addCall(name, args, result, duration);
         }
         // Track success or failure based on result
+        if (name === 'track_ui_event') {
+            return result;
+        }
         if (result.isError) {
             await usageTracker.trackFailure(name);
             console.log(`[FEEDBACK DEBUG] Tool ${name} failed, not checking feedback`);

package/dist/tools/docx/builders/image.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Image builder — creates w:drawing elements and manages image relationships.
+ */
+import PizZip from 'pizzip';
+import type { DocxContentImage, InsertImageOp } from '../types.js';
+/**
+ * Build an image element and add it to the ZIP archive.
+ *
+ * @param doc The XML document
+ * @param zip The DOCX ZIP archive
+ * @param spec The image specification (from content or operation)
+ * @returns A w:p element containing the image drawing
+ */
+export declare function buildImageElement(doc: Document, zip: PizZip, spec: DocxContentImage | InsertImageOp): Promise<Element>;

package/dist/tools/docx/builders/image.js

@@ -0,0 +1,84 @@
+/**
+ * Image builder — creates w:drawing elements and manages image relationships.
+ */
+import fs from 'fs/promises';
+import path from 'path';
+import { DOMParser } from '@xmldom/xmldom';
+import { addImageRelationship, ensureContentType } from '../relationships.js';
+import { escapeXmlAttr } from './utils.js';
+import { pixelsToEmu, DEFAULT_IMAGE_WIDTH, DEFAULT_IMAGE_HEIGHT, NAMESPACES } from '../constants.js';
+/**
+ * Build an image element and add it to the ZIP archive.
+ *
+ * @param doc The XML document
+ * @param zip The DOCX ZIP archive
+ * @param spec The image specification (from content or operation)
+ * @returns A w:p element containing the image drawing
+ */
+export async function buildImageElement(doc, zip, spec) {
+    // Validate image exists
+    try {
+        await fs.access(spec.imagePath);
+    }
+    catch {
+        throw new Error(`Image file not found: ${spec.imagePath}`);
+    }
+    // Read image
+    const imgBuffer = await fs.readFile(spec.imagePath);
+    const ext = path.extname(spec.imagePath).toLowerCase();
+    const baseName = path.basename(spec.imagePath);
+    // Find next available media filename
+    let mediaIndex = 1;
+    while (zip.file(`word/media/image${mediaIndex}${ext}`)) {
+        mediaIndex++;
+    }
+    const mediaFileName = `image${mediaIndex}${ext}`;
+    // Add image to ZIP
+    zip.file(`word/media/${mediaFileName}`, imgBuffer);
+    // Add relationship
+    const rId = addImageRelationship(zip, mediaFileName);
+    // Ensure Content_Types entry
+    ensureContentType(zip, ext);
+    // Compute dimensions (EMU)
+    const widthPx = spec.width ?? DEFAULT_IMAGE_WIDTH;
+    const heightPx = spec.height ?? DEFAULT_IMAGE_HEIGHT;
+    const widthEmu = pixelsToEmu(widthPx);
+    const heightEmu = pixelsToEmu(heightPx);
+    // Build drawing XML
+    const altText = spec.altText ?? baseName;
+    const drawingXmlStr = buildDrawingXml(rId, widthEmu, heightEmu, altText, mediaFileName);
+    // Parse drawing XML into a paragraph
+    const drawingFragment = new DOMParser().parseFromString(`<w:p xmlns:w="${NAMESPACES.W}">` +
+        `<w:r>${drawingXmlStr}</w:r></w:p>`, 'application/xml');
+    return doc.importNode(drawingFragment.documentElement, true);
+}
+/**
+ * Build the inline w:drawing XML for an image reference.
+ */
+function buildDrawingXml(rId, widthEmu, heightEmu, altText, fileName) {
+    return (`<w:drawing xmlns:w="${NAMESPACES.W}">` +
+        `<wp:inline distT="0" distB="0" distL="0" distR="0" ` +
+        `xmlns:wp="${NAMESPACES.WP}">` +
+        `<wp:extent cx="${widthEmu}" cy="${heightEmu}"/>` +
+        `<wp:docPr id="1" name="${fileName}" descr="${escapeXmlAttr(altText)}"/>` +
+        `<a:graphic xmlns:a="${NAMESPACES.A}">` +
+        `<a:graphicData uri="http://schemas.openxmlformats.org/drawingml/2006/picture">` +
+        `<pic:pic xmlns:pic="${NAMESPACES.PIC}">` +
+        `<pic:nvPicPr>` +
+        `<pic:cNvPr id="0" name="${fileName}" descr="${escapeXmlAttr(altText)}"/>` +
+        `<pic:cNvPicPr/>` +
+        `</pic:nvPicPr>` +
+        `<pic:blipFill>` +
+        `<a:blip r:embed="${rId}" xmlns:r="${NAMESPACES.R}"/>` +
+        `<a:stretch><a:fillRect/></a:stretch>` +
+        `</pic:blipFill>` +
+        `<pic:spPr>` +
+        `<a:xfrm><a:off x="0" y="0"/><a:ext cx="${widthEmu}" cy="${heightEmu}"/></a:xfrm>` +
+        `<a:prstGeom prst="rect"><a:avLst/></a:prstGeom>` +
+        `</pic:spPr>` +
+        `</pic:pic>` +
+        `</a:graphicData>` +
+        `</a:graphic>` +
+        `</wp:inline>` +
+        `</w:drawing>`);
+}

package/dist/tools/docx/builders/index.d.ts

@@ -1,5 +1,11 @@
 /**
- * DOCX Builders
- * Centralized exports for all building utilities
+ * DOCX element builders — Single Responsibility: build XML elements
+ * for paragraphs, tables, and images.
+ *
+ * These builders are shared between create.ts and ops/ modules to
+ * eliminate code duplication and ensure consistency.
  */
-export * from './markdown-builder.js';
+export { buildParagraph } from './paragraph.js';
+export { buildTable } from './table.js';
+export { buildImageElement } from './image.js';
+export { escapeXml, escapeXmlAttr } from './utils.js';

package/dist/tools/docx/builders/index.js

@@ -1,5 +1,11 @@
 /**
- * DOCX Builders
- * Centralized exports for all building utilities
+ * DOCX element builders — Single Responsibility: build XML elements
+ * for paragraphs, tables, and images.
+ *
+ * These builders are shared between create.ts and ops/ modules to
+ * eliminate code duplication and ensure consistency.
  */
-export * from './markdown-builder.js';
+export { buildParagraph } from './paragraph.js';
+export { buildTable } from './table.js';
+export { buildImageElement } from './image.js';
+export { escapeXml, escapeXmlAttr } from './utils.js';

package/dist/tools/docx/builders/paragraph.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Paragraph builder — creates w:p elements with optional styles.
+ */
+import type { DocxContentParagraph } from '../types.js';
+/**
+ * Build a paragraph element from content structure.
+ *
+ * @param doc The XML document
+ * @param item The paragraph content item
+ * @returns A w:p element
+ */
+export declare function buildParagraph(doc: Document, item: DocxContentParagraph): Element;

package/dist/tools/docx/builders/paragraph.js

@@ -0,0 +1,29 @@
+/**
+ * Paragraph builder — creates w:p elements with optional styles.
+ */
+/**
+ * Build a paragraph element from content structure.
+ *
+ * @param doc The XML document
+ * @param item The paragraph content item
+ * @returns A w:p element
+ */
+export function buildParagraph(doc, item) {
+    const p = doc.createElement('w:p');
+    // Set style if provided
+    if (item.style) {
+        const pPr = doc.createElement('w:pPr');
+        const pStyle = doc.createElement('w:pStyle');
+        pStyle.setAttribute('w:val', item.style);
+        pPr.appendChild(pStyle);
+        p.appendChild(pPr);
+    }
+    // Add text run
+    const r = doc.createElement('w:r');
+    const t = doc.createElement('w:t');
+    t.setAttribute('xml:space', 'preserve');
+    t.textContent = item.text;
+    r.appendChild(t);
+    p.appendChild(r);
+    return p;
+}

package/dist/tools/docx/builders/table.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Table builder — creates w:tbl elements with headers, rows, and styling.
+ */
+import type { DocxContentTable, InsertTableOp } from '../types.js';
+/**
+ * Build a table element from content structure or operation.
+ */
+export declare function buildTable(doc: Document, spec: DocxContentTable | InsertTableOp): Element;

package/dist/tools/docx/builders/table.js

@@ -0,0 +1,94 @@
+/**
+ * Table builder — creates w:tbl elements with headers, rows, and styling.
+ */
+/**
+ * Build a table element from content structure or operation.
+ */
+export function buildTable(doc, spec) {
+    const tbl = doc.createElement('w:tbl');
+    // Table properties
+    const tblPr = doc.createElement('w:tblPr');
+    if (spec.style) {
+        const tblStyle = doc.createElement('w:tblStyle');
+        tblStyle.setAttribute('w:val', spec.style);
+        tblPr.appendChild(tblStyle);
+    }
+    const tblW = doc.createElement('w:tblW');
+    tblW.setAttribute('w:w', '0');
+    tblW.setAttribute('w:type', 'auto');
+    tblPr.appendChild(tblW);
+    // Table borders
+    const tblBorders = doc.createElement('w:tblBorders');
+    for (const side of ['top', 'left', 'bottom', 'right', 'insideH', 'insideV']) {
+        const border = doc.createElement(`w:${side}`);
+        border.setAttribute('w:val', 'single');
+        border.setAttribute('w:sz', '4');
+        border.setAttribute('w:space', '0');
+        border.setAttribute('w:color', '000000');
+        tblBorders.appendChild(border);
+    }
+    tblPr.appendChild(tblBorders);
+    tbl.appendChild(tblPr);
+    // Table grid
+    const colCount = spec.headers
+        ? spec.headers.length
+        : spec.rows.length > 0
+            ? spec.rows[0].length
+            : 0;
+    if (colCount > 0) {
+        const tblGrid = doc.createElement('w:tblGrid');
+        for (let c = 0; c < colCount; c++) {
+            const gridCol = doc.createElement('w:gridCol');
+            const w = spec.colWidths?.[c] ?? Math.floor(9000 / colCount);
+            gridCol.setAttribute('w:w', String(w));
+            tblGrid.appendChild(gridCol);
+        }
+        tbl.appendChild(tblGrid);
+    }
+    // Helper to build a cell
+    const buildCell = (text, isHeader, widthTwips) => {
+        const tc = doc.createElement('w:tc');
+        if (widthTwips) {
+            const tcPr = doc.createElement('w:tcPr');
+            const tcW = doc.createElement('w:tcW');
+            tcW.setAttribute('w:w', String(widthTwips));
+            tcW.setAttribute('w:type', 'dxa');
+            tcPr.appendChild(tcW);
+            tc.appendChild(tcPr);
+        }
+        const p = doc.createElement('w:p');
+        const r = doc.createElement('w:r');
+        if (isHeader) {
+            const rPr = doc.createElement('w:rPr');
+            const b = doc.createElement('w:b');
+            rPr.appendChild(b);
+            r.appendChild(rPr);
+        }
+        const t = doc.createElement('w:t');
+        t.setAttribute('xml:space', 'preserve');
+        t.textContent = text;
+        r.appendChild(t);
+        p.appendChild(r);
+        tc.appendChild(p);
+        return tc;
+    };
+    // Header row
+    if (spec.headers && spec.headers.length > 0) {
+        const tr = doc.createElement('w:tr');
+        for (let i = 0; i < spec.headers.length; i++) {
+            const width = spec.colWidths?.[i];
+            tr.appendChild(buildCell(spec.headers[i], true, width));
+        }
+        tbl.appendChild(tr);
+    }
+    // Data rows
+    for (const row of spec.rows) {
+        const tr = doc.createElement('w:tr');
+        for (let i = 0; i < row.length; i++) {
+            const width = spec.colWidths?.[i];
+            tr.appendChild(buildCell(row[i], false, width));
+        }
+        tbl.appendChild(tr);
+    }
+    return tbl;
+}

package/dist/tools/docx/builders/utils.d.ts

@@ -0,0 +1,5 @@
+/**
+ * XML escaping utilities.
+ */
+export declare function escapeXml(s: string): string;
+export declare function escapeXmlAttr(s: string): string;

package/dist/tools/docx/builders/utils.js

@@ -0,0 +1,18 @@
+/**
+ * XML escaping utilities.
+ */
+export function escapeXml(s) {
+    return s
+        .replace(/&/g, '&')
+        .replace(/</g, '&lt;')
+        .replace(/>/g, '&gt;')
+        .replace(/"/g, '&quot;')
+        .replace(/'/g, '&apos;');
+}
+export function escapeXmlAttr(s) {
+    return s
+        .replace(/&/g, '&amp;')
+        .replace(/"/g, '&quot;')
+        .replace(/</g, '&lt;')
+        .replace(/>/g, '&gt;');
+}

package/dist/tools/docx/constants.d.ts

@@ -1,36 +1,32 @@
 /**
- * DOCX Constants
- *
- * Centralised constants shared across the DOCX module.
- *
- * @module docx/constants
+ * DOCX constants — shared values used across the module.
  */
-export declare const DEFAULT_CONVERSION_OPTIONS: {
-    readonly includeImages: true;
-    readonly preserveFormatting: true;
-    readonly styleMap: readonly string[];
-};
-export declare const DEFAULT_BUILD_OPTIONS: {
-    readonly font: "Calibri";
-    readonly fontSize: 11;
-    readonly orientation: "portrait";
-    readonly margins: {
-        readonly top: 1440;
-        readonly right: 1440;
-        readonly bottom: 1440;
-        readonly left: 1440;
-        readonly header: 720;
-        readonly footer: 720;
-        readonly gutter: 0;
-    };
-    readonly footer: true;
-    readonly pageNumber: false;
+export declare const IMAGE_MIME_TYPES: Record<string, string>;
+export declare function getMimeType(ext: string): string;
+/**
+ * Convert pixels to EMU (English Metric Units).
+ * 1 inch = 914400 EMU, 1 px ≈ 9525 EMU (at 96 DPI)
+ */
+export declare const PX_TO_EMU = 9525;
+export declare function pixelsToEmu(px: number): number;
+export declare const NAMESPACES: {
+    readonly W: "http://schemas.openxmlformats.org/wordprocessingml/2006/main";
+    readonly WP: "http://schemas.openxmlformats.org/drawingml/2006/wordprocessingDrawing";
+    readonly A: "http://schemas.openxmlformats.org/drawingml/2006/main";
+    readonly PIC: "http://schemas.openxmlformats.org/drawingml/2006/picture";
+    readonly R: "http://schemas.openxmlformats.org/officeDocument/2006/relationships";
+    readonly RELS: "http://schemas.openxmlformats.org/package/2006/relationships";
 };
-export declare const DOCX_NAMESPACES: {
-    readonly DUBLIN_CORE: "dc";
-    readonly CUSTOM_PROPERTIES: "cp";
-    readonly DCTERMS: "dcterms";
+export declare const DEFAULT_IMAGE_WIDTH = 300;
+export declare const DEFAULT_IMAGE_HEIGHT = 200;
+export declare const DOCX_PATHS: {
+    readonly CONTENT_TYPES: "[Content_Types].xml";
+    readonly DOCUMENT_XML: "word/document.xml";
+    readonly DOCUMENT_RELS: "word/_rels/document.xml.rels";
+    readonly ROOT_RELS: "_rels/.rels";
+    readonly STYLES_XML: "word/styles.xml";
+    readonly SETTINGS_XML: "word/settings.xml";
+    readonly WEB_SETTINGS_XML: "word/webSettings.xml";
+    readonly FONT_TABLE_XML: "word/fontTable.xml";
+    readonly MEDIA_FOLDER: "word/media";
 };
-export declare const CORE_PROPERTIES_PATH = "docProps/core.xml";
-export declare const IMAGE_MIME_TYPES: Readonly<Record<string, string>>;
-export declare const HTML_WRAPPER_TEMPLATE = "<!DOCTYPE html>\n<html>\n<head>\n  <meta charset=\"UTF-8\">\n</head>\n<body>\n{content}\n</body>\n</html>";