text: /**
  * Copyright 2012-2021, Plotly, Inc.
  * All rights reserved.
  *
  * This source code is licensed under the MIT license found in the
  * LICENSE file in the root directory of this source tree.
  */
  
  'use strict';
  
  var isArray = Array.isArray;
  
  // IE9 fallbacks
  
  var ab = (typeof ArrayBuffer === 'undefined' || !ArrayBuffer.isView) ?
      {isView: function() { return false; }} :
      ArrayBuffer;
  
  var dv = (typeof DataView === 'undefined') ?
      function() {} :
      DataView;
  
  function isTypedArray(a) {
      return ab.isView(a) && !(a instanceof dv);
  }
  exports.isTypedArray = isTypedArray;
  
  function isArrayOrTypedArray(a) {
      return isArray(a) || isTypedArray(a);
  }
  exports.isArrayOrTypedArray = isArrayOrTypedArray;
  
  /*
   * Test whether an input object is 1D.
   *
   * Assumes we already know the object is an array.
   *
   * Looks only at the first element, if the dimensionality is
   * not consistent we won't figure that out here.
   */
  function isArray1D(a) {
      return !isArrayOrTypedArray(a[0]);
  }
  exports.isArray1D = isArray1D;
  
  /*
   * Ensures an array has the right amount of storage space. If it doesn't
   * exist, it creates an array. If it does exist, it returns it if too
   * short or truncates it in-place.
   *
   * The goal is to just reuse memory to avoid a bit of excessive garbage
   * collection.
   */
  exports.ensureArray = function(out, n) {
      // TODO: typed array support here? This is only used in
      // traces/carpet/compute_control_points
      if(!isArray(out)) out = [];
  
      // If too long, truncate. (If too short, it will grow
      // automatically so we don't care about that case)
      out.length = n;
  
      return out;
  };
  
  /*
   * TypedArray-compatible concatenation of n arrays
   * if all arrays are the same type it will preserve that type,
   * otherwise it falls back on Array.
   * Also tries to avoid copying, in case one array has zero length
   * But never mutates an existing array
   */
  exports.concat = function() {
      var args = [];
      var allArray = true;
      var totalLen = 0;
  
      var _constructor, arg0, i, argi, posi, leni, out, j;
  
      for(i = 0; i < arguments.length; i++) {
          argi = arguments[i];
          leni = argi.length;
          if(leni) {
              if(arg0) args.push(argi);
              else {
                  arg0 = argi;
                  posi = leni;
              }
  
              if(isArray(argi)) {
                  _constructor = false;
              } else {
                  allArray = false;
                  if(!totalLen) {
                      _constructor = argi.constructor;
                  } else if(_constructor !== argi.constructor) {
                      // TODO: in principle we could upgrade here,
                      // ie keep typed array but convert all to Float64Array?
                      _constructor = false;
                  }
              }
  
              totalLen += leni;
          }
      }
  
      if(!totalLen) return [];
      if(!args.length) return arg0;
  
      if(allArray) return arg0.concat.apply(arg0, args);
      if(_constructor) {
          // matching typed arrays
          out = new _constructor(totalLen);
          out.set(arg0);
          for(i = 0; i < args.length; i++) {
              argi = args[i];
              out.set(argi, posi);
              posi += argi.length;
          }
          return out;
      }
  
      // mismatched types or Array + typed
      out = new Array(totalLen);
      for(j = 0; j < arg0.length; j++) out[j] = arg0[j];
      for(i = 0; i < args.length; i++) {
          argi = args[i];
          for(j = 0; j < argi.length; j++) out[posi + j] = argi[j];
          posi += j;
      }
      return out;
  };
  
  exports.maxRowLength = function(z) {
      return _rowLength(z, Math.max, 0);
  };
  
  exports.minRowLength = function(z) {
      return _rowLength(z, Math.min, Infinity);
  };
  
  function _rowLength(z, fn, len0) {
      if(isArrayOrTypedArray(z)) {
          if(isArrayOrTypedArray(z[0])) {
              var len = len0;
              for(var i = 0; i < z.length; i++) {
                  len = fn(len, z[i].length);
              }
              return len;
          } else {
              return z.length;
          }
      }
      return 0;
  }
  