@odoo/o-spreadsheet 18.5.0-alpha.10 → 18.5.0-alpha.11

package/dist/o-spreadsheet.iife.js

@@ -2,9 +2,9 @@
 /**
  * This file is generated by o-spreadsheet build tools. Do not edit it.
  * @see https://github.com/odoo/o-spreadsheet
- * @version 18.5.0-alpha.10
- * @date 2025-08-21T06:42:10.830Z
- * @hash 5800d1b
+ * @version 18.5.0-alpha.11
+ * @date 2025-08-26T10:14:05.357Z
+ * @hash b913e49
  */
 
 (function (exports, owl) {
@@ -724,7 +724,7 @@
   /*
    * Concatenate an array of strings.
    */
-  function concat(chars) {
+  function concat$1(chars) {
       // ~40% faster than chars.join("")
       let output = "";
       for (let i = 0, len = chars.length; i < len; i++) {
@@ -1196,7 +1196,7 @@
       if (alphaHex !== 255) {
           vals.push(alphaHex);
       }
-      return "#" + concat(vals.map((value) => value.toString(16).padStart(2, "0"))).toUpperCase();
+      return "#" + concat$1(vals.map((value) => value.toString(16).padStart(2, "0"))).toUpperCase();
   }
   /**
    * RGBA to HEX representation (#RRGGBBAA).
@@ -5110,6 +5110,9 @@
       if (content === "") {
           return null;
       }
+      if (content.includes("\n")) {
+          return content;
+      }
       if (isNumber(content, DEFAULT_LOCALE)) {
           return parseNumber(content, DEFAULT_LOCALE);
       }
@@ -7318,14 +7321,11 @@
       const width = content[0].length, height = content.length;
       return target.map((t) => splitZoneForPaste(t, width, height)).flat();
   }
-  function parseOSClipboardContent(content, clipboardId) {
+  function parseOSClipboardContent(content) {
       let spreadsheetContent = undefined;
       if (content[ClipboardMIMEType.Html]) {
           const htmlDocument = new DOMParser().parseFromString(content[ClipboardMIMEType.Html], "text/html");
-          const oSheetClipboardData = htmlDocument
-              .querySelector("div")
-              ?.getAttribute("data-osheet-clipboard");
-          spreadsheetContent = oSheetClipboardData && JSON.parse(oSheetClipboardData);
+          spreadsheetContent = getOSheetDataFromHTML(htmlDocument);
       }
       const textContent = content[ClipboardMIMEType.PlainText] || "";
       let imageBlob = undefined;
@@ -7344,6 +7344,17 @@
       };
       return osClipboardContent;
   }
+  function getOSheetDataFromHTML(htmlDocument) {
+      const attributes = [...htmlDocument.documentElement.attributes];
+      // Check if it's a Microsoft Office clipboard data (it will have some namespaces defined in the root element)
+      if (attributes.some((attr) => attr.value.includes("microsoft"))) {
+          return undefined;
+      }
+      const oSheetClipboardData = htmlDocument
+          .querySelector("div")
+          ?.getAttribute("data-osheet-clipboard");
+      return oSheetClipboardData && JSON.parse(oSheetClipboardData);
+  }
   /**
    * Applies each clipboard handler to paste its corresponding data into the target.
    */
@@ -18337,7 +18348,6 @@ stores.inject(MyMetaStore, storeInstance);
   const functionRegex = /[a-zA-Z0-9\_]+(\.[a-zA-Z0-9\_]+)*/;
   const UNARY_OPERATORS_PREFIX = ["-", "+"];
   const UNARY_OPERATORS_POSTFIX = ["%"];
-  const ASSOCIATIVE_OPERATORS = ["*", "+", "&"];
   class TokenList {
       tokens;
       currentIndex = 0;
@@ -18358,8 +18368,8 @@ stores.inject(MyMetaStore, storeInstance);
       }
   }
   const OP_PRIORITY = {
+      "%": 40,
       "^": 30,
-      "%": 30,
       "*": 20,
       "/": 20,
       "+": 15,
@@ -18640,64 +18650,6 @@ stores.inject(MyMetaStore, storeInstance);
               return ast;
       }
   }
-  /**
-   * Converts an ast formula to the corresponding string
-   */
-  function astToFormula(ast) {
-      switch (ast.type) {
-          case "FUNCALL":
-              const args = ast.args.map((arg) => astToFormula(arg));
-              return `${ast.value}(${args.join(",")})`;
-          case "NUMBER":
-              return ast.value.toString();
-          case "REFERENCE":
-              return ast.value;
-          case "STRING":
-              return `"${ast.value}"`;
-          case "BOOLEAN":
-              return ast.value ? "TRUE" : "FALSE";
-          case "UNARY_OPERATION":
-              return ast.postfix
-                  ? leftOperandToFormula(ast) + ast.value
-                  : ast.value + rightOperandToFormula(ast);
-          case "BIN_OPERATION":
-              return leftOperandToFormula(ast) + ast.value + rightOperandToFormula(ast);
-          default:
-              return ast.value;
-      }
-  }
-  /**
-   * Convert the left operand of a binary operation to the corresponding string
-   * and enclose the result inside parenthesis if necessary.
-   */
-  function leftOperandToFormula(operationAST) {
-      const mainOperator = operationAST.value;
-      const leftOperation = "left" in operationAST ? operationAST.left : operationAST.operand;
-      const leftOperator = leftOperation.value;
-      const needParenthesis = leftOperation.type === "BIN_OPERATION" && OP_PRIORITY[leftOperator] < OP_PRIORITY[mainOperator];
-      return needParenthesis ? `(${astToFormula(leftOperation)})` : astToFormula(leftOperation);
-  }
-  /**
-   * Convert the right operand of a binary or unary operation to the corresponding string
-   * and enclose the result inside parenthesis if necessary.
-   */
-  function rightOperandToFormula(operationAST) {
-      const mainOperator = operationAST.value;
-      const rightOperation = "right" in operationAST ? operationAST.right : operationAST.operand;
-      const rightPriority = OP_PRIORITY[rightOperation.value];
-      const mainPriority = OP_PRIORITY[mainOperator];
-      let needParenthesis = false;
-      if (rightOperation.type !== "BIN_OPERATION") {
-          needParenthesis = false;
-      }
-      else if (rightPriority < mainPriority) {
-          needParenthesis = true;
-      }
-      else if (rightPriority === mainPriority && !ASSOCIATIVE_OPERATORS.includes(mainOperator)) {
-          needParenthesis = true;
-      }
-      return needParenthesis ? `(${astToFormula(rightOperation)})` : astToFormula(rightOperation);
-  }
 
   /**
    * Add the following information on tokens:
@@ -22196,7 +22148,7 @@ stores.inject(MyMetaStore, storeInstance);
               };
           }
       }
-      return concat(tokens.map((token) => token.value));
+      return concat$1(tokens.map((token) => token.value));
   }
   function adaptStringRange(defaultSheetId, sheetXC, applyChange) {
       const sheetName = splitReference(sheetXC).sheetName;
@@ -28281,10 +28233,6 @@ stores.inject(MyMetaStore, storeInstance);
           };
       }
       getDefinitionForExcel() {
-          // Excel does not support aggregating labels
-          if (this.aggregated) {
-              return undefined;
-          }
           const { dataSets, labelRange } = this.getCommonDataSetAttributesForExcel(this.labelRange, this.dataSets, shouldRemoveFirstLabel(this.labelRange, this.dataSets[0], this.dataSetsHaveTitle));
           const definition = this.getDefinition();
           return {
@@ -29486,9 +29434,6 @@ stores.inject(MyMetaStore, storeInstance);
           };
       }
       getDefinitionForExcel() {
-          if (this.aggregated) {
-              return undefined;
-          }
           const { dataSets, labelRange } = this.getCommonDataSetAttributesForExcel(this.labelRange, this.dataSets, shouldRemoveFirstLabel(this.labelRange, this.dataSets[0], this.dataSetsHaveTitle));
           const definition = this.getDefinition();
           return {
@@ -29636,10 +29581,6 @@ stores.inject(MyMetaStore, storeInstance);
           return new ScatterChart(definition, this.sheetId, this.getters);
       }
       getDefinitionForExcel() {
-          // Excel does not support aggregating labels
-          if (this.aggregated) {
-              return undefined;
-          }
           const dataSets = this.dataSets
               .map((ds) => toExcelDataset(this.getters, ds))
               .filter((ds) => ds.range !== "");
@@ -30958,7 +30899,7 @@ stores.inject(MyMetaStore, storeInstance);
           const value = expressions[i] instanceof XMLString ? expressions[i] : xmlEscape(expressions[i]);
           str.push(value + strings[i + 1]);
       }
-      return new XMLString(concat(str));
+      return new XMLString(concat$1(str));
   }
   /**
    * Removes the escaped namespace of all the xml tags in the string.
@@ -32044,10 +31985,10 @@ stores.inject(MyMetaStore, storeInstance);
               const item = chartSubtypeRegistry.get(type);
               return {
                   id: item.chartType,
-                  label: item.displayName,
+                  label: _t("Show as %(chart_type)s chart", { chart_type: item.displayName.toLowerCase() }),
                   onClick: () => this.updateType(item.chartType),
-                  isSelected: item.chartType === this.getters.getChartDefinition(this.chartId).type,
-                  iconClass: this.getIconClasses(item.chartType),
+                  class: item.chartType === definition.type ? "active" : "",
+                  preview: item.preview,
               };
           });
       }
@@ -32083,18 +32024,6 @@ stores.inject(MyMetaStore, storeInstance);
               sheetId: this.getters.getActiveSheetId(),
           });
       }
-      getIconClasses(type) {
-          if (type.includes("bar")) {
-              return "fa fa-bar-chart";
-          }
-          if (type.includes("line")) {
-              return "fa fa-line-chart";
-          }
-          if (type.includes("pie")) {
-              return "fa fa-pie-chart";
-          }
-          return "";
-      }
   }
 
   class ChartDashboardMenu extends owl.Component {
@@ -32133,20 +32062,11 @@ stores.inject(MyMetaStore, storeInstance);
           if (definition.type === "scorecard") {
               return undefined;
           }
-          if (this.props.chartId === this.fullScreenFigureStore.fullScreenFigure?.id) {
-              return {
-                  id: "fullScreenChart",
-                  label: _t("Exit Full Screen"),
-                  iconClass: "fa fa-compress",
-                  onClick: () => {
-                      this.fullScreenFigureStore.toggleFullScreenChart(figureId);
-                  },
-              };
-          }
+          const isFullScreen = this.props.chartId === this.fullScreenFigureStore.fullScreenFigure?.id;
           return {
               id: "fullScreenChart",
-              label: _t("Full Screen"),
-              iconClass: "fa fa-expand",
+              label: isFullScreen ? _t("Exit Full Screen") : _t("Full Screen"),
+              class: `text-muted fa ${isFullScreen ? "fa-compress" : "fa-expand"}`,
               onClick: () => {
                   this.fullScreenFigureStore.toggleFullScreenChart(figureId);
               },
@@ -34328,7 +34248,7 @@ stores.inject(MyMetaStore, storeInstance);
                   if (isFormula(content)) {
                       const missing = this.getNumberOfMissingParenthesis(this.currentTokens);
                       if (missing > 0) {
-                          content += concat(new Array(missing).fill(")"));
+                          content += concat$1(new Array(missing).fill(")"));
                       }
                   }
               }
@@ -34380,9 +34300,10 @@ stores.inject(MyMetaStore, storeInstance);
           if (isNewCurrentContent || this.editionMode !== "inactive") {
               const locale = this.getters.getLocale();
               this.currentTokens = isFormula(text) ? composerTokenize(text, locale) : [];
-              if (this.currentTokens.length > 100) {
+              const nonSpaceTokensCount = this.currentTokens.filter((token) => token.type !== "SPACE").length;
+              if (nonSpaceTokensCount > 1000) {
                   if (raise) {
-                      this.notificationStore.raiseError(_t("This formula has over 100 parts. It can't be processed properly, consider splitting it into multiple cells"));
+                      this.notificationStore.raiseError(_t("This formula has over 1000 parts. It can't be processed properly, consider splitting it into multiple cells"));
                   }
               }
           }
@@ -34803,6 +34724,8 @@ stores.inject(MyMetaStore, storeInstance);
       padding-right: 3px;
       outline: none;
 
+      tab-size: 4;
+
       p {
         margin-bottom: 0px;
 
@@ -48653,6 +48576,280 @@ stores.inject(MyMetaStore, storeInstance);
       }
   }
 
+  const ASSOCIATIVE_OPERATORS = ["*", "+", "&"];
+  /**
+   * Pretty-prints formula ASTs into readable formulas.
+   *
+   * Implements a Wadler-inspired pretty printer:
+   * it converts an AST into a `Doc` structure,
+   * and then chooses between compact (flat) or expanded (with
+   * line breaks and indentation) layouts depending on space.
+   *
+   * References:
+   * - https://lik.ai/blog/how-a-pretty-printer-works/
+   * - Wadler, "A prettier printer": https://homepages.inf.ed.ac.uk/wadler/papers/prettier/prettier.pdf
+   */
+  function prettify(ast, width = 60) {
+      return "=" + print(astToDoc(ast), width - 1); // width-1 because of the leading '='
+  }
+  /**
+   * A possible line break.
+   * Printed as either space or newline.
+   */
+  function line() {
+      return { type: "insertLine" };
+  }
+  /**
+   * Increase indentation for a nested block.
+   */
+  function nest(indentLevel, doc) {
+      return { type: "nest", indentLevel, doc };
+  }
+  /**
+   * Combines multiple docs into a single doc, concatenating them side by side
+   * without any line breaks or indentation.
+   */
+  function concat(docs) {
+      return { type: "concat", docs };
+  }
+  /**
+   * Marks a document as a unit to be printed "flat" (all on one line)
+   * if it fits within the width, otherwise with line breaks.
+   */
+  function group(doc) {
+      return chooseBetween(flatten(doc), doc);
+  }
+  /**
+   * Creates a choice between two alternative layouts.
+   * The formatter tries `doc1`; if it does not fit within
+   * the line width, it falls back to `doc2`.
+   */
+  function chooseBetween(doc1, doc2) {
+      return { type: "chooseBetween", doc1, doc2 };
+  }
+  /**
+   * Flattens a doc into its single-line form.
+   */
+  function flatten(doc) {
+      if (typeof doc === "string") {
+          return doc;
+      }
+      if (doc.type === "chooseBetween") {
+          // Normally should be "chooseBetween(flatten(doc.doc1), flatten(doc.doc2))",
+          // but this is simplified for performance reasons.
+          return flatten(doc.doc1);
+      }
+      if (doc.type === "concat") {
+          return concat(doc.docs.map(flatten));
+      }
+      if (doc.type === "nest") {
+          return {
+              type: "nest",
+              indentLevel: doc.indentLevel,
+              doc: flatten(doc.doc),
+          };
+      }
+      if (doc.type === "insertLine") {
+          return "";
+      }
+      return doc;
+  }
+  const getIndentationString = memoize(function getIndentationString(indentLevel) {
+      return "\n" + "\t".repeat(indentLevel);
+  });
+  /**
+   * Converts a `Doc` into a string representation that fits within
+   * the specified width.
+   */
+  function print(doc, width) {
+      return stringify(selectBestLayout(width, doc));
+  }
+  /**
+   * Join all segments of a LinkedString into the final string.
+   */
+  function stringify(linkedString) {
+      let result = "";
+      while (linkedString) {
+          result += linkedString.subString;
+          linkedString = linkedString.next;
+      }
+      return result;
+  }
+  /**
+   * Layout selection for a `Doc` that fits within the given width.
+   */
+  function selectBestLayout(width, doc) {
+      const head = {
+          indentLevel: 0,
+          doc,
+          next: null,
+      };
+      return _selectBestLayout(width, 0, head);
+  }
+  function _selectBestLayout(width, currentIndentLevel, head) {
+      if (head === null) {
+          return null;
+      }
+      const { indentLevel, doc, next } = head;
+      if (typeof doc === "string") {
+          return {
+              subString: doc,
+              next: _selectBestLayout(width, currentIndentLevel + doc.length, next),
+          };
+      }
+      if (doc.type === "concat") {
+          let newHead = next;
+          for (let i = doc.docs.length - 1; i >= 0; i--) {
+              newHead = { indentLevel, doc: doc.docs[i], next: newHead };
+          }
+          return _selectBestLayout(width, currentIndentLevel, newHead);
+      }
+      if (doc.type === "nest") {
+          return _selectBestLayout(width, currentIndentLevel, {
+              indentLevel: indentLevel + doc.indentLevel,
+              doc: doc.doc,
+              next,
+          });
+      }
+      if (doc.type === "insertLine") {
+          return {
+              subString: getIndentationString(indentLevel),
+              next: _selectBestLayout(width, indentLevel, next),
+          };
+      }
+      if (doc.type === "chooseBetween") {
+          const head1 = { indentLevel, doc: doc.doc1, next };
+          const possibleLinkedString = _selectBestLayout(width, currentIndentLevel, head1);
+          if (fits(width - currentIndentLevel, possibleLinkedString)) {
+              return possibleLinkedString;
+          }
+          const head2 = { indentLevel, doc: doc.doc2, next };
+          return _selectBestLayout(width, currentIndentLevel, head2);
+      }
+      return null;
+  }
+  /**
+   * Check if a layout fits on a single line within width.
+   */
+  function fits(width, linkedString) {
+      while (linkedString) {
+          if (linkedString.subString[0] === "\n") {
+              return true;
+          }
+          width -= linkedString.subString.length;
+          if (width < 0)
+              return false;
+          linkedString = linkedString.next;
+      }
+      return true;
+  }
+  function astToDoc(ast) {
+      switch (ast.type) {
+          case "NUMBER":
+              return String(ast.value);
+          case "STRING":
+              return `"${ast.value}"`;
+          case "BOOLEAN":
+              return ast.value ? "TRUE" : "FALSE";
+          case "REFERENCE":
+              return ast.value;
+          case "FUNCALL":
+              const docs = ast.args.map(astToDoc);
+              return wrapInParentheses(concat(docs.map((doc, i) => (i < 1 ? doc : concat([", ", line(), doc])))), ast.value);
+          case "UNARY_OPERATION":
+              const operandDoc = astToDoc(ast.operand);
+              const needParenthesis = ast.postfix
+                  ? leftOperandNeedsParenthesis(ast)
+                  : rightOperandNeedsParenthesis(ast);
+              const finalOperandDoc = needParenthesis ? wrapInParentheses(operandDoc) : operandDoc;
+              return ast.postfix
+                  ? concat([finalOperandDoc, ast.value])
+                  : concat([ast.value, finalOperandDoc]);
+          case "BIN_OPERATION": {
+              const leftDoc = astToDoc(ast.left);
+              const needParenthesisLeftDoc = leftOperandNeedsParenthesis(ast);
+              const finalLeftDoc = needParenthesisLeftDoc ? wrapInParentheses(leftDoc) : leftDoc;
+              const rightDoc = astToDoc(ast.right);
+              const needParenthesisRightDoc = rightOperandNeedsParenthesis(ast);
+              const finalRightDoc = needParenthesisRightDoc ? wrapInParentheses(rightDoc) : rightDoc;
+              const operator = `${ast.value}`;
+              return group(concat([finalLeftDoc, operator, nest(1, concat([line(), finalRightDoc]))]));
+          }
+          case "SYMBOL":
+              return ast.value;
+          case "EMPTY":
+              return "";
+      }
+  }
+  /**
+   * Wraps a `Doc` in parentheses (with optional function name).
+   */
+  function wrapInParentheses(doc, functionName = undefined) {
+      const docToConcat = ["(", nest(1, concat([line(), doc])), line(), ")"];
+      if (functionName) {
+          docToConcat.unshift(functionName);
+      }
+      return group(concat(docToConcat));
+  }
+  /**
+   * Converts an ast formula to the corresponding string
+   */
+  function astToFormula(ast) {
+      switch (ast.type) {
+          case "FUNCALL":
+              const args = ast.args.map((arg) => astToFormula(arg));
+              return `${ast.value}(${args.join(",")})`;
+          case "NUMBER":
+              return ast.value.toString();
+          case "REFERENCE":
+              return ast.value;
+          case "STRING":
+              return `"${ast.value}"`;
+          case "BOOLEAN":
+              return ast.value ? "TRUE" : "FALSE";
+          case "UNARY_OPERATION":
+              if (ast.postfix) {
+                  const leftOperand = leftOperandNeedsParenthesis(ast)
+                      ? `(${astToFormula(ast.operand)})`
+                      : astToFormula(ast.operand);
+                  return leftOperand + ast.value;
+              }
+              const rightOperand = rightOperandNeedsParenthesis(ast)
+                  ? `(${astToFormula(ast.operand)})`
+                  : astToFormula(ast.operand);
+              return ast.value + rightOperand;
+          case "BIN_OPERATION":
+              const leftOperation = leftOperandNeedsParenthesis(ast)
+                  ? `(${astToFormula(ast.left)})`
+                  : astToFormula(ast.left);
+              const rightOperation = rightOperandNeedsParenthesis(ast)
+                  ? `(${astToFormula(ast.right)})`
+                  : astToFormula(ast.right);
+              return leftOperation + ast.value + rightOperation;
+          default:
+              return ast.value;
+      }
+  }
+  function leftOperandNeedsParenthesis(operationAST) {
+      const mainOperator = operationAST.value;
+      const leftOperation = "left" in operationAST ? operationAST.left : operationAST.operand;
+      const leftOperator = leftOperation.value;
+      return (leftOperation.type === "BIN_OPERATION" && OP_PRIORITY[leftOperator] < OP_PRIORITY[mainOperator]);
+  }
+  function rightOperandNeedsParenthesis(operationAST) {
+      const mainOperator = operationAST.value;
+      const rightOperation = "right" in operationAST ? operationAST.right : operationAST.operand;
+      const rightPriority = OP_PRIORITY[rightOperation.value];
+      const mainPriority = OP_PRIORITY[mainOperator];
+      if (rightOperation.type !== "BIN_OPERATION") {
+          return false;
+      }
+      if (rightPriority < mainPriority) {
+          return true;
+      }
+      return rightPriority === mainPriority && !ASSOCIATIVE_OPERATORS.includes(mainOperator);
+  }
+
   const CELL_DELETED_MESSAGE = _t("The cell you are trying to edit has been deleted.");
   class CellComposerStore extends AbstractComposerStore {
       canStopEdition() {
@@ -48796,7 +48993,10 @@ stores.inject(MyMetaStore, storeInstance);
           const locale = this.getters.getLocale();
           const cell = this.getters.getCell(position);
           if (cell?.isFormula) {
-              return localizeFormula(cell.content, locale);
+              const prettifiedContent = cell.compiledFormula.isBadExpression
+                  ? cell.content
+                  : prettify(parseTokens(cell.compiledFormula.tokens), 80);
+              return localizeFormula(prettifiedContent, locale);
           }
           const spreader = this.model.getters.getArrayFormulaSpreadingOn(position);
           if (spreader) {
@@ -61794,10 +61994,10 @@ stores.inject(MyMetaStore, storeInstance);
        */
       getFormulaString(sheetId, tokens, dependencies, useBoundedReference = false) {
           if (!dependencies.length) {
-              return concat(tokens.map((token) => token.value));
+              return concat$1(tokens.map((token) => token.value));
           }
           let rangeIndex = 0;
-          return concat(tokens.map((token) => {
+          return concat$1(tokens.map((token) => {
               if (token.type === "REFERENCE") {
                   const range = dependencies[rangeIndex++];
                   return this.getters.getRangeString(range, sheetId, { useBoundedReference });
@@ -62072,11 +62272,11 @@ stores.inject(MyMetaStore, storeInstance);
           };
       }
       get content() {
-          return concat(this.compiledFormula.tokens.map((token) => token.value));
+          return concat$1(this.compiledFormula.tokens.map((token) => token.value));
       }
       get contentWithFixedReferences() {
           let rangeIndex = 0;
-          return concat(this.compiledFormula.tokens.map((token) => {
+          return concat$1(this.compiledFormula.tokens.map((token) => {
               if (token.type === "REFERENCE") {
                   const index = rangeIndex++;
                   return this.getRangeString(this.compiledFormula.dependencies[index], this.sheetId, {
@@ -81236,7 +81436,7 @@ stores.inject(MyMetaStore, storeInstance);
       }
   }
 
-  const COMPOSER_MAX_HEIGHT = 100;
+  const COMPOSER_MAX_HEIGHT = 300;
   /* svg free of use from https://uxwing.com/formula-fx-icon/ */
   const FX_SVG = /*xml*/ `
 <svg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 121.8 122.9' width='16' height='16' focusable='false'>
@@ -87479,9 +87679,9 @@ stores.inject(MyMetaStore, storeInstance);
   exports.tokenize = tokenize;
 
 
-  __info__.version = "18.5.0-alpha.10";
-  __info__.date = "2025-08-21T06:42:10.830Z";
-  __info__.hash = "5800d1b";
+  __info__.version = "18.5.0-alpha.11";
+  __info__.date = "2025-08-26T10:14:05.357Z";
+  __info__.hash = "b913e49";
 
 
 })(this.o_spreadsheet = this.o_spreadsheet || {}, owl);