const result = bmSheet.functions.sumproduct([[1,2,3],[3,4,5]],[[0,2,1],[99,2,1]], 20)

// some utilities
var _handy = (() => {

  const isUndefined = (a) => typeof a === typeof undefined

  const forceArray = (a) => Array.isArray(a) ? a : [a]

  const flatten = (...args) => forceArray(args).map(f => forceArray(f).flat()).flat()

  const normalizeLengths = (arr) => {
    // normalize the argument array dimensions
    let items = arr.map(f => flatten(f))
    const maxLength = Math.max(...items.map(d => d.length))
    // blow out those of length 1
    items = items.map(f => f.length === 1 ? Array.from({ length: maxLength }).fill(f[0]) : f)
    // check they are all the same length
    if (!items.every(d => d.length === maxLength)) throw new Error("all arrays should be the same length or 1")
    return items
  }



  return {
    forceArray,
    asNumber: (a) => Number(a),
    isUndefined,
    fixOptional: (arg, defaultValue) => isUndefined(arg) ? defaultValue : arg,
    normalizeLengths,
    flatten
  }


})()

  const array_constrain = (input_range, num_rows, num_cols) =>
    _handy.forceArray(input_range).slice(0, num_rows).map(r => r.slice(0, num_cols))

  const frequency = (data, classes) => {

    // the extra one at the end for those that are too big
    const keys = flatten(classes).sort().concat([null])
    const freqs = [...keys].fill(0)
    flatten(data).forEach(d => {
      let i = 0;
      while (i < keys.length - 1 && d > keys[i]) i  ;
      freqs[i]  
    })
    return freqs.map(k => [k])
  }

  /**
   * note this flattens all arrays, so can only deal with 1 dependent variable at once
   * GROWTH(known_data_y, [known_data_x], [new_data_x], [b])
   */
  const growth = (known_y, known_x, new_x, use_const) =>
    _soGrowth(flatten(known_y), flatten(known_x), flatten(new_x), use_const)
  
  //https://stackoverflow.com/questions/14161990/how-to-implement-growth-function-in-javascript
  function _soGrowth(known_y, known_x, new_x, use_const) {
    // default values for optional parameters:
    if (typeof (known_x) == 'undefined') {
      known_x = [];
      for (var i = 1; i <= known_y.length; i  ) known_x.push(i);
    }
    if (typeof (new_x) == 'undefined') {
      new_x = [];
      for (var i = 1; i <= known_y.length; i  ) new_x.push(i);
    }
    if (typeof (use_const) == 'undefined') use_const = true;

    // calculate sums over the data:
    var n = known_y.length;
    var avg_x = 0; var avg_y = 0; var avg_xy = 0; var avg_xx = 0;
    for (var i = 0; i < n; i  ) {
      var x = known_x[i]; var y = Math.log(known_y[i]);
      avg_x  = x; avg_y  = y; avg_xy  = x * y; avg_xx  = x * x;
    }
    avg_x /= n; avg_y /= n; avg_xy /= n; avg_xx /= n;

    // compute linear regression coefficients:
    if (use_const) {
      var beta = (avg_xy - avg_x * avg_y) / (avg_xx - avg_x * avg_x);
      var alpha = avg_y - beta * avg_x;
    } else {
      var beta = avg_xy / avg_xx;
      var alpha = 0;
    }
    // console.log("alpha = "   alpha   ", beta = "    beta);

    // compute and return result array:
    var new_y = [];
    for (var i = 0; i < new_x.length; i  ) {
      new_y.push(Math.exp(alpha   beta * new_x[i]));
    }
    return new_y;
  }

  const linest = (known_data_y, known_data_x) =>
    _soLeastSquaresFitLinear(flatten(known_data_y), flatten(known_data_x))
  
  
    // https://stackoverflow.com/questions/7437660/how-do-i-recreate-an-excel-formula-which-calls-trend-in-c
  function _soLeastSquaresFitLinear(known_y, known_x, offset_x = 0) {
    if (known_y.length != known_x.length) {
      throw new Error('known y and known x arrays are unequal lengths')
    }
    var numPoints = known_y.length;

    var x1 = 0, y1 = 0, xy = 0, x2 = 0, J, M, B;
    for (var i = 0; i < numPoints; i  ) {
      known_x[i] -= offset_x;
      x1 = x1   known_x[i];
      y1 = y1   known_y[i];
      xy = xy   known_x[i] * known_y[i];
      x2 = x2   known_x[i] * known_x[i];
    }

    J = (numPoints * x2) - (x1 * x1);
    if (J != 0.0) {
      M = ((numPoints * xy) - (x1 * y1)) / J;
      B = ((y1 * x2) - (x1 * xy)) / J;
    }
    return [M, B];
  }

  const logest = (known_y, known_x) => {

    // get the slope
    const ls = linest(flatten(known_y).map(d => Math.log(d)), known_x)

    return [[
      Math.exp(ls[0]),
      Math.exp(ls[1])
    ]]

  }

  const mdeterm = (arr) => {
    if (!arr || !arr[0] || arr.length !== arr[0].length) throw new Error('matrix should be square')
    return Mathjs.det(arr)
  }

  const minverse = (arr) => {
    if (!arr || !arr[0] || arr.length !== arr[0].length) throw new Error('matrix should be square')
    return Mathjs.inv(arr)
  }

  const mmult = (a, b) => {
    const ca = a && a[0] && a[0].length
    const rb = b && b.length
    if (ca !== rb) throw new Error('the number of columns for matrix1 must equal the number of rows for matrix2')
    return Mathjs.multiply(a, b)
  }

  const sumproduct = (...args) => {
    const items = _handy.normalizeLengths(args)
    return Array.from({ length: items[0].length }).map((d, i) =>
      items.reduce((p, c) => p * Number(c[i]), 1)).reduce((p, c) => p   c, 0)
  }

  const transpose = (arr2d) => arr2d[0].map((_, col) => arr2d.map(row => row[col]));

  const trend = (known_y, known_x, new_x) => {

    // get the slope
    const ls = linest(known_y, known_x)

    // apply it
    return (flatten(new_x || known_x)).map((d, _, a) => ls[0] * d   ls[1])

  }

  // for use inside this namespace
  const flatten = (...args) => _handy.flatten(...args)
 
  // we're putting it into a column so it needs decoration
  // this is the functin that's exposed
  const exportFlatten = (...args) => flatten(...args).map(f=>[f])

/**
 * all the functions in the library can be accessed as custom functions
 * @customfunction
 * @param {string} name of the function
 * @param {...*} var_args
 * @return {*}
 */
const custom  = (name, ...args) =>  {
  // this is essential if the script is running in a different timezone to the sheets timezone for custom functions to work in the calling sheet
  bmSheet.customFunctions('settimezone', SpreadsheetApp.getActiveSpreadsheet().getSpreadsheetTimeZone())
  return bmSheet.customFunctions(name.toLowerCase(), ...args)
}

=custom("flatten",I25:K27,I25:K27)

// assuming that you have already done a getValues() on ranges I25:K27,I25:K27
const result = bmSheet.flatten(a,b)

// the result will be in values format
// [[x],[x],[x],.. etc]