@adobe/helix-md2docx 1.0.1

package/src/mdast2docx/handlers/table.js

@@ -0,0 +1,54 @@
+/*
+ * Copyright 2021 Adobe. All rights reserved.
+ * This file is licensed to you under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License. You may obtain a copy
+ * of the License at http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under
+ * the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+ * OF ANY KIND, either express or implied. See the License for the specific language
+ * governing permissions and limitations under the License.
+ */
+import docx from 'docx';
+import all from '../all.js';
+
+const { Paragraph, Table, WidthType } = docx;
+
+// see http://officeopenxml.com/WPtableWidth.php
+// Note: The 2006 version of the OOXML standard specified that the value was to be a decimal.
+// When type="pct", the value was interpreted as fifths of a percent, so 4975=99.5%,
+// and no % symbol was included in the attribute. In the 2011 version the value can be either a
+// decimal or a percent, so a % symbol should be included when type="pct".
+
+export default async function table(ctx, node) {
+  const oldTable = ctx.table;
+  ctx.table = {
+    // remember the table width (the column width will be calculated in the tableRow handler)
+    // default width: Letter Width - Margin = 8.5" - 2" = 6.5". the unit is 1/1440 inches.
+    width: oldTable ? oldTable.columnWidth : 1440 * 6.5,
+    align: node.align || [],
+  };
+  // process the rows
+  const rows = await all(ctx, node);
+
+  // and remember the column width
+  const { columnWidth } = ctx.table;
+  ctx.table = oldTable;
+
+  // use the same width for all columns
+  const numCols = rows.length ? rows[0].CellCount : 0;
+  const columnWidths = new Array(numCols).fill(Math.round(columnWidth));
+
+  const tbl = new Table({
+    style: 'PageBlock',
+    rows,
+    columnWidths,
+    width: {
+      size: 100,
+      type: WidthType.PERCENTAGE,
+    },
+  });
+
+  // add empty paragraph for better separation in word
+  return [tbl, new Paragraph([])];
+}

package/src/mdast2docx/handlers/tableCell.js

@@ -0,0 +1,51 @@
+/*
+ * Copyright 2021 Adobe. All rights reserved.
+ * This file is licensed to you under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License. You may obtain a copy
+ * of the License at http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under
+ * the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+ * OF ANY KIND, either express or implied. See the License for the specific language
+ * governing permissions and limitations under the License.
+ */
+import docx from 'docx';
+import all from '../all.js';
+
+const {
+  AlignmentType, Paragraph, Table, TableCell,
+} = docx;
+
+const ALIGN = {
+  left: null,
+  right: AlignmentType.RIGHT,
+  center: AlignmentType.CENTER,
+};
+
+export default async function tableCell(ctx, node, parent, siblings) {
+  const children = await all(ctx, node);
+  const alignment = ALIGN[ctx.table.align[siblings.length]];
+
+  const content = [];
+  let leaves = [];
+  // wrap non block elements with paragraph
+  for (let i = 0; i < children.length; i += 1) {
+    const child = children[i];
+    if ((child instanceof Paragraph) || (child instanceof Table)) {
+      if (leaves.length) {
+        content.push(new Paragraph({ alignment, children: leaves }));
+      }
+      content.push(child);
+      leaves = [];
+    } else {
+      leaves.push(child);
+    }
+  }
+  if (leaves.length) {
+    content.push(new Paragraph({ alignment, children: leaves }));
+  }
+
+  return new TableCell({
+    children: content,
+  });
+}

package/src/mdast2docx/handlers/tableRow.js

@@ -0,0 +1,28 @@
+/*
+ * Copyright 2021 Adobe. All rights reserved.
+ * This file is licensed to you under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License. You may obtain a copy
+ * of the License at http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under
+ * the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+ * OF ANY KIND, either express or implied. See the License for the specific language
+ * governing permissions and limitations under the License.
+ */
+import docx from 'docx';
+import all from '../all.js';
+
+const { TableRow } = docx;
+
+export default async function tableRow(ctx, node, parent, siblings) {
+  // adjust columnWidth
+  if (!ctx.table.columnWidth) {
+    ctx.table.columnWidth = ctx.table.width / node.children.length;
+  }
+
+  const children = await all(ctx, node);
+  return new TableRow({
+    children,
+    tableHeader: siblings.length === 0,
+  });
+}

package/src/mdast2docx/handlers/text.js

