@fiduswriter/editor 0.1.20 → 0.1.22

package/src/citations/{render.js → render.ts}

@@ -1,15 +1,36 @@
 import {FormatCitations} from "@fiduswriter/document/citations/format"
+import type {BibDB, CSL} from "@fiduswriter/document"
+
+interface CitationInfo {
+    format: string
+    references: Array<{
+        id: number
+        [key: string]: unknown
+    }>
+}
+
 /**
  * Render citations into the DOM.
  */
 
 export class RenderCitations {
+    contentElement: HTMLElement
+    citationStyle: string
+    bibliographyHeader: string
+    bibDB: BibDB
+    csl: CSL
+    synchronous: boolean
+    lang: string
+    allCitationNodes: NodeListOf<HTMLElement>
+    allCitationInfos: CitationInfo[]
+    fm: FormatCitations | false
+
     constructor(
-        contentElement,
-        citationStyle,
-        bibliographyHeader,
-        bibDB,
-        csl,
+        contentElement: HTMLElement,
+        citationStyle: string,
+        bibliographyHeader: string,
+        bibDB: BibDB,
+        csl: CSL,
         synchronous = false,
         lang = "en-US"
     ) {
@@ -21,17 +42,19 @@ export class RenderCitations {
         this.synchronous = synchronous
         this.lang = lang
 
-        this.allCitationNodes = []
+        this.allCitationNodes = document.querySelectorAll("span.citation")
         this.allCitationInfos = []
         this.fm = false
     }
 
-    init() {
+    init(): boolean | Promise<void> {
         this.allCitationNodes =
             this.contentElement.querySelectorAll("span.citation")
         this.allCitationNodes.forEach(cElement => {
-            const citeInfo = Object.assign({}, cElement.dataset)
-            citeInfo.references = JSON.parse(citeInfo.references)
+            const citeInfo: CitationInfo = {
+                format: cElement.dataset.format || "",
+                references: JSON.parse(cElement.dataset.references || "[]")
+            }
             this.allCitationInfos.push(citeInfo)
         })
         this.fm = new FormatCitations(
@@ -50,15 +73,20 @@ export class RenderCitations {
             this.renderCitations()
             return true
         } else {
-            return this.fm.init().then(() => {
-                this.renderCitations()
-                return Promise.resolve()
-            })
+            const initResult = this.fm.init()
+            if (initResult instanceof Promise) {
+                return initResult.then(() => {
+                    this.renderCitations()
+                    return Promise.resolve()
+                })
+            }
+            this.renderCitations()
+            return Promise.resolve()
         }
     }
 
-    renderCitations() {
-        if ("note" !== this.fm.citationType) {
+    renderCitations(): void {
+        if (this.fm && "note" !== this.fm.citationType) {
             this.fm.citationTexts.forEach(
                 (citationText, index) =>
                     (this.allCitationNodes[index].innerHTML = citationText)

package/src/clipboard/copy/{schema.js → schema.ts}

@@ -4,13 +4,22 @@ import {DOMSerializer, Node, Schema} from "prosemirror-model"
 import {citation} from "@fiduswriter/document/schema/common/index"
 import {footnote} from "@fiduswriter/document/schema/document/content"
 import {fnSchema} from "@fiduswriter/document/schema/footnotes"
+import type {BibDB} from "@fiduswriter/document"
+
+interface CachedSchema {
+    cached: {bibDB: BibDB}
+}
+
+const asCached = (schema: Schema): CachedSchema => schema as unknown as CachedSchema
 
 const copyCitation = Object.assign({}, citation)
 
 copyCitation.toDOM = node => {
-    const bibDB = node.type.schema.cached.bibDB,
-        bibs = {}
-    node.attrs.references.forEach(ref => (bibs[ref.id] = bibDB.db[ref.id]))
+    const bibDB = asCached(node.type.schema).cached.bibDB,
+        bibs: Record<string, Record<string, unknown>> = {}
+    ;(node.attrs.references as Array<{id: number | string}>).forEach(
+        ref => (bibs[ref.id] = bibDB.db[ref.id])
+    )
     return [
         "span",
         {
@@ -35,8 +44,8 @@ export const fnCopySchema = new Schema({
 const copyFootnote = Object.assign({}, footnote)
 
 copyFootnote.toDOM = node => {
-    if (!fnCopySchema.cached.bibDB) {
-        fnCopySchema.cached.bibDB = fnSchema.cached.bibDB
+    if (!asCached(fnCopySchema).cached.bibDB) {
+        asCached(fnCopySchema).cached.bibDB = asCached(fnSchema).cached.bibDB
     }
     const fnCopySerializer = DOMSerializer.fromSchema(fnCopySchema)
     const dom = document.createElement("span")
@@ -45,18 +54,20 @@ copyFootnote.toDOM = node => {
         type: "footnotecontainer",
         content: node.attrs.footnote
     })
-    dom.dataset.footnote = fnCopySerializer.serializeNode(pmNode).innerHTML
+    dom.dataset.footnote = (
+        fnCopySerializer.serializeNode(pmNode) as HTMLElement
+    ).innerHTML
     dom.innerHTML = "&nbsp;"
     return dom
 }
 
-export const createDocCopySchema = docSchema => {
+export const createDocCopySchema = (docSchema: Schema): Schema => {
     const newSchema = new Schema({
         marks: docSchema.spec.marks,
         nodes: docSchema.spec.nodes
             .update("citation", copyCitation)
             .update("footnote", copyFootnote)
     })
-    newSchema.cached.bibDB = docSchema.cached.bibDB
+    asCached(newSchema).cached.bibDB = asCached(docSchema).cached.bibDB
     return newSchema
 }

package/src/clipboard/copy/{serializers.js → serializers.ts}

@@ -1,24 +1,30 @@
 import {BIBLIOGRAPHY_HEADERS} from "@fiduswriter/document/schema/i18n"
+import type {Fragment, Schema} from "prosemirror-model"
 import {DOMSerializer} from "prosemirror-model"
+
 import {RenderCitations} from "../../citations/render.js"
 import {createDocCopySchema, fnCopySchema} from "./schema.js"
+import type {Editor} from "../../types.js"
 
 // Wrap around DOMSerializer, allowing post processing.
 class ClipboardDOMSerializer {
-    constructor(nodes, marks, editor) {
+    domSerializer: DOMSerializer
+    editor: Editor
+
+    constructor(nodes: Record<string, any>, marks: Record<string, any>, editor: Editor) {
         this.domSerializer = new DOMSerializer(nodes, marks)
         this.editor = editor
     }
 
-    serializeFragment(fragment, options) {
+    serializeFragment(fragment: Fragment, options?: {document?: Document}): DocumentFragment {
         const domFragment = this.domSerializer.serializeFragment(
             fragment,
             options
         )
-        return this.postProcessFragment(domFragment)
+        return this.postProcessFragment(domFragment as DocumentFragment)
     }
 
-    postProcessFragment(domFragment) {
+    postProcessFragment(domFragment: DocumentFragment): DocumentFragment {
         const citationFormatter = this.renderCitations(domFragment)
         this.renderFootnotes(domFragment, citationFormatter)
         this.removeTrackingData(domFragment)
@@ -27,34 +33,37 @@ class ClipboardDOMSerializer {
         return domFragment
     }
 
-    renderCitations(domFragment) {
-        const settings = this.editor.view.state.doc.attrs,
+    renderCitations(domFragment: DocumentFragment): any {
+        const settings = this.editor.view.state.doc.attrs as Record<string, any>,
             bibliographyHeader =
                 settings.bibliography_header[settings.language] ||
-                BIBLIOGRAPHY_HEADERS[settings.language]
+                (BIBLIOGRAPHY_HEADERS as any)[settings.language]
         const citRenderer = new RenderCitations(
-            domFragment,
+            domFragment as any,
             settings.citationstyle,
             bibliographyHeader,
-            this.editor.mod.db.bibDB,
-            this.editor.app.csl,
+            (this.editor.mod.db as any).bibDB,
+            (this.editor.app as any).csl,
             true // synchronous. Should work as the editor has used the same style previously.
         )
+        const fm = citRenderer.fm as any
         if (citRenderer.init()) {
-            if (citRenderer.fm.bibHTML.length) {
+            if (fm.bibHTML.length) {
                 const bibDiv = document.createElement("div")
                 bibDiv.classList.add("fiduswriter-clipboard-bibliography")
-                bibDiv.innerHTML = citRenderer.fm.bibHTML
-                bibDiv.firstElementChild.innerHTML = gettext("Bibliography")
+                bibDiv.innerHTML = fm.bibHTML
+                ;(bibDiv.firstElementChild as HTMLElement).innerHTML = gettext(
+                    "Bibliography"
+                )
                 domFragment.appendChild(bibDiv)
             }
-            return citRenderer.fm
+            return fm
         } else {
             return false
         }
     }
 
-    renderFootnotes(domFragment, citationFormatter) {
+    renderFootnotes(domFragment: DocumentFragment, citationFormatter: any): void {
         const footnoteSelector =
             citationFormatter && citationFormatter.citationType === "note"
                 ? ".footnote-marker, .citation"
@@ -76,13 +85,13 @@ class ClipboardDOMSerializer {
             const newFootnote = document.createElement("h6") // We use H6 as Wordpress Gutenberg only allows IDs on H1-6 elements.
             newFootnote.setAttribute("role", "doc-footnote")
             newFootnote.innerHTML = footnote.matches(".footnote-marker")
-                ? footnote.dataset.footnote
+                ? (footnote as HTMLElement).dataset.footnote || ""
                 : `<p>${citationFormatter.citationTexts[citationCount++] || " "}</p>`
             if (
                 newFootnote.firstElementChild &&
                 newFootnote.firstElementChild.matches("p")
             ) {
-                newFootnote.firstElementChild.insertAdjacentHTML(
+                ;(newFootnote.firstElementChild as HTMLElement).insertAdjacentHTML(
                     "afterbegin",
                     `${counter}. `
                 )
@@ -100,13 +109,14 @@ class ClipboardDOMSerializer {
         }
     }
 
-    addFigureNumbers(domFragment) {
+    addFigureNumbers(domFragment: DocumentFragment): void {
         domFragment
             .querySelectorAll(
                 "figure[data-category='figure'] figcaption span.label"
             )
             .forEach((el, index) => {
-                el.innerHTML += " " + (index + 1) + ": "
+                ;(el as HTMLElement).innerHTML +=
+                    " " + (index + 1) + ": "
             })
 
         domFragment
@@ -114,7 +124,8 @@ class ClipboardDOMSerializer {
                 "figure[data-category='photo'] figcaption span.label"
             )
             .forEach((el, index) => {
-                el.innerHTML += " " + (index + 1) + ": "
+                ;(el as HTMLElement).innerHTML +=
+                    " " + (index + 1) + ": "
             })
 
         domFragment
@@ -122,21 +133,22 @@ class ClipboardDOMSerializer {
                 "figure[data-category='table'] figcaption span.label"
             )
             .forEach((el, index) => {
-                el.innerHTML += " " + (index + 1) + ": "
+                ;(el as HTMLElement).innerHTML +=
+                    " " + (index + 1) + ": "
             })
     }
 
-    addBaseUrlToImages(domFragment) {
+    addBaseUrlToImages(domFragment: DocumentFragment): void {
         domFragment
             .querySelectorAll("img")
             .forEach(el => el.setAttribute("src", el.src))
     }
 
-    getRandomID() {
+    getRandomID(): string {
         return (0 | (Math.random() * 9e6)).toString(36)
     }
 
-    getFootnoteAnchor(counter, id) {
+    getFootnoteAnchor(counter: number, id: string): HTMLElement {
         const footnoteAnchor = document.createElement("a")
         footnoteAnchor.setAttribute("href", `#fn-${id}`)
         footnoteAnchor.classList.add("fn")
@@ -145,11 +157,11 @@ class ClipboardDOMSerializer {
         return footnoteAnchor
     }
 
-    removeTrackingData(domFragment) {
+    removeTrackingData(domFragment: DocumentFragment): void {
         domFragment
             .querySelectorAll(".approved-insertion, .insertion")
             .forEach(el => {
-                const parent = el.parentNode
+                const parent = el.parentNode as any
                 const fragment = document.createDocumentFragment()
                 while (el.firstChild) {
                     fragment.appendChild(el.firstChild)
@@ -158,10 +170,10 @@ class ClipboardDOMSerializer {
             })
         domFragment
             .querySelectorAll(".deletion")
-            .forEach(el => el.parentElement.removeChild(el))
+            .forEach(el => el.parentElement!.removeChild(el))
     }
 
-    static fromSchema(schema, editor) {
+    static fromSchema(schema: Schema, editor: Editor): ClipboardDOMSerializer {
         return new ClipboardDOMSerializer(
             DOMSerializer.nodesFromSchema(schema),
             DOMSerializer.marksFromSchema(schema),
@@ -170,10 +182,10 @@ class ClipboardDOMSerializer {
     }
 }
 
-export const docClipboardSerializer = editor =>
+export const docClipboardSerializer = (editor: Editor): ClipboardDOMSerializer =>
     ClipboardDOMSerializer.fromSchema(
-        createDocCopySchema(editor.schema),
+        createDocCopySchema(editor.schema) as Schema,
         editor
     )
-export const fnClipboardSerializer = editor =>
-    ClipboardDOMSerializer.fromSchema(fnCopySchema, editor)
+export const fnClipboardSerializer = (editor: Editor): ClipboardDOMSerializer =>
+    ClipboardDOMSerializer.fromSchema(fnCopySchema as Schema, editor)

package/src/clipboard/paste/{fidus_writer.js → fidus_writer.ts}

@@ -1,9 +1,11 @@
+import type {Editor} from "../../types.js"
+
 import {GeneralPasteHandler} from "./general.js"
 
 // Fidus Writer paste handler
 export class FidusWriterPasteHandler extends GeneralPasteHandler {
     // Convert an existing node to a different node, if needed.
-    convertNode(node) {
+    convertNode(node: HTMLElement): HTMLElement {
         node = super.convertNode(node)
         // Replace  nodes with other nodes to not change the number of child nodes
         // <b style="font-weight:normal;">...</b> => <span>...</span>
@@ -13,12 +15,30 @@ export class FidusWriterPasteHandler extends GeneralPasteHandler {
         return node
     }
 
-    verifyCitationNode(node) {
+    verifyCitationNode(node: HTMLElement): HTMLElement {
         try {
-            const bibs = JSON.parse(node.dataset.bibs),
-                references = JSON.parse(node.dataset.references),
-                bibDB = this.editor.mod.db.bibDB,
-                idTranslations = {}
+            const bibs = JSON.parse(node.dataset.bibs || "{}") as Record<
+                    string,
+                    Record<string, unknown>
+                >,
+                references = JSON.parse(node.dataset.references || "[]") as Array<{
+                    id: number | string
+                }>,
+                bibDB = (this.editor as Editor).mod.db?.bibDB as
+                    | {
+                          findReference: (
+                              reference: Record<string, unknown>
+                          ) => string | undefined
+                          addReference: (
+                              reference: Record<string, unknown>,
+                              id: string | number
+                          ) => string | number
+                      }
+                    | undefined,
+                idTranslations: Record<string, number | string> = {}
+            if (!bibDB) {
+                return node
+            }
             Object.keys(bibs).forEach(bibKey => {
                 const reference = bibs[bibKey]
                 const oldKey = bibDB.findReference(reference)
@@ -45,11 +65,11 @@ export class FidusWriterPasteHandler extends GeneralPasteHandler {
         }
     }
 
-    cleanDOM() {
+    cleanDOM(): void {
         // Remove the bibliography that was added by the copy serializer
         const clipboardArtifacts = this.dom.querySelectorAll(
             ".fiduswriter-clipboard-bibliography, .fiduswriter-clipboard-footnotes"
         )
-        clipboardArtifacts.forEach(el => el.parentElement.removeChild(el))
+        clipboardArtifacts.forEach(el => el.parentElement?.removeChild(el))
     }
 }

package/src/clipboard/paste/{general.js → general.ts}

@@ -1,15 +1,29 @@
+import type {Editor} from "../../types.js"
+
 // General Fallback handler for paste
 export class GeneralPasteHandler {
-    constructor(editor, htmlDoc, pmType) {
+    editor: Editor
+    htmlDoc: HTMLElement
+    pmType: string
+    footnoteMarkers: HTMLElement[]
+    footnotes: HTMLElement[]
+    dom: HTMLElement
+    inHTML: string
+    outHTML: string
+
+    constructor(editor: Editor, htmlDoc: HTMLElement, pmType: string) {
         this.editor = editor
         this.htmlDoc = htmlDoc
         this.pmType = pmType
         this.footnoteMarkers = []
         this.footnotes = []
+        this.dom = document.createElement("body")
+        this.inHTML = ""
+        this.outHTML = ""
     }
 
     // Iterate over each node in the body of the pasted content.
-    getOutput() {
+    getOutput(): string {
         this.dom = this.htmlDoc.getElementsByTagName("body")[0]
         this.inHTML = this.dom.innerHTML
         this.iterateNode(this.dom)
@@ -20,17 +34,17 @@ export class GeneralPasteHandler {
     }
 
     // Remove unused content
-    cleanDOM() {}
+    cleanDOM(): void {}
 
     // Iterate over pasted nodes and their children
-    iterateNode(node) {
-        if ((node.tagName === "P") & !node.firstChild) {
-            node.parentNode.removeChild(node)
-            return
+    iterateNode(node: ChildNode): boolean {
+        if ((node as HTMLElement).tagName === "P" && !node.firstChild) {
+            node.parentNode?.removeChild(node)
+            return true
         } else if (node.nodeType === 8) {
             // comment node
-            node.parentNode.removeChild(node)
-            return
+            node.parentNode?.removeChild(node)
+            return true
         } else if (node.nodeType === 1) {
             // element node
             let childNode = node.firstChild
@@ -39,12 +53,13 @@ export class GeneralPasteHandler {
                 this.iterateNode(childNode)
                 childNode = nextChildNode
             }
-            node = this.convertNode(node)
+            node = this.convertNode(node as HTMLElement)
         }
+        return true
     }
 
     // Convert an existing node to a different node, if needed.
-    convertNode(node) {
+    convertNode(node: HTMLElement): HTMLElement {
         if (
             node.tagName === "TABLE" &&
             node.firstElementChild?.tagName !== "CAPTION"
@@ -58,7 +73,7 @@ export class GeneralPasteHandler {
 
     // Move footnotes into their markers and turn footnote markers into the
     // required format.
-    convertFootnotes() {
+    convertFootnotes(): void {
         this.footnoteMarkers.forEach((fnM, index) => {
             const footnote = this.footnotes[index]
             const newFnM = document.createElement("span")
@@ -67,7 +82,7 @@ export class GeneralPasteHandler {
             // Remove linebreaks in string (not <BR>)
             // Turn multiple white spaces into single space
             newFnM.dataset.footnote = footnoteContents
-            fnM.parentNode.replaceChild(newFnM, fnM)
+            fnM.parentNode?.replaceChild(newFnM, fnM)
         })
         // Remove all footnotes from document. Some footnotes may have several
         // markers, so only remove each footnote once.

package/src/clipboard/paste/{google_docs.js → google_docs.ts}

@@ -3,23 +3,26 @@ import {GeneralPasteHandler} from "./general.js"
 // Google Docs (the writing component) paste handler
 export class GoogleDocsPasteHandler extends GeneralPasteHandler {
     // Convert an existing node to a different node, if needed.
-    convertNode(node) {
+    convertNode(node: HTMLElement) {
         node = super.convertNode(node)
         // Replace  nodes with other nodes to not change the number of child nodes
         // <b style="font-weight:normal;">...</b> => <span>...</span>
-        if (node.tagName === "B" && node.style.fontWeight === "normal") {
+        if (
+            node.tagName === "B" &&
+            node.style.fontWeight === "normal"
+        ) {
             node = this.neutralizeInlineNode(node)
         }
         return node
     }
 
     // Replace any type of inline node with a span node.
-    neutralizeInlineNode(node) {
+    neutralizeInlineNode(node: HTMLElement): HTMLElement {
         const newNode = document.createElement("span")
         while (node.firstChild) {
             newNode.appendChild(node.firstChild)
         }
-        node.parentNode.replaceChild(newNode, node)
+        node.parentNode?.replaceChild(newNode, node)
 
         return newNode
     }

package/src/clipboard/paste/{html.js → html.ts}

@@ -5,25 +5,49 @@ import {LibreOfficeWriterPasteHandler} from "./libreoffice_writer.js"
 import {MicrosoftWordPasteHandler} from "./microsoft_word.js"
 
 import {resetPasteRange} from "../../state_plugins/clipboard.js"
+import type {Editor} from "../../types.js"
 
 // Some pasted HTML will need slight conversions to work correctly.
 // We try to sniff whether paste comes from MsWord, LibreOffice or Google Docs
 // and use specialized handlers for these and a general handler everything else.
 
 export class HTMLPaste {
-    constructor(editor, inHTML, pmType, view) {
+    editor: Editor
+    inHTML: string
+    pmType: string
+    view: import("prosemirror-view").EditorView
+    htmlDoc: HTMLElement | undefined
+    handler:
+        | typeof FidusWriterPasteHandler
+        | typeof GeneralPasteHandler
+        | typeof GoogleDocsPasteHandler
+        | typeof LibreOfficeWriterPasteHandler
+        | typeof MicrosoftWordPasteHandler
+    handlerInstance: GeneralPasteHandler
+    outHTML: string
+
+    constructor(
+        editor: Editor,
+        inHTML: string,
+        pmType: string,
+        view: import("prosemirror-view").EditorView
+    ) {
         this.editor = editor
         this.inHTML = inHTML
         this.pmType = pmType
         this.view = view
+        this.htmlDoc = undefined
+        this.handler = GeneralPasteHandler
+        this.handlerInstance = new GeneralPasteHandler(editor, document.createElement("html"), pmType)
+        this.outHTML = ""
     }
 
-    getOutput() {
+    getOutput(): string {
         this.parseHTML()
         this.selectHandler()
         this.handlerInstance = new this.handler(
             this.editor,
-            this.htmlDoc,
+            this.htmlDoc as HTMLElement,
             this.pmType
         )
         this.outHTML = this.handlerInstance.getOutput()
@@ -33,7 +57,7 @@ export class HTMLPaste {
         return this.outHTML
     }
 
-    parseHTML() {
+    parseHTML(): void {
         const parser = new window.DOMParser()
         this.htmlDoc = parser
             .parseFromString(this.inHTML, "text/html")
@@ -42,13 +66,16 @@ export class HTMLPaste {
 
     // Find out what the source of the paste is and choose a corresponding
     // handler.
-    selectHandler() {
+    selectHandler(): void {
+        if (!this.htmlDoc) {
+            return
+        }
         // For LibreOffice
         const head = this.htmlDoc.getElementsByTagName("head")[0]
-        const generatorMetaTag = head.querySelector("meta[name=generator]")
+        const generatorMetaTag = head.querySelector("meta[name=generator]") as HTMLMetaElement | null
         // For Google Docs
         const body = this.htmlDoc.getElementsByTagName("body")[0]
-        const firstB = body.querySelector("b")
+        const firstB = body.querySelector("b") as HTMLElement | null
         // For Fidus Writer
         const pmSlice = this.htmlDoc.querySelector("[data-pm-slice]")
         if (
@@ -68,7 +95,7 @@ export class HTMLPaste {
         }
     }
 
-    resetPasteRange() {
+    resetPasteRange(): void {
         const tr = this.view.state.tr
         resetPasteRange(tr)
         this.view.dispatch(tr)

package/src/clipboard/paste/{libreoffice_writer.js → libreoffice_writer.ts}

@@ -3,7 +3,7 @@ import {GeneralPasteHandler} from "./general.js"
 // LibreOffice Writer paste handler
 export class LibreOfficeWriterPasteHandler extends GeneralPasteHandler {
     // Convert an existing node to a different node, if needed.
-    convertNode(node) {
+    convertNode(node: HTMLElement) {
         node = super.convertNode(node)
         // Footnote markers (only in main pm instance):
         if (
@@ -12,15 +12,15 @@ export class LibreOfficeWriterPasteHandler extends GeneralPasteHandler {
             this.pmType === "main"
         ) {
             // Remove "sym" at the end of the selector
-            const href = node.getAttribute("href")
+            const href = node.getAttribute("href") || ""
             const fnSelector =
                 href.length > 3 ? href.substring(0, href.length - 3) : href
-            const footnote = this.dom.querySelector(fnSelector)
+            const footnote = this.dom.querySelector(fnSelector) as HTMLElement | null
             if (footnote) {
                 const footnoteCounter =
                     footnote.querySelector("a.sdfootnotesym")
                 if (footnoteCounter) {
-                    footnoteCounter.parentNode.removeChild(footnoteCounter)
+                    footnoteCounter.parentNode?.removeChild(footnoteCounter)
                 }
                 this.footnoteMarkers.push(node)
                 this.footnotes.push(footnote)