@fiduswriter/document 0.1.0-alpha.3 → 0.1.0-alpha.5

package/src/editor/e2ee/{encryptor.js → encryptor.ts}

@@ -17,11 +17,11 @@ export class E2EEEncryptor {
     /**
      * Encrypt a string with AES-GCM.
      *
-     * @param {string} plaintext - The plaintext string to encrypt
-     * @param {CryptoKey} key - An AES-GCM key (from E2EEKeyManager.deriveKey)
-     * @returns {Promise<string>} Base64-encoded string (iv + ciphertext + auth tag)
+     * @param plaintext - The plaintext string to encrypt
+     * @param key - An AES-GCM key (from E2EEKeyManager.deriveKey)
+     * @returns Base64-encoded string (iv + ciphertext + auth tag)
      */
-    static async encrypt(plaintext, key) {
+    static async encrypt(plaintext: string, key: CryptoKey): Promise<string> {
         const iv = crypto.getRandomValues(new Uint8Array(12))
         const encoded = new TextEncoder().encode(plaintext)
         const ciphertext = await crypto.subtle.encrypt(
@@ -39,11 +39,14 @@ export class E2EEEncryptor {
     /**
      * Decrypt a Base64-encoded AES-GCM ciphertext.
      *
-     * @param {string} ciphertextBase64 - Base64-encoded (iv + ciphertext + auth tag)
-     * @param {CryptoKey} key - An AES-GCM key (from E2EEKeyManager.deriveKey)
-     * @returns {Promise<string>} The decrypted plaintext string
+     * @param ciphertextBase64 - Base64-encoded (iv + ciphertext + auth tag)
+     * @param key - An AES-GCM key (from E2EEKeyManager.deriveKey)
+     * @returns The decrypted plaintext string
      */
-    static async decrypt(ciphertextBase64, key) {
+    static async decrypt(
+        ciphertextBase64: string,
+        key: CryptoKey
+    ): Promise<string> {
         const combined = E2EEEncryptor._base64ToUint8Array(ciphertextBase64)
         const iv = combined.slice(0, 12)
         const ciphertext = combined.slice(12)
@@ -60,11 +63,14 @@ export class E2EEEncryptor {
      *
      * Serializes the object to JSON, then encrypts the JSON string.
      *
-     * @param {Object} obj - A JSON-serializable object
-     * @param {CryptoKey} key - An AES-GCM key
-     * @returns {Promise<string>} Base64-encoded encrypted data
+     * @param obj - A JSON-serializable object
+     * @param key - An AES-GCM key
+     * @returns Base64-encoded encrypted data
      */
-    static encryptObject(obj, key) {
+    static encryptObject(
+        obj: Record<string, unknown> | unknown[],
+        key: CryptoKey
+    ): Promise<string> {
         return E2EEEncryptor.encrypt(JSON.stringify(obj), key)
     }
 
@@ -73,11 +79,14 @@ export class E2EEEncryptor {
      *
      * Decrypts the Base64-encoded ciphertext, then parses the result as JSON.
      *
-     * @param {string} ciphertextBase64 - Base64-encoded encrypted data
-     * @param {CryptoKey} key - An AES-GCM key
-     * @returns {Promise<Object>} The decrypted and parsed object
+     * @param ciphertextBase64 - Base64-encoded encrypted data
+     * @param key - An AES-GCM key
+     * @returns The decrypted and parsed object
      */
-    static async decryptObject(ciphertextBase64, key) {
+    static async decryptObject(
+        ciphertextBase64: string,
+        key: CryptoKey
+    ): Promise<unknown> {
         const plaintext = await E2EEEncryptor.decrypt(ciphertextBase64, key)
         return JSON.parse(plaintext)
     }
@@ -85,11 +94,14 @@ export class E2EEEncryptor {
     /**
      * Encrypt an ArrayBuffer (for images and other binary data).
      *
-     * @param {ArrayBuffer} buffer - The binary data to encrypt
-     * @param {CryptoKey} key - An AES-GCM key
-     * @returns {Promise<string>} Base64-encoded encrypted data (iv + ciphertext)
+     * @param buffer - The binary data to encrypt
+     * @param key - An AES-GCM key
+     * @returns Base64-encoded encrypted data (iv + ciphertext)
      */
-    static async encryptBuffer(buffer, key) {
+    static async encryptBuffer(
+        buffer: ArrayBuffer,
+        key: CryptoKey
+    ): Promise<string> {
         const iv = crypto.getRandomValues(new Uint8Array(12))
         const ciphertext = await crypto.subtle.encrypt(
             {name: "AES-GCM", iv: iv},
@@ -106,15 +118,22 @@ export class E2EEEncryptor {
     /**
      * Decrypt to an ArrayBuffer.
      *
-     * @param {string} ciphertextBase64 - Base64-encoded encrypted data
-     * @param {CryptoKey} key - An AES-GCM key
-     * @returns {Promise<ArrayBuffer>} The decrypted binary data
+     * @param ciphertextBase64 - Base64-encoded encrypted data
+     * @param key - An AES-GCM key
+     * @returns The decrypted binary data
      */
-    static decryptBuffer(ciphertextBase64, key) {
+    static decryptBuffer(
+        ciphertextBase64: string,
+        key: CryptoKey
+    ): Promise<ArrayBuffer> {
         const combined = E2EEEncryptor._base64ToUint8Array(ciphertextBase64)
         const iv = combined.slice(0, 12)
         const ciphertext = combined.slice(12)
-        return crypto.subtle.decrypt({name: "AES-GCM", iv: iv}, key, ciphertext)
+        return crypto.subtle.decrypt(
+            {name: "AES-GCM", iv: iv},
+            key,
+            ciphertext
+        )
     }
 
     /**
@@ -124,11 +143,14 @@ export class E2EEEncryptor {
      * a Blob with application/octet-stream type (since the encrypted
      * data is opaque binary).
      *
-     * @param {File|Blob} file - The image file to encrypt
-     * @param {CryptoKey} key - An AES-GCM key
-     * @returns {Promise<Blob>} An encrypted Blob with type application/octet-stream
+     * @param file - The image file to encrypt
+     * @param key - An AES-GCM key
+     * @returns An encrypted Blob with type application/octet-stream
      */
-    static async encryptImage(file, key) {
+    static async encryptImage(
+        file: Blob,
+        key: CryptoKey
+    ): Promise<Blob> {
         const buffer = await file.arrayBuffer()
         const iv = crypto.getRandomValues(new Uint8Array(12))
         const ciphertext = await crypto.subtle.encrypt(
@@ -146,11 +168,14 @@ export class E2EEEncryptor {
     /**
      * Decrypt an encrypted image back to an ArrayBuffer.
      *
-     * @param {string} ciphertextBase64 - Base64-encoded encrypted image data
-     * @param {CryptoKey} key - An AES-GCM key
-     * @returns {Promise<ArrayBuffer>} The decrypted image data
+     * @param ciphertextBase64 - Base64-encoded encrypted image data
+     * @param key - An AES-GCM key
+     * @returns The decrypted image data
      */
-    static decryptImage(ciphertextBase64, key) {
+    static decryptImage(
+        ciphertextBase64: string,
+        key: CryptoKey
+    ): Promise<ArrayBuffer> {
         return E2EEEncryptor.decryptBuffer(ciphertextBase64, key)
     }
 
@@ -160,11 +185,14 @@ export class E2EEEncryptor {
      * Useful for decrypting encrypted images that need to be stored
      * as Base64 data URLs or re-exported.
      *
-     * @param {string} ciphertextBase64 - Base64-encoded encrypted data
-     * @param {CryptoKey} key - An AES-GCM key
-     * @returns {Promise<string>} Base64-encoded decrypted data
+     * @param ciphertextBase64 - Base64-encoded encrypted data
+     * @param key - An AES-GCM key
+     * @returns Base64-encoded decrypted data
      */
-    static async decryptBufferToBase64(ciphertextBase64, key) {
+    static async decryptBufferToBase64(
+        ciphertextBase64: string,
+        key: CryptoKey
+    ): Promise<string> {
         const buffer = await E2EEEncryptor.decryptBuffer(ciphertextBase64, key)
         const bytes = new Uint8Array(buffer)
         let binary = ""
@@ -180,12 +208,16 @@ export class E2EEEncryptor {
      * Fetches the encrypted image file from the given URL, decrypts it,
      * and creates a temporary object URL that can be used as an img src.
      *
-     * @param {string} imageUrl - The URL of the encrypted image file
-     * @param {CryptoKey} key - An AES-GCM key
-     * @param {string} mimeType - The MIME type of the decrypted image
-     * @returns {Promise<string>} A blob URL for the decrypted image
+     * @param imageUrl - The URL of the encrypted image file
+     * @param key - An AES-GCM key
+     * @param mimeType - The MIME type of the decrypted image
+     * @returns A blob URL for the decrypted image
      */
-    static async decryptImageToUrl(imageUrl, key, mimeType = "image/png") {
+    static async decryptImageToUrl(
+        imageUrl: string,
+        key: CryptoKey,
+        mimeType = "image/png"
+    ): Promise<string> {
         const response = await fetch(imageUrl)
         const arrayBuffer = await response.arrayBuffer()
         const bytes = new Uint8Array(arrayBuffer)
@@ -205,7 +237,7 @@ export class E2EEEncryptor {
      * Convert a Uint8Array to a Base64-encoded string.
      * @private
      */
-    static _uint8ArrayToBase64(bytes) {
+    private static _uint8ArrayToBase64(bytes: Uint8Array): string {
         let binary = ""
         for (let i = 0; i < bytes.length; i++) {
             binary += String.fromCharCode(bytes[i])
@@ -217,7 +249,7 @@ export class E2EEEncryptor {
      * Convert a Base64-encoded string to a Uint8Array.
      * @private
      */
-    static _base64ToUint8Array(base64) {
+    private static _base64ToUint8Array(base64: string): Uint8Array {
         const binary = atob(base64)
         const bytes = new Uint8Array(binary.length)
         for (let i = 0; i < binary.length; i++) {

package/src/exporter/docx/{citations.js → citations.ts}

@@ -3,10 +3,28 @@ import {DOMParser, DOMSerializer} from "prosemirror-model"
 import {cslBibSchema} from "../../bibliography/csl_bib.js"
 import {FormatCitations} from "../../citations/format.js"
 import {fnSchema} from "../../schema/footnotes.js"
+import type {BibDB, CSL, DocSettings, FidusNode} from "../../types.js"
 import {descendantNodes} from "../tools/doc_content.js"
+import type {XMLElement} from "../tools/xml.js"
+import type {XmlZip} from "../tools/xml_zip.js"
 
 export class DOCXExporterCitations {
-    constructor(docContent, settings, bibDB, csl, xml, origCitInfos = []) {
+    docContent: FidusNode
+    settings: DocSettings
+    bibDB: BibDB
+    csl: CSL
+    xml: XmlZip
+    origCitInfos: Record<string, unknown>[]
+
+    citInfos: Record<string, unknown>[]
+    citationTexts: string[]
+    pmCits: FidusNode[]
+    citFm: FormatCitations | false
+    pmBib: FidusNode | false
+    styleXML: XMLElement | null
+    styleFilePath: string
+
+    constructor(docContent: FidusNode, settings: DocSettings, bibDB: BibDB, csl: CSL, xml: XmlZip, origCitInfos: Record<string, unknown>[] = []) {
         this.docContent = docContent
         this.settings = settings
         this.bibDB = bibDB
@@ -19,11 +37,11 @@ export class DOCXExporterCitations {
         this.pmCits = []
         this.citFm = false
         this.pmBib = false
-        this.styleXML = false
+        this.styleXML = null
         this.styleFilePath = "word/styles.xml"
     }
 
-    init() {
+    init(): Promise<void> {
         return this.xml
             .getXml(this.styleFilePath)
             .then(styleXML => {
@@ -35,7 +53,7 @@ export class DOCXExporterCitations {
 
     // Citations are highly interdependent -- so we need to format them all
     // together before laying out the document.
-    formatCitations() {
+    formatCitations(): Promise<void> {
         if (this.origCitInfos.length) {
             // Initial citInfos are taken from a previous run to include in bibliography,
             // and they are removed before spitting out the citation entries for the given document.
@@ -44,21 +62,22 @@ export class DOCXExporterCitations {
         }
 
         descendantNodes(this.docContent).forEach(node => {
-            if (node.type === "citation") {
+            if (node.type === "citation" && node.attrs) {
                 this.citInfos.push(JSON.parse(JSON.stringify(node.attrs)))
             }
         })
-        this.citFm = new FormatCitations(
+        const citFm = new FormatCitations(
             this.csl,
-            this.citInfos,
-            this.settings.citationstyle,
+            this.citInfos as any,
+            this.settings.citationstyle || "",
             "",
             this.bibDB,
             false,
             this.settings.language
         )
-        return this.citFm.init().then(() => {
-            this.citationTexts = this.citFm.citationTexts
+        this.citFm = citFm
+        return (citFm.init() as Promise<void>).then(() => {
+            this.citationTexts = citFm.citationTexts
             if (this.origCitInfos.length) {
                 // Remove all citation texts originating from original starting citInfos
                 this.citationTexts.splice(0, this.origCitInfos.length)
@@ -68,7 +87,10 @@ export class DOCXExporterCitations {
         })
     }
 
-    convertCitations() {
+    convertCitations(): void {
+        if (!this.citFm) {
+            return
+        }
         // There could be some formatting in the citations, so we parse them through the PM schema for final formatting.
         // We need to put the citations each in a paragraph so that it works with
         // the fiduswriter schema and so that the converter doesn't mash them together.
@@ -83,30 +105,36 @@ export class DOCXExporterCitations {
 
             const serializer = DOMSerializer.fromSchema(fnSchema)
             const dom = serializer.serializeNode(fnNode)
-            dom.innerHTML = citationsHTML
+            ;(dom as HTMLElement).innerHTML = citationsHTML
             this.pmCits = DOMParser.fromSchema(fnSchema)
                 .parse(dom, {topNode: fnNode})
-                .toJSON().content
+                .toJSON().content as FidusNode[]
         }
 
         // Now we do the same for the bibliography.
-        const cslBib = this.citFm.bibliography
+        const cslBib = this.citFm!.bibliography
         if (cslBib && cslBib[1].length > 0) {
             this.addReferenceStyle(cslBib[0])
             const bibNode = cslBibSchema.nodeFromJSON({type: "cslbib"})
             const cslSerializer = DOMSerializer.fromSchema(cslBibSchema)
             const dom = cslSerializer.serializeNode(bibNode)
-            dom.innerHTML = cslBib[1].join("")
+            ;(dom as HTMLElement).innerHTML = cslBib[1].join("")
             this.pmBib = DOMParser.fromSchema(cslBibSchema)
                 .parse(dom, {topNode: bibNode})
-                .toJSON()
+                .toJSON() as FidusNode
         }
     }
 
-    addReferenceStyle(bibInfo) {
-        const stylesEl = this.styleXML.query("w:styles")
+    addReferenceStyle(bibInfo: {
+        linespacing: number
+        entryspacing: number
+        hangingindent?: boolean
+        maxoffset: number
+        "second-field-align"?: "margin" | "flush"
+    }): void {
+        const stylesEl = this.styleXML!.query("w:styles")
         if (
-            !this.styleXML.query("w:style", {
+            !this.styleXML!.query("w:style", {
                 "w:styleId": "BibliographyHeading"
             })
         ) {
@@ -126,15 +154,15 @@ export class DOCXExporterCitations {
                         <w:szCs w:val="32"/>
                     </w:rPr>
                 </w:style>`
-            stylesEl.appendXML(headingStyleDef)
+            stylesEl?.appendXML(headingStyleDef)
         }
         // The style called "Bibliography" will override any previous style
         // of the same name.
-        const stylesParStyle = this.styleXML.query("w:style", {
+        const stylesParStyle = this.styleXML!.query("w:style", {
             "w:styleId": "Bibliography"
         })
         if (stylesParStyle) {
-            stylesParStyle.parentElement.removeChild(stylesParStyle)
+            stylesParStyle.parentElement!.removeChild(stylesParStyle)
         }
 
         const lineHeight = 240 * bibInfo.linespacing
@@ -172,6 +200,6 @@ export class DOCXExporterCitations {
                 <w:rPr></w:rPr>
             </w:style>`
 
-        stylesEl.appendXML(styleDef)
+        stylesEl?.appendXML(styleDef)
     }
 }

package/src/exporter/docx/{comments.js → comments.ts}

@@ -1,5 +1,10 @@
 import {escapeText} from "fwtoolkit"
+
+import type {CommentData, FidusNode} from "../../types.js"
 import {descendantNodes} from "../tools/doc_content.js"
+import type {XMLElement} from "../tools/xml.js"
+import type {XmlZip} from "../tools/xml_zip.js"
+import type {DOCXExporterRels} from "./rels.js"
 
 const DEFAULT_COMMENTS_XML = `<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
     <w:comments xmlns:o="urn:schemas-microsoft-com:office:office" xmlns:r="http://schemas.openxmlformats.org/officeDocument/2006/relationships" xmlns:v="urn:schemas-microsoft-com:vml" xmlns:w="http://schemas.openxmlformats.org/wordprocessingml/2006/main" xmlns:w10="urn:schemas-microsoft-com:office:word" xmlns:wp="http://schemas.openxmlformats.org/drawingml/2006/wordprocessingDrawing" xmlns:wps="http://schemas.microsoft.com/office/word/2010/wordprocessingShape" xmlns:wpg="http://schemas.microsoft.com/office/word/2010/wordprocessingGroup" xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006" xmlns:wp14="http://schemas.microsoft.com/office/word/2010/wordprocessingDrawing" xmlns:w14="http://schemas.microsoft.com/office/word/2010/wordml" xmlns:w15="http://schemas.microsoft.com/office/word/2012/wordml" mc:Ignorable="w14 wp14 w15">
@@ -10,7 +15,26 @@ const DEFAULT_COMMENTS_EXTENDED_XML = `<?xml version="1.0" encoding="UTF-8" stan
     </w15:commentsEx>`
 
 export class DOCXExporterComments {
-    constructor(docContent, commentsDB, xml, rels, richtext) {
+    docContent: FidusNode
+    commentsDB: Record<string, CommentData>
+    xml: XmlZip
+    rels: DOCXExporterRels
+    richtext: any
+
+    usedComments: string[]
+    commentsXML: XMLElement | null
+    commentsExtendedXML: XMLElement | null
+    commentsFilePath: string
+    commentsExtendedFilePath: string
+    commentIdCounter: number
+
+    constructor(
+        docContent: FidusNode,
+        commentsDB: Record<string, CommentData>,
+        xml: XmlZip,
+        rels: DOCXExporterRels,
+        richtext: any
+    ) {
         this.docContent = docContent
         this.commentsDB = commentsDB
         this.xml = xml
@@ -18,14 +42,14 @@ export class DOCXExporterComments {
         this.richtext = richtext
 
         this.usedComments = []
-        this.commentsXML = false
-        this.commentsExtendedXML = false
+        this.commentsXML = null
+        this.commentsExtendedXML = null
         this.commentsFilePath = "word/comments.xml"
         this.commentsExtendedFilePath = "word/commentsExtended.xml"
         this.commentIdCounter = -1
     }
 
-    init() {
+    init(): Promise<void> | undefined {
         let useExtended = false
         descendantNodes(this.docContent).forEach(node => {
             if (node.marks) {
@@ -33,14 +57,17 @@ export class DOCXExporterComments {
                     mark => mark.type === "comment"
                 )
                 comments.forEach(comment => {
+                    const commentId = String(comment.attrs?.id)
                     if (
-                        !this.usedComments.includes(comment.attrs.id) &&
-                        this.commentsDB[comment.attrs.id]
+                        commentId &&
+                        !this.usedComments.includes(commentId) &&
+                        this.commentsDB[commentId]
                     ) {
-                        this.usedComments.push(comment.attrs.id)
+                        this.usedComments.push(commentId)
+                        const commentDBEntry = this.commentsDB[commentId]
                         if (
-                            this.commentsDB[comment.attrs.id].resolved ||
-                            this.commentsDB[comment.attrs.id].answers?.length
+                            commentDBEntry.resolved ||
+                            commentDBEntry.answers?.length
                         ) {
                             useExtended = true
                         }
@@ -52,10 +79,13 @@ export class DOCXExporterComments {
             return Promise.resolve()
         }
         this.rels.addCommentsRel()
-        const addCommentXMLs = [
+        const addCommentXMLs: Array<Promise<void>> = [
             this.xml
                 .getXml(this.commentsFilePath, DEFAULT_COMMENTS_XML)
-                .then(commentsXML => (this.commentsXML = commentsXML))
+                .then(commentsXML => {
+                    this.commentsXML = commentsXML
+                    return undefined
+                })
         ]
         if (useExtended) {
             this.rels.addCommentsExtendedRel()
@@ -65,15 +95,18 @@ export class DOCXExporterComments {
                         this.commentsExtendedFilePath,
                         DEFAULT_COMMENTS_EXTENDED_XML
                     )
-                    .then(
-                        commentsExtendedXML =>
-                            (this.commentsExtendedXML = commentsExtendedXML)
-                    )
+                    .then(commentsExtendedXML => {
+                        this.commentsExtendedXML = commentsExtendedXML
+                        return undefined
+                    })
             )
         }
         return Promise.all(addCommentXMLs).then(() => {
+            if (!this.commentsXML) {
+                return Promise.resolve()
+            }
             this.commentsXML.queryAll("w:comment").forEach(el => {
-                const id = Number.parseInt(el.getAttribute("w:id"))
+                const id = Number.parseInt(String(el.getAttribute("w:id")))
                 if (id > this.commentIdCounter) {
                     this.commentIdCounter = id
                 }
@@ -82,11 +115,17 @@ export class DOCXExporterComments {
         })
     }
 
-    addComment(id) {
+    addComment(id: string): void {
         const commentId = ++this.commentIdCounter
         this.richtext.comments[id] = commentId
         const commentDBEntry = this.commentsDB[id]
+        if (!this.commentsXML || !commentDBEntry) {
+            return
+        }
         const comments = this.commentsXML.query("w:comments")
+        if (!comments) {
+            return
+        }
         let string = `<w:comment w:id="${commentId}" w:author="${escapeText(commentDBEntry.username)}" w:date="${new Date(commentDBEntry.date).toISOString().split(".")[0]}Z" w:initials="${escapeText(
             commentDBEntry.username
                 .split(" ")
@@ -97,7 +136,7 @@ export class DOCXExporterComments {
         let parentParagraphId = ""
         string += commentDBEntry.comment
             .map((node, index) => {
-                const options = {section: "CommentText"}
+                const options: Record<string, unknown> = {section: "CommentText"}
                 if (
                     (commentDBEntry.resolved ||
                         commentDBEntry.answers?.length) &&
@@ -110,9 +149,11 @@ export class DOCXExporterComments {
                         .padStart(8, "0")
                     options.paragraphId = parentParagraphId
                     const extendedString = `<w15:commentEx w15:paraId="${parentParagraphId}" w15:done="${commentDBEntry.resolved ? "1" : "0"}"/>`
-                    const extendedComments =
-                        this.commentsExtendedXML.query("w15:commentsEx")
-                    extendedComments.appendXML(extendedString)
+                    if (this.commentsExtendedXML) {
+                        const extendedComments =
+                            this.commentsExtendedXML.query("w15:commentsEx")
+                        extendedComments?.appendXML(extendedString)
+                    }
                 }
                 if (!index) {
                     options.commentReference = true
@@ -132,7 +173,7 @@ export class DOCXExporterComments {
             )}">`
             string += answer.answer
                 .map((node, index) => {
-                    const options = {section: "CommentText"}
+                    const options: Record<string, unknown> = {section: "CommentText"}
                     if (index === answer.answer.length - 1) {
                         // We need to add an id to the last paragraph of the comment and add an entry
                         // into commentsExtended.xml pointing to the last paragraph of the parent comment.
@@ -141,9 +182,11 @@ export class DOCXExporterComments {
                             .padStart(8, "0")
                         options.paragraphId = paragraphId
                         const extendedString = `<w15:commentEx w15:paraId="${paragraphId}" w15:done="${commentDBEntry.resolved ? "1" : "0"}" w15:paraIdParent="${parentParagraphId}"/>`
-                        const extendedComments =
-                            this.commentsExtendedXML.query("w15:commentsEx")
-                        extendedComments.appendXML(extendedString)
+                        if (this.commentsExtendedXML) {
+                            const extendedComments =
+                                this.commentsExtendedXML.query("w15:commentsEx")
+                            extendedComments?.appendXML(extendedString)
+                        }
                     }
                     if (!index) {
                         options.commentReference = true
@@ -156,7 +199,7 @@ export class DOCXExporterComments {
         comments.appendXML(string)
     }
 
-    exportComments() {
+    exportComments(): Promise<void> {
         this.usedComments.forEach(comment => {
             this.addComment(comment)
         })