Properly support currency fields

Add column width calculation
Update repository url
2026-02-05 03:32:14 -07:00 · 2026-02-05 01:54:56 -07:00 · 2026-02-05 01:10:55 -07:00 · 2026-02-05 01:10:10 -07:00 · 2025-09-22 16:35:43 +02:00 · 2025-09-22 16:35:13 +02:00
31 changed files with 1570 additions and 495 deletions
--- a/.gitignore
+++ b/.gitignore
@ -3,5 +3,7 @@ node_modules/
 build/*

 .~lock*
+**/*(Copie)*
+**/*(Copy)*

 stats.html
--- a/package-lock.json
+++ b/package-lock.json
@ -1,16 +1,17 @@
 {
  "name": "@odfjs/odfjs",
-  "version": "0.18.0",
+  "version": "0.30.0",
  "lockfileVersion": 2,
  "requires": true,
  "packages": {
    "": {
      "name": "@odfjs/odfjs",
-      "version": "0.18.0",
+      "version": "0.30.0",
      "dependencies": {
        "@xmldom/xmldom": "^0.9.8",
        "@zip.js/zip.js": "^2.7.57",
-        "ses": "^1.12.0"
+        "image-size": "^2.0.2",
+        "ses": "^1.14.0"
      },
      "devDependencies": {
        "@rollup/plugin-commonjs": "^25.0.7",
@ -41,10 +42,22 @@
        "node": ">=6.0.0"
      }
    },
+    "node_modules/@endo/cache-map": {
+      "version": "1.1.0",
+      "resolved": "https://registry.npmjs.org/@endo/cache-map/-/cache-map-1.1.0.tgz",
+      "integrity": "sha512-owFGshs/97PDw9oguZqU/px8Lv1d0KjAUtDUiPwKHNXRVUE/jyettEbRoTbNJR1OaI8biMn6bHr9kVJsOh6dXw==",
+      "license": "Apache-2.0"
+    },
    "node_modules/@endo/env-options": {
-      "version": "1.1.8",
-      "resolved": "https://registry.npmjs.org/@endo/env-options/-/env-options-1.1.8.tgz",
-      "integrity": "sha512-Xtxw9n33I4guo8q0sDyZiRuxlfaopM454AKiELgU7l3tqsylCut6IBZ0fPy4ltSHsBib7M3yF7OEMoIuLwzWVg==",
+      "version": "1.1.11",
+      "resolved": "https://registry.npmjs.org/@endo/env-options/-/env-options-1.1.11.tgz",
+      "integrity": "sha512-p9OnAPsdqoX4YJsE98e3NBVhIr2iW9gNZxHhAI2/Ul5TdRfoOViItzHzTqrgUVopw6XxA1u1uS6CykLMDUxarA==",
+      "license": "Apache-2.0"
+    },
+    "node_modules/@endo/immutable-arraybuffer": {
+      "version": "1.1.2",
+      "resolved": "https://registry.npmjs.org/@endo/immutable-arraybuffer/-/immutable-arraybuffer-1.1.2.tgz",
+      "integrity": "sha512-u+NaYB2aqEugQ3u7w3c5QNkPogf8q/xGgsPaqdY6pUiGWtYiTiFspKFcha6+oeZhWXWQ23rf0KrUq0kfuzqYyQ==",
      "license": "Apache-2.0"
    },
    "node_modules/@jridgewell/gen-mapping": {
@ -2185,6 +2198,18 @@
        "node": ">=10 <11 || >=12 <13 || >=14"
      }
    },
+    "node_modules/image-size": {
+      "version": "2.0.2",
+      "resolved": "https://registry.npmjs.org/image-size/-/image-size-2.0.2.tgz",
+      "integrity": "sha512-IRqXKlaXwgSMAMtpNzZa1ZAe8m+Sa1770Dhk8VkSsP9LS+iHD62Zd8FQKs8fbPiagBE7BzoFX23cxFnwshpV6w==",
+      "license": "MIT",
+      "bin": {
+        "image-size": "bin/image-size.js"
+      },
+      "engines": {
+        "node": ">=16.x"
+      }
+    },
    "node_modules/immutable": {
      "version": "4.2.4",
      "resolved": "https://registry.npmjs.org/immutable/-/immutable-4.2.4.tgz",
@ -3615,12 +3640,14 @@
      }
    },
    "node_modules/ses": {
-      "version": "1.12.0",
-      "resolved": "https://registry.npmjs.org/ses/-/ses-1.12.0.tgz",
-      "integrity": "sha512-jvmwXE2lFxIIY1j76hFjewIIhYMR9Slo3ynWZGtGl5M7VUCw3EA0wetS+JCIbl2UcSQjAT0yGAHkyxPJreuC9w==",
+      "version": "1.14.0",
+      "resolved": "https://registry.npmjs.org/ses/-/ses-1.14.0.tgz",
+      "integrity": "sha512-T07hNgOfVRTLZGwSS50RnhqrG3foWP+rM+Q5Du4KUQyMLFI3A8YA4RKl0jjZzhihC1ZvDGrWi/JMn4vqbgr/Jg==",
      "license": "Apache-2.0",
      "dependencies": {
-        "@endo/env-options": "^1.1.8"
+        "@endo/cache-map": "^1.1.0",
+        "@endo/env-options": "^1.1.11",
+        "@endo/immutable-arraybuffer": "^1.1.2"
      }
    },
    "node_modules/set-blocking": {
@ -4571,10 +4598,20 @@
        "@jridgewell/trace-mapping": "^0.3.9"
      }
    },
+    "@endo/cache-map": {
+      "version": "1.1.0",
+      "resolved": "https://registry.npmjs.org/@endo/cache-map/-/cache-map-1.1.0.tgz",
+      "integrity": "sha512-owFGshs/97PDw9oguZqU/px8Lv1d0KjAUtDUiPwKHNXRVUE/jyettEbRoTbNJR1OaI8biMn6bHr9kVJsOh6dXw=="
+    },
    "@endo/env-options": {
-      "version": "1.1.8",
-      "resolved": "https://registry.npmjs.org/@endo/env-options/-/env-options-1.1.8.tgz",
-      "integrity": "sha512-Xtxw9n33I4guo8q0sDyZiRuxlfaopM454AKiELgU7l3tqsylCut6IBZ0fPy4ltSHsBib7M3yF7OEMoIuLwzWVg=="
+      "version": "1.1.11",
+      "resolved": "https://registry.npmjs.org/@endo/env-options/-/env-options-1.1.11.tgz",
+      "integrity": "sha512-p9OnAPsdqoX4YJsE98e3NBVhIr2iW9gNZxHhAI2/Ul5TdRfoOViItzHzTqrgUVopw6XxA1u1uS6CykLMDUxarA=="
+    },
+    "@endo/immutable-arraybuffer": {
+      "version": "1.1.2",
+      "resolved": "https://registry.npmjs.org/@endo/immutable-arraybuffer/-/immutable-arraybuffer-1.1.2.tgz",
+      "integrity": "sha512-u+NaYB2aqEugQ3u7w3c5QNkPogf8q/xGgsPaqdY6pUiGWtYiTiFspKFcha6+oeZhWXWQ23rf0KrUq0kfuzqYyQ=="
    },
    "@jridgewell/gen-mapping": {
      "version": "0.3.2",
@ -6129,6 +6166,11 @@
      "integrity": "sha512-yiWd4GVmJp0Q6ghmM2B/V3oZGRmjrKLXvHR3TE1nfoXsmoggllfZUQe74EN0fJdPFZu2NIvNdrMMLm3OsV7Ohw==",
      "dev": true
    },
+    "image-size": {
+      "version": "2.0.2",
+      "resolved": "https://registry.npmjs.org/image-size/-/image-size-2.0.2.tgz",
+      "integrity": "sha512-IRqXKlaXwgSMAMtpNzZa1ZAe8m+Sa1770Dhk8VkSsP9LS+iHD62Zd8FQKs8fbPiagBE7BzoFX23cxFnwshpV6w=="
+    },
    "immutable": {
      "version": "4.2.4",
      "resolved": "https://registry.npmjs.org/immutable/-/immutable-4.2.4.tgz",
@ -7138,11 +7180,13 @@
      }
    },
    "ses": {
-      "version": "1.12.0",
-      "resolved": "https://registry.npmjs.org/ses/-/ses-1.12.0.tgz",
-      "integrity": "sha512-jvmwXE2lFxIIY1j76hFjewIIhYMR9Slo3ynWZGtGl5M7VUCw3EA0wetS+JCIbl2UcSQjAT0yGAHkyxPJreuC9w==",
+      "version": "1.14.0",
+      "resolved": "https://registry.npmjs.org/ses/-/ses-1.14.0.tgz",
+      "integrity": "sha512-T07hNgOfVRTLZGwSS50RnhqrG3foWP+rM+Q5Du4KUQyMLFI3A8YA4RKl0jjZzhihC1ZvDGrWi/JMn4vqbgr/Jg==",
      "requires": {
-        "@endo/env-options": "^1.1.8"
+        "@endo/cache-map": "^1.1.0",
+        "@endo/env-options": "^1.1.11",
+        "@endo/immutable-arraybuffer": "^1.1.2"
      }
    },
    "set-blocking": {
--- a/package.json
+++ b/package.json
@ -1,8 +1,12 @@
 {
  "name": "@odfjs/odfjs",
-  "version": "0.18.0",
+  "version": "0.30.0",
  "type": "module",
  "exports": "./exports.js",
+  "files": [
+    "exports.js",
+    "scripts"
+  ],
  "imports": {
    "#DOM": {
      "node": "./scripts/DOM/node.js",
@ -17,7 +21,7 @@
    "test": "ava"
  },
  "repository": {
-    "url": "https://github.com/odfjs/odfjs.git"
+    "url": "https://source.netsyms.com/PostalPortal/odfjs.git"
  },
  "devDependencies": {
    "@rollup/plugin-commonjs": "^25.0.7",
@ -37,6 +41,7 @@
  "dependencies": {
    "@xmldom/xmldom": "^0.9.8",
    "@zip.js/zip.js": "^2.7.57",
-    "ses": "^1.12.0"
+    "image-size": "^2.0.2",
+    "ses": "^1.14.0"
  }
 }
--- a/readme.md
+++ b/readme.md
@ -18,7 +18,7 @@ Small lib to parse/understand .odf files (.odt, .ods) in the browser and node.js
 ### Install

 ```sh
-npm i https://github.com/odfjs/odfjs.git#v0.18.0
+npm i https://github.com/odfjs/odfjs.git#v0.30.0
 ```


@ -99,8 +99,7 @@ And then run the code:
 ```js
 import {join} from 'node:path';

-import {getOdtTemplate} from '../scripts/odf/odtTemplate-forNode.js'
-import {fillOdtTemplate} from '../scripts/node.js'
+import {getOdtTemplate, fillOdtTemplate} from '@odfjs/odfjs'

 // replace with your template path
 const templatePath = join(import.meta.dirname, './tests/data/template-anniversaire.odt')
@ -126,6 +125,19 @@ There are also loops in the form:
 They can be used to generate lists or tables in .odt files from data and a template using this syntax


+#### Securing calls to fillOdtTemplate
+
+`fillOdtTemplate` evaluate arbitrary JavaScript code in `{#each <collection> as élément}` and `{#if <condition>}` and in `{<expression>}`
+
+By default, `fillOdtTemplate` limits access to global functions to only ECMAScript defaults via the use of [ses' Compartment](https://www.npmjs.com/package/ses#compartment), this prevents naïve data exfiltration
+
+However, `fillOdtTemplate` is vulnerable to [prototype pollution](https://cheatsheetseries.owasp.org/cheatsheets/Prototype_Pollution_Prevention_Cheat_Sheet.html) inside template code. Two main ways to be secure are:
+- control the set of possible templates
+- call ses' `lockdown` which freezes Javascript intrinsics before calling `fillOdtTemplate` (this may lead to incompatibilities)
+
+
+
+
 ### Demo

 https://odfjs.github.io/odfjs/
@ -146,4 +158,3 @@ npm run dev
 I hope to be credited for the work on this repo

 Everything written by me and contributors to this repo is licenced under **CC0 1.0 (Public Domain)**
-
--- a/scripts/DOMUtils.js
+++ b/scripts/DOMUtils.js
@ -42,6 +42,51 @@ export function traverse(node, visit) {
    visit(node);
 }

+
+/**
+ * 
+ * @param {Node} node1 
+ * @param {Node} node2 
+ * @returns {Node}
+ */
+export function findCommonAncestor(node1, node2) {
+    const ancestors1 = getAncestors(node1);
+    const ancestors2 = new Set(getAncestors(node2));
+
+    for(const ancestor of ancestors1) {
+        if(ancestors2.has(ancestor)) {
+            return ancestor;
+        }
+    }
+
+    throw new Error(`node1 and node2 do not have a common ancestor`)
+}
+
+/**
+ * returns ancestors youngest first, oldest last
+ * 
+ * @param {Node} node 
+ * @param {Node} [until] 
+ * @returns {Node[]} 
+ */
+export function getAncestors(node, until = undefined) {
+    const ancestors = [];
+    let current = node;
+
+    while(current && current !== until) {
+        ancestors.push(current);
+        current = current.parentNode;
+    }
+
+    if(current === until){
+        ancestors.push(until);
+    }
+
+    return ancestors;
+}
+
+
+
 export {
    DOMParser, 
    XMLSerializer,
--- a/scripts/createOdsFile.js
+++ b/scripts/createOdsFile.js
@ -10,7 +10,11 @@ const stylesXml = `<?xml version="1.0" encoding="UTF-8"?>
  xmlns:office="urn:oasis:names:tc:opendocument:xmlns:office:1.0"
  xmlns:style="urn:oasis:names:tc:opendocument:xmlns:style:1.0"
  office:version="1.2">
-  <office:styles/>
+  <office:styles>
+    <style:style style:name="boldcell" style:family="table-cell">
+      <style:text-properties fo:font-weight="bold"/>
+    </style:style>
+  </office:styles>
  <office:automatic-styles/>
  <office:master-styles/>
 </office:document-styles>`;
@ -27,7 +31,7 @@ const manifestXml = `<?xml version="1.0" encoding="UTF-8"?>
 * @param {Map<SheetName, SheetRawContent>} sheetsData
 * @returns {Promise<ArrayBuffer>}
 */
-export async function createOdsFile(sheetsData) {
+export async function createOdsFile(sheetsData, currencyData = null) {
    // Create a new zip writer
    const zipWriter = new ZipWriter(new BlobWriter('application/vnd.oasis.opendocument.spreadsheet'));

@ -45,7 +49,7 @@ export async function createOdsFile(sheetsData) {
        }
    );

-    const contentXml = generateContentFileXMLString(sheetsData);
+    const contentXml = generateContentFileXMLString(sheetsData, currencyData);
    zipWriter.add("content.xml", new TextReader(contentXml), {level: 9});

    zipWriter.add("styles.xml", new TextReader(stylesXml));
@ -63,7 +67,7 @@ export async function createOdsFile(sheetsData) {
 * @param {Map<SheetName, SheetRawContent>} sheetsData
 * @returns {string}
 */
-function generateContentFileXMLString(sheetsData) {
+function generateContentFileXMLString(sheetsData, currencyData) {
    const doc = createDocument('urn:oasis:names:tc:opendocument:xmlns:office:1.0', 'office:document-content');
    const root = doc.documentElement;

@ -75,6 +79,52 @@ function generateContentFileXMLString(sheetsData) {
    root.setAttribute('xmlns:fo', 'urn:oasis:names:tc:opendocument:xmlns:xsl-fo-compatible:1.0');
    root.setAttribute('office:version', '1.2');

+    const styleNode = doc.createElement("office:automatic-styles");
+
+    var currencyStyleName = "currencyStyle";
+    if (currencyData != null) {
+        currencyStyleName = `currency${currencyData.currencyCode.toUpperCase()}`;
+        const numberStyle = doc.createElement("number:currency-style");
+        numberStyle.setAttribute("style:name", currencyStyleName);
+
+        const numberCurrencySymbolStyle = doc.createElement("number:currency-symbol");
+        numberCurrencySymbolStyle.setAttribute("number:language", "en");
+        numberCurrencySymbolStyle.setAttribute("number:country", currencyData.countryCode.toUpperCase());
+        numberCurrencySymbolStyle.textContent = currencyData.currencySymbol;
+        numberStyle.appendChild(numberCurrencySymbolStyle);
+
+        const numberCurrencyStyle = doc.createElement("number:number");
+        numberCurrencyStyle.setAttribute("number:min-integer-digits", "1");
+        numberCurrencyStyle.setAttribute("number:decimal-places", `${currencyData.decimalPlaces}`);
+        numberCurrencyStyle.setAttribute("number:min-decimal-places", `${currencyData.decimalPlaces}`);
+        numberCurrencyStyle.setAttribute("number:grouping", "true");
+        numberStyle.appendChild(numberCurrencyStyle);
+
+        styleNode.appendChild(numberStyle);
+
+        const currencyCellStyleNode = doc.createElement("style:style");
+        currencyCellStyleNode.setAttribute("style:name", "currencycell");
+        currencyCellStyleNode.setAttribute("style:family", "table-cell");
+        currencyCellStyleNode.setAttribute("style:data-style-name", currencyStyleName);
+
+        const currencyCellTableCellProperties = doc.createElement("style:table-cell-properties");
+
+        currencyCellStyleNode.appendChild(currencyCellTableCellProperties);
+
+        styleNode.appendChild(currencyCellStyleNode);
+    }
+
+    const boldCellStyleNode = doc.createElement("style:style");
+    boldCellStyleNode.setAttribute("style:name", "boldcell");
+    boldCellStyleNode.setAttribute("style:family", "table-cell");
+    const boldCellTextPropsNode = doc.createElement("style:text-properties");
+    boldCellTextPropsNode.setAttribute("fo:font-weight", "bold");
+    boldCellStyleNode.appendChild(boldCellTextPropsNode);
+    styleNode.appendChild(boldCellStyleNode);
+
+
+    root.appendChild(styleNode);
+
    const bodyNode = doc.createElement('office:body');
    root.appendChild(bodyNode);

@ -87,9 +137,31 @@ function generateContentFileXMLString(sheetsData) {
        tableNode.setAttribute('table:name', sheetName);
        spreadsheetNode.appendChild(tableNode);

-        const columnNode = doc.createElement('table:table-column');
+        var columnsWidthChars = {};
+        for (let r = 0; r < sheetData.length; r++) {
+            for (let c = 0; c < sheetData[r].length; c++) {
+                var len = ((sheetData[r][c].display ?? sheetData[r][c].value) + "").length;
+                if (typeof columnsWidthChars[c] == "undefined") {
+                    columnsWidthChars[c] = len;
+                }
+                columnsWidthChars[c] = Math.max(columnsWidthChars[c], len);
+            }
+        }
+
+        for (var prop in columnsWidthChars) {
+            var columnNode = doc.createElement('table:table-column');
+            columnNode.setAttribute("table:style-name", "colwidth" + columnsWidthChars[prop]);
            tableNode.appendChild(columnNode);

+            var columnWidthNode = doc.createElement("style:style");
+            columnWidthNode.setAttribute("style:name", "colwidth" + columnsWidthChars[prop]);
+            columnWidthNode.setAttribute("style:family", "table-column");
+            const columnWidthPropsNode = doc.createElement("style:table-column-properties");
+            columnWidthPropsNode.setAttribute("style:column-width", `${columnsWidthChars[prop] * 0.26}cm`);
+            columnWidthNode.appendChild(columnWidthPropsNode);
+            styleNode.appendChild(columnWidthNode);
+        }
+
        // Iterate through rows
        sheetData.forEach((row) => {
            const rowNode = doc.createElement('table:table-row');
@ -101,6 +173,10 @@ function generateContentFileXMLString(sheetsData) {
                const cellType = convertCellType(cell.type);
                cellNode.setAttribute('office:value-type', cellType);

+                if (cell.style && cell.style == "bold") {
+                    cellNode.setAttribute('table:style-name', "boldcell");
+                }
+
                // Add value attribute based on type
                if (cell.value !== null && cell.value !== undefined) {
                    switch (cellType) {
@ -111,6 +187,14 @@ function generateContentFileXMLString(sheetsData) {
                            cellNode.setAttribute('office:value', cell.value.toString());
                            cellNode.setAttribute('office:value-type', 'percentage');
                            break;
+                        case 'currency':
+                            cellNode.setAttribute('office:value', cell.value.toString());
+                            cellNode.setAttribute('office:value-type', 'currency');
+                            if (currencyData != null) {
+                                cellNode.setAttribute("table:style-name", "currencycell");
+                                cellNode.setAttribute('office:currency', currencyData.currencyCode.toUpperCase());
+                            }
+                            break;
                        case 'date':
                            cellNode.setAttribute('office:date-value', cell.value.toString());
                            break;
@ -126,7 +210,11 @@ function generateContentFileXMLString(sheetsData) {

                    if (cellType !== 'string') {
                        const textNode = doc.createElement('text:p');
+                        if (typeof cell.display != "undefined") {
+                            textNode.textContent = cell.display.toString();
+                        } else {
                            textNode.textContent = cell.value.toString();
+                        }
                        cellNode.appendChild(textNode);
                    }
                }
--- a/scripts/odf/odt/getOdtTextContent.js
+++ b/scripts/odf/odt/getOdtTextContent.js
@ -7,7 +7,7 @@ import {parseXML, Node} from '../../DOMUtils.js'
 * @param {ODTFile} odtFile 
 * @returns {Promise<Document>}
 */
-async function getContentDocument(odtFile) {
+export async function getContentDocument(odtFile) {
    const reader = new ZipReader(new Uint8ArrayReader(new Uint8Array(odtFile)));

    const entries = await reader.getEntries();
--- a/scripts/odf/templating/fillOdtElementTemplate.js
+++ b/scripts/odf/templating/fillOdtElementTemplate.js
@ -1,5 +1,8 @@
-import {traverse, Node} from '../../DOMUtils.js'
-import {closingIfMarker, eachClosingMarker, eachStartMarkerRegex, elseMarker, ifStartMarkerRegex, variableRegex} from './markers.js'
+import {traverse, Node, getAncestors, findCommonAncestor} from "../../DOMUtils.js";
+import {closingIfMarker, eachClosingMarker, eachStartMarkerRegex, elseMarker, ifStartMarkerRegex, imageMarkerRegex, variableRegex} from './markers.js'
+import {isOdfjsImage} from "../../shared.js"
+import imageSize from "image-size";
+/** @import {OdfjsImage} from "../../types.js" */

 /**
 * @typedef TextPlaceToFill
@ -7,6 +10,357 @@ import {closingIfMarker, eachClosingMarker, eachStartMarkerRegex, elseMarker, if
 * @property {() => void} fill
 */

+class TemplateDOMBranch{
+    /** @type {Node} */
+    #branchBaseNode
+    
+    /** @type {Node} */
+    #leafNode
+
+    // ancestors with this.#ancestors[0] === this.#branchBaseNode and this.#ancestors.at(-1) === this.#leafNode
+    /** @type {Node[]} */
+    #ancestors
+
+    /**
+     * 
+     * @param {Node} branchBaseNode 
+     * @param {Node} leafNode 
+     */
+    constructor(branchBaseNode, leafNode){
+        this.#branchBaseNode = branchBaseNode
+        this.#leafNode = leafNode
+
+        this.#ancestors = getAncestors(this.#leafNode, this.#branchBaseNode).reverse()
+    }
+
+    /**
+     * 
+     * @param {number} n 
+     * @returns {Node | undefined}
+     */
+    at(n){
+        return this.#ancestors.at(n)
+    }
+
+    removeLeafAndEmptyAncestors(){
+        //this.logBranch('[removeLeafAndEmptyAncestors] branch at the start')
+
+        // it may happen (else marker of if/else/endif) that the leaf was already removed as part of another block
+        // so before removing anything, let's update #ancestors and #leaf
+
+        this.#ancestors.every((ancestor, i) => {
+            if(!ancestor.parentNode){
+                // ancestor already removed from tree
+                this.#ancestors = this.#ancestors.slice(0, i)
+                return false;
+            }
+
+            return true // continue
+        })
+
+        this.#leafNode = this.#ancestors.at(-1)
+
+        //this.logBranch('[removeLeafAndEmptyAncestors] after adjusting this.#ancestors')
+
+        //console.log('removeLeafAndEmptyAncestors', this.#startNode.textContent)
+        let nextLeaf
+        if(this.#leafNode !== this.#branchBaseNode){
+            nextLeaf = this.#leafNode.parentNode
+            //console.log('nextLeaf', !!nextLeaf)
+            nextLeaf.removeChild(this.#leafNode)
+            this.#leafNode = nextLeaf
+        }
+
+        while(this.#leafNode !== this.#branchBaseNode && 
+            (this.#leafNode.textContent === null || this.#leafNode.textContent.trim() === ''))
+        {
+            nextLeaf = this.#leafNode.parentNode
+            this.#leafNode.parentNode.removeChild(this.#leafNode)
+            this.#leafNode = nextLeaf
+        }
+
+        this.#ancestors = getAncestors(this.#leafNode, this.#branchBaseNode).reverse()
+    }
+
+    /**
+     * 
+     * @param {number} [startIndex]
+     */
+    removeRightContent(startIndex = 0){
+        //console.log('[removeRightContent]', startIndex, this.#ancestors.slice(startIndex).length)
+
+        for(const branchNode of this.#ancestors.slice(startIndex)){
+            //console.log('[removeRightContent]', branchNode.nodeType, branchNode.nodeName)
+
+            let toRemove = branchNode.nextSibling
+
+            while(toRemove){
+                const toRemoveNext = toRemove.nextSibling
+                toRemove.parentNode.removeChild(toRemove)
+                toRemove = toRemoveNext
+            }
+        }
+    }
+
+    /**
+     * 
+     * @param {number} [startIndex]
+     */
+    removeLeftContent(startIndex = 0){
+        for(const branchNode of this.#ancestors.slice(startIndex)){
+            let toRemove = branchNode.previousSibling
+
+            while(toRemove){
+                const toRemoveNext = toRemove.previousSibling
+                toRemove.parentNode.removeChild(toRemove)
+                toRemove = toRemoveNext
+            }
+        }
+    }
+
+    /**
+     * 
+     * @returns {number[]}
+     */
+    getBranchPath(){
+        //console.log('[getBranchPath]', this.#branchBaseNode.nodeName, this.#branchBaseNode.textContent)
+        //console.log('[getBranchPath] leaf', this.#leafNode.nodeName, this.#leafNode.textContent)
+
+        /** @type {ReturnType<typeof TemplateDOMBranch.prototype.getBranchPath>} */
+        const pathFromLeafToBase = [];
+
+        let currentNode = this.#leafNode
+        let currentNodeParent = currentNode.parentNode
+
+        while(currentNodeParent){
+            //console.log('[getBranchPath] currentNodeParent', currentNodeParent.nodeName)
+            //console.log('[getBranchPath] looking for currentNode', currentNode.nodeName, currentNode.textContent)
+            //console.log('[getBranchPath] currentNodeParent.childNodes.length', currentNodeParent.childNodes.length)
+            /*console.log('[getBranchPath] currentNodeParent.childNodes', Array.from(currentNodeParent.childNodes)
+                .map(n => `${n.nodeName} - ${n.textContent}`)
+            )*/
+
+            const index = Array.from(currentNodeParent.childNodes).indexOf(currentNode)
+            //console.log('[getBranchPath] indexOf', index)
+            if(index === -1){
+                throw new Error(`Could not find currentNode in currentNodeParent's childNodes`)
+            }
+            pathFromLeafToBase.push(index)
+            //console.log('[getBranchPath] currentNodeParent and index', currentNodeParent.nodeName, index)
+
+            if(currentNodeParent === this.#ancestors[0]){
+                break; // path is fnished
+            }
+            else{
+                currentNode = currentNodeParent
+                currentNodeParent = currentNode.parentNode
+            }
+        }
+
+        //@ts-expect-error ES2023
+        return pathFromLeafToBase.toReversed()
+    }
+
+    logBranch(message){
+        console.group('[TemplateDOMBranch] Showing branch')
+        console.log(message)
+        for(const node of this.#ancestors){
+            console.log('branch node', node.nodeType, node.nodeName, node.nodeType === node.TEXT_NODE ? node.textContent : '')
+        }
+        console.groupEnd()
+    }
+
+
+}
+
+
+class TemplateBlock{
+    /** @type {Element | Document | DocumentFragment} */
+    #commonAncestor;
+    /** @type {TemplateDOMBranch} */
+    startBranch;
+    /** @type {TemplateDOMBranch} */
+    endBranch;
+
+    /** @type {Node[]} */
+    #middleContent;
+
+    /**@type {any} */
+    #addImageToOdtFile;
+
+    /**
+     * 
+     * @param {Node} startNode 
+     * @param {Node} endNode 
+     * @param {(OdfjsImage) => string} addImageToOdtFile
+     */
+    constructor(startNode, endNode, addImageToOdtFile){
+        this.#addImageToOdtFile = addImageToOdtFile
+
+        // @ts-expect-error xmldom.Node
+        this.#commonAncestor = findCommonAncestor(startNode, endNode)
+
+        //console.log('create start branch')
+        this.startBranch = new TemplateDOMBranch(this.#commonAncestor, startNode)
+        //console.log('create end branch')
+        this.endBranch = new TemplateDOMBranch(this.#commonAncestor, endNode)
+
+
+
+        this.#middleContent = []
+
+        let content = this.startBranch.at(1).nextSibling
+        while(content && content !== this.endBranch.at(1)){
+            this.#middleContent.push(content)
+            content = content.nextSibling
+        }
+
+        //console.group('\n== TemplateBlock ==')
+        //this.startBranch.logBranch('startBranch')
+        //console.log('middleContent', this.#middleContent.map(n => n.textContent).join(''))
+        //this.endBranch.logBranch('endBranch')
+        //console.log('common ancestor', this.#commonAncestor.nodeName, '\n')
+        //console.groupEnd()
+    }
+
+    removeMarkersAndEmptyAncestors(){
+        //console.log('[removeMarkersAndEmptyAncestors]', this.#commonAncestor.textContent)
+        this.startBranch.removeLeafAndEmptyAncestors()
+        this.endBranch.removeLeafAndEmptyAncestors()
+        //console.log('[removeMarkersAndEmptyAncestors] after', this.#commonAncestor.textContent)
+    }
+
+    /**
+     * 
+     * @param {Compartment} compartement 
+     */
+    fillBlockContentTemplate(compartement){
+        //console.log('[fillBlockContentTemplate] start')
+
+        const startChild = this.startBranch.at(1)
+        if(startChild /*&& startChild !== */){
+            //console.log('[fillBlockContentTemplate] startChild', startChild.nodeName, startChild.textContent)
+            fillOdtElementTemplate(startChild, compartement, this.#addImageToOdtFile)
+        }
+        //console.log('[fillBlockContentTemplate] after startChild')
+
+        
+        // if content consists of several parts of an {#each}{/each}
+        // when arriving to the {/each}, it will be alone (and imbalanced)
+        // and will trigger an error
+        fillOdtElementTemplate(Array.from(this.#middleContent), compartement, this.#addImageToOdtFile)
+
+        //console.log('[fillBlockContentTemplate] after middleContent')
+
+        const endChild = this.endBranch.at(1)
+        //console.log('fillBlockContentTemplate] [endBranch]')
+        //this.endBranch.logBranch('endBranch')
+
+        if(endChild){
+            //console.log('[fillBlockContentTemplate] endChild', endChild.nodeName, endChild.textContent)
+            fillOdtElementTemplate(endChild, compartement, this.#addImageToOdtFile)
+        }
+        //console.log('[fillBlockContentTemplate] after endChild')
+
+        //console.log('[fillBlockContentTemplate] end')
+    }
+
+    removeContent(){
+        this.startBranch.removeRightContent(2)
+
+        for(const content of this.#middleContent){
+            content.parentNode.removeChild(content)
+        }
+
+        this.endBranch.removeLeftContent(2)
+    }
+
+    
+
+    /**
+     * @returns {TemplateBlock}
+     */
+    cloneAndAppendAfter(){
+        //console.log('[cloneAndAppendAfter]')
+        const clonedPieces = []
+
+        let startBranchClone;
+        let endBranchClone;
+
+        for(const sibling of [this.startBranch.at(1), ...this.#middleContent, this.endBranch.at(1)]){
+            if(sibling){
+                const siblingClone = sibling.cloneNode(true)
+                clonedPieces.push(siblingClone)
+                
+                if(sibling === this.startBranch.at(1))
+                    startBranchClone = siblingClone
+                
+                if(sibling === this.endBranch.at(1))
+                    endBranchClone = siblingClone
+                
+            }
+        }
+
+        let startChildPreviousSiblingsCount = 0
+        let previousSibling = this.startBranch.at(1).previousSibling
+        while(previousSibling){
+            startChildPreviousSiblingsCount = startChildPreviousSiblingsCount + 1
+            previousSibling = previousSibling.previousSibling
+        }
+
+        const startBranchPathFromBaseToLeaf = this.startBranch.getBranchPath().slice(1)
+        const endBranchPathFromBaseToLeaf = this.endBranch.getBranchPath().slice(1)
+
+        
+        //console.log('startBranchClone', !!startBranchClone)
+        //console.log('startBranchPathFromBaseToLeaf', startBranchPathFromBaseToLeaf)
+
+        let startLeafCloneNode
+        {
+            let node = startBranchClone
+            for(let pathIndex of startBranchPathFromBaseToLeaf){
+                //console.log('[startLeafCloneNode] node.childNodes.length', node.childNodes.length)
+                //console.log('[startLeafCloneNode] pathIndex', pathIndex)
+
+                node = node.childNodes[pathIndex]
+            }
+            startLeafCloneNode = node
+        }
+
+        //console.log('endBranchClone', !!endBranchClone)
+        //console.log('endBranchPathFromBaseToLeaf', endBranchPathFromBaseToLeaf)
+
+        let endLeafCloneNode
+        {
+            let node = endBranchClone
+            for(let pathIndex of endBranchPathFromBaseToLeaf){
+
+                //console.log('[endLeafCloneNode] node.childNodes.length', node.childNodes.length)
+                //console.log('[endLeafCloneNode] pathIndex', pathIndex)
+
+                node = node.childNodes[pathIndex]
+            }
+            endLeafCloneNode = node
+        }
+
+        let insertBeforePoint = this.endBranch.at(1) && this.endBranch.at(1).nextSibling
+
+        if(insertBeforePoint){
+            for(const node of clonedPieces){
+                this.#commonAncestor.insertBefore(node, insertBeforePoint)
+            }
+        }
+        else{
+            for(const node of clonedPieces){
+                this.#commonAncestor.appendChild(node)
+            }
+        }
+
+        return new TemplateBlock(startLeafCloneNode, endLeafCloneNode, this.#addImageToOdtFile)
+    }
+
+}
+

 /**
 * @param {string} str
@ -71,77 +425,6 @@ function findPlacesToFillInString(str, compartment) {
 }


-/**
- * Content between blockStartNode and blockEndNode is extracted to a documentFragment
- * The original document is modified because nodes are removed from it to be part of the returned documentFragment
- * 
- * startChild and endChild are ancestors of, respectively, blockStartNode and blockEndNode
- * and startChild.parentNode === endChild.parentNode
- * 
- * @precondition blockStartNode needs to be before blockEndNode in document order
- * 
- * @param {Node} blockStartNode 
- * @param {Node} blockEndNode 
- * @returns {{startChild: Node, endChild:Node, content: DocumentFragment}}
- */
-function extractBlockContent(blockStartNode, blockEndNode) {
-    // find common ancestor of blockStartNode and blockEndNode
-    let commonAncestor
-
-    let startAncestor = blockStartNode
-    let endAncestor = blockEndNode
-
-    const startAncestry = new Set([startAncestor])
-    const endAncestry = new Set([endAncestor])
-
-    while(!startAncestry.has(endAncestor) && !endAncestry.has(startAncestor)) {
-        if(startAncestor.parentNode) {
-            startAncestor = startAncestor.parentNode
-            startAncestry.add(startAncestor)
-        }
-        if(endAncestor.parentNode) {
-            endAncestor = endAncestor.parentNode
-            endAncestry.add(endAncestor)
-        }
-    }
-
-    if(startAncestry.has(endAncestor)) {
-        commonAncestor = endAncestor
-    }
-    else {
-        commonAncestor = startAncestor
-    }
-
-    const startAncestryToCommonAncestor = [...startAncestry].slice(0, [...startAncestry].indexOf(commonAncestor))
-    const endAncestryToCommonAncestor = [...endAncestry].slice(0, [...endAncestry].indexOf(commonAncestor))
-
-    const startChild = startAncestryToCommonAncestor.at(-1)
-    const endChild = endAncestryToCommonAncestor.at(-1)
-
-    // Extract DOM content in a documentFragment
-    const contentFragment = blockStartNode.ownerDocument.createDocumentFragment()
-
-    /** @type {Element[]} */
-    const repeatedPatternArray = []
-    let sibling = startChild.nextSibling
-
-    while(sibling !== endChild) {
-        repeatedPatternArray.push(sibling)
-        sibling = sibling.nextSibling;
-    }
-
-    for(const sibling of repeatedPatternArray) {
-        sibling.parentNode?.removeChild(sibling)
-        contentFragment.appendChild(sibling)
-    }
-
-    return {
-        startChild,
-        endChild,
-        content: contentFragment
-    }
-}
-



@ -152,70 +435,55 @@ function extractBlockContent(blockStartNode, blockEndNode) {
 * @param {Node} ifClosingMarkerNode 
 * @param {string} ifBlockConditionExpression 
 * @param {Compartment} compartment 
+ * // TODO type,addImageToOdtFile
 */
-function fillIfBlock(ifOpeningMarkerNode, ifElseMarkerNode, ifClosingMarkerNode, ifBlockConditionExpression, compartment) {
+function fillIfBlock(ifOpeningMarkerNode, ifElseMarkerNode, ifClosingMarkerNode, ifBlockConditionExpression, compartment, addImageToOdtFile) {
+    //const docEl = ifOpeningMarkerNode.ownerDocument.documentElement
+    
    const conditionValue = compartment.evaluate(ifBlockConditionExpression)

-    let startChild
-    let endChild
-
-    let markerNodes = new Set()
-
-    let chosenFragment
+    /** @type {TemplateBlock | undefined} */
+    let thenTemplateBlock
+    /** @type {TemplateBlock | undefined} */
+    let elseTemplateBlock

    if(ifElseMarkerNode) {
-        const {
-            startChild: startIfThenChild,
-            endChild: endIfThenChild,
-            content: thenFragment
-        } = extractBlockContent(ifOpeningMarkerNode, ifElseMarkerNode)
+        /*console.log('before first extract', 
+            ifOpeningMarkerNode.childNodes.length, ifOpeningMarkerNode.textContent, 
+            ifElseMarkerNode.childNodes.length, ifElseMarkerNode.textContent
+        )*/

-        const {
-            startChild: startIfElseChild,
-            endChild: endIfElseChild,
-            content: elseFragment
-        } = extractBlockContent(ifElseMarkerNode, ifClosingMarkerNode)
-
-        chosenFragment = conditionValue ? thenFragment : elseFragment
-        startChild = startIfThenChild
-        endChild = endIfElseChild
-
-        markerNodes
-            .add(startIfThenChild).add(endIfThenChild)
-            .add(startIfElseChild).add(endIfElseChild)
+        thenTemplateBlock = new TemplateBlock(ifOpeningMarkerNode, ifElseMarkerNode, addImageToOdtFile)
+        elseTemplateBlock = new TemplateBlock(ifElseMarkerNode, ifClosingMarkerNode, addImageToOdtFile)
    }
    else {
-        const {
-            startChild: startIfThenChild,
-            endChild: endIfThenChild,
-            content: thenFragment
-        } = extractBlockContent(ifOpeningMarkerNode, ifClosingMarkerNode)
-
-        chosenFragment = conditionValue ? thenFragment : undefined
-        startChild = startIfThenChild
-        endChild = endIfThenChild
-
-        markerNodes
-            .add(startIfThenChild).add(endIfThenChild)
+        thenTemplateBlock = new TemplateBlock(ifOpeningMarkerNode, ifClosingMarkerNode, addImageToOdtFile)
    }

-
-    if(chosenFragment) {
-        fillOdtElementTemplate(
-            chosenFragment,
-            compartment
-        )
-
-        endChild.parentNode.insertBefore(chosenFragment, endChild)
+    if(conditionValue) {
+        if(elseTemplateBlock){
+            elseTemplateBlock.removeContent()
        }

-    for(const markerNode of markerNodes) {
-        try {
-            // may throw if node already out of tree
-            // might happen if 
-            markerNode.parentNode.removeChild(markerNode)
+        thenTemplateBlock.removeMarkersAndEmptyAncestors()
+        if(elseTemplateBlock){
+            elseTemplateBlock.removeMarkersAndEmptyAncestors()
+        }
+
+        thenTemplateBlock.fillBlockContentTemplate(compartment)
+    }
+    else{
+        // remove content before removing markers so that right and left content are fully removed
+        thenTemplateBlock.removeContent()
+        
+        thenTemplateBlock.removeMarkersAndEmptyAncestors()
+        if(elseTemplateBlock){
+            elseTemplateBlock.removeMarkersAndEmptyAncestors()
+        }
+
+        if(elseTemplateBlock){
+            elseTemplateBlock.fillBlockContentTemplate(compartment)
        }
-        catch(e) {}
    }

 }
@ -228,60 +496,119 @@ function fillIfBlock(ifOpeningMarkerNode, ifElseMarkerNode, ifClosingMarkerNode,
 * @param {string} itemExpression 
 * @param {Node} endNode 
 * @param {Compartment} compartment 
+ * // TODO type addImageToOdtFile
 */
-function fillEachBlock(startNode, iterableExpression, itemExpression, endNode, compartment) {
+function fillEachBlock(startNode, iterableExpression, itemExpression, endNode, compartment, addImageToOdtFile) {
    //console.log('fillEachBlock', iterableExpression, itemExpression)
-    //console.log('startNode', startNode.nodeType, startNode.nodeName)
-    //console.log('endNode', endNode.nodeType, endNode.nodeName)

-    const {startChild, endChild, content: repeatedFragment} = extractBlockContent(startNode, endNode)
+    const docEl = startNode.ownerDocument.documentElement
+    //console.log('[fillEachBlock] docEl', docEl.textContent)
+
+    const repeatedTemplateBlock = new TemplateBlock(startNode, endNode, addImageToOdtFile)

    // Find the iterable in the data
-    // PPP eventually, evaluate the expression as a JS expression
    let iterable = compartment.evaluate(iterableExpression)
    if(!iterable || typeof iterable[Symbol.iterator] !== 'function') {
        // when there is no iterable, silently replace with empty array
        iterable = []
    }

-    // create each loop result
-    // using a for-of loop to accept all iterable values
-    for(const item of iterable) {
-        /** @type {DocumentFragment} */
-        // @ts-ignore
-        const itemFragment = repeatedFragment.cloneNode(true)
+    // convert to array to know the size and know which element is last
+    if(!Array.isArray(iterable))
+        iterable = [...iterable]
+
+
+    if(iterable.length === 0){
+        repeatedTemplateBlock.removeMarkersAndEmptyAncestors()
+        repeatedTemplateBlock.removeContent()
+    }
+    else{
+        let nextTemplateBlock = repeatedTemplateBlock
+
+        iterable.forEach((item, i) => {
+            //console.log('[fillEachBlock] loop i', i, docEl.textContent)
+            const firstItem = i === 0
+            const lastItem = i === iterable.length - 1
+            let currentTemplateBlock = nextTemplateBlock;
+
+            //console.log('currentTemplateBlock', currentTemplateBlock.startBranch.at(0).textContent)
+
+            if(!lastItem){
+                nextTemplateBlock = currentTemplateBlock.cloneAndAppendAfter()
+            }

            let insideCompartment = new Compartment({
                globals: Object.assign({}, compartment.globalThis, {[itemExpression]: item}),
                __options__: true
            })

-        // recursive call to fillTemplatedOdtElement on itemFragment
-        fillOdtElementTemplate(
-            itemFragment,
-            insideCompartment
-        )
-
-        endChild.parentNode.insertBefore(itemFragment, endChild)
+            if(!firstItem){
+                currentTemplateBlock.startBranch.removeLeftContent(2)
+            }
+            if(!lastItem){
+                //console.log('[fillEachBlock] removeRightContent')
+                currentTemplateBlock.endBranch.removeRightContent(2)
+            }
+
+            //console.log('[fillEachBlock] docEl i before removeMarkers', i, docEl.textContent)
+            currentTemplateBlock.removeMarkersAndEmptyAncestors()
+            //console.log('[fillEachBlock] docEl i after removeMarkers', i, docEl.textContent)
+
+            //console.log('\nrecursive call to fillBlockContentTemplate')
+            currentTemplateBlock.fillBlockContentTemplate(insideCompartment)
+
+            //console.log('[fillEachBlock] docEl i after remove contents', i, docEl.textContent)
+
+        })
    }

-    // remove block marker elements
-    startChild.parentNode.removeChild(startChild)
-    endChild.parentNode.removeChild(endChild)
 }


-const IF = 'IF'
-const EACH = 'EACH'
+/**
+ * @param {string} str
+ * @param {Compartement} compartment
+ * @returns { {expression: string, odfjsImage: OdfjsImage | undefined} | undefined}
+ */
+function findImageMarker(str, compartment) {
+    const imageRexExp = new RegExp(imageMarkerRegex.source, 'g');
+    const match = imageRexExp.exec(str)
+
+    if (match===null){
+        return;
+    }
+
+    const expression = match[1]
+    const value = compartment.evaluate(expression)
+    
+    if (isOdfjsImage(value)) {
+        return { expression, odfjsImage: value}
+    } else {
+        return { expression }
+    }
+}
+
+const IF = ifStartMarkerRegex.source
+const EACH = eachStartMarkerRegex.source
+
+/** @typedef {Element | DocumentFragment | Document} RootElementArgument */
+

 /**
 * 
- * @param {Element | DocumentFragment | Document} rootElement 
+ * @param {RootElementArgument | RootElementArgument[]} rootElements
 * @param {Compartment} compartment 
+ * @param {(OdfjsImage) => string} addImageToOdtFile
 * @returns {void}
 */
-export default function fillOdtElementTemplate(rootElement, compartment) {
-    //console.log('fillTemplatedOdtElement', rootElement.nodeType, rootElement.nodeName)
+export default function fillOdtElementTemplate(rootElements, compartment, addImageToOdtFile) {
+    
+    if(!Array.isArray(rootElements)){
+        rootElements = [rootElements]
+    }
+
+    //console.log('[fillTemplatedOdtElement]', rootElements.length, rootElements[0].nodeType, rootElements[0].nodeName, rootElements[0].textContent)
+    //console.log('[fillTemplatedOdtElement]', rootElement.documentElement && rootElement.documentElement.textContent)

    let currentlyOpenBlocks = []

@ -303,9 +630,14 @@ export default function fillOdtElementTemplate(rootElement, compartment) {
    let ifBlockConditionExpression
    // Traverse "in document order"

+
+    for(const rootElement of rootElements){
+
        // @ts-ignore
        traverse(rootElement, currentNode => {
-        //console.log('currentlyUnclosedBlocks', currentlyUnclosedBlocks)
+            //console.log('currentlyOpenBlocks', currentlyOpenBlocks)
+            //console.log('eachOpeningMarkerNode', eachOpeningMarkerNode)
+
            const insideAnOpenBlock = currentlyOpenBlocks.length >= 1

            if(currentNode.nodeType === Node.TEXT_NODE) {
@ -341,10 +673,10 @@ export default function fillOdtElementTemplate(rootElement, compartment) {

                if(isEachClosingBlock) {

-                //console.log('isEachClosingBlock', isEachClosingBlock)
+                    //console.log('isEachClosingBlock', isEachClosingBlock, currentlyOpenBlocks)

-                if(!eachOpeningMarkerNode)
-                    throw new Error(`{/each} found without corresponding opening {#each x as y}`)
+                    if(!insideAnOpenBlock)
+                        throw new Error('{/each} found without corresponding opening {#each x as y}')

                    if(currentlyOpenBlocks.at(-1) !== EACH)
                        throw new Error(`{/each} found while the last opened block was not an opening {#each x as y}`)
@ -354,7 +686,11 @@ export default function fillOdtElementTemplate(rootElement, compartment) {

                        // found an {#each} and its corresponding {/each}
                        // execute replacement loop
-                    fillEachBlock(eachOpeningMarkerNode, eachBlockIterableExpression, eachBlockItemExpression, eachClosingMarkerNode, compartment)
+                        //console.log('start of fillEachBlock')
+
+                        fillEachBlock(eachOpeningMarkerNode, eachBlockIterableExpression, eachBlockItemExpression, eachClosingMarkerNode, compartment, addImageToOdtFile)
+
+                        //console.log('end of fillEachBlock')

                        eachOpeningMarkerNode = undefined
                        eachBlockIterableExpression = undefined
@ -365,6 +701,7 @@ export default function fillOdtElementTemplate(rootElement, compartment) {
                        // ignore because it will be treated as part of the outer {#each}
                    }

+                    //console.log('popping currentlyOpenBlocks')
                    currentlyOpenBlocks.pop()
                }

@ -414,9 +751,9 @@ export default function fillOdtElementTemplate(rootElement, compartment) {
                /**
                 * Looking for {/if}
                 */
-            const hasClosingMarker = text.includes(closingIfMarker);
+                const ifClosingMarker = text.includes(closingIfMarker);

-            if(hasClosingMarker) {
+                if(ifClosingMarker) {
                    if(!insideAnOpenBlock)
                        throw new Error('{/if} without a corresponding {#if}')

@ -426,7 +763,7 @@ export default function fillOdtElementTemplate(rootElement, compartment) {

                            // found an {#if} and its corresponding {/if}
                            // execute replacement loop
-                        fillIfBlock(ifOpeningMarkerNode, ifElseMarkerNode, ifClosingMarkerNode, ifBlockConditionExpression, compartment)
+                            fillIfBlock(ifOpeningMarkerNode, ifElseMarkerNode, ifClosingMarkerNode, ifBlockConditionExpression, compartment, addImageToOdtFile)

                            ifOpeningMarkerNode = undefined
                            ifElseMarkerNode = undefined
@ -439,6 +776,8 @@ export default function fillOdtElementTemplate(rootElement, compartment) {
                    else {
                        // do nothing because the marker is too deep
                    }
+
+                    currentlyOpenBlocks.pop()
                }


@ -457,6 +796,54 @@ export default function fillOdtElementTemplate(rootElement, compartment) {
                            const newTextNode = currentNode.ownerDocument?.createTextNode(newText)
                            // @ts-ignore
                            currentNode.parentNode?.replaceChild(newTextNode, currentNode)
+                        } else {
+                            const imageMarker = findImageMarker(currentNode.data, compartment)
+                            if (imageMarker){
+                                //console.log({imageMarker}, "dans le if imageMarker")
+                                if (imageMarker.odfjsImage) {
+                                    const href  = addImageToOdtFile(imageMarker.odfjsImage)
+
+                                    const newImageNode = currentNode.ownerDocument?.createElement("draw:image")
+                                    newImageNode.setAttribute("xlink:href", href)
+                                    newImageNode.setAttribute("xlink:type", "simple")
+                                    newImageNode.setAttribute("xlink:show", "embed")
+                                    newImageNode.setAttribute("xlink:actuate", "onLoad")
+                                    newImageNode.setAttribute("draw:mime-type", imageMarker.odfjsImage.mediaType)
+
+                                    const newFrameNode = currentNode.ownerDocument?.createElement('draw:frame')
+                                    newFrameNode.setAttribute("text:anchor-type", "as-char")
+                                    const buffer = new Uint8Array(imageMarker.odfjsImage.content)
+                                    
+                                    const dimensions = imageSize(buffer)
+
+                                    const MAX_WIDTH = 10 // cm
+                                    const MAX_HEIGHT = 10 // cm
+
+                                    let width;
+                                    let height;
+
+                                    if(dimensions.width > dimensions.height){
+                                        // image in landscape
+                                        width = MAX_WIDTH;
+                                        height = width*dimensions.height/dimensions.width
+                                    }
+                                    else{
+                                        // image in portrait
+                                        height = MAX_HEIGHT;
+                                        width = height*dimensions.width/dimensions.height
+                                    }
+
+                                    newFrameNode.setAttribute("svg:width", `${width}cm`)
+                                    newFrameNode.setAttribute("svg:height", `${height}cm`)
+                                    newFrameNode.appendChild(newImageNode)
+
+                                    currentNode.parentNode?.replaceChild(newFrameNode, currentNode)                                
+                                } else {
+                                    throw new Error(`No valid OdfjsImage value has been found for expression: ${imageMarker.expression}`)
+                                }
+                            }
+                            
+
                        }
                    }
                }
@ -483,4 +870,6 @@ export default function fillOdtElementTemplate(rootElement, compartment) {
                }
            }
        })
+
+    }
 }
--- a/scripts/odf/templating/fillOdtTemplate.js
+++ b/scripts/odf/templating/fillOdtTemplate.js
@ -7,11 +7,10 @@ import prepareTemplateDOMTree from './prepareTemplateDOMTree.js';
 import 'ses'
 import fillOdtElementTemplate from './fillOdtElementTemplate.js';

-lockdown();
-

 /** @import {Reader, ZipWriterAddDataOptions} from '@zip.js/zip.js' */
-/** @import {ODFManifest} from '../manifest.js' */
+/** @import {ODFManifest, ODFManifestFileEntry} from '../manifest.js' */
+/** @import {OdfjsImage} from '../../types.js' */

 /** @typedef {ArrayBuffer} ODTFile */

@ -23,11 +22,12 @@ const ODTMimetype = 'application/vnd.oasis.opendocument.text'
 * 
 * @param {Document} document 
 * @param {Compartment} compartment 
+ * @param {(OdfjsImage) => string} addImageToOdtFile
 * @returns {void}
 */
-function fillOdtDocumentTemplate(document, compartment) {
+function fillOdtDocumentTemplate(document, compartment, addImageToOdtFile) {
    prepareTemplateDOMTree(document)
-    fillOdtElementTemplate(document, compartment)
+    fillOdtElementTemplate(document, compartment, addImageToOdtFile)
 }


@ -64,6 +64,21 @@ export default async function fillOdtTemplate(odtTemplate, data) {

    /** @type {{filename: string, content: Reader, options?: ZipWriterAddDataOptions}[]} */
    const zipEntriesToAdd = []
+    /** @type {ODFManifestFileEntry[]} */
+    const newManifestEntries = []
+
+    /** 
+     * Return href
+     * @param {OdfjsImage} odfjsImage
+     * @returns {string}
+    */
+    function addImageToOdtFile(odfjsImage) {
+        // console.log({odfjsImage})
+        const filename = `Pictures/${odfjsImage.fileName}`
+        zipEntriesToAdd.push({content: new Uint8ArrayReader(new Uint8Array(odfjsImage.content)), filename})
+        newManifestEntries.push({fullPath: filename, mediaType: odfjsImage.mediaType})
+        return filename
+    }

    // Parcourir chaque entrée du fichier ODT
    for await(const entry of entries) {
@ -97,12 +112,14 @@ export default async function fillOdtTemplate(odtTemplate, data) {
                    const contentXml = await entry.getData(new TextWriter());
                    const contentDocument = parseXML(contentXml);
                    
+
+
                    const compartment = new Compartment({
                        globals: data,
                        __options__: true
                    })

-                    fillOdtDocumentTemplate(contentDocument, compartment)
+                    fillOdtDocumentTemplate(contentDocument, compartment, addImageToOdtFile)

                    const updatedContentXml = serializeToString(contentDocument)

@ -138,6 +155,9 @@ export default async function fillOdtTemplate(odtTemplate, data) {
        }
    }

+    for(const {fullPath, mediaType} of newManifestEntries){
+        manifestFileData.fileEntries.set(fullPath, {fullPath, mediaType})
+    }

    for(const {filename, content, options} of zipEntriesToAdd) {
        await writer.add(filename, content, options);
--- a/scripts/odf/templating/markers.js
+++ b/scripts/odf/templating/markers.js
@ -1,5 +1,6 @@
 // the regexps below are shared, so they shoudn't have state (no 'g' flag)
-export const variableRegex = /\{([^{#\/]+?)\}/
+export const variableRegex = /\{([^{#\/:]+?)\}/
+export const imageMarkerRegex = /{#image\s+([^}]+?)\s*}/;

 export const ifStartMarkerRegex = /{#if\s+([^}]+?)\s*}/;
 export const elseMarker = '{:else}'
--- a/scripts/odf/templating/prepareTemplateDOMTree.js
+++ b/scripts/odf/templating/prepareTemplateDOMTree.js
@ -1,6 +1,9 @@
-import {traverse, Node} from "../../DOMUtils.js";
+//@ts-check
+
+import {traverse, Node, getAncestors, findCommonAncestor} from "../../DOMUtils.js";
 import {closingIfMarker, eachClosingMarker, eachStartMarkerRegex, elseMarker, ifStartMarkerRegex, variableRegex} from './markers.js'

+
 /**
 * 
 * @param {string} text 
@ -35,41 +38,7 @@ function findAllMatches(text, pattern) {
    return results;
 }

-/**
- * 
- * @param {Node} node1 
- * @param {Node} node2 
- * @returns {Node | undefined}
- */
-function findCommonAncestor(node1, node2) {
-    const ancestors1 = getAncestors(node1);
-    const ancestors2 = getAncestors(node2);

-    for(const ancestor of ancestors1) {
-        if(ancestors2.includes(ancestor)) {
-            return ancestor;
-        }
-    }
-
-    return undefined;
-}
-
-/**
- * 
- * @param {Node} node 
- * @returns {Node[]}
- */
-function getAncestors(node) {
-    const ancestors = [];
-    let current = node;
-
-    while(current) {
-        ancestors.push(current);
-        current = current.parentNode;
-    }
-
-    return ancestors;
-}

 /**
 * text position of a node relative to a text nodes within a container
@ -98,19 +67,14 @@ function getNodeTextPosition(node, containerTextNodes) {

 /**
 * remove nodes between startNode and endNode
- * but keep startNode and endNode
- * 
- * returns the common ancestor child in start branch 
- * for the purpose for inserting something between startNode and endNode
- * with insertionPoint.parentNode.insertBefore(newBetweenContent, insertionPoint)
+ * including startNode and endNode
 * 
 * @param {Node} startNode
 * @param {Node} endNode
- * @returns {Node}
+ * @param {string} text 
+ * @returns {void}
 */
-function removeNodesBetween(startNode, endNode) {
-    let nodesToRemove = new Set();
-
+function replaceBetweenNodesWithText(startNode, endNode, text) {
    // find both ancestry branch
    const startNodeAncestors = new Set(getAncestors(startNode))
    const endNodeAncestors = new Set(getAncestors(endNode))
@ -118,43 +82,42 @@ function removeNodesBetween(startNode, endNode) {
    // find common ancestor
    const commonAncestor = findCommonAncestor(startNode, endNode)

-    // remove everything "on the right" of start branch
-    let currentAncestor = startNode
-    let commonAncestorChildInEndNodeBranch
+    let remove = false
+    let toRemove = []
+    let commonAncestorChild = commonAncestor.firstChild
+    let commonAncestorInsertionChild

-    while(currentAncestor !== commonAncestor){
-        let siblingToRemove = currentAncestor.nextSibling
-        
-        while(siblingToRemove && !endNodeAncestors.has(siblingToRemove)){
-            nodesToRemove.add(siblingToRemove)
-            siblingToRemove = siblingToRemove.nextSibling
-        }
-        if(endNodeAncestors.has(siblingToRemove)){
-            commonAncestorChildInEndNodeBranch = siblingToRemove
+    while(commonAncestorChild){
+        if(startNodeAncestors.has(commonAncestorChild)){
+            remove = true
        }

-        currentAncestor = currentAncestor.parentNode;
+        if(remove){
+            toRemove.push(commonAncestorChild)
+
+            if(endNodeAncestors.has(commonAncestorChild)){
+                commonAncestorInsertionChild = commonAncestorChild.nextSibling
+                break;
+            }
+        }
+        commonAncestorChild = commonAncestorChild.nextSibling
    }

-    // remove everything "on the left" of end branch
-    currentAncestor = endNode
-
-    while(currentAncestor !== commonAncestor){
-        let siblingToRemove = currentAncestor.previousSibling
-        
-        while(siblingToRemove && !startNodeAncestors.has(siblingToRemove)){
-            nodesToRemove.add(siblingToRemove)
-            siblingToRemove = siblingToRemove.previousSibling
+    for(const node of toRemove){
+        commonAncestor.removeChild(node)
    }

-        currentAncestor = currentAncestor.parentNode;
+    //console.log('replaceBetweenNodesWithText startNode', startNode.textContent)
+
+    const newTextNode = commonAncestor.ownerDocument.createTextNode(text)
+
+    if(commonAncestorInsertionChild){
+        commonAncestor.insertBefore(newTextNode, commonAncestorInsertionChild)
+    }
+    else{
+        commonAncestor.appendChild(newTextNode)
    }

-    for(const node of nodesToRemove){
-        node.parentNode.removeChild(node)
-    }
-
-    return commonAncestorChildInEndNodeBranch
 }

 /**
@ -170,6 +133,7 @@ function consolidateMarkers(document){
    ]

    for(const potentialMarkersContainer of potentialMarkersContainers) {
+        /** @type {{marker: string, index: number}[]} */
        const consolidatedMarkers = []

        /** @type {Text[]} */
@ -202,8 +166,10 @@ function consolidateMarkers(document){
            ...findAllMatches(fullText, variableRegex)
        ];

-        /*if(positionedMarkers.length >= 1)
-            console.log('positionedMarkers', positionedMarkers)*/
+        
+        //if(positionedMarkers.length >= 1)
+        //    console.log('positionedMarkers', positionedMarkers)
+        

        while(consolidatedMarkers.length < positionedMarkers.length) {
            refreshContainerTextNodes()
@ -246,6 +212,21 @@ function consolidateMarkers(document){

                // Check if marker spans multiple nodes
                if(startNode !== endNode) {
+                    //console.log('startNode !== endNode', startNode.textContent, endNode.textContent)
+                    const commonAncestor = findCommonAncestor(startNode, endNode)
+
+                    /** @type {Node} */
+                    let commonAncestorStartChild = startNode
+                    while(commonAncestorStartChild.parentNode !== commonAncestor){
+                        commonAncestorStartChild = commonAncestorStartChild.parentNode
+                    }
+
+                    /** @type {Node} */
+                    let commonAncestorEndChild = endNode
+                    while(commonAncestorEndChild.parentNode !== commonAncestor){
+                        commonAncestorEndChild = commonAncestorEndChild.parentNode
+                    }
+
                    // Calculate relative positions within the nodes
                    let startNodeTextContent = startNode.textContent || '';
                    let endNodeTextContent = endNode.textContent || '';
@ -256,47 +237,51 @@ function consolidateMarkers(document){
                    // Calculate the position within the end node
                    let posInEndNode = (positionedMarker.index + positionedMarker.marker.length) - getNodeTextPosition(endNode, containerTextNodesInTreeOrder);

-                    /** @type {Node} */
-                    let beforeStartNode = startNode
+                    let newStartNode = startNode

                    // if there is before-text, split
                    if(posInStartNode > 0) {
                        // Text exists before the marker - preserve it

                        // set newStartNode to a Text node containing only the marker beginning
-                        const newStartNode = startNode.splitText(posInStartNode)
+                        newStartNode = startNode.splitText(posInStartNode)
                        // startNode/beforeStartNode now contains only non-marker text

                        // then, by definition of .splitText(posInStartNode):
                        posInStartNode = 0

-                        // remove the marker beginning part from the tree (since the marker will be inserted in full later)
+                        // move the marker beginning part to become a child of commonAncestor
                        newStartNode.parentNode?.removeChild(newStartNode)
+
+                        commonAncestor.insertBefore(newStartNode, commonAncestorStartChild.nextSibling)
+
+                        //console.log('commonAncestor after before-text split', commonAncestor.textContent )
                    }

-                    /** @type {Node} */
-                    let afterEndNode

                    // if there is after-text, split
                    if(posInEndNode < endNodeTextContent.length) {
                        // Text exists after the marker - preserve it

-                        // set afterEndNode to a Text node containing only non-marker text
-                        afterEndNode = endNode.splitText(posInEndNode);
+                        endNode.splitText(posInEndNode);
                        // endNode now contains only the end of marker text

                        // then, by definition of .splitText(posInEndNode):
                        posInEndNode = endNodeTextContent.length

-                        // remove the marker ending part from the tree (since the marker will be inserted in full later)
+                        // move the marker ending part to become a child of commonAncestor
+                        if(endNode !== commonAncestorEndChild){
                            endNode.parentNode?.removeChild(endNode)
+                            commonAncestor.insertBefore(endNode, commonAncestorEndChild)
+                        }
+
+                        //console.log('commonAncestor after after-text split', commonAncestor.textContent )
                    }

                    // then, replace all nodes between (new)startNode and (new)endNode with a single textNode in commonAncestor
-                    const insertionPoint = removeNodesBetween(beforeStartNode, afterEndNode)
-                    const markerTextNode = insertionPoint.ownerDocument.createTextNode(positionedMarker.marker)
+                    replaceBetweenNodesWithText(newStartNode, endNode, positionedMarker.marker)

-                    insertionPoint.parentNode.insertBefore(markerTextNode, insertionPoint)
+                    //console.log('commonAncestor after replaceBetweenNodesWithText', commonAncestor.textContent )

                    // After consolidation, break as the DOM structure has changed 
                    // and containerTextNodesInTreeOrder needs to be refreshed
@ -307,16 +292,35 @@ function consolidateMarkers(document){
                consolidatedMarkers.push(positionedMarker)
            }
        }
+
+        //console.log('consolidatedMarkers', consolidatedMarkers)
    }
+
 }

+/**
+ * @typedef {typeof closingIfMarker | typeof eachClosingMarker | typeof eachStartMarkerRegex.source | typeof elseMarker | typeof ifStartMarkerRegex.source | typeof variableRegex.source} MarkerType
+ */
+
+/**
+ * @typedef {Object} MarkerNode
+ * @prop {Node} node
+ * @prop {MarkerType} markerType
+ */
+
 /**
 * isolate markers which are in Text nodes with other texts
 * 
 * @param {Document} document 
+ * @returns {Map<Node, MarkerType>}
 */
-function isolateMarkers(document){
+function isolateMarkerText(document){
+    /** @type {ReturnType<isolateMarkerText>} */
+    const markerNodes = new Map()
+
    traverse(document, currentNode => {
+        //console.log('isolateMarkers', currentNode.nodeName, currentNode.textContent)
+
        if(currentNode.nodeType === Node.TEXT_NODE) {
            // find all marker starts and ends and split textNode
            let remainingText = currentNode.textContent || ''
@ -324,6 +328,8 @@ function isolateMarkers(document){
            while(remainingText.length >= 1) {
                let matchText;
                let matchIndex;
+                /** @type {MarkerType} */
+                let markerType;

                // looking for a block marker
                for(const marker of [ifStartMarkerRegex, elseMarker, closingIfMarker, eachStartMarkerRegex, eachClosingMarker]) {
@ -333,6 +339,7 @@ function isolateMarkers(document){
                        if(index !== -1) {
                            matchText = marker
                            matchIndex = index
+                            markerType = marker

                            // found the first match
                            break; // get out of loop
@ -345,6 +352,7 @@ function isolateMarkers(document){
                        if(match) {
                            matchText = match[0]
                            matchIndex = match.index
+                            markerType = marker.source

                            // found the first match
                            break; // get out of loop
@ -367,11 +375,21 @@ function isolateMarkers(document){

                        // per spec, currentNode now contains before-match and match text

+                        /** @type {Node} */
+                        let matchTextNode
+
                        // @ts-ignore
                        if(matchIndex > 0) {
                            // @ts-ignore
-                            currentNode.splitText(matchIndex)
+                            matchTextNode = currentNode.splitText(matchIndex)
                        }
+                        else{
+                            matchTextNode = currentNode
+                        }
+
+                        markerNodes.set(matchTextNode, markerType)
+
+                        // per spec, currentNode now contains only before-match text

                        if(afterMatchTextNode) {
                            currentNode = afterMatchTextNode
@ -391,8 +409,102 @@ function isolateMarkers(document){
            // skip
        }
    })
+
+    //console.log('markerNodes', [...markerNodes].map(([node, markerType]) => [node.textContent, markerType]))
+
+    return markerNodes
 }

+
+
+/**
+ * after isolateMatchingMarkersStructure, matching markers (opening/closing each, if/then/closing if)
+ * are put in isolated branches within their common ancestors
+ * 
+ * UNFINISHED - maybe another day if relevant
+ * 
+ * @param {Document} document 
+ * @param {Map<Node, MarkerType>} markerNodes 
+ */
+//function isolateMatchingMarkersStructure(document, markerNodes){
+    /** @type {MarkerNode[]} */
+/*    let currentlyOpenBlocks = []
+
+    traverse(document, currentNode => {
+
+        const markerType = markerNodes.get(currentNode)
+
+        if(markerType){
+            switch(markerType){
+                case eachStartMarkerRegex.source:
+                case ifStartMarkerRegex.source: {
+                    currentlyOpenBlocks.push({
+                        node: currentNode,
+                        markerType
+                    })
+                    break;
+                }
+                case eachClosingMarker: {
+                    const lastOpenedBlockMarkerNode = currentlyOpenBlocks.pop()
+
+                    if(!lastOpenedBlockMarkerNode)
+                        throw new Error(`{/each} found without corresponding opening {#each x as y}`)
+    
+                    if(lastOpenedBlockMarkerNode.markerType !== eachStartMarkerRegex.source)
+                        throw new Error(`{/each} found while the last opened block was not an opening {#each x as y} (it was a ${lastOpenedBlockMarkerNode.markerType})`)
+    
+                    const openingEachNode = lastOpenedBlockMarkerNode.node
+                    const closingEachNode = currentNode
+
+                    const commonAncestor = findCommonAncestor(openingEachNode, closingEachNode)
+
+                    if(openingEachNode.parentNode !== commonAncestor && openingEachNode.parentNode.childNodes.length >= 2){
+                        if(openingEachNode.previousSibling){
+                            // create branch for previousSiblings
+                            let previousSibling = openingEachNode.previousSibling
+                            const previousSiblings = []
+                            while(previousSibling){
+                                previousSiblings.push(previousSibling.previousSibling)
+                                previousSibling = previousSibling.previousSibling
+                            }
+
+                            // put previous siblings in tree order
+                            previousSiblings.reverse()
+
+                            const parent = openingEachNode.parentNode
+                            const parentClone = parent.cloneNode(false)
+                            for(const previousSibling of previousSiblings){
+                                previousSibling.parentNode.removeChild(previousSibling)
+                                parentClone.appendChild(previousSibling)
+                            }
+
+                            let openingEachNodeBranch = openingEachNode.parentNode
+                            let branchForPreviousSiblings = parentClone
+
+                            while(openingEachNodeBranch.parentNode !== commonAncestor){
+                                const newParentClone = openingEachNodeBranch.parentNode.cloneNode(false)
+                                branchForPreviousSiblings.parentNode.removeChild(branchForPreviousSiblings)
+                                newParentClone.appendChild(branchForPreviousSiblings)
+                            }
+                        }
+                    }
+
+
+
+
+                    break;
+                }
+
+                default:
+                    throw new TypeError(`MarkerType not recognized: '${markerType}`)
+            }
+        }
+
+    })
+
+}*/
+
+
 /**
 * This function prepares the template DOM tree in a way that makes it easily processed by the template execution
 * Specifically, after the call to this function, the document is altered to respect the following property:
@ -409,5 +521,10 @@ function isolateMarkers(document){
 */
 export default function prepareTemplateDOMTree(document){
    consolidateMarkers(document)
-    isolateMarkers(document)
+    // after consolidateMarkers, each marker is in at most one text node
+    // (formatting with markers is removed)
+
+    isolateMarkerText(document)
+    // after isolateMarkerText, each marker is in exactly one text node
+    // (markers are separated from text that was before or after in the same text node)
 }
--- a/scripts/shared.js
+++ b/scripts/shared.js
@ -4,7 +4,7 @@ import { Uint8ArrayReader, ZipReader, TextWriter } from '@zip.js/zip.js';
 import {parseXML} from './DOMUtils.js'

 /** @import {Entry} from '@zip.js/zip.js'*/
-/** @import {SheetName, SheetRawContent, SheetRowRawContent, SheetCellRawContent} from './types.js' */
+/** @import {SheetName, SheetRawContent, SheetRowRawContent, SheetCellRawContent, OdfjsImage} from './types.js' */


 // https://dom.spec.whatwg.org/#interface-node
@ -18,7 +18,6 @@ const TEXT_NODE = 3
 function extraxtODSCellText(cell) {
    let text = '';
    const childNodes = cell.childNodes;
-
    for (const child of Array.from(childNodes)) {
        if (child.nodeType === TEXT_NODE) {
            // Direct text node, append the text directly
@ -34,6 +33,8 @@ function extraxtODSCellText(cell) {
                    text += pChild.nodeValue;  // Append text inside <text:p>
                } else if (pChild.nodeName === 'text:line-break') {
                    text += '\n';  // Append newline for <text:line-break />
+                } else if (pChild.nodeName === 'text:a' || pChild.nodeName === 'text:span') {
+                    text += pChild.textContent
                }
            }
        } else if (child.nodeName === 'text:line-break') {
@ -160,6 +161,22 @@ export function convertCellValue({value, type}) {
 }


+/**
+ * @param {unknown} value
+ * @returns {value is OdfjsImage}
+ */
+export function isOdfjsImage(value) {
+    if (typeof value === 'object' && value!==null
+        && "content" in value && value.content instanceof ArrayBuffer
+        && "fileName" in value && typeof value.fileName === 'string'
+        && "mediaType" in value && typeof value.mediaType === 'string'
+    ) {
+        return true
+    } else {
+        return false
+    }
+}
+



--- a/scripts/types.js
+++ b/scripts/types.js
@ -10,4 +10,12 @@

 /** @typedef {string} SheetName */

+/** 
+ * @typedef OdfjsImage  
+ * @prop {ArrayBuffer} content
+ * @prop {string} fileName
+ * @prop {string} mediaType
+ * 
+*/
+
 export {}
--- a/tests/fill-odt-template/complex.js
+++ b/tests/fill-odt-template/complex.js
@ -0,0 +1,25 @@
+import test from 'ava';
+import {join} from 'node:path';
+
+import {getOdtTemplate} from '../../scripts/odf/odtTemplate-forNode.js'
+
+import {fillOdtTemplate, getOdtTextContent} from '../../exports.js'
+
+
+test('template with {#each} inside an {#if}', async t => {
+    const templatePath = join(import.meta.dirname, '../fixtures/if-then-each.odt')
+    const templateContent = `{#if liste_départements.length >= 2}{#each liste_départements as département}{département}, {/each} {/if}`
+
+    const data = {liste_départements : ['95', '33']}
+
+    const odtTemplate = await getOdtTemplate(templatePath)
+    const templateTextContent = await getOdtTextContent(odtTemplate)
+    t.deepEqual(templateTextContent.trim(), templateContent.trim(), 'reconnaissance du template')
+
+    const odtResult = await fillOdtTemplate(odtTemplate, data)
+
+    const odtResultTextContent = await getOdtTextContent(odtResult)
+    t.deepEqual(odtResultTextContent.trim(), `95, 33,`)
+
+});
+
--- a/tests/fill-odt-template/each.js
+++ b/tests/fill-odt-template/each.js
@ -28,7 +28,7 @@ test('basic template filling with {#each}', async t => {
    const templateTextContent = await getOdtTextContent(odtTemplate)

    t.deepEqual(templateTextContent, templateContent, 'reconnaissance du template')
-
+try{
    const odtResult = await fillOdtTemplate(odtTemplate, data)

    const odtResultTextContent = await getOdtTextContent(odtResult)
@ -38,6 +38,7 @@ Radis
 Jus d'orange
 Pâtes à lasagne (fraîches !)
 `)
+    }catch(e){console.error(e); throw e}


 });
@ -247,6 +248,43 @@ Hiver
 });


+test('template filling with text after {/each} in same text node', async t => {
+    const templatePath = join(import.meta.dirname, '../fixtures/text-after-closing-each.odt')
+    const templateContent = `Légumes de saison
+
+{#each légumes as légume}
+{légume}, 
+{/each} en {saison}
+`
+
+	const data = {
+        saison: 'Printemps',
+        légumes: [
+            'Asperge',
+            'Betterave',
+            'Blette'
+        ]
+    }
+
+    const odtTemplate = await getOdtTemplate(templatePath)
+
+    const templateTextContent = await getOdtTextContent(odtTemplate)    
+    t.deepEqual(templateTextContent, templateContent, 'reconnaissance du template')
+
+    const odtResult = await fillOdtTemplate(odtTemplate, data)
+
+    const odtResultTextContent = await getOdtTextContent(odtResult)
+    t.deepEqual(odtResultTextContent, `Légumes de saison
+
+Asperge, 
+Betterave, 
+Blette, 
+ en Printemps
+`)
+
+});
+
+
 test('template filling of a table', async t => {
    const templatePath = join(import.meta.dirname, '../fixtures/tableau-simple.odt')
    const templateContent = `Évolution énergie en kWh par personne en France
@ -306,3 +344,32 @@ Année
 `.trim())

 });
+
+
+test('nested each without common ancestor for inner each', async t => {
+    const templatePath = join(import.meta.dirname, '../fixtures/nested-each-without-common-ancestor-for-inner-each.odt')
+    const templateContent = `{#each liste_espèces_par_impact as élément}
+{#each élément.liste_espèces as espèce}
+{/each}
+{/each}
+`
+
+	const data = {
+        liste_espèces_par_impact: [
+            {}
+        ]
+    }
+
+    const odtTemplate = await getOdtTemplate(templatePath)
+
+    const templateTextContent = await getOdtTextContent(odtTemplate)
+
+    t.deepEqual(templateTextContent, templateContent, 'reconnaissance du template')
+
+    const odtResult = await fillOdtTemplate(odtTemplate, data)
+
+    const odtResultTextContent = await getOdtTextContent(odtResult)
+    t.deepEqual(odtResultTextContent, ``)
+
+
+});
--- a/tests/fill-odt-template/formatting.js
+++ b/tests/fill-odt-template/formatting.js
@ -5,6 +5,7 @@ import {getOdtTemplate} from '../../scripts/odf/odtTemplate-forNode.js'

 import {fillOdtTemplate, getOdtTextContent} from '../../exports.js'

+
 test('template filling with several layers of formatting in {#each ...} start marker', async t => {
    const templatePath = join(import.meta.dirname, '../fixtures/formatting-liste-nombres-plusieurs-couches.odt')
    const templateContent = `Liste de nombres
@ -86,7 +87,6 @@ Les nombres : 3 5 8 13  !!
 });


-
 test('template filling - {/each} and text after partially formatted', async t => {
    const templatePath = join(import.meta.dirname, '../fixtures/formatting-liste-nombres-each-end-and-after-formatted.odt')
    const templateContent = `Liste de nombres
@ -114,8 +114,6 @@ Les nombres : 5 8 13 21  !!
 });


-
-
 test('template filling - partially formatted variable', async t => {
    const templatePath = join(import.meta.dirname, '../fixtures/partially-formatted-variable.odt')
    const templateContent = `Nombre
@ -129,9 +127,9 @@ Voici le nombre : {nombre} !!!

    const templateTextContent = await getOdtTextContent(odtTemplate)    
    t.deepEqual(templateTextContent, templateContent, 'reconnaissance du template')
-
+//try{
    const odtResult = await fillOdtTemplate(odtTemplate, data)
-
+//}catch(e){console.error(e)}
    const odtResultTextContent = await getOdtTextContent(odtResult)
    t.deepEqual(odtResultTextContent, `Nombre

@ -139,3 +137,75 @@ Voici le nombre : 37 !!!
 `)

 });
+
+
+test('template filling - formatted-start-each-single-paragraph', async t => {
+    const templatePath = join(import.meta.dirname, '../fixtures/formatted-start-each-single-paragraph.odt')
+    const templateContent = `
+{#each nombres as n}
+{n}
+{/each}
+`
+
+    const data = {nombres : [37, 38, 39]}
+
+    const odtTemplate = await getOdtTemplate(templatePath)
+
+    const templateTextContent = await getOdtTextContent(odtTemplate)    
+    t.deepEqual(templateTextContent.trim(), templateContent.trim(), 'reconnaissance du template')
+    
+    const odtResult = await fillOdtTemplate(odtTemplate, data)
+
+    const odtResultTextContent = await getOdtTextContent(odtResult)
+    t.deepEqual(odtResultTextContent, `
+
+37
+38
+39
+`)
+
+});
+
+
+test('template filling - formatted ghost if then', async t => {
+    const templatePath = join(import.meta.dirname, '../fixtures/ghost-if.odt')
+    const templateContent = `
+    Utilisation de sources lumineuses : {#if scientifique.source_lumineuses}Oui{:else}Non{/if}
+`
+
+    const data = {scientifique: {source_lumineuses: true}}
+
+    const odtTemplate = await getOdtTemplate(templatePath)
+
+    const templateTextContent = await getOdtTextContent(odtTemplate)    
+    t.deepEqual(templateTextContent.trim(), templateContent.trim(), 'reconnaissance du template')
+    let odtResult = await fillOdtTemplate(odtTemplate, data)
+
+    const odtResultTextContent = await getOdtTextContent(odtResult)
+    t.deepEqual(odtResultTextContent.trim(), `
+ Utilisation de sources lumineuses : Oui
+`.trim())
+
+});
+
+
+test('template filling - formatted ghost if else', async t => {
+    const templatePath = join(import.meta.dirname, '../fixtures/ghost-if.odt')
+    const templateContent = `
+    Utilisation de sources lumineuses : {#if scientifique.source_lumineuses}Oui{:else}Non{/if}
+`
+
+    const data = {scientifique: {source_lumineuses: false}}
+
+    const odtTemplate = await getOdtTemplate(templatePath)
+
+    const templateTextContent = await getOdtTextContent(odtTemplate)    
+    t.deepEqual(templateTextContent.trim(), templateContent.trim(), 'reconnaissance du template')
+    let odtResult = await fillOdtTemplate(odtTemplate, data)
+
+    const odtResultTextContent = await getOdtTextContent(odtResult)
+    t.deepEqual(odtResultTextContent.trim(), `
+ Utilisation de sources lumineuses : Non
+`.trim())
+
+});
--- a/tests/fill-odt-template/if.js
+++ b/tests/fill-odt-template/if.js
@ -6,7 +6,7 @@ import {getOdtTemplate} from '../../scripts/odf/odtTemplate-forNode.js'
 import {fillOdtTemplate, getOdtTextContent} from '../../exports.js'


-test('basic template filling with {#if}', async t => {
+test('basic template filling with {#if}{:else} - then branch', async t => {
    const templatePath = join(import.meta.dirname, '../fixtures/description-nombre.odt')
    const templateContent = `Description du nombre {n}

@ -29,6 +29,26 @@ n est un grand nombre
 n est un petit nombre
 `)

+
+});
+
+
+test('basic template filling with {#if}{:else} - else branch', async t => {
+    const templatePath = join(import.meta.dirname, '../fixtures/description-nombre.odt')
+    const templateContent = `Description du nombre {n}
+
+{#if n<5}
+n est un petit nombre
+{:else}
+n est un grand nombre
+{/if}
+`
+
+    const odtTemplate = await getOdtTemplate(templatePath)
+    const templateTextContent = await getOdtTextContent(odtTemplate)
+    t.deepEqual(templateTextContent, templateContent, 'reconnaissance du template')
+    
+    try{
    // else branch
    const odtResult8 = await fillOdtTemplate(odtTemplate, {n: 8})
    const odtResult8TextContent = await getOdtTextContent(odtResult8)
@ -36,7 +56,36 @@ n est un petit nombre

 n est un grand nombre
 `)
+    }
+    catch(e){console.error(e); throw e}


 });

+
+test('complex structured if', async t => {
+    const templatePath = join(import.meta.dirname, '../fixtures/left-branch-content-and-two-consecutive-ifs.odt')
+    const templateContent = `Utilisation de sources lumineuses : {#if scientifique.source_lumineuses}Oui{:else}Non{/if}
+{#if scientifique.source_lumineuses && scientifique.modalités_source_lumineuses }
+Modalités d’utilisation de sources lumineuses : {scientifique.modalités_source_lumineuses}
+{/if}
+`
+
+    const data = {
+        scientifique: {
+            source_lumineuses: false,
+            //modalités_source_lumineuses: 'lampes torches'
+        }
+    }
+
+
+    const odtTemplate = await getOdtTemplate(templatePath)
+    const templateTextContent = await getOdtTextContent(odtTemplate)
+    t.deepEqual(templateTextContent.trim(), templateContent.trim(), 'reconnaissance du template')
+
+    const odtResult = await fillOdtTemplate(odtTemplate, data)
+    const odtResultTextContent = await getOdtTextContent(odtResult)
+    t.deepEqual(odtResultTextContent.trim(), `Utilisation de sources lumineuses : Non`)
+
+});
+
--- a/tests/fill-odt-template/image.js
+++ b/tests/fill-odt-template/image.js
@ -1,10 +1,12 @@
 import test from 'ava';
 import {join} from 'node:path';
+import { readFile } from 'node:fs/promises'

 import {getOdtTemplate} from '../../scripts/odf/odtTemplate-forNode.js'

-import {fillOdtTemplate} from '../../exports.js'
+import {fillOdtTemplate, getOdtTextContent} from '../../exports.js'
 import { listZipEntries } from '../helpers/zip-analysis.js';
+import { getContentDocument } from '../../scripts/odf/odt/getOdtTextContent.js';


 test('template filling preserves images', async t => {
@ -36,3 +38,47 @@ test('template filling preserves images', async t => {
    )

 })
+
+test('insert 2 images', async t => {
+    const templatePath = join(import.meta.dirname, '../fixtures/basic-image-insertion.odt')
+
+    
+    const odtTemplate = await getOdtTemplate(templatePath)
+    const templateContent = `{title}
+
+{#each photos as photo}
+{#image photo}
+{/each}
+`
+    const templateTextContent = await getOdtTextContent(odtTemplate)
+
+    t.is(templateTextContent, templateContent, 'reconnaissance du template')
+
+    const photo1Path = join(import.meta.dirname, '../fixtures/pitchou-1.png')
+    const photo2Path = join(import.meta.dirname, '../fixtures/pitchou-2.png')
+
+    const photo1Buffer = (await readFile(photo1Path)).buffer
+    const photo2Buffer = (await readFile(photo2Path)).buffer
+
+    const photos = [{content: photo1Buffer, fileName: 'pitchou-1.png', mediaType: 'image/png'}, {content: photo2Buffer, fileName: 'pitchou-2.png', mediaType: 'image/png'}]
+
+    const data = {
+        title: 'Titre de mon projet',
+        photos,
+    }
+
+    const odtResult = await fillOdtTemplate(odtTemplate, data)
+    const resultEntries = await listZipEntries(odtResult)
+    
+    
+    t.is(
+        resultEntries.filter(entry => entry.filename.startsWith('Pictures/')).length, 2, 
+        `Two pictures in 'Pictures/' folder are expected`
+    )
+
+    const odtContentDocument = await getContentDocument(odtResult)
+
+    const drawImageElements = odtContentDocument.getElementsByTagName('draw:image')
+    t.is(drawImageElements.length, 2, 'Two draw:image elements should be in the generated document.')
+   
+})
--- a/tests/fixtures/basic-image-insertion.odt
+++ b/tests/fixtures/basic-image-insertion.odt
--- a/tests/fixtures/cellule
+++ b/tests/fixtures/cellule
--- a/tests/fixtures/cellules
+++ b/tests/fixtures/cellules
--- a/tests/fixtures/formatted-start-each-single-paragraph.odt
+++ b/tests/fixtures/formatted-start-each-single-paragraph.odt
--- a/tests/fixtures/ghost-if.odt
+++ b/tests/fixtures/ghost-if.odt
--- a/tests/fixtures/if-then-each.odt
+++ b/tests/fixtures/if-then-each.odt
--- a/tests/fixtures/left-branch-content-and-two-consecutive-ifs.odt
+++ b/tests/fixtures/left-branch-content-and-two-consecutive-ifs.odt
--- a/tests/fixtures/nested-each-without-common-ancestor-for-inner-each.odt
+++ b/tests/fixtures/nested-each-without-common-ancestor-for-inner-each.odt
--- a/tests/fixtures/pitchou-1.png
+++ b/tests/fixtures/pitchou-1.png
--- a/tests/fixtures/pitchou-2.png
+++ b/tests/fixtures/pitchou-2.png
--- a/tests/fixtures/text-after-closing-each.odt
+++ b/tests/fixtures/text-after-closing-each.odt
--- a/tests/ods-files.js
+++ b/tests/ods-files.js
@ -56,3 +56,33 @@ Si t'es pas comme eux quand t'es naturel`

    t.deepEqual(feuille1[0][0].value, expectedValue)
 });
+
+test('.ods cells with mails should be recognized', async t => {
+    const odsFileWithEmails = (await readFile('./tests/fixtures/cellules avec emails.ods')).buffer
+	const table = await getODSTableRawContent(odsFileWithEmails);
+
+    const feuille1 = table.get('Feuille1')
+
+    const row1 = feuille1[0]
+    t.deepEqual(row1[0].value, 'Nom')
+    t.deepEqual(row1[1].value, 'Email')
+
+    const row2 = feuille1[1]
+
+    t.deepEqual(row2[0].value, 'Dav')
+    t.deepEqual(row2[1].value, 'david@example.org')
+
+    const row3 = feuille1[2]
+    t.deepEqual(row3[0].value, 'Fanny')
+    t.deepEqual(row3[1].value, 'lemaildeFanny@example.com')
+});
+
+test('.ods cells with partially styled content should be recognized', async t => {
+    const odsFileWithStyle = (await readFile('./tests/fixtures/cellule avec style.ods')).buffer;
+    const table = await getODSTableRawContent(odsFileWithStyle);
+
+    const feuille1 = table.get('Feuille1');
+
+    const row1 = feuille1[0];
+    t.deepEqual(row1[0].value, 'Toto titi');
+});
--- a/tools/create-odt-file-from-template.js
+++ b/tools/create-odt-file-from-template.js
@ -1,31 +1,28 @@
-import {writeFile} from 'node:fs/promises'
+import {writeFile, readFile} from 'node:fs/promises'
 import {join} from 'node:path';

 import {getOdtTemplate} from '../scripts/odf/odtTemplate-forNode.js'
-import {fillOdtTemplate} from '../scripts/node.js'
+import {fillOdtTemplate} from '../exports.js'

 /*
-const templatePath = join(import.meta.dirname, '../tests/data/template-anniversaire.odt')
+const templatePath = join(import.meta.dirname, '../tests/fixtures/template-anniversaire.odt')
 const data = {
    nom: 'David Bruant',
    dateNaissance: '8 mars 1987'
 }
 */

-
-/*
-const templatePath = join(import.meta.dirname, '../tests/data/liste-courses.odt')
+/*const templatePath = join(import.meta.dirname, '../tests/fixtures/enum-courses.odt')
 const data = {
    listeCourses : [
        'Radis',
        `Jus d'orange`,
        'Pâtes à lasagne (fraîches !)'
    ]
-}
-*/
+}*/

 /*
-const templatePath = join(import.meta.dirname, '../tests/data/liste-fruits-et-légumes.odt')
+const templatePath = join(import.meta.dirname, '../tests/fixtures/liste-fruits-et-légumes.odt')
 const data = {
    fruits : [
        'Pastèque 🍉',
@ -40,7 +37,7 @@ const data = {
 }*/

 /*
-const templatePath = join(import.meta.dirname, '../tests/data/légumes-de-saison.odt')
+const templatePath = join(import.meta.dirname, '../tests/fixtures/légumes-de-saison.odt')
 const data = {
    légumesSaison : [
        {
@ -79,8 +76,8 @@ const data = {
 }
 */

-
-const templatePath = join(import.meta.dirname, '../tests/data/tableau-simple.odt')
+/*
+const templatePath = join(import.meta.dirname, '../tests/fixtures/tableau-simple.odt')
 const data = {
    annéeConsos : [
        { année: 1970, conso: 36252.637},
@ -91,16 +88,60 @@ const data = {
        { année: 2020, conso: 37859.246},
    ]
 }
-
+    */


 /*
-const templatePath = join(import.meta.dirname, '../tests/data/template-avec-image.odt')
+const templatePath = join(import.meta.dirname, '../tests/fixtures/template-avec-image.odt')

 const data = {
    commentaire : `J'adooooooore 🤩 West covinaaaaaaaaaaa 🎶`
 }
 */
+/*
+const templatePath = join(import.meta.dirname, '../tests/fixtures/partially-formatted-variable.odt')
+const data = {nombre : 37}
+*/  
+
+/*
+const templatePath = join(import.meta.dirname, '../tests/fixtures/text-after-closing-each.odt')
+const data = {
+    saison: 'Printemps',
+    légumes: [
+        'Asperge',
+        'Betterave',
+        'Blette'
+    ]
+}
+*/
+// const templatePath = join(import.meta.dirname, '../tests/fixtures/text-after-closing-each.odt')
+// const data = {
+//     saison: 'Printemps',
+//     légumes: [
+//         'Asperge',
+//         'Betterave',
+//         'Blette'
+//     ]
+// }
+
+// const templatePath = join(import.meta.dirname, '../tests/fixtures/if-then-each.odt')
+// const data = {liste_départements : ['95', '33']}
+
+
+const templatePath = join(import.meta.dirname, '../tests/fixtures/basic-image-insertion.odt')
+const photo1Path = join(import.meta.dirname, '../tests/fixtures/pitchou-1.png')
+const photo2Path = join(import.meta.dirname, '../tests/fixtures/pitchou-2.png')
+
+const photo1Buffer = (await readFile(photo1Path)).buffer
+const photo2Buffer = (await readFile(photo2Path)).buffer
+
+const photos = [{content: photo1Buffer, fileName: 'pitchou-1.png', mediaType: 'image/png'}, {content: photo2Buffer, fileName: 'pitchou-2.png', mediaType: 'image/png'}]
+
+const data = {
+    title: 'Titre de mon projet',
+    photos,
+}
+

 const odtTemplate = await getOdtTemplate(templatePath)
 const odtResult = await fillOdtTemplate(odtTemplate, data)
Author	SHA1	Message	Date
Skylar Ittner	e6e09a0361	Properly support currency fields Some checks failed Build and Deploy / build (push) Failing after 5m8s Build and Deploy / deploy (push) Has been skipped	2026-02-05 03:32:14 -07:00
Skylar Ittner	3d98e41d2b	Add column width calculation Some checks failed Build and Deploy / build (push) Failing after 11s Build and Deploy / deploy (push) Has been skipped	2026-02-05 01:54:56 -07:00
Skylar Ittner	7c87d3220d	Update repository url Some checks failed Build and Deploy / build (push) Failing after 12s Build and Deploy / deploy (push) Has been skipped	2026-02-05 01:10:55 -07:00
Skylar Ittner	8b60ceb39c	Add bold cell formatting option Some checks failed Build and Deploy / build (push) Failing after 14s Build and Deploy / deploy (push) Has been skipped	2026-02-05 01:10:10 -07:00
Hannaeko	c677c7267b	bump readme version	2025-09-22 16:35:43 +02:00
Hannaeko	415a26e3f1	0.30.0	2025-09-22 16:35:13 +02:00
hannaeko	90b97e23e9	fix text extraction for cells with partial styling (#23 )	2025-09-22 16:34:43 +02:00
David Bruant	02d5338634	bump readme version	2025-09-18 16:16:21 +02:00
David Bruant	542183a593	0.29.0	2025-09-18 16:15:55 +02:00
David Bruant	a31f57026d	Remove default call to lockdown (#22 ) * restore test * suppression de l'appel à lockdown par défaut * improving readme * ses@1.14 * add section on securing fillOdtTemplate	2025-09-18 16:15:24 +02:00
David Bruant	98817e9d34	bump readme version	2025-09-18 10:41:35 +02:00
David Bruant	ca40785155	0.28.0	2025-09-18 10:41:10 +02:00
Clémence	8cc74a6fe6	Extract text inside a text:a tag (#21 ) * Extract text inside a text:a tag * Extract text inside a text:a tag and create a test * Fix test regression * Use example domain name for mails * nettoyage console.log --------- Co-authored-by: David Bruant <davidbruant@protonmail.com>	2025-09-18 10:36:59 +02:00
Clémence Fernandez	0938a97a83	bump readme version 0.27.0	2025-09-16 16:45:34 +02:00
Clémence Fernandez	8b0c1c6eb0	0.27.0	2025-09-16 16:44:27 +02:00
Clémence	d934d0dfb0	Add images (#16 ) * add template * Rename template * Add test for insert 2 images * image marker regex * Ajout d'un test pour vérifier que le texte du template est bon * WORK IN PROGRESS - trouver et évaluer la balise image * Create OfjsImage type * create addImageToOdtFile * Regenerate yo odt to inspect it * Add a draw image and a draw frame into odt file * Test if there are two draw:image in the generated document * Add pictures in manifest.xml to fix corrupted file * Adapt anchor type * Fix images aspect with ratio	2025-09-16 16:43:47 +02:00
David Bruant	a4d273793e	bump readme version	2025-09-12 17:23:37 +02:00
David Bruant	9d942899ed	0.26.0	2025-09-12 17:23:15 +02:00
David Bruant	8d3d91da2f	Error thrown by mistake for {#each} inside an {#if} (#19 ) * reduced test case * test case * adding complex test case	2025-09-12 17:22:19 +02:00
David Bruant	fbadfc7144	0.25.0	2025-07-19 14:07:54 +02:00
David Bruant	e0b2316c42	bump readme version	2025-07-19 14:07:46 +02:00
David Bruant	8eb15ad97c	fillOdtElementTemplate now takes an array of nodes as argument for the situation of calling it on the middleContent of a block with several elements so they're evaluated together (#15 ) * reproducing bug * reducing test case * fillOdtElementTemplate now takes an array of nodes as argument for the situation of calling it on the middleContent of a block with several elements so they're evaluated together	2025-07-19 14:07:10 +02:00
David Bruant	136b240b99	0.24.0	2025-05-27 14:56:15 +02:00
David Bruant	4c67eaacd0	bump readme version	2025-05-27 14:56:10 +02:00
David Bruant	5aac86553c	Ouinon bug (#10 ) * rename * change order of removals in fillIfBlock to properly remove right/left content	2025-05-27 14:55:53 +02:00
David Bruant	9fa9c9eb62	0.23.0	2025-05-27 08:20:31 +02:00
David Bruant	38b146155c	bump readme version	2025-05-27 08:20:23 +02:00
David Bruant	2d559bac5d	Better abstraction (#9 ) * beginning of refactoring - if tests passing * Beginning of passing tests for each * Les tests each passent * progress * Les tests passent	2025-05-27 08:19:51 +02:00
David Bruant	a1e99b4519	0.22.0	2025-05-21 15:38:49 +02:00
David Bruant	4f49685acd	bump readme version	2025-05-21 15:38:35 +02:00
David Bruant	03c8188bf5	add package.files field	2025-05-21 15:35:56 +02:00
David Bruant	6bb363485d	0.21.0	2025-05-21 15:10:28 +02:00
David Bruant	95a20b23c0	readme version bump	2025-05-21 15:10:25 +02:00
David Bruant	29a2429c00	Bug if 2 (#8 ) * Adjust variable marker to ignore {:else} * Getting start branch right content and end branch left content when extracting block content * remove open if block after {/if} * look for left/right branch content only up to common ancestor * fix test case to new reality * fix minor bug	2025-05-21 15:09:47 +02:00
David Bruant	4e86fc1656	0.20.0	2025-05-09 18:49:02 +02:00
David Bruant	9bdf7cdf1b	readme version bump	2025-05-09 18:48:56 +02:00
David Bruant	5400c963a7	after-text in #each block (#7 ) * Text 'text after {/each} in same text node' failing * some tests passing * tests passing * unused var * styling	2025-05-09 18:48:34 +02:00
David Bruant	6ad0bab069	0.19.0	2025-05-08 21:29:20 +02:00
David Bruant	e916456d41	bump readme version	2025-05-08 21:29:10 +02:00
David Bruant	183da0053b	the tests ae passing (#6 )	2025-05-08 21:28:45 +02:00