@@ -0,0 +1,24 @@
+/*
+ * Copyright 2021 Adobe. All rights reserved.
+ * This file is licensed to you under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License. You may obtain a copy
+ * of the License at http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under
+ * the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+ * OF ANY KIND, either express or implied. See the License for the specific language
+ * governing permissions and limitations under the License.
+ */
+import docx from 'docx';
+
+const { TextRun } = docx;
+
+export default function textNode(ctx, node) {
+  return node.value.split('\n').map((text, idx) => (
+    new TextRun({
+      ...ctx.style,
+      text,
+      break: idx > 0 ? 1 : 0,
+    })
+  ));
+}

package/src/mdast2docx/handlers/thematicBreak.js

@@ -0,0 +1,24 @@
+/*
+ * Copyright 2021 Adobe. All rights reserved.
+ * This file is licensed to you under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License. You may obtain a copy
+ * of the License at http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under
+ * the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+ * OF ANY KIND, either express or implied. See the License for the specific language
+ * governing permissions and limitations under the License.
+ */
+import docx from 'docx';
+
+const { Paragraph } = docx;
+
+export default function thematicBreak() {
+  return new Paragraph({
+    text: '---',
+    spacing: {
+      before: 250,
+      after: 250,
+    },
+  });
+}

package/src/mdast2docx/hast-table-handler.js

@@ -0,0 +1,145 @@
+/*
+ * Copyright 2021 Adobe. All rights reserved.
+ * This file is licensed to you under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License. You may obtain a copy
+ * of the License at http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under
+ * the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+ * OF ANY KIND, either express or implied. See the License for the specific language
+ * governing permissions and limitations under the License.
+ */
+
+'use strict';
+
+import { convertElement } from 'hast-util-is-element';
+import { visit } from 'unist-util-visit';
+import { all } from 'hast-util-to-mdast/lib/all.js';
+
+const thead = convertElement('thead');
+const tr = convertElement('tr');
+const cell = convertElement(['th', 'td']);
+
+/*
+   copied and adapted from
+   https://github.com/syntax-tree/hast-util-to-mdast/blob/7.1.3/lib/handlers/table.js
+ */
+
+// Infer whether the HTML table has a head and how it aligns.
+function inspect(node) {
+  let headless = true;
+  const align = [];
+  let rowIndex = 0;
+  let cellIndex = 0;
+
+  function visitor(child) {
+    // If there is a `thead`, assume there is a header row.
+    if (thead(child)) {
+      headless = false;
+    } else if (tr(child)) {
+      rowIndex += 1;
+      cellIndex = 0;
+    } else if (cell(child)) {
+      if (align[cellIndex] === undefined) {
+        align[cellIndex] = child.properties.align || null;
+      }
+
+      // If there is a th in the first row, assume there is a header row.
+      if (headless && rowIndex < 2 && child.tagName === 'th') {
+        headless = false;
+      }
+
+      cellIndex += 1;
+      return visit.SKIP;
+    }
+    return visit.CONTINUE;
+  }
+
+  visit(node, 'element', visitor);
+
+  return { align, headless };
+}
+
+// Ensure the cells in a row are properly structured.
+function toCells(children, info) {
+  const nodes = [];
+  let queue;
+
+  children.forEach((node) => {
+    if (node.type === 'tableCell') {
+      if (queue) {
+        // eslint-disable-next-line no-param-reassign
+        node.children = queue.concat(node.children);
+        queue = undefined;
+      }
+
+      nodes.push(node);
+    } else {
+      if (!queue) {
+        queue = [];
+      }
+      queue.push(node);
+    }
+  });
+
+  if (queue) {
+    let node = nodes[nodes.length - 1];
+
+    if (!node) {
+      node = { type: 'tableCell', children: [] };
+      nodes.push(node);
+    }
+
+    node.children = node.children.concat(queue);
+  }
+
+  // add empty cells if there are more in the table
+  for (let index = nodes.length; index < info.align.length; index += 1) {
+    nodes.push({ type: 'tableCell', children: [] });
+  }
+
+  return nodes;
+}
+
+// Ensure the rows are properly structured.
+function toRows(children, info) {
+  const nodes = [];
+  let queue;
+
+  // Add an empty header row.
+  // we don't need extra header rows
+  // if (info.headless) {
+  //   nodes.push({ type: 'tableRow', children: [] });
+  // }
+
+  children.forEach((node) => {
+    if (node.type === 'tableRow') {
+      if (queue) {
+        // eslint-disable-next-line no-param-reassign
+        node.children = queue.concat(node.children);
+        queue = undefined;
+      }
+
+      nodes.push(node);
+    } else {
+      if (!queue) queue = [];
+      queue.push(node);
+    }
+  });
+
+  if (queue) {
+    const node = nodes[nodes.length - 1];
+    node.children = node.children.concat(queue);
+  }
+  nodes.forEach((node) => {
+    // eslint-disable-next-line no-param-reassign
+    node.children = toCells(node.children, info);
+  });
+
+  return nodes;
+}
+
+export default function table(h, node) {
+  const info = inspect(node);
+  return h(node, 'table', { align: info.align }, toRows(all(h, node), info));
+}

