@odoo/o-spreadsheet 16.4.0-alpha.6 → 16.4.0-alpha.7

package/dist/o-spreadsheet.cjs.js

@@ -12596,6 +12596,18 @@ const AND = {
     isExported: true,
 };
 // -----------------------------------------------------------------------------
+// FALSE
+// -----------------------------------------------------------------------------
+const FALSE = {
+    description: _lt("Logical value `false`."),
+    args: [],
+    returns: ["BOOLEAN"],
+    compute: function () {
+        return false;
+    },
+    isExported: true,
+};
+// -----------------------------------------------------------------------------
 // IF
 // -----------------------------------------------------------------------------
 const IF = {
@@ -12731,6 +12743,18 @@ const OR = {
     isExported: true,
 };
 // -----------------------------------------------------------------------------
+// TRUE
+// -----------------------------------------------------------------------------
+const TRUE = {
+    description: _lt("Logical value `true`."),
+    args: [],
+    returns: ["BOOLEAN"],
+    compute: function () {
+        return true;
+    },
+    isExported: true,
+};
+// -----------------------------------------------------------------------------
 // XOR
 // -----------------------------------------------------------------------------
 const XOR = {
@@ -12757,12 +12781,14 @@ const XOR = {
 var logical = /*#__PURE__*/Object.freeze({
   __proto__: null,
   AND: AND,
+  FALSE: FALSE,
   IF: IF,
   IFERROR: IFERROR,
   IFNA: IFNA,
   IFS: IFS,
   NOT: NOT,
   OR: OR,
+  TRUE: TRUE,
   XOR: XOR
 });
 
@@ -13949,7 +13975,6 @@ function indentCode(code) {
  * is useful for the composer, which needs to be able to work with incomplete
  * formulas.
  */
-const functions$3 = functionRegistry.content;
 const POSTFIX_UNARY_OPERATORS = ["%"];
 const OPERATORS = "+,-,*,/,:,=,<>,>=,>,<=,<,^,&".split(",").concat(POSTFIX_UNARY_OPERATORS);
 function tokenize(str, locale = DEFAULT_LOCALE) {
@@ -14080,17 +14105,11 @@ function tokenizeSymbol(chars) {
     }
     if (result.length) {
         const value = result;
-        const isFunction = value.toUpperCase() in functions$3;
-        if (isFunction) {
-            return { type: "FUNCTION", value };
-        }
         const isReference = rangeReference.test(value);
         if (isReference) {
             return { type: "REFERENCE", value };
         }
-        else {
-            return { type: "SYMBOL", value };
-        }
+        return { type: "SYMBOL", value };
     }
     return null;
 }
@@ -14190,9 +14209,6 @@ function parseOperand(tokens) {
             return { type: "NUMBER", value: parseNumber(current.value, DEFAULT_LOCALE) };
         case "STRING":
             return { type: "STRING", value: removeStringQuotes(current.value) };
-        case "FUNCTION":
-            const args = parseFunctionArgs(tokens);
-            return { type: "FUNCALL", value: current.value, args };
         case "INVALID_REFERENCE":
             throw new InvalidReferenceError();
         case "REFERENCE":
@@ -14209,13 +14225,15 @@ function parseOperand(tokens) {
                 value: current.value,
             };
         case "SYMBOL":
-            if (["TRUE", "FALSE"].includes(current.value.toUpperCase())) {
-                return { type: "BOOLEAN", value: current.value.toUpperCase() === "TRUE" };
+            const value = current.value;
+            const nextToken = tokens[0];
+            if (nextToken?.type === "LEFT_PAREN" && functionRegex.test(current.value)) {
+                const args = parseFunctionArgs(tokens);
+                return { type: "FUNCALL", value: value, args };
             }
-            if (current.value) {
-                if (functionRegex.test(current.value) && tokens[0]?.type === "LEFT_PAREN") {
-                    throw new UnknownFunctionError(current.value);
-                }
+            const upperCaseValue = value.toUpperCase();
+            if (upperCaseValue === "TRUE" || upperCaseValue === "FALSE") {
+                return { type: "BOOLEAN", value: upperCaseValue === "TRUE" };
             }
             throw new BadExpressionError(_lt("Invalid formula"));
         case "LEFT_PAREN":
@@ -14317,36 +14335,60 @@ function parseTokens(tokens) {
  * to nodes of a specific type.
  * Useful if you want to convert some part of a formula.
  *
- * e.g.
- * ```ts
+ * @example
  * convertAstNodes(ast, "FUNCALL", convertFormulaToExcel)
  *
  * function convertFormulaToExcel(ast: ASTFuncall) {
  *   // ...
  *   return modifiedAst
  * }
- * ```
  */
 function convertAstNodes(ast, type, fn) {
-    if (type === ast.type) {
-        ast = fn(ast);
+    return mapAst(ast, (ast) => {
+        if (ast.type === type) {
+            return fn(ast);
+        }
+        return ast;
+    });
+}
+function iterateAstNodes(ast) {
+    return Array.from(astIterator(ast));
+}
+function* astIterator(ast) {
+    yield ast;
+    switch (ast.type) {
+        case "FUNCALL":
+            for (const arg of ast.args) {
+                yield* astIterator(arg);
+            }
+            break;
+        case "UNARY_OPERATION":
+            yield* astIterator(ast.operand);
+            break;
+        case "BIN_OPERATION":
+            yield* astIterator(ast.left);
+            yield* astIterator(ast.right);
+            break;
     }
+}
+function mapAst(ast, fn) {
+    ast = fn(ast);
     switch (ast.type) {
         case "FUNCALL":
             return {
                 ...ast,
-                args: ast.args.map((child) => convertAstNodes(child, type, fn)),
+                args: ast.args.map((child) => mapAst(child, fn)),
             };
         case "UNARY_OPERATION":
             return {
                 ...ast,
-                operand: convertAstNodes(ast.operand, type, fn),
+                operand: mapAst(ast.operand, fn),
             };
         case "BIN_OPERATION":
             return {
                 ...ast,
-                right: convertAstNodes(ast.right, type, fn),
-                left: convertAstNodes(ast.left, type, fn),
+                right: mapAst(ast.right, fn),
+                left: mapAst(ast.left, fn),
             };
         default:
             return ast;
@@ -14616,6 +14658,9 @@ function compile(formula) {
             const { args } = ast;
             const functionName = ast.value.toUpperCase();
             const functionDefinition = functions$2[functionName];
+            if (!functionDefinition) {
+                throw new UnknownFunctionError(ast.value);
+            }
             assertEnoughArgs(ast);
             const compiledArgs = [];
             for (let i = 0; i < args.length; i++) {
@@ -14874,7 +14919,7 @@ function mapParentFunction(tokens) {
             functionStarted = "";
         }
         switch (token.type) {
-            case "FUNCTION":
+            case "SYMBOL":
                 functionStarted = token.value;
                 break;
             case "LEFT_PAREN":
@@ -14911,6 +14956,17 @@ function composerTokenize(formula, locale) {
     return mapParentFunction(mapParenthesis(enrichTokens(tokens)));
 }
 
+const functions$1 = functionRegistry.content;
+function isExportableToExcel(tokens) {
+    try {
+        const nonExportableFunctions = iterateAstNodes(parseTokens(tokens)).filter((ast) => ast.type === "FUNCALL" && !functions$1[ast.value.toUpperCase()]?.isExported);
+        return nonExportableFunctions.length === 0;
+    }
+    catch (error) {
+        return false;
+    }
+}
+
 function isValidLocale(locale) {
     if (!(locale &&
         typeof locale === "object" &&
@@ -17483,8 +17539,14 @@ function getImageMenuRegistry(figureId, onFigureDeleted, env) {
             id: "reset_size",
             name: _lt("Reset size"),
             sequence: 4,
-            execute: () => {
-                const size = env.model.getters.getImageSize(figureId);
+            execute: async () => {
+                const imagePath = env.model.getters.getImagePath(figureId);
+                const size = env.model.getters.getImageSize(figureId) ??
+                    (await env.imageProvider?.getImageOriginalSize(imagePath));
+                if (!env.model.getters.getImageSize(figureId)) {
+                    const image = env.model.getters.getImage(figureId);
+                    image.size = size;
+                }
                 const { height, width } = getMaxFigureSize(env.model.getters, size);
                 env.model.dispatch("UPDATE_FIGURE", {
                     sheetId: env.model.getters.getActiveSheetId(),
@@ -23537,7 +23599,7 @@ FunctionDescriptionProvider.props = {
     argToFocus: Number,
 };
 
-const functions$1 = functionRegistry.content;
+const functions = functionRegistry.content;
 const ASSISTANT_WIDTH = 300;
 const selectionIndicatorClass = "selector-flag";
 const selectionIndicatorColor = "#a9a9a9";
@@ -23571,10 +23633,6 @@ css /* scss */ `
       padding-right: 3px;
       outline: none;
 
-      &.unfocusable {
-        pointer-events: none;
-      }
-
       p {
         margin-bottom: 0px;
 
@@ -23822,7 +23880,10 @@ class Composer extends owl.Component {
         }
     }
     showAutocomplete(searchTerm) {
-        if (!this.env.model.getters.getCurrentContent().startsWith("=")) {
+        const searchTermUpperCase = searchTerm.toUpperCase();
+        if (!this.env.model.getters.getCurrentContent().startsWith("=") ||
+            searchTermUpperCase === "TRUE" ||
+            searchTermUpperCase === "FALSE") {
             return;
         }
         this.autoCompleteState.showProvider = true;
@@ -23940,7 +24001,6 @@ class Composer extends owl.Component {
             switch (token.type) {
                 case "OPERATOR":
                 case "NUMBER":
-                case "FUNCTION":
                 case "ARG_SEPARATOR":
                 case "STRING":
                     result.push({ value: token.value, color: tokenColors[token.type] || "#000" });
@@ -23950,10 +24010,14 @@ class Composer extends owl.Component {
                     result.push({ value: token.value, color: this.rangeColor(xc, sheetName) || "#000" });
                     break;
                 case "SYMBOL":
-                    let value = token.value;
-                    if (["TRUE", "FALSE"].includes(value.toUpperCase())) {
+                    const value = token.value;
+                    const upperCaseValue = value.toUpperCase();
+                    if (upperCaseValue === "TRUE" || upperCaseValue === "FALSE") {
                         result.push({ value: token.value, color: tokenColors.NUMBER });
                     }
+                    else if (upperCaseValue in functionRegistry.content) {
+                        result.push({ value: token.value, color: tokenColors.FUNCTION });
+                    }
                     else {
                         result.push({ value: token.value, color: "#000" });
                     }
@@ -24049,25 +24113,28 @@ class Composer extends owl.Component {
         this.autoCompleteState.showProvider = false;
         this.functionDescriptionState.showDescription = false;
         if (content.startsWith("=")) {
-            const tokenAtCursor = this.env.model.getters.getTokenAtCursor();
-            if (tokenAtCursor) {
-                const { xc } = splitReference(tokenAtCursor.value);
-                if (tokenAtCursor.type === "FUNCTION" ||
-                    (tokenAtCursor.type === "SYMBOL" && !rangeReference.test(xc))) {
-                    // initialize Autocomplete Dropdown
-                    this.showAutocomplete(tokenAtCursor.value);
-                }
-                else if (tokenAtCursor.functionContext && tokenAtCursor.type !== "UNKNOWN") {
-                    // initialize Formula Assistant
-                    const tokenContext = tokenAtCursor.functionContext;
-                    const parentFunction = tokenContext.parent.toUpperCase();
-                    const description = functions$1[parentFunction];
-                    const argPosition = tokenContext.argPosition;
-                    this.functionDescriptionState.functionName = parentFunction;
-                    this.functionDescriptionState.functionDescription = description;
-                    this.functionDescriptionState.argToFocus = description.getArgToFocus(argPosition + 1) - 1;
-                    this.functionDescriptionState.showDescription = true;
-                }
+            const token = this.env.model.getters.getTokenAtCursor();
+            if (!token) {
+                return;
+            }
+            if (token.type === "SYMBOL") {
+                // initialize Autocomplete Dropdown
+                this.showAutocomplete(token.value);
+                return;
+            }
+            const tokenContext = token.functionContext;
+            const parentFunction = tokenContext?.parent.toUpperCase();
+            if (tokenContext &&
+                parentFunction &&
+                parentFunction in functions &&
+                token.type !== "UNKNOWN") {
+                // initialize Formula Assistant
+                const description = functions[parentFunction];
+                const argPosition = tokenContext.argPosition;
+                this.functionDescriptionState.functionName = parentFunction;
+                this.functionDescriptionState.functionDescription = description;
+                this.functionDescriptionState.argToFocus = description.getArgToFocus(argPosition + 1) - 1;
+                this.functionDescriptionState.showDescription = true;
             }
         }
     }
@@ -26767,7 +26834,12 @@ const XLSX_RELATION_TYPE = {
 };
 const RELATIONSHIP_NSR = "http://schemas.openxmlformats.org/officeDocument/2006/relationships";
 const HEIGHT_FACTOR = 0.75; // 100px => 75 u
-const WIDTH_FACTOR = 0.1317; // 100px => 13.17 u
+/**
+ * Excel says its default column width is 8.43 characters (64px)
+ * which makes WIDTH_FACTOR = 0.1317, but it doesn't work well
+ * 0.143 is a value from dev's experiments.
+ */
+const WIDTH_FACTOR = 0.143;
 /** unit : maximum number of characters a column can hold at the standard font size. What. */
 const EXCEL_DEFAULT_COL_WIDTH = 8.43;
 /** unit : points */
@@ -27284,7 +27356,7 @@ const XLSX_INDEXED_COLORS = {
     64: "000000",
     65: "FFFFFF", // system background
 };
-const IMAGE_MIMETYPE_EXTENSION_MAPPING = {
+const IMAGE_MIMETYPE_TO_EXTENSION_MAPPING = {
     "image/avif": "avif",
     "image/bmp": "bmp",
     "image/gif": "gif",
@@ -27293,6 +27365,17 @@ const IMAGE_MIMETYPE_EXTENSION_MAPPING = {
     "image/png": "png",
     "image/tiff": "tiff",
     "image/webp": "webp",
+};
+const IMAGE_EXTENSION_TO_MIMETYPE_MAPPING = {
+    avif: "image/avif",
+    bmp: "image/bmp",
+    gif: "image/gif",
+    ico: "image/vnd.microsoft.icon",
+    jpeg: "image/jpeg",
+    png: "image/png",
+    tiff: "image/tiff",
+    webp: "image/webp",
+    jpg: "image/jpeg",
 };
 
 /**
@@ -28096,20 +28179,35 @@ function convertFigure(figure, id, sheetData) {
         convertEMUToDotValue(figure.anchors[0].rowOffset);
     const y2 = getRowPosition(figure.anchors[1].row, sheetData) +
         convertEMUToDotValue(figure.anchors[1].rowOffset);
-    const width = x2 - x1;
-    const height = y2 - y1;
-    const chartData = convertChartData(figure.data);
-    if (!chartData)
-        return undefined;
-    return {
-        id: id,
-        x: x1,
-        y: y1,
-        width: width,
-        height: height,
-        tag: "chart",
-        data: convertChartData(figure.data),
-    };
+    const figureData = { id, x: x1, y: y1 };
+    if (isChartData(figure.data)) {
+        return {
+            ...figureData,
+            width: x2 - x1,
+            height: y2 - y1,
+            tag: "chart",
+            data: convertChartData(figure.data),
+        };
+    }
+    else if (isImageData(figure.data)) {
+        return {
+            ...figureData,
+            width: convertEMUToDotValue(figure.data.size.cx),
+            height: convertEMUToDotValue(figure.data.size.cy),
+            tag: "image",
+            data: {
+                path: figure.data.imageSrc,
+                mimetype: figure.data.mimetype,
+            },
+        };
+    }
+    return undefined;
+}
+function isChartData(data) {
+    return "dataSets" in data;
+}
+function isImageData(data) {
+    return "imageSrc" in data;
 }
 function convertChartData(chartData) {
     const dataSetsHaveTitle = chartData.dataSets[0].label !== undefined;
@@ -28816,9 +28914,13 @@ class XlsxBaseExtractor {
     /**
      * Get the list of all the XLSX files in the XLSX file structure
      */
-    getListOfFiles() {
-        const files = Object.values(this.xlsxFileStructure).flat().filter(isDefined$1);
-        return files;
+    getListOfXMLFiles() {
+        const XMLFiles = Object.entries(this.xlsxFileStructure)
+            .filter(([key]) => key !== "images")
+            .map(([_, value]) => value)
+            .flat()
+            .filter(isDefined$1);
+        return XMLFiles;
     }
     /**
      * Return an array containing the return value of the given function applied to all the XML elements
@@ -28990,20 +29092,31 @@ class XlsxBaseExtractor {
         return color;
     }
     /**
-     * Returns the xlsx file targeted by a relationship.
+     * Returns the xml file targeted by a relationship.
      */
     getTargetXmlFile(relationship) {
         if (!relationship)
             throw new Error("Undefined target file");
-        let target = relationship.target;
-        target = target.replace("../", "");
-        target = target.replace("./", "");
+        const target = this.processRelationshipTargetName(relationship.target);
         // Use "endsWith" because targets are relative paths, and we know the files by their absolute path.
-        const f = this.getListOfFiles().find((f) => f.file.fileName.endsWith(target));
+        const f = this.getListOfXMLFiles().find((f) => f.file.fileName.endsWith(target));
         if (!f || !f.file)
             throw new Error("Cannot find target file");
         return f;
     }
+    /**
+     * Returns the image parameters targeted by a relationship.
+     */
+    getTargetImageFile(relationship) {
+        if (!relationship)
+            throw new Error("Undefined target file");
+        const target = this.processRelationshipTargetName(relationship.target);
+        // Use "endsWith" because targets are relative paths, and we know the files by their absolute path.
+        const f = this.xlsxFileStructure.images.find((f) => f.fileName.endsWith(target));
+        if (!f)
+            throw new Error("Cannot find target file");
+        return f;
+    }
     /**
      * Wrapper of querySelector, but we'll remove the namespaces from the query if areNamespacesIgnored is true.
      *
@@ -29050,6 +29163,10 @@ class XlsxBaseExtractor {
                 return clrScheme[colorId].value;
         }
     }
+    /** Remove signs of relative path. */
+    processRelationshipTargetName(targetName) {
+        return targetName.replace(/\.+\//, "");
+    }
 }
 
 /**
@@ -29279,15 +29396,16 @@ class XlsxFigureExtractor extends XlsxBaseExtractor {
                 throw new Error("Only twoCellAnchor are supported for xlsx drawings.");
             }
             const chartElement = this.querySelector(figureElement, "c:chart");
-            if (!chartElement) {
-                throw new Error("Only chart figures are currently supported.");
+            const imageElement = this.querySelector(figureElement, "a:blip");
+            if (!chartElement && !imageElement) {
+                throw new Error("Only chart and image figures are currently supported.");
             }
             return {
                 anchors: [
                     this.extractFigureAnchor("xdr:from", figureElement),
                     this.extractFigureAnchor("xdr:to", figureElement),
                 ],
-                data: this.extractChart(chartElement),
+                data: chartElement ? this.extractChart(chartElement) : this.extractImage(figureElement),
             };
         });
     }
@@ -29312,6 +29430,24 @@ class XlsxFigureExtractor extends XlsxBaseExtractor {
         }
         return chartDefinition;
     }
+    extractImage(figureElement) {
+        const imageElement = this.querySelector(figureElement, "a:blip");
+        const imageId = this.extractAttr(imageElement, "r:embed", { required: true }).asString();
+        const image = this.getTargetImageFile(this.relationships[imageId]);
+        if (!image) {
+            throw new Error("Unable to extract image");
+        }
+        const shapePropertyElement = this.querySelector(figureElement, "a:xfrm");
+        const extension = image.fileName.split(".").at(-1);
+        return {
+            imageSrc: image.imageSrc,
+            mimetype: extension ? IMAGE_EXTENSION_TO_MIMETYPE_MAPPING[extension] : undefined,
+            size: {
+                cx: this.extractChildAttr(shapePropertyElement, "a:ext", "cx", { required: true }).asNum(),
+                cy: this.extractChildAttr(shapePropertyElement, "a:ext", "cy", { required: true }).asNum(),
+            },
+        };
+    }
 }
 
 /**
@@ -29881,14 +30017,22 @@ const EXCEL_IMPORT_VERSION = 12;
 class XlsxReader {
     warningManager;
     xmls;
+    images;
     constructor(files) {
         this.warningManager = new XLSXImportWarningManager();
         this.xmls = {};
+        this.images = [];
         for (let key of Object.keys(files)) {
             // Random files can be in xlsx (like a bin file for printer settings)
             if (key.endsWith(".xml") || key.endsWith(".rels")) {
                 this.xmls[key] = parseXML(new XMLString(files[key]));
             }
+            else if (key.includes("media/image")) {
+                this.images.push({
+                    fileName: key,
+                    imageSrc: files[key]["imageSrc"],
+                });
+            }
         }
     }
     convertXlsx() {
@@ -29941,6 +30085,7 @@ class XlsxReader {
             tables: getXLSXFilesOfType(CONTENT_TYPES.table, this.xmls),
             pivots: getXLSXFilesOfType(CONTENT_TYPES.pivot, this.xmls),
             externalLinks: getXLSXFilesOfType(CONTENT_TYPES.externalLink, this.xmls),
+            images: this.images,
         };
         if (!xlsxFileStructure.workbook.rels) {
             throw Error(_lt("Cannot find workbook relations file"));
@@ -33091,7 +33236,7 @@ class ImagePlugin extends CorePlugin {
     handle(cmd) {
         switch (cmd.type) {
             case "CREATE_IMAGE":
-                this.addFigure(cmd.figureId, cmd.sheetId, cmd.position, cmd.size);
+                this.addImage(cmd.figureId, cmd.sheetId, cmd.position, cmd.size);
                 this.history.update("images", cmd.sheetId, cmd.figureId, cmd.definition);
                 this.syncedImages.add(cmd.definition.path);
                 break;
@@ -33155,7 +33300,7 @@ class ImagePlugin extends CorePlugin {
     // ---------------------------------------------------------------------------
     // Private
     // ---------------------------------------------------------------------------
-    addFigure(id, sheetId, position, size) {
+    addImage(id, sheetId, position, size) {
         const figure = {
             id,
             x: position.x,
@@ -35662,7 +35807,6 @@ class PositionBitsEncoder {
     }
 }
 
-const functions = functionRegistry.content;
 //#region
 // ---------------------------------------------------------------------------
 // INTRODUCTION
@@ -35884,9 +36028,7 @@ class EvaluationPlugin extends UIPlugin {
             let isExported = true;
             const formulaCell = this.getCorrespondingFormulaCell(position);
             if (formulaCell) {
-                isExported = formulaCell.compiledFormula.tokens
-                    .filter((tk) => tk.type === "FUNCTION")
-                    .every((tk) => functions[tk.value.toUpperCase()].isExported);
+                isExported = isExportableToExcel(formulaCell.compiledFormula.tokens);
                 isFormula = isExported;
                 if (!isExported) {
                     newContent = value.toString();
@@ -44292,7 +44434,7 @@ class ImageProvider {
     async requestImage() {
         const file = await this.getImageFromUser();
         const path = await this.fileStore.upload(file);
-        const size = await this.getImageSize(path);
+        const size = await this.getImageOriginalSize(path);
         return { path, size, mimetype: file.type };
     }
     getImageFromUser() {
@@ -44311,7 +44453,7 @@ class ImageProvider {
             input.click();
         });
     }
-    getImageSize(path) {
+    getImageOriginalSize(path) {
         return new Promise((resolve, reject) => {
             const image = new Image();
             image.src = path;
@@ -45796,6 +45938,10 @@ css /* scss */ `
       top: 20%;
     }
   }
+
+  .user-select-text {
+    user-select: text;
+  }
 `;
 class TopBarComposer extends owl.Component {
     static template = "o-spreadsheet-TopBarComposer";
@@ -48834,6 +48980,8 @@ function createImageDrawing(figure, sheet, imageRelId) {
         ["name", `Image ${imageId}`],
         ["title", "Image"],
     ];
+    const cx = convertDotValueToEMU(figure.width);
+    const cy = convertDotValueToEMU(figure.height);
     return escapeXml /*xml*/ `
     <xdr:twoCellAnchor editAs="oneCell">
       <xdr:from>
@@ -48860,6 +49008,9 @@ function createImageDrawing(figure, sheet, imageRelId) {
           </a:stretch>
         </xdr:blipFill>
         <xdr:spPr>
+          <a:xfrm>
+            <a:ext cx="${cx}" cy="${cy}" />
+          </a:xfrm>
           <a:prstGeom prst="rect">
             <a:avLst/>
           </a:prstGeom>
@@ -49379,7 +49530,7 @@ function createWorksheets(data, construct) {
             const mimeType = image.data.mimetype;
             if (mimeType === undefined)
                 continue;
-            const extension = IMAGE_MIMETYPE_EXTENSION_MAPPING[mimeType];
+            const extension = IMAGE_MIMETYPE_TO_EXTENSION_MAPPING[mimeType];
             // only support exporting images with mimetypes specified in the mapping
             if (extension === undefined)
                 continue;
@@ -49515,7 +49666,7 @@ function createRelsFiles(relsFiles) {
 function createContentTypes(files) {
     const overrideNodes = [];
     // hard-code supported image mimetypes
-    const imageDefaultNodes = Object.entries(IMAGE_MIMETYPE_EXTENSION_MAPPING).map(([mimetype, extension]) => createDefaultXMLElement(extension, mimetype));
+    const imageDefaultNodes = Object.entries(IMAGE_MIMETYPE_TO_EXTENSION_MAPPING).map(([mimetype, extension]) => createDefaultXMLElement(extension, mimetype));
     for (const file of files) {
         if ("contentType" in file && file.contentType) {
             overrideNodes.push(createOverride("/" + file.path, CONTENT_TYPES[file.contentType]));
@@ -50145,6 +50296,7 @@ exports.helpers = helpers;
 exports.invalidateCFEvaluationCommands = invalidateCFEvaluationCommands;
 exports.invalidateDependenciesCommands = invalidateDependenciesCommands;
 exports.invalidateEvaluationCommands = invalidateEvaluationCommands;
+exports.iterateAstNodes = iterateAstNodes;
 exports.links = links;
 exports.load = load;
 exports.parse = parse;
@@ -50155,6 +50307,6 @@ exports.setTranslationMethod = setTranslationMethod;
 exports.tokenize = tokenize;
 
 
-__info__.version = '16.4.0-alpha.6';
-__info__.date = '2023-06-28T11:40:12.377Z';
-__info__.hash = '7d15d3c';
+__info__.version = '16.4.0-alpha.7';
+__info__.date = '2023-07-04T13:46:24.130Z';
+__info__.hash = 'b04cf78';