@sheetxl/studio-vanilla 0.7.28-beta.4 → 0.8.0-beta.10

package/{browser/esm/CsKCqLuggHhYC93k2.mjs → cdn/assets/ycmpAs4kQfeh78Pa.js}

@@ -1,5 +1,5 @@
 /**
-* @license @sheetxl/studio-vanilla - SheetXL Studio - Vanilla entry point for integrating SheetXL UI. - v0.7.28-beta.4
+* @license @sheetxl/studio-vanilla - SheetXL Studio - Vanilla entry point for integrating SheetXL UI. - v0.8.0-beta.10
 *
 * (C) 2026-present SheetXL Inc. & Michael T. Ford
 * License: The license can be found at https://www.sheetxl.com/license.

package/cdn/index.js

@@ -1,5 +1,5 @@
 /**
-* @license @sheetxl/studio-vanilla - SheetXL Studio - Vanilla entry point for integrating SheetXL UI. - v0.7.28-beta.4
+* @license @sheetxl/studio-vanilla - SheetXL Studio - Vanilla entry point for integrating SheetXL UI. - v0.8.0-beta.10
 *
 * (C) 2026-present SheetXL Inc. & Michael T. Ford
 * License: The license can be found at https://www.sheetxl.com/license.
@@ -43,7 +43,7 @@ var e, t = /* @__PURE__ */ new Map(), n = (e, n = {}) => {
 	});
 }, o = /* @__PURE__ */ new Map(), s = async (t) => {
 	if (e) return e;
-	let { resolveDependencies: n } = await import("./assets/xMskoOI2CK9-AmBF2.js");
+	let { resolveDependencies: n } = await import("./assets/DCnWyVXikb_8Dat3.js");
 	return e = await (async (e, t) => {
 		typeof t == "string" && (t = { selector: t });
 		try {

package/package.json

@@ -1,16 +1,15 @@
 {
   "name": "@sheetxl/studio-vanilla",
   "description": "SheetXL Studio - Vanilla entry point for integrating SheetXL UI.",
-  "version": "0.7.28-beta.4",
+  "version": "0.8.0-beta.10",
   "license": "SEE LICENSE IN <LICENSE>",
   "type": "module",
   "main": "./browser/esm/index.mjs",
   "module": "./browser/esm/index.mjs",
   "exports": {
     ".": {
-      "import": "./browser/esm/index.mjs",
-      "require": "./browser/cjs/index.cjs",
-      "types": "./types/index.d.ts"
+      "types": "./types/index.d.ts",
+      "default": "./browser/esm/index.mjs"
     },
     "./cdn": "./cdn/index.js",
     "./loader.js": "./cdn/loader.js"
@@ -48,19 +47,19 @@
     "@emotion/cache": "^11.14.0",
     "@emotion/react": "^11.14.0",
     "@emotion/styled": "^11.14.1",
-    "@mui/material": "^9.2.0",
-    "@mui/styled-engine": "^9.1.1",
-    "@mui/system": "^9.2.0",
-    "@mui/utils": "^9.2.0",
-    "@sheetxl/sdk": "^0.7.28-beta.4",
-    "@sheetxl/studio-mui": "^0.7.28-beta.4",
+    "@mui/material": "^9.5.0",
+    "@mui/styled-engine": "^9.5.0",
+    "@mui/system": "^9.5.0",
+    "@mui/utils": "^9.5.0",
+    "@sheetxl/sdk": "^0.8.0-beta.10",
+    "@sheetxl/studio-mui": "^0.8.0-beta.10",
     "csstype": "^3.2.3",
     "http-server": "^14.1.1",
-    "react": "^19.2.8",
-    "react-dom": "^19.2.8"
+    "react": "^19.3.0",
+    "react-dom": "^19.3.0"
   },
   "devDependencies": {
-    "@types/react": "^19.2.17",
-    "@types/react-dom": "^19.2.3"
+    "@types/react": "^19.3.0",
+    "@types/react-dom": "^19.3.0"
   }
 }

package/browser/cjs/1XrWGMP3GmsQOMIX.cjs

@@ -1 +0,0 @@
-exports.default={ERF:{s:`Returns the error function.`,p:{lowerLimit:{d:`is the lower bound for integrating ERF.`},upperLimit:{d:`is the upper bound for integrating ERF.`}}},"ERF.PRECISE":{s:`Returns the error function.`,p:{x:{d:`is the lower bound for integrating ERF.PRECISE.`}}},ERFC:{s:`Returns the complementary error function.`,p:{x:{d:`is the lower bound for integrating ERF.`}}},"ERFC.PRECISE":{s:`Returns the complementary error function.`,p:{x:{d:`is the lower bound for integrating ERF.`}}}};

package/browser/cjs/49_x589Na12sizKK2.cjs

@@ -1 +0,0 @@
-exports.default={ACOS:{s:`Returns the arccosine of a number, in radians in the range 0 to Pi. The arccosine is the angle whose cosine is Number.`,p:{number:{d:`is the cosine of the angle you want and must be from -1 to 1.`}}},ACOSH:{s:`Returns the inverse hyperbolic cosine of a number.`,p:{number:{d:`is any real number equal to or greater than 1.`}}},ACOT:{s:`Returns the arccotangent of a number, in radians in the range 0 to Pi.`,p:{number:{d:`is the cotangent of the angle you want.`}}},ACOTH:{s:`Returns the inverse hyperbolic cotangent of a number.`,p:{number:{d:`is the hyperbolic cotangent of the angle that you want.`}}},ASIN:{s:`Returns the arcsine of a number in radians, in the range -Pi/2 to Pi/2.`,p:{number:{d:`is the sine of the angle you want and must be from -1 to 1.`}}},ASINH:{s:`Returns the inverse hyperbolic sine of a number.`,p:{number:{d:`is any real number equal to or greater than 1.`}}},ATAN:{s:`Returns the arctangent of a number in radians, in the range -Pi/2 to Pi/2.`,p:{number:{d:`is the tangent of the angle you want.`}}},ATAN2:{s:`Returns the arctangent of the specified x- and y- coordinates, in radians between -Pi and Pi, excluding -Pi.`,p:{x:{d:`is the x-coordinate of the point.`},y:{d:`is the y-coordinate of the point.`}}},ATANH:{s:`Returns the inverse hyperbolic tangent of a number.`,p:{number:{d:`is any real number between -1 and 1 excluding -1 and 1.`}}},COS:{s:`Returns the cosine of an angle.`,p:{number:{d:`is the angle in radians for which you want the cosine.`}}},COSH:{s:`Returns the hyperbolic cosine of a number.`,p:{number:{d:`is any real number.`}}},COT:{s:`Returns the cotangent of an angle.`,p:{number:{d:`is the angle in radians for which you want the cotangent.`}}},COTH:{s:`Returns the hyperbolic cotangent of a number.`,p:{number:{d:`is the angle in radians for which you want the hyperbolic cotangent.`}}},CSC:{s:`Returns the cosecant of an angle.`,p:{number:{d:`is the angle in radians for which you want the cosecant.`}}},CSCH:{s:`Returns the hyperbolic cosecant of an angle.`,p:{number:{d:`is the angle in radians for which you want the hyperbolic cosecant.`}}},SEC:{s:`Returns the secant of an angle.`,p:{number:{d:`is the angle in radians for which you want the secant.`}}},SECH:{s:`Returns the hyperbolic secant of an angle.`,p:{number:{d:`is the angle in radians for which you want the hyperbolic secant.`}}},SIN:{s:`Returns the sine of an angle.`,p:{number:{d:`is the angle in radians for which you want the sine. Degrees * PI()/180 = radians.`}}},SINH:{s:`Returns the hyperbolic sine of a number.`,p:{number:{d:`is any real number.`}}},TAN:{s:`Returns the tangent of an angle.`,p:{number:{d:`is the angle in radians for which you want the tangent. Degrees * PI()/180 = radians.`}}},TANH:{s:`Returns the hyperbolic tangent of a number.`,p:{number:{d:`is any real number.`}}}};

package/browser/cjs/4nReftSsKWmnRdtf2.cjs

@@ -1 +0,0 @@
-exports.default={AND:{s:`Checks whether all arguments are TRUE, and returns TRUE if all arguments are TRUE.`,p:{logical:{d:`are 1 to 255 conditions you want to test that can be either TRUE or FALSE and can be logical values, arrays, or references.`}}},BYCOL:{s:`Applies a LAMBDA function to each column and returns an array of the results.`,p:{array:{d:`is an array to be separated by column.`},fn:{d:`is a LAMBDA that takes a column as its single parameter and returns one result for it.`}}},BYROW:{s:`Applies a LAMBDA function to each row and returns an array of the results.`,p:{array:{d:`is an array to be separated by row.`},fn:{d:`is a LAMBDA that takes a row as its single parameter and returns one result for it.`}}},FALSE:{s:`Returns the logical value FALSE.`,p:{}},FLATTEN:{s:`Flattens all the values from one or more ranges into a single column.`,c:`Sheets`,p:{ranges:{d:`One or more ranges or scalar values to flatten.`}}},IF:{s:`Checks whether a condition is met, and returns one value if TRUE, and another value if FALSE.`,p:{logicalTest:{d:`is any value or expression that can be evaluated to TRUE or FALSE.`},valueIfTrue:{d:`is the value that is returned if logicalTest is TRUE. If omitted, TRUE is returned. You can nest up to seven IF functions.`},valueIfFalse:{d:`is the value that is returned if logicalTest is FALSE. If omitted, FALSE is returned.`}}},IFERROR:{s:`Returns valueIfError if expression is an error and the value of the expression itself otherwise.`,p:{value:{d:`is any value or expression or reference.`},valueIfError:{d:`is any value or expression or reference.`}}},IFNA:{s:`Returns the value you specify if the expression resolves to #N/A, otherwise returns the result of the expression.`,p:{value:{d:`is any value or expression or reference.`},valueIfNA:{d:`is any value or expression or reference.`}}},IFS:{s:`Checks whether one or more conditions are met and returns a value corresponding to the first TRUE condition.`,p:{condition:{d:`the conditions to test and the values to return for them.`},"condition.logicalTest":{d:`is any value or expression that can be evaluated to TRUE or FALSE.`},"condition.logicalTrue":{d:`is the value returned if logicalTest is TRUE.`}}},LAMBDA:{s:`Creates a function value which can be called within formulas.`,p:{parameterOrCalculation:{d:`a parameter or a calculation that returns a value. If a parameter, it must be the last argument.`}}},LET:{s:`Assigns calculation results to names. Useful for storing intermediate calculations and values by defining names inside a formula. These names only apply within the scope of the LET function.`,p:{name:{d:`the name, or a calculation which can make use of all names within the LET. Names must start with a letter, cannot be the output of a formula, or conflict with range syntax.`},nameOrValue:{d:`the value associated with the name.`},calculationOrName:{},rest:{}}},MAKEARRAY:{s:`Returns a calculated array of a specified row and column size, by applying a LAMBDA function.`,p:{rows:{d:`is the number of rows in the array. Must be greater than zero.`},columns:{d:`is the number of columns in the array. Must be greater than zero.`},fn:{d:`is a LAMBDA that is called to create the array. The LAMBDA takes two parameters, row index and column index.`}}},MAP:{s:`Returns an array formed by 'mapping' each value in the array(s) to a new value by applying a lambda to create a new value.`,p:{array:{d:`is an array to be mapped.`},lambdaOrArray:{d:`is a LAMBDA which must be the last argument and must have a parameter for each array passed, or another array to be mapped.`}}},NOT:{s:`Changes FALSE to TRUE, or TRUE to FALSE.`,p:{logical:{d:`is a value or expression that can be evaluated to TRUE or FALSE.`}}},OR:{s:`Checks whether any of the arguments are TRUE, and returns TRUE or FALSE. Returns FALSE only if all arguments are FALSE.`,p:{logical:{d:`are 1 to 255 conditions that you want to test that can be either TRUE or FALSE.`}}},REDUCE:{s:`Reduces an array to an accumulated value by applying a LAMBDA function to each value and returning the total value in the accumulator.`,p:{initialValue:{d:`is the starting value for the accumulator.`},array:{d:`is an array to be reduced.`},fn:{d:`is a LAMBDA that is called to reduce the array. The LAMBDA takes two parameters, accumulator and value.`}}},REDUCEIF:{s:`Reduces the cells specified by a given condition or criteria.`,c:`SheetXL`,p:{range:{d:`is the range of cells you want evaluated.`},criteria:{d:`is the condition or criteria in the form of a number, expression, or text that defines which cells will be reduced.`},reduceRange:{d:`are the actual cells to reduce. If omitted, the cells in range are used. This can be blank.`},fn:{d:`is a LAMBDA that is called to reduce the array. The LAMBDA takes two parameters, accumulator and value.`}}},SCAN:{s:`Scans an array by applying a LAMBDA function to each value and returns an array that has each intermediate value.`,p:{initialValue:{d:`is the starting value for the accumulator.`},array:{d:`is an array to be reduced.`},fn:{d:`is a LAMBDA that is called to reduce the array. The LAMBDA takes two parameters, accumulator and value.`}}},SWITCH:{s:`Evaluates an expression against a list of values and returns the result corresponding to the first matching value. If there is no match, an optional default value is returned.`,p:{expression:{d:`is an expression to be evaluated.`},match:{d:`the values to compare against expression and the results to return for them.`},"match.value":{d:`is a value to compare against expression.`},"match.result":{d:`is a result to be returned if the corresponding value matches expression.`},defaultResult:{d:`is the result to be returned when no value matches expression.`}}},TRUE:{s:`Returns the logical value TRUE.`,p:{}},XOR:{s:`Returns a logical 'Exclusive Or' of all arguments.`,p:{logical:{d:`are 1 to 254 conditions you want to test that can be either TRUE or FALSE and can be logical values, arrays, or references.`}}}};

package/browser/cjs/507hQYooKKjnRzsZ2.cjs

@@ -1 +0,0 @@
-exports.default={CONVERT:{s:`Converts a number from one measurement system to another.`,p:{number:{d:`is the value in fromUnit to convert.`},fromUnit:{d:`is the units for number.`},toUnit:{d:`is the units for the result.`}}}};

package/browser/cjs/B4JJfKSI4ppwU8552.cjs

@@ -1 +0,0 @@
-exports.default={AMORDEGRC:{s:`Returns the depreciation for each accounting period using a`,p:{cost:{d:`is the cost of the asset.`},datePurchased:{d:`is the date the asset is purchased.`},firstPeriod:{d:`is the date of the end of the first period.`},salvage:{d:`is the salvage value at the end of life of the asset.`},period:{d:`is the period.`},rate:{d:`is the depreciation rate.`},basis:{d:`is the type of day count basis to use.`}}}};

package/browser/cjs/B7_pDFYCVzt-3hUs.cjs

@@ -1 +0,0 @@
-var e=Object.create,t=Object.defineProperty,n=Object.getOwnPropertyDescriptor,r=Object.getOwnPropertyNames,i=Object.getPrototypeOf,a=Object.prototype.hasOwnProperty,o=(e,t)=>()=>(t||(e((t={exports:{}}).exports,t),e=null),t.exports),s=(e,n)=>{let r={};for(var i in e)t(r,i,{get:e[i],enumerable:!0});return n||t(r,Symbol.toStringTag,{value:`Module`}),r},c=(o,s,c)=>(c=o==null?{}:e(i(o)),((e,i,o,s)=>{if(i&&typeof i==`object`||typeof i==`function`)for(var c,l=r(i),u=0,d=l.length;u<d;u++)c=l[u],a.call(e,c)||c===o||t(e,c,{get:(e=>i[e]).bind(null,c),enumerable:!(s=n(i,c))||s.enumerable});return e})(!s&&o&&o.__esModule?c:t(c,`default`,{value:o,enumerable:!0}),o));Object.defineProperty(exports,"n",{enumerable:!0,get:function(){return s}}),Object.defineProperty(exports,"r",{enumerable:!0,get:function(){return c}}),Object.defineProperty(exports,"t",{enumerable:!0,get:function(){return o}});

package/browser/cjs/BAxVLKkxFgI6cXnR2.cjs

@@ -1 +0,0 @@
-exports.default={ADD:{s:`Returns the sum of two numbers. Equal to the '+' operator.`,c:`Sheets`,p:{value1:{d:`The first number to add.`},value2:{d:`The second number to add.`}}},DIVIDE:{s:`Returns the result of dividing one number by another. Equal to the '/' operator.`,c:`Sheets`,p:{dividend:{d:`The number to be divided.`},divisor:{d:`The number to divide by.`}}},EQ:{s:`Returns TRUE if the two specified values are equal. Equal to the '=' operator.`,c:`Sheets`,p:{value1:{d:`The first value to compare.`},value2:{d:`The second value to compare.`}}},GT:{s:`Returns TRUE if the first value is greater than the second. Equal to the '>' operator.`,c:`Sheets`,p:{value1:{d:`The first value to compare.`},value2:{d:`The second value to compare.`}}},GTE:{s:`Returns TRUE if the first value is greater than or equal to the second. Equal to the '>=' operator.`,c:`Sheets`,p:{value1:{d:`The first value to compare.`},value2:{d:`The second value to compare.`}}},LT:{s:`Returns TRUE if the first value is less than the second. Equal to the '<' operator.`,c:`Sheets`,p:{value1:{d:`The first value to compare.`},value2:{d:`The second value to compare.`}}},LTE:{s:`Returns TRUE if the first value is less than or equal to the second. Equal to the '<=' operator.`,c:`Sheets`,p:{value1:{d:`The first value to compare.`},value2:{d:`The second value to compare.`}}},MINUS:{s:`Returns the difference of two numbers. Equal to the '-' operator.`,c:`Sheets`,p:{value1:{d:`The number from which to subtract.`},value2:{d:`The number to subtract.`}}},MULTIPLY:{s:`Returns the product of two numbers. Equal to the '*' operator.`,c:`Sheets`,p:{value1:{d:`The first number to multiply.`},value2:{d:`The second number to multiply.`}}},NE:{s:`Returns TRUE if the two specified values are not equal. Equal to the '<>' operator.`,c:`Sheets`,p:{value1:{d:`The first value to compare.`},value2:{d:`The second value to compare.`}}},POW:{s:`Returns a number raised to a power. Equal to the '^' operator.`,c:`Sheets`,p:{base:{d:`The number to raise to a power.`},exponent:{d:`The power to raise the base to.`}}},UMINUS:{s:`Returns the negation of a number. Equal to the unary '-' operator.`,c:`Sheets`,p:{value:{d:`The number to negate.`}}},UNARY_PERCENT:{s:`Converts a number to a percentage. Equal to the '%' operator.`,c:`Sheets`,p:{value:{d:`The number to convert to a percentage.`}}},UPLUS:{s:`Returns a number unchanged. Equal to the unary '+' operator.`,c:`Sheets`,p:{value:{d:`The number to return.`}}},ISBETWEEN:{s:`Checks whether a number is between two numbers, inclusive by default.`,c:`Sheets`,p:{value:{d:`The value to test.`},lower:{d:`The lower bound.`},upper:{d:`The upper bound.`},lowerInclusive:{d:`Whether the lower bound is inclusive. Default TRUE.`},upperInclusive:{d:`Whether the upper bound is inclusive. Default TRUE.`}}}};