@sheetxl/studio-vanilla 0.4.19 → 0.4.21

package/cdn/assets/CZ54d8Ueai6uZgy6.js

@@ -1,10 +0,0 @@
-/**
- * @license @sheetxl/studio-vanilla - SheetXL Studio - Vanilla entry point for integrating SheetXL UI. - v0.4.19
- *
- * (C) 2025-present SheetXL Inc. & Michael T. Ford
- * License: The license can be found at https://www.sheetxl.com/license.
- */
-const e = { AVEDEV: { s: "Returns the average of the absolute deviations of data points from their mean. Arguments can be numbers or names, arrays, or references that contain numbers", p: { number: { d: "number1,number2,... are 1 to 255 arguments for which you want the average of the absolute deviations" } } }, AVERAGE: { s: "Returns the average (arithmetic mean) of its arguments, which can be numbers or names, arrays, or references that contain numbers", p: { number: { d: "number1,number2,... are 1 to 255 numeric arguments for which you want the average" } } }, AVERAGEA: { s: "Returns the average (arithmetic mean) of its arguments, evaluating text and FALSE in arguments as 0; TRUE evaluates as 1. Arguments can be numbers, names, arrays, or references", p: { value: { d: "value1,value2,... are 1 to 255 arguments for which you want the average" } } }, AVERAGEIF: { s: "Finds average(arithmetic mean) for the cells specified by a given condition or criteria", 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 used to find the average" }, averageRange: { d: "are the actual cells to be used to find the average. If omitted, the cells in range are used" } }, h: "Unimplemented" }, AVERAGEIFS: { s: "Finds average(arithmetic mean) for the cells specified by a given set of conditions or criteria", p: { averageRange: { d: "are the actual cells to be used to find the average." }, criteriaRange: { d: "criteria_range1,criteria_range2,... is the range of cells you want evaluated for the particular condition" }, criteria: { d: "criteria1,criteria2,... is the condition or criteria in the form of a number, expression, or text that defines which cells will be used to find the average" } }, h: "Unimplemented" }, COUNT: { s: "Counts the number of cells in a range that contain numbers", p: { number: { d: "value1,value2,... are 1 to 255 arguments that can contain or refer to a variety of different types of data, but only numbers are counted" } } }, COUNTA: { s: "Counts the number of cells in a range that are not empty", p: { value: { d: "value1,value2,... are 1 to 255 arguments representing the values and cells you want to count. Values can be any type of information" } } }, COUNTBLANK: { s: "Counts the number of empty cells in a specified range of cells", p: { range: { d: "is the range from which you want to count the empty cells" } }, h: "Unimplemented" }, COUNTIF: { s: "Counts the number of cells within a range that meet the given condition", p: { range: { d: "is the range of cells from which you want to count nonblank cells" }, criteria: { d: "is the condition in the form of a number, expression, or text that defines which cells will be counted" } }, h: "Unimplemented" }, COUNTIFS: { s: "Counts the number of cells specified by a given set of conditions or criteria", p: { criteriaRange: { d: "criteria_range1,criteria_range2,... is the range of cells you want evaluated for the particular condition" }, criteria: { d: "criteria1,criteria2,... is the condition in the form of a number, expression, or text that defines which cells will be counted" } }, h: "Unimplemented" }, LARGE: { s: "Returns the k-th largest value in a data set. For example, the fifth largest number.", p: { array: { d: "is the array or range of data for which you want to determine the k-th largest value." }, k: { d: "is the position (from the largest) in the array or cell range of the value to return." } } }, MAX: { s: "Returns the largest value in a set of values. Ignores logical values and text", p: { number: { d: "number1,number2,... are 1 to 255 numbers, empty cells, logical values, or text numbers for which you want the maximum" } } }, MAXA: { s: "Returns the largest value in a set of values. Does not ignore logical values and text", p: { value: { d: "value1,value2,... are 1 to 255 numbers, empty cells, logical values, or text numbers for which you want the maximum" } } }, MAXIFS: { s: "Returns the maximum value among cells specified by a given set of conditions or criteria", p: { maxRange: { d: "the cells in which to determine the maximum value" }, criteriaRange: { d: "criteria_range1,criteria_range2,... is the range of cells you want to evaluate for the particular condition" }, criteria: { d: "criteria1,criteria2,... is the condition or criteria in the form of a number, expression, or text that defines which cells will be included when determining the maximum value" } }, h: "Unimplemented" }, MEDIAN: { s: "Returns the median, or the number in the middle of the set of given numbers", p: { number: { d: "number1,number2,... are 1 to 255 numbers or names, arrays, or references that contain numbers for which you want the median" } } }, MIN: { s: "Returns the smallest number in a set of values. Ignores logical values and text", p: { number: { d: "number1,number2,... are 1 to 255 numbers, empty cells, logical values, or text numbers for which you want the minimum" } } }, MINA: { s: "Returns the smallest value in a set of values. Does not ignore logical values and text", p: { value: { d: "value1,value2,... are 1 to 255 numbers, empty cells, logical values, or text numbers for which you want the minimum" } } }, MINIFS: { s: "Returns the minimum value among cells specified by a given set of conditions or criteria", p: { maxRange: { d: "is the range of cells to evaluate for the minimum value" }, criteriaRange: { d: "is the range of cells to evaluate against the criteria" }, criteria: { d: "is the criteria to evaluate against the criteria range" } }, h: "Unimplemented" }, PERMUT: { s: "Returns the number of permutations for a given number of objects that can be selected from the total objects", p: { number: { d: "is the total number of objects" }, numberChoosen: { d: "is the number of objects in each permutation" } }, h: "Unimplemented" }, PERMUTATIONA: { s: "Returns the number of permutations for a given number of objects (with repetitions) that can be selected from the total objects", p: { number: { d: "is the total number of objects" }, numberChoosen: { d: "is the number of objects in each permutation" } }, h: "Unimplemented" }, SMALL: { s: "Returns the k-th smallest value in a data set. For example, the fifth smallest number", p: { array: { d: "is an array or range of numerical data for which you want to determine the k-th smallest value" }, k: { d: "is the position (from the smallest) in the array or range of the value to return" } } } };
-export {
-  e as default
-};

package/cdn/assets/CZM2uNUNI4W8qUw3.js

@@ -1,10 +0,0 @@
-/**
- * @license @sheetxl/studio-vanilla - SheetXL Studio - Vanilla entry point for integrating SheetXL UI. - v0.4.19
- *
- * (C) 2025-present SheetXL Inc. & Michael T. Ford
- * License: The license can be found at https://www.sheetxl.com/license.
- */
-const e = { "BETA.DIST": { s: "Returns the beta probability distribution function", p: { x: { d: "is the value between A and B at which to evaluate the function" }, alpha: { d: "is a parameter to the distribution and must be greater than 0" }, beta: { d: "is a parameter to the distribution and must be greater than 0" }, cumulative: { d: "is a logical value: for the cumulative distribution function, use TRUE; for the probability density function, use FALSE" }, a: { d: "lower bound to the interval of x", v: 0 }, b: { d: "upper bound to the interval of x", v: 1 } } }, BETADIST: { s: "Returns the cumulative beta probability density function", p: { x: { d: "is the value between A and B at which to evaluate the function" }, alpha: { d: "is a parameter to the distribution and must be greater than 0" }, beta: { d: "is a parameter to the distribution and must be greater than 0" }, cumulative: { d: "is a logical value: for the cumulative distribution function, use TRUE; for the probability density function, use FALSE" }, a: { d: "lower bound to the interval of x", v: 0 }, b: { d: "upper bound to the interval of x", v: 1 } }, c: "Compatibility" }, "BETA.INV": { s: "Returns the inverse of the cumulative beta probability density function (BETA.DIST)", p: { probability: { d: "is a probability associated with the beta distribution" }, alpha: { d: "is a parameter to the distribution and must be greater than 0" }, beta: { d: "is a parameter to the distribution and must be greater than 0" }, a: { d: "lower bound to the interval of x", v: 0 }, b: { d: "upper bound to the interval of x", v: 1 } } }, BETAINV: { s: "Returns the inverse of the cumulative beta probability density function (BETADIST)", p: { probability: { d: "is a probability associated with the beta distribution" }, alpha: { d: "is a parameter to the distribution and must be greater than 0" }, beta: { d: "is a parameter to the distribution and must be greater than 0" }, a: { d: "lower bound to the interval of x", v: 0 }, b: { d: "upper bound to the interval of x", v: 1 } }, c: "Compatibility" }, "BINOM.DIST": { s: "Returns the individual term binomial distribution probability", p: { numberS: { d: "is the number of successes in trials" }, trials: { d: "is the number of independent trials" }, probabilityS: { d: "is the probability of success on each trial" }, cumulative: { d: "is a logical value: for the cumulative distribution function, use TRUE; for the probability mass function, use FALSE" } } }, BINOMDIST: { s: "Returns the individual term binomial distribution probability", p: { numberS: { d: "is the number of successes in trials" }, trials: { d: "is the number of independent trials" }, probabilityS: { d: "is the probability of success on each trial" }, cumulative: { d: "is a logical value: for the cumulative distribution function, use TRUE; for the probability mass function, use FALSE" } }, c: "Compatibility" }, "BINOM.DIST.RANGE": { s: "Returns the probability of a trial result using a binomial distribution", p: { trials: { d: "is the number of independent trials" }, probabilityS: { d: "is the probability of success on each trial" }, numberS: { d: "is the number of successes in trials" }, numberS2: { d: "if provided this function returns the probability that the number of successful trials shall lie between number_s and number_s2", v: "numberS" } } }, "BINOM.INV": { s: "Returns the smallest value for which the cumulative binomial distribution is greater than or equal to a criterion value", p: { trials: { d: "is the number of Bernoulli trials" }, probabilityS: { d: "is the probability of success on each trial, a number between 0 and 1 inclusive" }, alpha: { d: "is the criterion value, a number between 0 and 1 inclusive" } } }, "CHISQ.DIST": { s: "Returns the left-tailed probability of the chi-squared distribution", p: { x: { d: "is the value at which you want to evaluate the distribution, a nonnegative number" }, degFreedom: { d: "is the number of degrees of freedom, a number between 1 and 10^10, excluding 10^10" }, cumulative: { d: "is a logical value for the function to return: the cumulative distribution function = TRUE; the probability density function = FALSE", v: !1 } } }, CHIDIST: { s: "Returns the right-tailed probability of the chi-squared distribution", p: { x: { d: "is the value at which you want to evaluate the distribution, a nonnegative number" }, degFreedom: { d: "is the number of degrees of freedom, a number between 1 and 10^10, excluding 10^10" } }, c: "Compatibility" }, "CHISQ.DIST.RT": { s: "Returns the right-tailed probability of the chi-squared distribution", p: { x: { d: "is the value at which you want to evaluate the distribution, a nonnegative number" }, degFreedom: { d: "is the number of degrees of freedom, a number between 1 and 10^10, excluding 10^10" } } }, "CHISQ.INV": { s: "Returns the inverse of the left-tailed probability of the chi-squared distribution", p: { probability: { d: "is a probability associated with the chi-squared distribution, a value between 0 and 1 inclusive" }, degFreedom: { d: "is the number of degrees of freedom, a number between 1 and 10^10, excluding 10^10" } } }, CHIINV: { s: "Returns the inverse of the right-tailed probability of the chi-squared distribution", p: { probability: { d: "is a probability associated with the chi-squared distribution, a value between 0 and 1 inclusive" }, degFreedom: { d: "is the number of degrees of freedom, a number between 1 and 10^10, excluding 10^10" } }, c: "Compatibility" }, "CHISQ.INV.RT": { s: "Returns the right-tailed probability of the chi-squared distribution", p: { probability: { d: "is a probability associated with the chi-squared distribution, a value between 0 and 1 inclusive" }, degFreedom: { d: "is the number of degrees of freedom, a number between 1 and 10^10, excluding 10^10" } } }, "CHISQ.TEST": { s: "Returns the test for independence: the value from the chi-squared distribution for the statistic and the appropriate degrees of freedom", p: { actualRange: { d: "is the range of data that contains observations to test against expected values" }, expectedRange: { d: "is the range of data that contains the ratio of the product of row totals and column totals to the grand total" } } }, CHITEST: { s: "Returns the test for independence: the value from the chi-squared distribution for the statistic and the appropriate degrees of freedom", p: { actualRange: { d: "is the range of data that contains observations to test against expected values" }, expectedRange: { d: "is the range of data that contains the ratio of the product of row totals and column totals to the grand total" } }, c: "Compatibility" }, "CONFIDENCE.NORM": { s: "Returns the confidence interval for a population mean, using a normal distribution", p: { alpha: { d: "is the significance level used to compute the confidence level, a number greater than 0 and less than 1" }, standardDev: { d: "is the population standard deviation for the data range and is assumed to be known. Standard_dev must be greater than 0" }, size: { d: "is the sample size" } } }, CONFIDENCE: { s: "Returns the confidence interval for a population mean, using a normal distribution", p: { alpha: { d: "is the significance level used to compute the confidence level, a number greater than 0 and less than 1" }, std: { d: "is the population standard deviation for the data range and is assumed to be known. Standard_dev must be greater than 0" }, dev: { d: "is the population standard deviation for the data range and is assumed to be known. Standard_dev must be greater than 0" }, size: { d: "is the sample size" } }, c: "Compatibility" }, "CONFIDENCE.T": { s: "Returns the confidence interval for a population mean, using a Student's T distribution", p: { alpha: { d: "is the significance level used to compute the confidence level, a number greater than 0 and less than 1" }, standardDev: { d: "is the population standard deviation for the data range and is assumed to be known. Standard_dev must be greater than 0" }, size: { d: "is the sample size" } } }, CORREL: { s: "Returns the correlation coefficient between two data sets", p: { array1: { d: "is a cell range of values. The values should be numbers, names, arrays, or references that contain numbers" }, array2: { d: "is a second cell range of values. The values should be numbers, names, arrays, or references that contain numbers" } } }, "COVARIANCE.P": { s: "Returns population covariance, the average of the products of deviations for each data point pair in two data sets", p: { array1: { d: "is the first cell range of integers and must be numbers, arrays, or references that contain numbers" }, array2: { d: "is the second cell range of integers and must be numbers, arrays, or references that contain numbers" } } }, COVARIANCE: { s: "Returns population covariance, the average of the products of deviations for each data point pair in two data sets", p: { array1: { d: "is the first cell range of integers and must be numbers, arrays, or references that contain numbers" }, array2: { d: "is the second cell range of integers and must be numbers, arrays, or references that contain numbers" } }, c: "Compatibility" }, "COVARIANCE.S": { s: "Returns sample covariance, the average of the products of deviations for each data point pair in two data sets", p: { array1: { d: "is the first cell range of integers and must be numbers, arrays, or references that contain numbers" }, array2: { d: "is the second cell range of integers and must be numbers, arrays, or references that contain numbers" } } }, CRITBINOM: { s: "Returns the smallest value for which the cumulative binomial distribution is greater than or equal to a criterion value", p: { trails: { d: "is the number of Bernoulli trials" }, probabilityS: { d: "is the probability of success on each trial, a number between 0 and 1 inclusive" }, alpha: { d: "is the criterion value, a number between 0 and 1 inclusive" } }, c: "Compatibility", h: "Unimplemented" }, DEVSQ: { s: "Returns the sum of squares of deviations of data points from their sample mean", p: { number: { d: "number1,number2,... are 1 to 255 arguments, or an array or array reference, on which you want DEVSQ to calculate" } } }, "EXPON.DIST": { s: "Returns the exponential distribution", p: { x: { d: "is the value of the function, a nonnegative number" }, lambda: { d: "is the parameter value, a positive number" }, cumulative: { d: "is a logical value for the function to return: the cumulative distribution function = TRUE; the probability density function = FALSE" } } }, EXPONDIST: { s: "Returns the exponential distribution", p: { x: { d: "is the value of the function, a nonnegative number" }, lambda: { d: "is the parameter value, a positive number" }, cumulative: { d: "is a logical value for the function to return: the cumulative distribution function = TRUE; the probability density function = FALSE" } }, c: "Compatibility" }, "F.DIST": { s: "Returns the (left-tailed) F probability distribution (degree of diversity) for two data sets", p: { x: { d: "is the value at which to evaluate the function, a nonnegative number" }, degFreedom1: { d: "is the numerator degrees of freedom, a number between 1 and 10^10, excluding 10^10" }, degFreedom2: { d: "is the denominator degrees of freedom, a number between 1 and 10^10, excluding 10^10" }, cumulative: { d: "is a logical value for the function to return: the cumulative distribution function = TRUE; the probability density function = FALSE" } } }, FDIST: { s: "Returns the (left-tailed) F probability distribution (degree of diversity) for two data sets", p: { x: { d: "is the value at which to evaluate the function, a nonnegative number" }, degFreedom1: { d: "is the numerator degrees of freedom, a number between 1 and 10^10, excluding 10^10" }, degFreedom2: { d: "is the denominator degrees of freedom, a number between 1 and 10^10, excluding 10^10" } }, c: "Compatibility" }, "F.DIST.RT": { s: "Returns the (right-tailed) F probability distribution (degree of diversity) for two data sets", p: { x: { d: "is the value at which to evaluate the function, a nonnegative number" }, degFreedom1: { d: "is the numerator degrees of freedom, a number between 1 and 10^10, excluding 10^10" }, degFreedom2: { d: "is the denominator degrees of freedom, a number between 1 and 10^10, excluding 10^10" } } }, "F.INV": { s: "Returns the inverse of the (left-tailed) F probability distribution: if p = F.DIST(x,...), then F.INV(p,...) = x", p: { probability: { d: "is a probability associated with the F cumulative distribution, a number between 0 and 1 inclusive" }, degFreedom1: { d: "is the numerator degrees of freedom, a number between 1 and 10^10, excluding 10^10" }, degFreedom2: { d: "is the denominator degrees of freedom, a number between 1 and 10^10, excluding 10^10" } } }, FINV: { s: "Returns the inverse of the (left-tailed) F probability distribution: if p = F.DIST(x,...), then F.INV(p,...) = x", p: { probability: { d: "is a probability associated with the F cumulative distribution, a number between 0 and 1 inclusive" }, degFreedom1: { d: "is the numerator degrees of freedom, a number between 1 and 10^10, excluding 10^10" }, degFreedom2: { d: "is the denominator degrees of freedom, a number between 1 and 10^10, excluding 10^10" } }, c: "Compatibility" }, "F.INV.RT": { s: "Returns the inverse of the (right-tailed) F probability distribution: if p = F.DIST.RT(x,...), then F.INV.RT(p,...) = x", p: { probability: { d: "is a probability associated with the F cumulative distribution, a number between 0 and 1 inclusive" }, degFreedom1: { d: "is the numerator degrees of freedom, a number between 1 and 10^10, excluding 10^10" }, degFreedom2: { d: "is the denominator degrees of freedom, a number between 1 and 10^10, excluding 10^10" } } }, "F.TEST": { s: "Returns the result of an F-test, the two-tailed probability that the variances in Array1 and Array2 are not significantly different", p: { array1: { d: "is the first array or range of data and can be numbers or names, arrays, or references that contain numbers (blanks are ignored)" }, array2: { d: "is the second array or range of data and can be numbers or names, arrays, or references that contain numbers (blanks are ignored)" } } }, FTEST: { s: "Returns the result of an F-test, the two-tailed probability that the variances in Array1 and Array2 are not significantly different", p: { array1: { d: "is the first array or range of data and can be numbers or names, arrays, or references that contain numbers (blanks are ignored)" }, array2: { d: "is the second array or range of data and can be numbers or names, arrays, or references that contain numbers (blanks are ignored)" } }, c: "Compatibility" }, FISHER: { s: "Returns the Fisher transformation", p: { x: { d: "is the value for which you want the transformation, a number between -1 and 1, excluding -1 and 1" } } }, FISHERINV: { s: "Returns the inverse of the Fisher transformation: if y = FISHER(x), then FISHERINV(y) = x", p: { y: { d: "is the value for which you want to perform the inverse of the transformation" } } }, FORECAST: { s: "Calculates, or predicts, a future value along a linear trend by using existing values", p: { x: { d: "is the data point for which you want to predict a value and must be a numeric value" }, knownYs: { d: "is the dependent array or range of numeric data", v: null }, knownXs: { d: "is the independent array or range of numeric data. The variance of Known_x's must not be zero", v: null } }, c: "Compatibility" }, "FORECAST.ETS": { s: "Returns the forecasted value for a specific future target date using exponential smoothing method", p: { targetDate: { d: "is the data point for which you want to predict a value. It should carry on the pattern of values in the timeline" }, values: { d: "is the array or range of numberic data you're predicting" }, timeline: { d: "is the independent array or range of numberic data. The dtes in the timeline must have a consistent step between them and can't be zero." }, seasonality: { d: "is a number value that indicates the length of the seasonal pattern in the data. It must be between 0 and 1, where 0 means no seasonality and 1 means full seasonality", v: 0.95 }, dataCompletion: { d: "is a number value that indicates how much of the data is complete. It must be between 0 and 1, where 0 means no data is complete and 1 means all data is complete", v: 1 }, aggregation: { d: "is a number value that indicates how the data should be aggregated. It must be between 0 and 1, where 0 means no aggregation and 1 means full aggregation", v: 1 } }, h: "Unimplemented" }, "FORECAST.ETS.CONFINT": { s: "Retursn a confidence interval for the forecasted value at the specified target date", p: { targetDate: { d: "is the data point for which you want to predict a value. It should carry on the pattern of values in the timeline" }, values: { d: "is the array or range of numberic data you're predicting" }, timeline: { d: "is the independent array or range of numberic data. The dtes in the timeline must have a consistent step between them and can't be zero." }, confiedenceLevel: { d: "is a number value that indicates the confidence level for the forecasted value. It must be between 0 and 1, where 0 means no confidence and 1 means full confidence", v: 0.95 }, seasonality: { d: "is a number value that indicates the length of the seasonal pattern in the data. It must be between 0 and 1, where 0 means no seasonality and 1 means full seasonality", v: 0.95 }, dataCompletion: { d: "is a number value that indicates how much of the data is complete. It must be between 0 and 1, where 0 means no data is complete and 1 means all data is complete", v: 1 }, aggregation: { d: "is a number value that indicates how the data should be aggregated. It must be between 0 and 1, where 0 means no aggregation and 1 means full aggregation", v: 1 } }, h: "Unimplemented" }, "FORECAST.ETS.SEASONALITY": { s: "Returns the length of the repetitive pattern in the data for the specific time series.", p: { values: { d: "is the array or range of numberic data you're predicting" }, timeline: { d: "is the independent array or range of numberic data. The dtes in the timeline must have a consistent step between them and can't be zero." }, dataCompletion: { d: "is a number value that indicates how much of the data is complete. It must be between 0 and 1, where 0 means no data is complete and 1 means all data is complete", v: 1 }, aggregation: { d: "is a number value that indicates how the data should be aggregated. It must be between 0 and 1, where 0 means no aggregation and 1 means full aggregation", v: 1 } }, h: "Unimplemented" }, "FORECAST.ETS.STAT": { s: "Returns the requested statistic for the forecast", p: { values: { d: "is the array or range of numberic data you're predicting" }, timeline: { d: "is the independent array or range of numberic data. The dtes in the timeline must have a consistent step between them and can't be zero." }, statisticType: { d: "is a number between 1 and 8 that indicates the type of statistic to return:" }, seasonality: { d: "is a number value that indicates the length of the seasonal pattern in the data. It must be between 0 and 1, where 0 means no seasonality and 1 means full seasonality", v: 1 }, dataCompletion: { d: "is a number value that indicates how much of the data is complete. It must be between 0 and 1, where 0 means no data is complete and 1 means all data is complete", v: 1 }, aggregation: { d: "is a number value that indicates how the data should be aggregated. It must be between 0 and 1, where 0 means no aggregation and 1 means full aggregation", v: 1 } }, h: "Unimplemented" }, "FORECAST.LINEAR": { s: "Calculates, or predicts, a future value along a linear trend by using existing values", p: { x: { d: "is the data point for which you want to predict a value and must be a numeric value" }, knownYs: { d: "is the dependent array or range of numeric data" }, knownXs: { d: "is the independent array or range of numeric data. The variance of Known_x's must not be zero", v: null } }, h: "Unimplemented" }, FREQUENCY: { s: "Calculates how often values occur within a range of values and then returns a vertical array of numbers having one more element than Bins_array", p: { dataArray: { d: "is an array of or reference to a set of values for which you want to count frequencies (blanks and text are ignored)" }, binsArray: { d: "is an array of or reference to intervals into which you want to group the values in data_array" } } }, GAMMA: { s: "Returns the Gamma function value", p: { x: { d: "is the value for which you want to calculate Gamma" } } }, "GAMMA.DIST": { s: "Returns the gamma distribution", p: { x: { d: "is the value at which you want to evaluate the distribution, a nonnegative number" }, alpha: { d: "is a parameter to the distribution, a positive number" }, beta: { d: "is a parameter to the distribution, a positive number. If beta = 1, GAMMA.DIST returns the standard gamma distribution" }, cumulative: { d: "is a logical value: return the cumulative distribution function = TRUE; return the probability mass function = FALSE", v: !1 } } }, "GAMMA.INV": { s: "Returns the inverse of the gamma cumulative distribution: if p = GAMMA.DIST(x,...), then GAMMA.INV(p,...) = x", p: { probability: { d: "is the probability associated with the gamma distribution, a number between 0 and 1, inclusive" }, alpha: { d: "is a parameter to the distribution, a positive number" }, beta: { d: "is a parameter to the distribution, a positive number. If beta = 1, GAMMA.DIST returns the standard gamma distribution" } } }, GAMMALN: { s: "Returns the natural logarithm of the gamma function", p: { x: { d: "is the value for which you want to calculate GAMMALN, a positive number" } } }, "GAMMALN.PRECISE": { s: "Returns the natural logarithm of the gamma function", p: { x: { d: "is the value for which you want to calculate GAMMALN.PRECISE, a positive number" } } }, GAUSS: { s: "Returns 0.5 less than the standard normal cumulative distribution", p: { x: { d: "is the value for which you want the distribution" } } }, GEOMEAN: { s: "Returns the geometric mean of an array or range of positive numeric data", p: { number: { d: "number1,number2,... are 1 to 255 numbers or names, arrays, or references that contain numbers for which you want the mean" } } }, GROWTH: { s: "Returns numbers in an exponential growth trend matching known data points", p: { knownYs: { d: "is the set of y-values you already know in the relationship y = b*m^x, an array or range of positive numbers" }, knownXs: { d: "is an optional set of x-values that you may already know in the relationship y = b*m^x, an array or range the same size as Known_y's", v: null }, newXs: { d: "are new x-values for which you want GROWTH to return corresponding y-values", v: null }, useConst: { d: "is a logical value: the constant b is calculated normally if Const = TRUE; b is set equal to 1 if Const = FALSE", v: !0 } } }, HARMEAN: { s: "Returns the harmonic mean of a data set of positive numbers: the reciprocal of the arithmetic mean of reciprocals", p: { number: { d: "number1,number2,... are 1 to 255 numbers or names, arrays, or references that contain numbers for which you want the harmonic mean" } } }, "HYPGEOM.DIST": { s: "Returns the hypergeometric distribution", p: { sampleS: { d: "is the number of successes in the sample" }, numberSample: { d: "is the size of the sample" }, populationS: { d: "is the number of successes in the population" }, numberPop: { d: "is the population size" }, cumulative: { d: "is a logical value: for the cumulative distribution function, use TRUE; for the probability density function, use FALSE" } } }, INTERCEPT: { s: "Calculates the point at which a line will intersect the y-axis by using a best-fit regression line plotted through the known x-values and y-values", p: { knownYs: { d: "is the dependent set of observations or data and can be numbers or names, arrays, or references that contain numbers" }, knownXs: { d: "is the independent set of observations or data and can be numbers or names, arrays, or references that contain numbers" } } }, KURT: { s: "Returns the kurtosis of a data set", p: { number: { d: "number1,number2,... are 1 to 255 numbers or names, arrays, or references that contain numbers for which you want the kurtosis" } } }, LINEST: { s: "Returns statistics that describe a linear trend matching known data points, by fitting a straight line using the least squares method", p: { knownYs: { d: "is the set of y-values you already know in the relationship y = mx + b" }, knownXs: { d: "is an optional set of x-values that you may already know in the relationship y = mx + b", v: null }, constant: { d: "is a logical value: the constant b is calculated normally if Const = TRUE; b is set equal to 0 if Const = FALSE", v: !0 }, stats: { d: "is a logical value: return additional regression statistics = TRUE; return m-coefficients and the constant b = FALSE", v: !1 } } }, LOGEST: { s: "Returns statistics that describe an exponential curve matching known data points", p: { knownYs: { d: "is the set of y-values you already know in the relationship y = b*m^x" }, knownXs: { d: "is an optional set of x-values that you may already know in the relationship y = b*m^x", v: null }, constant: { d: "is a logical value: the constant b is calculated normally if Const = TRUE; b is set equal to 1 if Const = FALSE", v: !0 }, stats: { d: "is a logical value: return additional regression statistics = TRUE; return m-coefficients and the constant b = FALSE", v: !1 } }, h: "Unimplemented Buggy" }, "LOGNORM.DIST": { s: "Returns the lognormal distribution of x, where ln(x) is normally distributed with parameters Mean and Standard_dev", p: { x: { d: "is the value at which to evaluate the function, a positive number" }, mean: { d: "is the mean of ln(x)" }, standardDev: { d: "is the standard deviation of ln(x), a positive number" }, cumulative: { d: "is a logical value: for the cumulative distribution function, use TRUE; for the probability density function, use FALSE" } } }, "LOGNORM.INV": { s: "Returns the inverse of the lognormal cumulative distribution function of x, where ln(x) is normally distributed with parameters Mean and Standard_dev", p: { probability: { d: "is a probability associated with the lognormal distribution, a number between 0 and 1, inclusive" }, mean: { d: "is the mean of ln(x)" }, standardDev: { d: "is the standard deviation of ln(x), a positive number" } } }, "MODE.MULT": { s: "Returns a vertical array of the most frequently occurring, or repetitive, values in an array or range of data.  For a horizontal array, use =TRANSPOSE(MODE.MULT(number1,number2,...))", p: { number: { d: '<div class="param-538">number1,number2,... are 1 to 255 numbers, or names, arrays, or references that contain numbers for which you want the mode</div>' } }, h: "Unimplemented" }, "MODE.SNGL": { s: "Returns the most frequently occurring, or repetitive, value in an array or range of data", p: { number: { d: "number1,number2,... are 1 to 255 numbers, or names, arrays, or references that contain numbers for which you want the mode" } }, h: "Unimplemented" }, "NEGBINOM.DIST": { s: "Returns the negative binomial distribution, the probability that there will be Number_f failures before the Number_s-th success, with Probability_s probability of a success", p: { numberF: { d: "is the number of failures" }, numberS: { d: "is the threshold number of successes" }, probabilityS: { d: "is the probability of a success; a number between 0 and 1" }, cumulative: { d: "is a logical value: for the cumulative distribution function, use TRUE; for the probability mass function, use FALSE" } } }, "NORM.DIST": { s: "Returns the normal distribution for the specified mean and standard deviation", p: { x: { d: "is the value for which you want the distribution" }, mean: { d: "is the arithmetic mean of the distribution" }, standardDev: { d: "is the standard deviation of the distribution, a positive number" }, cumulative: { d: "is a logical value: for the cumulative distribution function, use TRUE; for the probability density function, use FALSE" } } }, "NORM.INV": { s: "Returns the inverse of the normal cumulative distribution for the specified mean and standard deviation", p: { probability: { d: "is a probability corresponding to the normal distribution, a number between 0 and 1 inclusive" }, mean: { d: "is the arithmetic mean of the distribution" }, standardDev: { d: "is the standard deviation of the distribution, a positive number" } } }, "NORM.S.DIST": { s: "Returns the standard normal distribution (has a mean of zero and a standard deviation of one)", p: { z: { d: "is the value for which you want the distribution" }, cumulative: { d: "is a logical value for the function to return: the cumulative distribution function = TRUE; the probability density function = FALSE" } } }, "NORM.S.INV": { s: "Returns the inverse of the standard normal cumulative distribution (has a mean of zero and a standard deviation of one)", p: { probability: { d: "is a probability corresponding to the normal distribution, a number between 0 and 1 inclusive" } } }, PEARSON: { s: "Returns the Pearson product moment correlation coefficient, r", p: { array1: { d: "is a set of independent values" }, array2: { d: "is a set of dependent values" } } }, "PERCENTILE.EXC": { s: "Returns the k-th percentile of values in a range, where k is in the range 0..1, exclusive", p: { array: { d: "is the array or range of data that defines relative standing" }, k: { d: "is the percentile value that is between 0 through 1, inclusive" } }, h: "Unimplemented" }, "PERCENTILE.INC": { s: "Returns the k-th percentile of values in a range, where k is in the range 0..1, inclusive", p: { array: { d: "is the array or range of data that defines relative standing" }, k: { d: "is the percentile value that is between 0 through 1, inclusive" } }, h: "Unimplemented" }, "PERCENTRANK.EXC": { s: "Returns the rank of a value in a data set as a percentage (0..1, exclusive) of the data set", p: { array: { d: "is the array or range of data with numeric values that defines relative standing" }, x: { d: "is the value for which you want to know the rank" }, significance: { d: "is an optional value that identifies the number of significant digits for the returned percentage", v: 3 } }, h: "Unimplemented" }, "PERCENTRANK.INC": { s: "Returns the rank of a value in a data set as a percentage (0..1, inclusive) of the data set", p: { array: { d: "is the array or range of data with numeric values that defines relative standing" }, x: { d: "is the value for which you want to know the rank" }, significance: { d: "is an optional value that identifies the number of significant digits for the returned percentage", v: 3 } }, h: "Unimplemented" }, PHI: { s: "Returns the value of the density function for a standard normal distribution", p: { x: { d: "is the number for which you want the density of the standard normal distribution" } } }, "POISSON.DIST": { s: "Returns the Poisson distribution", p: { x: { d: "is the number of events" }, mean: { d: "is the expected numeric value, a positive number" }, cumulative: { d: "is a logical value: for the cumulative Poisson probability, use TRUE; for the Poisson probability mass function, use FALSE" } } }, PROB: { s: "Returns the probability that values in a range are between two limits or equal to a lower limit", p: { xRange: { d: "is the range of numeric values of x with which there are associated probabilities" }, probRange: { d: "is the set of probabilities associated with values in X_range, values between 0 and 1 and excluding 0" }, lowerLimit: { d: "is the lower bound on the value for which you want a probability" }, upperLimit: { d: "is the optional upper bound on the value. If omitted, PROB returns the probability that X_range values are equal to Lower_limit" } } }, "QUARTILE.EXC": { s: "Returns the quartile of a data set, based on percentile values from 0..1, exclusive", p: { array: { d: "is the array or cell range of numeric values for which you want the quartile value" }, quart: { d: "is a number: minimum value = 0; 1st quartile = 1; median value = 2; 3rd quartile = 3; maximum value = 4" } }, h: "Unimplemented" }, "QUARTILE.INC": { s: "Returns the quartile of a data set, based on percentile values from 0..1, inclusive", p: { array: { d: "is the array or cell range of numeric values for which you want the quartile value" }, quart: { d: "is a number: minimum value = 0; 1st quartile = 1; median value = 2; 3rd quartile = 3; maximum value = 4" } }, h: "Unimplemented" }, "RANK.AVG": { s: "Returns the rank of a number in a list of numbers: its size relative to other values in the list; if more than one value has the same rank, the average rank is returned", p: { number: { d: "is the number for which you want to find the rank" }, ref: { d: "is an array of, or a reference to, a list of numbers. Nonnumeric values are ignored" }, order: { d: "is a number: rank in the list sorted descending = 0; rank in the list sorted ascending = any nonzero value", v: 0 } }, h: "Unimplemented" }, "RANK.EQ": { s: "Returns the rank of a number in a list of numbers: its size relative to other values in the list; if more than one value has the same rank, the top rank of that set of values is returned", p: { number: { d: "is the number for which you want to find the rank" }, ref: { d: "is an array of, or a reference to, a list of numbers. Nonnumeric values are ignored" }, order: { d: "is a number: rank in the list sorted descending = 0; rank in the list sorted ascending = any nonzero value", v: 0 } }, h: "Unimplemented" }, RSQ: { s: "Returns the square of the Pearson product moment correlation coefficient through the given data points", p: { knownYs: { d: "is an array or range of data points and can be numbers or names, arrays, or references that contain numbers" }, knownXs: { d: "is an array or range of data points and can be numbers or names, arrays, or references that contain numbers" } }, h: "Unimplemented" }, SKEW: { s: "Returns the skewness of a distribution: a characterization of the degree of asymmetry of a distribution around its mean", p: { number: { d: "number1,number2,... are 1 to 255 numbers or names, arrays, or references that contain numbers for which you want the skewness" } }, h: "Unimplemented" }, "SKEW.P": { s: "Returns the skewness of a distribution based on a population: a characterization of the degree of asymmetry of a distribution around its mean", p: { number: { d: "number1,number2,... are 1 to 254 numbers or names, arrays, or references that contain numbers for which you want the population skewness" } }, h: "Unimplemented" }, SLOPE: { s: "Returns the slope of the linear regression line through the given data points", p: { knownYs: { d: "is an array or cell range of numeric dependent data points and can be numbers or names, arrays, or references that contain numbers" }, knownXs: { d: "iis the set of independent data points and can be numbers or names, arrays, or references that contain numbers" } } }, STANDARDIZE: { s: "Returns a normalized value from a distribution characterized by a mean and standard deviation", p: { x: { d: "is the value you want to normalize" }, mean: { d: "is the arithmetic mean of the distribution" }, standardDev: { d: "is the standard deviation of the distribution, a positive number" } } }, "STDEV.P": { s: "Calculates standard deviation based on the entire population given as arguments (ignores logical values and text)", p: { number: { d: "number1,number2,... are 1 to 255 numbers corresponding to a population and can be numbers or references that contain numbers" } }, h: "Unimplemented" }, "STDEV.S": { s: "Estimates standard deviation based on a sample (ignores logical values and text in the sample)", p: { number: { d: "number1,number2,... are 1 to 255 numbers corresponding to a sample of a population and can be numbers or references that contain numbers" } } }, STDEVA: { s: "Estimates standard deviation based on a sample, including logical values and text. Text and the logical value FALSE have the value 0; the logical value TRUE has the value 1", p: { value: { d: "value1,value2,... are 1 to 255 values corresponding to a sample of a population and can be values or names or references to values" } }, h: "Unimplemented" }, STDEVPA: { s: "Calculates standard deviation based on an entire population, including logical values and text. Text and the logical value FALSE have the value 0; the logical value TRUE has the value 1", p: { value: { d: "value1,value2,... are 1 to 255 values corresponding to a population and can be values, names, arrays, or references that contain values" } }, h: "Unimplemented" }, STEYX: { s: "Returns the standard error of the predicted y-value for each x in a regression", p: { knownYs: { d: "is an array or range of dependent data points and can be numbers or names, arrays, or references that contain numbers" }, knownXs: { d: "is an array or range of independent data points and can be numbers or names, arrays, or references that contain numbers" } }, h: "Unimplemented" }, "T.DIST": { s: "Returns the left-tailed Student's t-distribution", p: { x: { d: "is the numeric value at which to evaluate the distribution" }, degFreedom: { d: "is an integer indicating the number of degrees of freedom that characterize the distribution" }, cumulative: { d: "is a logical value: for the cumulative distribution function, use TRUE; for the probability density function, use FALSE" } } }, "T.DIST.2T": { s: "Returns the two-tailed Student's t-distribution", p: { x: { d: "is the numeric value at which to evaluate the distribution" }, degFreedom: { d: "is an integer indicating the number of degrees of freedom that characterize the distribution" } } }, "T.DIST.RT": { s: "Returns the right-tailed Student's t-distribution", p: { x: { d: "is the numeric value at which to evaluate the distribution" }, degFreedom: { d: "is an integer indicating the number of degrees of freedom that characterize the distribution" } } }, "T.INV": { s: "Returns the left-tailed inverse of the Student's t-distribution", p: { probability: { d: "is the probability associated with the two-tailed Student's t-distribution, a number between 0 and 1 inclusive" }, degFreedom: { d: "is a positive integer indicating the number of degrees of freedom to characterize the distribution" } } }, "T.INV.2T": { s: "Returns the two-tailed inverse of the Student's t-distribution", p: { probability: { d: "is the probability associated with the two-tailed Student's t-distribution, a number between 0 and 1 inclusive" }, degFreedom: { d: "is a positive integer indicating the number of degrees of freedom to characterize the distribution" } } }, "T.TEST": { s: "Returns the probability associated with a Student's t-Test", p: { array1: { d: "is the first data set" }, array2: { d: "is the second data set" }, tails: { d: "specifies the number of distribution tails to return: one-tailed distribution = 1; two-tailed distribution = 2" }, type: { d: "is the kind of t-test: paired = 1, two-sample equal variance (homoscedastic) = 2, two-sample unequal variance = 3" } }, h: "Unimplemented" }, TREND: { s: "Returns numbers in a linear trend matching known data points, using the least squares method", p: { knownYs: { d: "is a range or array of y-values you already know in the relationship y = mx + b" }, knownXs: { d: "is an optional range or array of x-values that you know in the relationship y = mx + b, an array the same size as Known_y's", v: null }, newXs: { d: "is a range or array of new x-values for which you want TREND to return corresponding y-values", v: null }, consts: { d: "is a logical value: the constant b is calculated normally if Const = TRUE; b is set equal to 0 if Const = FALSE", v: !0 } }, h: "Unimplemented" }, TRIMMEAN: { s: "Returns the mean of the interior portion of a set of data values", p: { array: { d: "is the range or array of values to trim and average" }, percent: { d: "is the fractional number of data points to exclude from the top and bottom of the data set" } }, h: "Unimplemented" }, "VAR.P": { s: "Calculates variance based on the entire population (ignores logical values and text in the population)", p: { number: { d: "number1,number2,... are 1 to 255 numeric arguments corresponding to a population" } } }, "VAR.S": { s: "Estimates variance based on a sample (ignores logical values and text in the sample)", p: { number: { d: "number1,number2,... are 1 to 255 numeric arguments corresponding to a sample of a population" } } }, VARA: { s: "Estimates variance based on a sample, including logical values and text. Text and the logical value FALSE have the value 0; the logical value TRUE has the value 1", p: { value: { d: "value1,value2,... are 1 to 255 value arguments corresponding to a sample of a population" } } }, VARPA: { s: "Calculates variance based on the entire population, including logical values and text. Text and the logical value FALSE have the value 0; the logical value TRUE has the value 1", p: { value: { d: "value1,value2,... are 1 to 255 value arguments corresponding to a population" } } }, "WEIBULL.DIST": { s: "Returns the Weibull distribution", p: { x: { d: "is the value at which to evaluate the function, a nonnegative number" }, alpha: { d: "is a parameter to the distribution, a positive number" }, beta: { d: "is a parameter to the distribution, a positive number" }, cumulative: { d: "is a logical value: for the cumulative distribution function, use TRUE; for the probability mass function, use FALSE" } } }, "Z.TEST": { s: "Returns the one-tailed P-value of a z-test", p: { array: { d: "is the array or range of data against which to test X" }, x: { d: "is the value to test" }, sigma: { d: "is the population (known) standard deviation. If omitted, the sample standard deviation is used", v: 0 } } } };
-export {
-  e as default
-};

package/cdn/assets/CaaAGrJF7OxdprqB.js

@@ -1,10 +0,0 @@
-/**
- * @license @sheetxl/studio-vanilla - SheetXL Studio - Vanilla entry point for integrating SheetXL UI. - v0.4.19
- *
- * (C) 2025-present SheetXL Inc. & Michael T. Ford
- * License: The license can be found at https://www.sheetxl.com/license.
- */
-const e = { CUBEKPIMEMBER: { s: "Returns a key performance indicator (KPI) property and displays the KPI name in the cell.", p: { connection: { d: "is the name of a connection to an OLAP cube" }, kpiName: { d: "is the KPI name" }, kpiProperty: { d: "is the KPI property" }, caption: { d: "is the caption to be displayed in the cell" } }, h: "Unimplemented" }, CUBEMEMBER: { s: "Returns a member or tuple from the cube.", p: { connection: { d: "is the name of a connection to an OLAP cube" }, memberExpression: { d: "is the expression representing the name of a member or tuple in the OLAP cube" }, caption: { d: "is the caption to be displayed in the cell" } }, h: "Unimplemented" }, CUBEMEMBERPROPERTY: { s: "Returns the value of a member property from the cube.", p: { connection: { d: "is the name of a connection to an OLAP cube" }, memberExpression: { d: "is the expression representing the name of a member in the OLAP cube" }, kpiProperty: { d: "is the property name" } }, h: "Unimplemented" }, CUBERANKEDMEMBER: { s: "Returns the nth, or ranked, member in a set.", p: { connection: { d: "is the name of a connection to an OLAP cube" }, setExpression: { d: "is the set from which the element is to be retrieved" }, rank: { d: "is the rank of the element to be retrieved" }, caption: { d: "is the caption to be displayed in the cell" } }, h: "Unimplemented" }, CUBESET: { s: "Defines a calculated set of members or tuples by sending a set expression to the cube on the server, which creates the set, and then returns that set to Microsoft Excel.", p: { connection: { d: "is the name of a connection to an OLAP cube" }, setExpression: { d: "is the expression for the set" }, caption: { d: "is the caption to be displayed in the cell" }, sortOrder: { d: "is the sort order" }, sortBy: { d: "is the sort by" } }, h: "Unimplemented" }, CUBESETCOUNT: { s: "Returns the number of items in a set.", p: { set: { d: "is the set whose elements are to be counted" } }, h: "Unimplemented" }, CUBEVALUE: { s: "Returns an aggregated value from the cube.", p: { connection: { d: "is the name of a connection to an OLAP cube" }, memberExpression: {} }, h: "Unimplemented" } };
-export {
-  e as default
-};

package/cdn/assets/Cfgui52VcoZakyBi.js

@@ -1,50 +0,0 @@
-import { jsx as i } from "react/jsx-runtime";
-import { memo as j, useMemo as B, useState as x, useCallback as M } from "react";
-import { P as r, $ as E, h as S, i as V, j as z, l as h, a0 as C } from "./Dj-9L-ifpIi1HChy.js";
-/**
- * @license @sheetxl/studio-vanilla - SheetXL Studio - Vanilla entry point for integrating SheetXL UI. - v0.4.19
- *
- * (C) 2025-present SheetXL Inc. & Michael T. Ford
- * License: The license can be found at https://www.sheetxl.com/license.
- */
-const G = ["Ok", "Cancel"], U = j((O) => {
-  const { initialComments: P = null, onUpdateComments: m, context: k, onOption: u, onValidateOption: l, onDone: p, options: d = G, defaultOption: c = d?.[0], cancelOption: s = "Cancel", sx: w, ...y } = O, g = B(() => {
-    const n = P ?? k?.()?.getComments();
-    let t = "";
-    if (n && n.content && n.content.runs) {
-      const a = n.content.runs;
-      for (let o = 0; o < a.length; o++) {
-        const $ = a[o];
-        t += $?.text;
-      }
-    }
-    return t;
-  }, []), [e, F] = x(g), [T, b] = x(!1), f = M(async (n, t) => null, []), v = r(async (n) => {
-    const t = e === "" ? [] : e.split(`
-`);
-    if (n !== s) {
-      const a = [];
-      for (let o = 0; o < t.length; o++) a.push({ text: t[o] });
-      m?.({ content: { runs: a } });
-    }
-    u?.(n, n === s, n === c), p?.();
-  }, [e, m, p, u, c, s]), D = r((n) => {
-    F(n.target.value), f(n.target.value, null);
-  }, [l]), I = r(async (n) => {
-    let t = await Promise.resolve(l?.(n));
-    try {
-      t !== !1 && (t = await f(e, n));
-    } catch {
-    }
-    return t ?? !0;
-  }, [l, e]);
-  return i(E, { title: (g ? "Edit" : "Insert") + " Comments", options: d, onDone: p, onOption: (n) => v(n), onValidateOption: I, defaultOption: c, cancelOption: s, autoFocusSel: ".autoFocus", sx: { width: "480px", ...w }, ...y, children: i(S, { sx: { paddingTop: (n) => n.spacing(1), paddingBottom: (n) => n.spacing(0), rowGap: (n) => n.spacing(1), display: "flex", flexDirection: "column" }, children: i(V, { sx: { paddingTop: (n) => n.spacing(1.5), minWidth: 135, width: "100%" }, size: "small", children: i(z, { label: "Comments", placeholder: "Enter a comment.", onFocus: (n) => {
-    T || n.target?.select(), b(!0);
-  }, sx: { "& .MuiFormHelperText-root": { marginTop: (n) => n.spacing(0.5) } }, InputLabelProps: { shrink: !0 }, InputProps: { inputProps: { className: "autoFocus", spellCheck: !1, autoComplete: "off", sx: { paddingTop: (n) => n.spacing(1.25), paddingBottom: (n) => n.spacing(0.75), backgroundImage: `linear-gradient(${h("#fff", C(5))}, ${h("#fff", C(5))})` } } }, value: e, onChange: D, onContextMenu: (n) => {
-    n.stopPropagation();
-  } }) }) }) });
-});
-export {
-  U as CommentsDialog,
-  U as default
-};

package/cdn/assets/Ck6R7vI9j0vG-mKU.js

@@ -1,390 +0,0 @@
-import C, { memo as ne, useState as _, useRef as m, useCallback as re, useEffect as S } from "react";
-/**
- * @license @sheetxl/studio-vanilla - SheetXL Studio - Vanilla entry point for integrating SheetXL UI. - v0.4.19
- *
- * (C) 2025-present SheetXL Inc. & Michael T. Ford
- * License: The license can be found at https://www.sheetxl.com/license.
- */
-function we(e, t, r) {
-  return t in e ? Object.defineProperty(e, t, { value: r, enumerable: !0, configurable: !0, writable: !0 }) : e[t] = r, e;
-}
-function ue(e, t) {
-  var r = Object.keys(e);
-  if (Object.getOwnPropertySymbols) {
-    var n = Object.getOwnPropertySymbols(e);
-    t && (n = n.filter(function(o) {
-      return Object.getOwnPropertyDescriptor(e, o).enumerable;
-    })), r.push.apply(r, n);
-  }
-  return r;
-}
-function ae(e) {
-  for (var t = 1; t < arguments.length; t++) {
-    var r = arguments[t] != null ? arguments[t] : {};
-    t % 2 ? ue(Object(r), !0).forEach(function(n) {
-      we(e, n, r[n]);
-    }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(r)) : ue(Object(r)).forEach(function(n) {
-      Object.defineProperty(e, n, Object.getOwnPropertyDescriptor(r, n));
-    });
-  }
-  return e;
-}
-function le(e, t) {
-  (t == null || t > e.length) && (t = e.length);
-  for (var r = 0, n = new Array(t); r < t; r++) n[r] = e[r];
-  return n;
-}
-function Oe(e, t, r) {
-  return t in e ? Object.defineProperty(e, t, { value: r, enumerable: !0, configurable: !0, writable: !0 }) : e[t] = r, e;
-}
-function se(e, t) {
-  var r = Object.keys(e);
-  if (Object.getOwnPropertySymbols) {
-    var n = Object.getOwnPropertySymbols(e);
-    t && (n = n.filter(function(o) {
-      return Object.getOwnPropertyDescriptor(e, o).enumerable;
-    })), r.push.apply(r, n);
-  }
-  return r;
-}
-function de(e) {
-  for (var t = 1; t < arguments.length; t++) {
-    var r = arguments[t] != null ? arguments[t] : {};
-    t % 2 ? se(Object(r), !0).forEach(function(n) {
-      Oe(e, n, r[n]);
-    }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(r)) : se(Object(r)).forEach(function(n) {
-      Object.defineProperty(e, n, Object.getOwnPropertyDescriptor(r, n));
-    });
-  }
-  return e;
-}
-function R(e) {
-  return function t() {
-    for (var r = this, n = arguments.length, o = new Array(n), i = 0; i < n; i++) o[i] = arguments[i];
-    return o.length >= e.length ? e.apply(this, o) : function() {
-      for (var u = arguments.length, c = new Array(u), l = 0; l < u; l++) c[l] = arguments[l];
-      return t.apply(r, [].concat(o, c));
-    };
-  };
-}
-function Y(e) {
-  return {}.toString.call(e).includes("Object");
-}
-function q(e) {
-  return typeof e == "function";
-}
-var k = R(function(e, t) {
-  throw new Error(e[t] || e.default);
-})({ initialIsRequired: "initial state is required", initialType: "initial state should be an object", initialContent: "initial state shouldn't be an empty object", handlerType: "handler should be an object or a function", handlersType: "all handlers should be a functions", selectorType: "selector should be a function", changeType: "provided value of changes should be an object", changeField: 'it seams you want to change a field in the state which is not specified in the "initial" state', default: "an unknown error accured in `state-local` package" }), je = function(e, t) {
-  return Y(t) || k("changeType"), Object.keys(t).some(function(r) {
-    return n = e, o = r, !Object.prototype.hasOwnProperty.call(n, o);
-    var n, o;
-  }) && k("changeField"), t;
-};
-function Me(e, t) {
-  return q(t) ? t(e.current) : t;
-}
-function Ee(e, t) {
-  return e.current = de(de({}, e.current), t), t;
-}
-function Pe(e, t, r) {
-  return q(t) ? t(e.current) : Object.keys(r).forEach(function(n) {
-    var o;
-    return (o = t[n]) === null || o === void 0 ? void 0 : o.call(t, e.current[n]);
-  }), r;
-}
-var X, pe = { configIsRequired: "the configuration object is required", configType: "the configuration object should be an object", default: "an unknown error accured in `@monaco-editor/loader` package", deprecation: `Deprecation warning!
-    You are using deprecated way of configuration.
-
-    Instead of using
-      monaco.config({ urls: { monacoBase: '...' } })
-    use
-      monaco.config({ paths: { vs: '...' } })
-
-    For more please check the link https://github.com/suren-atoyan/monaco-loader#config
-  ` }, fe = (X = function(e, t) {
-  throw new Error(e[t] || e.default);
-}, function e() {
-  for (var t = this, r = arguments.length, n = new Array(r), o = 0; o < r; o++) n[o] = arguments[o];
-  return n.length >= X.length ? X.apply(this, n) : function() {
-    for (var i = arguments.length, u = new Array(i), c = 0; c < i; c++) u[c] = arguments[c];
-    return e.apply(t, [].concat(n, u));
-  };
-})(pe);
-function he(e, t) {
-  return Object.keys(t).forEach(function(r) {
-    t[r] instanceof Object && e[r] && Object.assign(t[r], he(e[r], t[r]));
-  }), ae(ae({}, e), t);
-}
-var Se = { type: "cancelation", msg: "operation is manually canceled" };
-function Z(e) {
-  var t = !1, r = new Promise(function(n, o) {
-    e.then(function(i) {
-      return t ? o(Se) : n(i);
-    }), e.catch(o);
-  });
-  return r.cancel = function() {
-    return t = !0;
-  }, r;
-}
-var ee, me = function(e) {
-  if (Array.isArray(e)) return e;
-}(ee = function(e) {
-  var t = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {};
-  (function(c) {
-    var l;
-    c || k("initialIsRequired"), Y(c) || k("initialType"), l = c, Object.keys(l).length || k("initialContent");
-  })(e), function(c) {
-    q(c) || Y(c) || k("handlerType"), Y(c) && Object.values(c).some(function(l) {
-      return !q(l);
-    }) && k("handlersType");
-  }(t);
-  var r = { current: e }, n = R(Pe)(r, t), o = R(Ee)(r), i = R(je)(e), u = R(Me)(r);
-  return [function() {
-    var c = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : function(l) {
-      return l;
-    };
-    return function(l) {
-      q(l) || k("selectorType");
-    }(c), c(r.current);
-  }, function(c) {
-    (function() {
-      for (var l = arguments.length, g = new Array(l), O = 0; O < l; O++) g[O] = arguments[O];
-      return function(b) {
-        return g.reduceRight(function(E, P) {
-          return P(E);
-        }, b);
-      };
-    })(n, o, i, u)(c);
-  }];
-}({ config: { paths: { vs: "https://cdn.jsdelivr.net/npm/monaco-editor@0.52.2/min/vs" } }, isInitialized: !1, resolve: null, reject: null, monaco: null })) || function(e) {
-  if (typeof Symbol < "u" && Symbol.iterator in Object(e)) {
-    var t = [], r = !0, n = !1, o = void 0;
-    try {
-      for (var i, u = e[Symbol.iterator](); !(r = (i = u.next()).done) && (t.push(i.value), t.length !== 2); r = !0) ;
-    } catch (c) {
-      n = !0, o = c;
-    } finally {
-      try {
-        r || u.return == null || u.return();
-      } finally {
-        if (n) throw o;
-      }
-    }
-    return t;
-  }
-}(ee) || function(e) {
-  if (e) {
-    if (typeof e == "string") return le(e, 2);
-    var t = Object.prototype.toString.call(e).slice(8, -1);
-    return t === "Object" && e.constructor && (t = e.constructor.name), t === "Map" || t === "Set" ? Array.from(e) : t === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? le(e, 2) : void 0;
-  }
-}(ee) || function() {
-  throw new TypeError(`Invalid attempt to destructure non-iterable instance.
-In order to be iterable, non-array objects must have a [Symbol.iterator]() method.`);
-}(), N = me[0], $ = me[1];
-function ke(e) {
-  return document.body.appendChild(e);
-}
-function xe(e) {
-  var t, r, n = N(function(i) {
-    return { config: i.config, reject: i.reject };
-  }), o = (t = "".concat(n.config.paths.vs, "/loader.js"), r = document.createElement("script"), t && (r.src = t), r);
-  return o.onload = function() {
-    return e();
-  }, o.onerror = n.reject, o;
-}
-function Ie() {
-  var e = N(function(r) {
-    return { config: r.config, resolve: r.resolve, reject: r.reject };
-  }), t = window.require;
-  t.config(e.config), t(["vs/editor/editor.main"], function(r) {
-    ye(r), e.resolve(r);
-  }, function(r) {
-    e.reject(r);
-  });
-}
-function ye(e) {
-  N().monaco || $({ monaco: e });
-}
-var te = new Promise(function(e, t) {
-  return $({ resolve: e, reject: t });
-}), G = { config: function(e) {
-  var t = function(o) {
-    var i;
-    return o || fe("configIsRequired"), i = o, {}.toString.call(i).includes("Object") || fe("configType"), o.urls ? (console.warn(pe.deprecation), { paths: { vs: o.urls.monacoBase } }) : o;
-  }(e), r = t.monaco, n = function(o, i) {
-    if (o == null) return {};
-    var u, c, l = function(O, b) {
-      if (O == null) return {};
-      var E, P, x = {}, I = Object.keys(O);
-      for (P = 0; P < I.length; P++) E = I[P], b.indexOf(E) >= 0 || (x[E] = O[E]);
-      return x;
-    }(o, i);
-    if (Object.getOwnPropertySymbols) {
-      var g = Object.getOwnPropertySymbols(o);
-      for (c = 0; c < g.length; c++) u = g[c], i.indexOf(u) >= 0 || Object.prototype.propertyIsEnumerable.call(o, u) && (l[u] = o[u]);
-    }
-    return l;
-  }(t, ["monaco"]);
-  $(function(o) {
-    return { config: he(o.config, n), monaco: r };
-  });
-}, init: function() {
-  var e = N(function(t) {
-    return { monaco: t.monaco, isInitialized: t.isInitialized, resolve: t.resolve };
-  });
-  if (!e.isInitialized) {
-    if ($({ isInitialized: !0 }), e.monaco) return e.resolve(e.monaco), Z(te);
-    if (window.monaco && window.monaco.editor) return ye(window.monaco), e.resolve(window.monaco), Z(te);
-    (function() {
-      for (var t = arguments.length, r = new Array(t), n = 0; n < t; n++) r[n] = arguments[n];
-      return function(o) {
-        return r.reduceRight(function(i, u) {
-          return u(i);
-        }, o);
-      };
-    })(ke, xe)(Ie);
-  }
-  return Z(te);
-}, __getMonacoInstance: function() {
-  return N(function(e) {
-    return e.monaco;
-  });
-} }, Te = { display: "flex", position: "relative", textAlign: "initial" }, Ae = { width: "100%" }, Ce = { display: "none" }, De = { container: { display: "flex", height: "100%", width: "100%", justifyContent: "center", alignItems: "center" } }, Ve = function({ children: e }) {
-  return C.createElement("div", { style: De.container }, e);
-}, ve = ne(function({ width: e, height: t, isEditorReady: r, loading: n, _ref: o, className: i, wrapperProps: u }) {
-  return C.createElement("section", { style: { ...Te, width: e, height: t }, ...u }, !r && C.createElement(Ve, null, n), C.createElement("div", { ref: o, style: { ...Ae, ...!r && Ce }, className: i }));
-}), oe = function(e) {
-  S(e, []);
-}, j = function(e, t, r = !0) {
-  let n = m(!0);
-  S(n.current || !r ? () => {
-    n.current = !1;
-  } : e, t);
-};
-function z() {
-}
-function A(e, t, r, n) {
-  return g = n, (l = e).editor.getModel(ge(l, g)) || (i = t, u = r, c = n, (o = e).editor.createModel(i, u, c ? ge(o, c) : void 0));
-  var o, i, u, c, l, g;
-}
-function ge(e, t) {
-  return e.Uri.parse(t);
-}
-var qe = ne(function({ original: e, modified: t, language: r, originalLanguage: n, modifiedLanguage: o, originalModelPath: i, modifiedModelPath: u, keepCurrentOriginalModel: c = !1, keepCurrentModifiedModel: l = !1, theme: g = "light", loading: O = "Loading...", options: b = {}, height: E = "100%", width: P = "100%", className: x, wrapperProps: I = {}, beforeMount: H = z, onMount: J = z }) {
-  let [w, D] = _(!1), [V, h] = _(!0), y = m(null), d = m(null), L = m(null), v = m(J), a = m(H), T = m(!1);
-  oe(() => {
-    let s = G.init();
-    return s.then((f) => (d.current = f) && h(!1)).catch((f) => f?.type !== "cancelation" && console.error("Monaco initialization: error:", f)), () => y.current ? function() {
-      let f = y.current?.getModel();
-      c || f?.original?.dispose(), l || f?.modified?.dispose(), y.current?.dispose();
-    }() : s.cancel();
-  }), j(() => {
-    if (y.current && d.current) {
-      let s = y.current.getOriginalEditor(), f = A(d.current, e || "", n || r || "text", i || "");
-      f !== s.getModel() && s.setModel(f);
-    }
-  }, [i], w), j(() => {
-    if (y.current && d.current) {
-      let s = y.current.getModifiedEditor(), f = A(d.current, t || "", o || r || "text", u || "");
-      f !== s.getModel() && s.setModel(f);
-    }
-  }, [u], w), j(() => {
-    let s = y.current.getModifiedEditor();
-    s.getOption(d.current.editor.EditorOption.readOnly) ? s.setValue(t || "") : t !== s.getValue() && (s.executeEdits("", [{ range: s.getModel().getFullModelRange(), text: t || "", forceMoveMarkers: !0 }]), s.pushUndoStop());
-  }, [t], w), j(() => {
-    y.current?.getModel()?.original.setValue(e || "");
-  }, [e], w), j(() => {
-    let { original: s, modified: f } = y.current.getModel();
-    d.current.editor.setModelLanguage(s, n || r || "text"), d.current.editor.setModelLanguage(f, o || r || "text");
-  }, [r, n, o], w), j(() => {
-    d.current?.editor.setTheme(g);
-  }, [g], w), j(() => {
-    y.current?.updateOptions(b);
-  }, [b], w);
-  let F = re(() => {
-    if (!d.current) return;
-    a.current(d.current);
-    let s = A(d.current, e || "", n || r || "text", i || ""), f = A(d.current, t || "", o || r || "text", u || "");
-    y.current?.setModel({ original: s, modified: f });
-  }, [r, t, o, e, n, i, u]), U = re(() => {
-    !T.current && L.current && (y.current = d.current.editor.createDiffEditor(L.current, { automaticLayout: !0, ...b }), F(), d.current?.editor.setTheme(g), D(!0), T.current = !0);
-  }, [b, g, F]);
-  return S(() => {
-    w && v.current(y.current, d.current);
-  }, [w]), S(() => {
-    !V && !w && U();
-  }, [V, w, U]), C.createElement(ve, { width: P, height: E, isEditorReady: w, loading: O, _ref: L, className: x, wrapperProps: I });
-}), ze = function() {
-  let [e, t] = _(G.__getMonacoInstance());
-  return oe(() => {
-    let r;
-    return e || (r = G.init(), r.then((n) => {
-      t(n);
-    })), () => r?.cancel();
-  }), e;
-}, B = /* @__PURE__ */ new Map(), Le = ne(function({ defaultValue: e, defaultLanguage: t, defaultPath: r, value: n, language: o, path: i, theme: u = "light", line: c, loading: l = "Loading...", options: g = {}, overrideServices: O = {}, saveViewState: b = !0, keepCurrentModel: E = !1, width: P = "100%", height: x = "100%", className: I, wrapperProps: H = {}, beforeMount: J = z, onMount: w = z, onChange: D, onValidate: V = z }) {
-  let [h, y] = _(!1), [d, L] = _(!0), v = m(null), a = m(null), T = m(null), F = m(w), U = m(J), s = m(), f = m(n), be = function(p) {
-    let M = m();
-    return S(() => {
-      M.current = p;
-    }, [p]), M.current;
-  }(i), ie = m(!1), K = m(!1);
-  oe(() => {
-    let p = G.init();
-    return p.then((M) => (v.current = M) && L(!1)).catch((M) => M?.type !== "cancelation" && console.error("Monaco initialization: error:", M)), () => a.current ? (s.current?.dispose(), E ? b && B.set(i, a.current.saveViewState()) : a.current.getModel()?.dispose(), void a.current.dispose()) : p.cancel();
-  }), j(() => {
-    let p = A(v.current, e || n || "", t || o || "", i || r || "");
-    p !== a.current?.getModel() && (b && B.set(be, a.current?.saveViewState()), a.current?.setModel(p), b && a.current?.restoreViewState(B.get(i)));
-  }, [i], h), j(() => {
-    a.current?.updateOptions(g);
-  }, [g], h), j(() => {
-    !a.current || n === void 0 || (a.current.getOption(v.current.editor.EditorOption.readOnly) ? a.current.setValue(n) : n !== a.current.getValue() && (K.current = !0, a.current.executeEdits("", [{ range: a.current.getModel().getFullModelRange(), text: n, forceMoveMarkers: !0 }]), a.current.pushUndoStop(), K.current = !1));
-  }, [n], h), j(() => {
-    let p = a.current?.getModel();
-    p && o && v.current?.editor.setModelLanguage(p, o);
-  }, [o], h), j(() => {
-    c !== void 0 && a.current?.revealLine(c);
-  }, [c], h), j(() => {
-    v.current?.editor.setTheme(u);
-  }, [u], h);
-  let ce = re(() => {
-    if (T.current && v.current && !ie.current) {
-      U.current(v.current);
-      let p = i || r, M = A(v.current, n || e || "", t || o || "", p || "");
-      a.current = v.current?.editor.create(T.current, { model: M, automaticLayout: !0, ...g }, O), b && a.current.restoreViewState(B.get(p)), v.current.editor.setTheme(u), c !== void 0 && a.current.revealLine(c), y(!0), ie.current = !0;
-    }
-  }, [e, t, r, n, o, i, g, O, b, u, c]);
-  return S(() => {
-    h && F.current(a.current, v.current);
-  }, [h]), S(() => {
-    !d && !h && ce();
-  }, [d, h, ce]), f.current = n, S(() => {
-    h && D && (s.current?.dispose(), s.current = a.current?.onDidChangeModelContent((p) => {
-      K.current || D(a.current.getValue(), p);
-    }));
-  }, [h, D]), S(() => {
-    if (h) {
-      let p = v.current.editor.onDidChangeMarkers((M) => {
-        let Q = a.current.getModel()?.uri;
-        if (Q && M.find((W) => W.path === Q.path)) {
-          let W = v.current.editor.getModelMarkers({ resource: Q });
-          V?.(W);
-        }
-      });
-      return () => {
-        p?.dispose();
-      };
-    }
-    return () => {
-    };
-  }, [h, V]), C.createElement(ve, { width: P, height: x, isEditorReady: h, loading: l, _ref: T, className: I, wrapperProps: H });
-}), _e = Le;
-export {
-  qe as DiffEditor,
-  Le as Editor,
-  _e as default,
-  G as loader,
-  ze as useMonaco
-};

package/cdn/assets/ClTJpu1UdRW0KLAX.js

@@ -1,23 +0,0 @@
-import { jsx as n, jsxs as C } from "react/jsx-runtime";
-import { useState as O } from "react";
-import { O as a, P as m, $ as H, h as S, R as s, U as l, F as r } from "./Dj-9L-ifpIi1HChy.js";
-/**
- * @license @sheetxl/studio-vanilla - SheetXL Studio - Vanilla entry point for integrating SheetXL UI. - v0.4.19
- *
- * (C) 2025-present SheetXL Inc. & Michael T. Ford
- * License: The license can be found at https://www.sheetxl.com/license.
- */
-const x = ({ range: h, options: c, cell: p, onDone: d, ...v }) => {
-  const [t, o] = O(c ?? a.DefaultRangeOptions), u = m((e) => {
-    let i = null;
-    e === "Sort" && (i = { ...c, options: t }), d?.(i);
-  }, [t, d, c]);
-  return n(H, { title: "Sort", options: ["Sort", "Cancel"], onDone: u, ...v, children: C(S, { sx: { display: "flex", flexDirection: "column" }, children: [n(s, { control: n(l, { checked: !t.reverse, onChange: () => o((e) => ({ ...e, reverse: !e.reverse })) }), label: "Is Ascending", labelPlacement: "end" }), n(s, { control: n(l, { checked: t.hasHeader, onChange: () => o((e) => ({ ...e, hasHeader: !e.hasHeader })) }), label: "Has Header", labelPlacement: "end" }), n(s, { control: n(l, { checked: t.collatorOptions?.sensitivity === a.CaseSensitiveOptions.sensitivity, onChange: () => o((e) => ({ ...e, collatorOptions: t.collatorOptions?.sensitivity === a.CaseSensitiveOptions.sensitivity ? a.CaseInsensitiveOptions : a.CaseSensitiveOptions })) }), label: "Case Sensitive", labelPlacement: "end" }), n(s, { control: n(l, { checked: t.orientation === r.Orientation.Row, onChange: () => o((e) => {
-    const i = e.orientation === r.Orientation.Row ? r.Orientation.Column : r.Orientation.Row;
-    return { ...h.getDefaultSortCriteria(i, p).options, includeHidden: e.includeHidden, reverse: e.reverse, orientation: i };
-  }) }), label: "Row Sort", labelPlacement: "end" }), n(s, { control: n(l, { checked: t.includeHidden, onChange: () => o((e) => ({ ...e, includeHidden: !e.includeHidden })) }), label: "Include Hidden", labelPlacement: "end" })] }) });
-};
-export {
-  x as SortDialog,
-  x as default
-};

package/cdn/assets/Co1yPh9LPeUa-tCm.js

@@ -1,29 +0,0 @@
-/**
- * @license @sheetxl/studio-vanilla - SheetXL Studio - Vanilla entry point for integrating SheetXL UI. - v0.4.19
- *
- * (C) 2025-present SheetXL Inc. & Michael T. Ford
- * License: The license can be found at https://www.sheetxl.com/license.
- */
-class o {
-  constructor(r = {}) {
-    this.workerWrapper = null;
-  }
-  async getWorkerWrapper() {
-    if (this.workerWrapper) return this.workerWrapper;
-    const { createCompilerWorker: r } = await import("./cgKx_r-dAv2kc57N.js");
-    return this.workerWrapper = await r(), this.workerWrapper;
-  }
-  async compileModule(r) {
-    try {
-      return (await this.getWorkerWrapper()).execute(r);
-    } catch (e) {
-      throw console.error("Failed to compile using worker:", e), e;
-    }
-  }
-  terminate() {
-    this.workerWrapper?.terminate(), this.workerWrapper = null;
-  }
-}
-export {
-  o as TypeScriptCompiler
-};