package/src/mdast2docx/index.d.ts

@@ -0,0 +1,21 @@
+/*
+ * Copyright 2022 Adobe. All rights reserved.
+ * This file is licensed to you under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License. You may obtain a copy
+ * of the License at http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under
+ * the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+ * OF ANY KIND, either express or implied. See the License for the specific language
+ * governing permissions and limitations under the License.
+ */
+declare interface Logger {}
+
+/**
+ * Converts the mdast to a word document (docx).
+ *
+ * @param {Node} mdast The mdast
+ * @param {Logger} [log] a console like logger
+ * @returns {Promise<Buffer>} the docx
+ */
+export default function mdast2docx(mdast: object, log: Logger): Promise<Buffer>;

package/src/mdast2docx/index.js

@@ -0,0 +1,88 @@
+/*
+ * Copyright 2021 Adobe. All rights reserved.
+ * This file is licensed to you under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License. You may obtain a copy
+ * of the License at http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under
+ * the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+ * OF ANY KIND, either express or implied. See the License for the specific language
+ * governing permissions and limitations under the License.
+ */
+import { readFile } from 'fs/promises';
+import path from 'path';
+import { dirname } from 'dirname-filename-esm';
+import docx from 'docx';
+
+import all from './all.js';
+import handlers from './handlers/index.js';
+import numbering from './default-numbering.js';
+import sanitizeHtml from './mdast-sanitize-html.js';
+// import { openArrayBuffer } from '../zipfile.js';
+import { findXMLComponent } from './utils.js';
+import downloadImages from './mdast-download-images.js';
+
+const { Document, Packer } = docx;
+
+// eslint-disable-next-line no-underscore-dangle
+const __dirname = dirname(import.meta);
+
+export default async function mdast2docx(mdast, log = console) {
+  const ctx = {
+    handlers,
+    style: {},
+    paragraphStyle: '',
+    images: {},
+    listLevel: -1,
+    lists: [],
+    log,
+  };
+
+  // eslint-disable-next-line no-param-reassign
+  mdast = sanitizeHtml(mdast);
+
+  // process.stdout.write('==================================================\n');
+  // process.stdout.write(inspect(mdast));
+  // process.stdout.write('\n');
+  // process.stdout.write('==================================================\n');
+
+  await downloadImages(ctx, mdast);
+
+  const children = await all(ctx, mdast);
+
+  // read styles from template.docx. this seems to be the most reliable
+  // const templateDoc = await readFile(path.resolve(__dirname, 'template.docx'));
+  // const zip = await openArrayBuffer(templateDoc);
+  // const styleXML = await zip.read('word/styles.xml', 'utf-8');
+  const styleXML = await readFile(path.resolve(__dirname, 'template', 'word', 'styles.xml'), 'utf-8');
+
+  const doc = new Document({
+    numbering,
+    externalStyles: styleXML,
+    sections: [{
+      children,
+    }],
+  });
+
+  // temporary hack for problems with online word
+  const cn = doc.numbering.concreteNumberingMap.get('default-bullet-numbering');
+  cn.root[0].root.numId = 1;
+  cn.numId = 1;
+
+  // temporary hack for problems with lists in online word
+  for (const nb of doc.numbering.abstractNumberingMap.values()) {
+    nb.root.forEach((attr) => {
+      if (attr.rootKey !== 'w:lvl') {
+        return;
+      }
+      const jc = findXMLComponent(attr, 'w:lvlJc');
+      if (jc) {
+        const idx = attr.root.indexOf(jc);
+        attr.root.splice(idx, 1);
+        attr.root.push(jc);
+      }
+    });
+  }
+
+  return Packer.toBuffer(doc);
+}

package/src/mdast2docx/mdast-download-images.js

@@ -0,0 +1,92 @@
+/*
+ * Copyright 2020 Adobe. All rights reserved.
+ * This file is licensed to you under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License. You may obtain a copy
+ * of the License at http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under
+ * the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+ * OF ANY KIND, either express or implied. See the License for the specific language
+ * governing permissions and limitations under the License.
+ */
+/* eslint-disable no-param-reassign */
+import crypto from 'crypto';
+import { context as fetchAPI, h1 } from '@adobe/helix-fetch';
+import processQueue from '@adobe/helix-shared-process-queue';
+import { visit } from 'unist-util-visit';
+import getDimensions from 'image-size';
+
+function createFetchContext() {
+  return process.env.HELIX_FETCH_FORCE_HTTP1
+    ? h1()
+    : fetchAPI();
+}
+
+function hsize(bytes, decimals = 2) {
+  if (bytes === 0) {
+    return '0   ';
+  }
+  const k = 1024;
+  const dm = decimals < 0 ? 0 : decimals;
+  const sizes = ['  ', 'KB', 'MB', 'GB', 'TB', 'PB', 'EB', 'ZB', 'YB'];
+  const i = Math.floor(Math.log(bytes) / Math.log(k));
+  return `${parseFloat((bytes / k ** i).toFixed(dm))} ${sizes[i]}`;
+}
+
+export default async function downloadImages(ctx, tree) {
+  const context = createFetchContext();
+  const { fetch } = context;
+
+  // gather all image nodes
+  const images = [];
+  visit(tree, (node) => {
+    if (node.type === 'image' && node.url) {
+      images.push(node);
+    }
+    return visit.CONTINUE;
+  });
+  let count = 0;
+
+  // download images
+  await processQueue(images, async (node) => {
+    try {
+      const ref = crypto.createHash('sha1')
+        .update(node.url)
+        .digest('hex');
+      const key = `${ref}.png`;
+      node.data = ctx.images[key];
+      if (node.data) {
+        return;
+      }
+
+      let buffer;
+      if (node.url.startsWith('data:image/png;base64,')) {
+        buffer = Buffer.from(node.url.split(',').pop(), 'base64');
+      } else {
+        const idx = String(count).padStart(2, ' ');
+        count += 1;
+        ctx.log.info(`[${idx}] GET ${node.url}`);
+        const ret = await fetch(node.url);
+        if (!ret.ok) {
+          const text = await ret.text();
+          ctx.log.error(`[${idx}] ${ret.status} ${text}`);
+          return;
+        }
+        buffer = await ret.buffer();
+        ctx.log.info(`[${idx}] ${ret.status} ${hsize(buffer.length).padStart(10)} ${ret.headers.get('content-type')}`);
+      }
+
+      node.data = {
+        key,
+        buffer,
+        dimensions: getDimensions(buffer),
+      };
+      ctx.images[key] = node.data;
+    } catch (error) {
+      ctx.log.error(`Cannot download image ${node.url}: ${error.message}`);
+    }
+  }, 8);
+
+  // reset fetch context
+  context.reset();
+}

package/src/mdast2docx/mdast-sanitize-html.js

@@ -0,0 +1,112 @@
+/*
+ * Copyright 2020 Adobe. All rights reserved.
+ * This file is licensed to you under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License. You may obtain a copy
+ * of the License at http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under
+ * the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+ * OF ANY KIND, either express or implied. See the License for the specific language
+ * governing permissions and limitations under the License.
+ */
+import { visit } from 'unist-util-visit';
+import { unified } from 'unified';
+import parse from 'rehype-parse';
+import { toMdast } from 'hast-util-to-mdast';
+// import inspect from 'unist-util-inspect';
+import tableHandler from './hast-table-handler.js';
+
+/**
+ * Creates simple format handler
+ * @param type
+ */
+function formatHandler(type) {
+  return (h, node) => h(node, type, node.children);
+}
+
+/**
+ * Handler for `<markdown>` elements.
+ * @param {[]} mdasts array of mdast sub trees
+ */
+function mdHandler(mdasts) {
+  return (h, node) => {
+    const { idx } = node.properties;
+    return mdasts[idx];
+  };
+}
+
+/**
+ * Sanitizes html:
+ * - collapses consecutive html content (simply concat all nodes until the last html sibling)
+ * - parses and converts them to mdast again
+ *
+ * @param {object} tree
+ * @returns {object} The modified (original) tree.
+ */
+export default function sanitizeHtml(tree) {
+  const mdInserts = [];
+
+  visit(tree, (node, index, parent) => {
+    const { children: siblings = [] } = parent || {};
+
+    // collapse html blocks
+    if (node.type === 'html') {
+      // find last html block
+      let lastHtml = siblings.length - 1;
+      while (lastHtml >= index) {
+        if (siblings[lastHtml].type === 'html') {
+          break;
+        }
+        lastHtml -= 1;
+      }
+
+      let html = node.value;
+      if (lastHtml > index) {
+        // remove all html nodes
+        const removed = siblings.splice(index + 1, lastHtml - index);
+
+        // and append to html as special markdown element marker which is then handled in the
+        // mdHandler for the `<markdown>` elements.
+        removed.forEach((n) => {
+          if (n.type === 'html' || n.type === 'text') {
+            html += n.value;
+          } else {
+            html += `<markdown idx="${mdInserts.length}"></markdown>`;
+          }
+          mdInserts.push(n);
+        });
+      }
+
+      // try parse html
+      const hast = unified()
+        .use(parse, { fragment: true })
+        .parse(html);
+
+      // convert to mdast with extra handlers
+      const mdast = toMdast(hast, {
+        handlers: {
+          u: formatHandler('underline'),
+          sub: formatHandler('subScript'),
+          sup: formatHandler('superScript'),
+          table: tableHandler,
+          markdown: mdHandler(mdInserts),
+        },
+      });
+
+      // console.log('************************************');
+      // // console.log('>>>>', html);
+      // process.stdout.write(inspect(hast));
+      // process.stdout.write('\n');
+      // console.log('************************************');
+
+      // inject children of parsed tree
+      siblings.splice(index, 1, ...mdast.children);
+
+      // continue after
+      return index + mdast.children.length;
+    }
+
+    return visit.CONTINUE;
+  });
+  return tree;
+}

package/src/mdast2docx/template/[Content_Types].xml

@@ -0,0 +1,41 @@
+<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
+<Types xmlns="http://schemas.openxmlformats.org/package/2006/content-types">
+    <Default Extension="png" ContentType="image/png"/>
+    <Default Extension="rels"
+             ContentType="application/vnd.openxmlformats-package.relationships+xml"/>
+    <Default Extension="xml" ContentType="application/xml"/>
+    <Override PartName="/word/document.xml"
+              ContentType="application/vnd.openxmlformats-officedocument.wordprocessingml.document.main+xml"/>
+    <Override PartName="/word/numbering.xml"
+              ContentType="application/vnd.openxmlformats-officedocument.wordprocessingml.numbering+xml"/>
+    <Override PartName="/word/styles.xml"
+              ContentType="application/vnd.openxmlformats-officedocument.wordprocessingml.styles+xml"/>
+    <Override PartName="/word/settings.xml"
+              ContentType="application/vnd.openxmlformats-officedocument.wordprocessingml.settings+xml"/>
+    <Override PartName="/word/webSettings.xml"
+              ContentType="application/vnd.openxmlformats-officedocument.wordprocessingml.webSettings+xml"/>
+    <Override PartName="/word/footnotes.xml"
+              ContentType="application/vnd.openxmlformats-officedocument.wordprocessingml.footnotes+xml"/>
+    <Override PartName="/word/endnotes.xml"
+              ContentType="application/vnd.openxmlformats-officedocument.wordprocessingml.endnotes+xml"/>
+    <Override PartName="/word/header1.xml"
+              ContentType="application/vnd.openxmlformats-officedocument.wordprocessingml.header+xml"/>
+    <Override PartName="/word/header2.xml"
+              ContentType="application/vnd.openxmlformats-officedocument.wordprocessingml.header+xml"/>
+    <Override PartName="/word/footer1.xml"
+              ContentType="application/vnd.openxmlformats-officedocument.wordprocessingml.footer+xml"/>
+    <Override PartName="/word/footer2.xml"
+              ContentType="application/vnd.openxmlformats-officedocument.wordprocessingml.footer+xml"/>
+    <Override PartName="/word/header3.xml"
+              ContentType="application/vnd.openxmlformats-officedocument.wordprocessingml.header+xml"/>
+    <Override PartName="/word/footer3.xml"
+              ContentType="application/vnd.openxmlformats-officedocument.wordprocessingml.footer+xml"/>
+    <Override PartName="/word/fontTable.xml"
+              ContentType="application/vnd.openxmlformats-officedocument.wordprocessingml.fontTable+xml"/>
+    <Override PartName="/word/theme/theme1.xml"
+              ContentType="application/vnd.openxmlformats-officedocument.theme+xml"/>
+    <Override PartName="/docProps/core.xml"
+              ContentType="application/vnd.openxmlformats-package.core-properties+xml"/>
+    <Override PartName="/docProps/app.xml"
+              ContentType="application/vnd.openxmlformats-officedocument.extended-properties+xml"/>
+</Types>